text:
# Tic Tac Toe

> Microverse Object Oriented Programming Ruby Tic Tac Toe game.

![screenshot](./screenshot.png)

This project required to use Object Oriented Design to follow good practices in programming, such as:

- DRY (Don't Repeat Yourself)
- Single Responsibility Rule (a class does one only thing)
- No classes or methods on executable file

## Built With

- Ruby
- Rubocop

## Rules

- 3 x 3 grid as board
- First player is X, second player is O. Players put their marks in numbered squares.
- First player to get 3 of her marks in a row (up, down, across, or diagonally) wins.
- 9 squares full mean the game is over. If no winner, it's a draw.

## Flow

- Player's name asked
- Board displayed before each player marks a cell to check current game status.
- Players mark available cell by entering its number.
- Game over i there is a winner or a tie after each turn.

## Getting Started

To get a local copy up and running follow these simple example steps.

- Create a local clone of the repo.
- Run it through `main.rb` in your terminal.

## Authors

👤 **Opeyemi Oyelesi**

- Github: [Opeyemi Oyelesi](https://github.com/githubhandle)
- Linkedin: [Opeyemi Oyelesi](https://www.linkedin.com/in/opeyemioyelesi/)

👤 **Angel Mora**

- Github: [Angel Mora](https://github.com/angel-mora)
- Linkedin: [Angel Mora](https://www.linkedin.com/in/angelmoma/)

## 🤝 Contributing

Contributions, issues and feature requests are welcome!

Feel free to check the [issues page](issues/).

## Show your support

Give a ⭐ if you like this project!

## Acknowledgments

- Thanks to Microverse and its awesome community

## 📝 License

This project is [MIT](https://opensource.org/licenses/MIT) licensed.

repository: AdedayoOpeyemi/Tic-Tac-Toe

branch_name: refs/heads/development

repo_name: AdedayoOpeyemi/Tic-Tac-Toe


text:
---
title: "ZAP and Hacktoberfest 2022"
summary: >
    ZAP is participating in Hacktoberfest 2022.
images:
- https://www.zaproxy.org/blog/2022-10-01-zap-and-hacktoberfest/images/Hfest_Badge.png
type: post
tags:
- blog
- hacktoberfest
date: "2022-10-01"
addSocialPreview: true
authors:
- arkaprabha
---
![Hacktoberfest X ZAP](images/zap_Hacktoberfest.png)

We are happy to announce that ZAP is participating in [Hacktoberfest](https://hacktoberfest.com/) 2022.

## Contributors
This is what contributors need to know to participate in and complete Hacktoberfest 2022:
- Go through the [Hacktoberfest 2022 contributor](https://hacktoberfest.com/participation/#contributors) section to know more about what you should do and the rewards you will receive. We would be genuinely happy if you choose the "plant a tree" option as your reward.
- Contributions/pull requests can be made to the following repositories under the [OWASP ZAP](https://github.com/zaproxy) organization:
    - ZAP Core: [link](https://github.com/zaproxy/zaproxy)
    - ZAP Extensions: [link](https://github.com/zaproxy/zap-extensions)
    - ZAP HUD: [link](https://github.com/zaproxy/zap-hud)
    - ZAP Core Help: [link](https://github.com/zaproxy/zap-core-help)
    - ZAP Community Scripts: [link](https://github.com/zaproxy/community-scripts)
- Read the [ZAP Contributing Guide](/docs/contribute/).
- We recommend you to go through the [ZAP Developer Guide](/docs/developer/). It has all the answers to your questions about the development environment setup and the checks that your PR should pass before it is merged.
- If you are a beginner, please check out the curated [Hacktoberfest issues](https://github.com/zaproxy/zaproxy/issues?q=is%3Aopen+is%3Aissue+label%3AHacktoberFest) on the main ZAP repo.
- If you would like to challenge yourself, you can check out the [good second issues](https://github.com/zaproxy/zaproxy/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+second+issue%22) and [enhancement](https://github.com/zaproxy/zaproxy/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement) issues.

Some good resources to get started for beginners:
 - Open Source Guides: [How to contribute to Open Source](https://opensource.guide/how-to-contribute/)
 - GitHub: [GitHub training kit](https://training.github.com/)
 - DigitalOcean: [Introduction to Open Source](https://www.digitalocean.com/community/tutorial_series/an-introduction-to-open-source)
 - GitHub: [Write good PRs](https://github.blog/2015-01-21-how-to-write-the-perfect-pull-request/)

license: MIT

repository: zaproxy/zaproxy-website

branch_name: refs/heads/master

extension: md

gha_language: HTML

gha_license_id: MIT

license_type: permissive

repo_name: zaproxy/zaproxy-website


text:
![Launch5j](etc/img/logo.png)

**Java JAR file wrapper for creating Windows™ native executables**

# Introduction

**Launch5j** is a reimagination of “Launch4j”, *with full Unicode support*. This is a tool for wrapping Java applications distributed as JARs in lightweight Windows™ native executables. The executable can be configured to search for a certain JRE version or use a bundled one. The wrapper also provides better user experience through an application icon, a native pre-JRE splash screen, and a Java download page in case the appropriate JRE cannot be found.

# Usage

There currently are two different ways to use Launch5j with your application code:

* **Use the launcher executable with a separate JAR file**

  Simply put the launcher executable (`launch5j.exe`) and your JAR file into the same directory. Launch5j will automatically detect the path of the JAR file based on the location of the executable file. More specifically, Launch5j detects the full path of the executable file and then replaces the `.exe` file extension with a `.jar` file extension. Of course, you can rename the `launch5j.exe` executable to whatever you prefer.

  ***For example:*** Assuming your application's JAR file is called `thingamabob.jar`, pick the Launch5j launcher variant of your choice (**no** `wrapped` variant though!), rename the launcher executable to `thingamabob.exe`, and put these two files into the “install” directory. Also, the Java runtime should be located in the `runtime` sub-directory within the “install” directory – unless you are using the `registry` variant of Launch5j.

  ```
  install_dir
  ├── thingamabob.exe
  ├── thingamabob.jar
  ├── runtime
  │   └── bin
  │       ├── java.exe
  │       ├── javaw.exe
  │       └── [...]
  └── [...]
  ```

* **Combine the launcher executable and the JAR file (“wrapping”)**

  In order to combine the Launch5j launcher executable and the JAR file to a ***single*** file, you can simply *concatenate* these two files. For this purpose, you have to choose one of the `wrapped` variants of Launch5j. Also, the executable launcher code must go before the JAR file content. There are many ways to achieve this, but probably the most simple method is running the following **copy** command-line in the terminal:

      copy /B launch5j_wrapped.exe + thingamabob.jar thingamabob.exe

  If you are building your application with [**Apache Ant**](https://ant.apache.org/), consider using the `concat` task like this:

      <concat destfile="thingamabob.exe" binary="true">
         <fileset file="launch5j_wrapped.exe"/>
         <fileset file="thingamabob.jar"/>
      </concat>

  The resulting `thingamabob.exe` is fully self-contained, **no** separate JAR file needs to be shipped. Still, a Java runtime is required to run the application! The Java runtime should be located in the `runtime` sub-directory within the “install” directory – unless you are using the `registry` variant of Launch5j.

  ```
  install_dir
  ├── thingamabob.exe
  ├── runtime
  │   └── bin
  │       ├── java.exe
  │       ├── javaw.exe
  │       └── [...]
  └── [...]
  ```

  **Warning:** Code signing, as with Microsoft®'s `SignTool`, probably does **not** work with the “wrapped” executable file! If code signing is a requirement, please use a *separate* JAR file and just sing the launcher executable.

# Variants

Launch5j executables come in a number of variants, allowing you to pick the most suitable one for your project:

* **`nogui`**
  No graphical user interface is created and the Java application is launched via the `java.exe` (console mode) program; default variant launches the Java application via the `javaw.exe` (windowed mode) program.

  *Note:* If using this variant, the program should be called from within a terminal window!

* **`wrapped`**
  Expects that the JAR file and the executable launcher have been combined to a *single* file; default variant expects that a separate JAR file is present in the same directory where the executable launcher resides.

* **`registry`**
  Tries to automatically detect the install path of the JRE from the Windows™ registry; default variant expects the JRE to be located in the `runtime` path relative to the location of the executable launcher.

  At this time, the following Java distributions can be detected from the registry:
  - [Oracle JDK (JavaSoft)](https://www.oracle.com/java/technologies/javase-downloads.html)
  - [Eclipse Adoptium](https://adoptium.net/)
  - [Liberica OpenJDK](https://bell-sw.com/)
  - [Zulu OpenJDK](https://www.azul.com/downloads/zulu-community/)

  Regarding the different available distributions of Java, please refer to this document:
  [***Java Is Still Free***](https://docs.google.com/document/d/1nFGazvrCvHMZJgFstlbzoHjpAVwv5DEdnaBr_5pKuHo/preview)

* **`nowait`**
  Does **not** keep the launcher executable alive while the application is running; default variant keeps the launcher executable alive until the application terminates and then forwards the application's exit code.

* **`nosplash`**
  Does **not** display a splash screen while the application is launching; default variant *does* display a splash screen while the application is launching – will be hidden as soon as application window shows up.

* **`noenc`**
  Does **not** apply [URL encoding](https://en.wikipedia.org/wiki/Percent-encoding) to the given command-line arguments; default variant *does* apply URL encoding to all given command-line arguments in order to work around a long standing bug in Java.

## Supported platforms

All of the above Launch5j variants are available as `x86` (32-Bit) and `amd64` (64-Bit) executables. The `x86` (32-Bit) executables can run on *32-Bit* and *64-Bit* versions of Microsoft® Windows™, whereas the `amd64` (64-Bit) executables require a *64-Bit* version of Microsoft® Windows™. Consequently, it is generally recommended to distribute the `x86` (32-Bit) launcher executable. Please note that this does **not** restrict the “bitness” of the JRE that can be used. Even the `x86` (32-Bit) launcher executable is perfectly able to detect and launch a *64-Bit* JRE – if it is available.

*Note:* Launch5j has been tested to work correctly on Windows XP with Service Pack 3, or a compatible newer version.

# Customizations

Launch5j comes with a *default* executable icon and a *default* splash screen bitmap. These just server as an example and you probably want to replace them with your own *application-specific* graphics.

It is ***not*** necessary to re-build the executable files for that purpose. Instead, you can simply use a resource editor, such as [**XN Resource Editor**](https://web.archive.org/web/20100419201225/http://www.wilsonc.demon.co.uk/d10resourceeditor.htm) ([mirror](https://stefansundin.github.io/xn_resource_editor/)) or [**Resource Hacker™**](http://www.angusj.com/resourcehacker/), to *modify* the pre-compiled executable files as needed:

![Resource Hacker](etc/img/reshacker-example.png)

## Additional options

Some options can be configured via the launcher executable's [STRINGTABLE](https://docs.microsoft.com/en-us/windows/win32/menurc/stringtable-resource) resource:

* **`ID_STR_HEADING` (0x1)**
  Specifies a custom application title that will be used, e.g., as the heading of message boxes.

* **`ID_STR_JVMARGS` (0x2)**
  Specifies *additional* options JVM options to be passed, such as `-Xmx2g` or `-Dproperty=value`.
  See here for a list of available options:
  <https://docs.oracle.com/javase/7/docs/technotes/tools/windows/java.html>

* **`ID_STR_CMDARGS` (0x3)**
  Specifies *additional* fixed command-line parameters to be passed to the Java application.

* **`ID_STR_JREPATH` (0x4)**
  Specifies the path to the Java runtime (`javaw.exe`) relative to the launcher executable location.
  If not specified, then the *default* runtime path `runtime\\bin\\javaw.exe` is assumed.

  (This option does **not** apply to the “registry” variant of Launch5j)

* **`ID_STR_MUTEXID` (0x5)**
  Specifies the application ID to be used when creating the [*single-instance*](http://www.bcbjournal.org/articles/vol3/9911/Single-instance_applications.htm) mutex.
  The ID **must** be at least 5 characters in length and **should** be a *unique* string for each application!
  If not specified, then **no** mutex will be created and thus *multiple* instances will be allowed.

  *Hint:* If the specified application ID *starts* with an **`@`** character, then Launch5j will **not** show a message box when the application is already running; the **`@`** character is *not* considered a part of the actual ID.

  (This option does **not** apply to the “nowait” variant of Launch5j)

* **`ID_STR_HEAPMIN` (0x6)**
  Specifies the the ***minimum*** Java heap size (i.e. JVM option `-Xms`), as percentage of the total physical memory.
  This value must be an integral value in the `1` to `100` range.

  (If `ID_STR_HEAPMAX` is specified too, then this value **must** be less than or equal to `ID_STR_HEAPMAX`).

* **`ID_STR_HEAPMAX` (0x7)**
  Specifies the the ***maximum*** Java heap size (i.e. JVM option `-Xmx`), as percentage of the total physical memory.
  This value must be an integral value in the `1` to `100` range.

  (If `ID_STR_HEAPMIN` is specified too, then this value **must** be greater than or equal to `ID_STR_HEAPMIN`).

* **`ID_STR_JAVAMIN` (0x8)**
  Specifies the ***minimum*** supported JRE version, in the **`w.x.y.z`** format (e.g. `<IP_ADDRESS>`).
  This values is *inclusive*, i.e. the specified JRE version or any newer JRE version will be accepted.
  If not specified, then the *default* minimum supported JRE version `<IP_ADDRESS>` applies.

  *Hint:* Old-style `1.x.y_z` Java versions  are automatically translated to the new `x.y.z` format!

  (This option only applies to the “registry” variant of Launch5j)

* **`ID_STR_JAVAMAX` (0x9)**
  Specifies the ***maximum*** supported JRE version, in the **`w.x.y.z`** format (e.g. `<IP_ADDRESS>`).
  This values is *exclusive*, i.e. only JRE versions *older* than the specified JRE version will be accepted.
  If not specified, then there is **no** upper limit on the supported JRE version.

  *Hint:* Old-style `1.x.y.z` Java versions are automatically translated to the `x.y.z.0` format!

  (This option only applies to the “registry” variant of Launch5j)

* **`ID_STR_BITNESS` (0xA)**
  Specifies the required ***bitness*** of the JRE. This can be either **`32`** (x86, aka i586) or **`64`** (x86-64).
  If not specified, then 32-Bit *and* 64-Bit JREs are accepted, with a preference to 64-Bit.

  (This option only applies to the “registry” variant of Launch5j)

* **`ID_STR_JAVAURL` (0xB)**
  The Java download URL that will ne suggested, if **no** suitable JRE could be detected on the machine.
  If not specified, wes suggest downloading OpenJDK, as provided by the [Eclipse Adoptium](https://adoptium.net/) project.

  *Hint:* The URL must begin with a `http://` or `https://` prefix; otherwise the URL will be ignored!

  (This option only applies to the “registry” variant of Launch5j)

*Note:* We use the convention that the default resource string value `"?"` is used to represent an “undefined” value, because resource strings cannot be empty. You can replace the default value as needed!

# Unicode command-line arguments

There is a *long-standing* bug in Java on the Windows™ platform, which causes *Unicode* command-line arguments to be “mangled”. Even if the Unicode command-line arguments are properly passed to the Java executable (`java.exe`), they are **not** passed trough correctly to the `main()` method of your Java program! This problem can be reproduced in *all* Java versions ranging from Java 7 (1.7) up to and including the latest Java 15, as of October 2020.

More specifically, Java replaces any characters in the given command-line arguments that can **not** be represented in the computer's *local* ANSI codepage (i.e. pretty much any *non*-ASCII characters) with **`?`** characters. The cause of the problem apparently is that the “native” C code of the Java executable still uses the *legacy* `main()` entry point instead of the [`wmain()`](https://docs.microsoft.com/en-us/cpp/c-language/using-wmain?view=vs-2015) entry point; the latter is the modern Unicode-aware entry point – which **should** be used by programs written for *Windows 2000 or later*. Why this has **not** been fixed in 20 years is beyond my understanding.

As a workaround for the current situation in Java, Launch5j will (by default) convert the given Unicode command-line arguments to the [UTF-8](https://en.wikipedia.org/wiki/UTF-8) format and then apply the [URL encoding](https://en.wikipedia.org/wiki/Percent-encoding) scheme. This ensures that *only* pure ASCII characters need to be passed to the Java executable, thus preventing the command-line arguments from being “mangled”. Still the original Unicode command-line arguments are preserved and *can* be reconstructed in the Java code.

The only downside is that a bit of additional processing is required in the application code. The command-line arguments can be decoded by using the `URLDecoder.decode()` method with the **UTF-8** charset. Also, applications should check the `l5j.encargs` system property before decoding the command-line arguments:

```java
public class MainClass {
    public static void main(final String[] args) {
        initCommandlineArgs(args);
        /* Your application code goes here! */
    }

    private static void initCommandlineArgs(final String[] argv) {
        if (boolify(System.getProperty("l5j.encargs"))) {
            final String enc = StandardCharsets.UTF_8.name();
            for (int i = 0; i < argv.length; ++i) {
                try {
                    argv[i] = URLDecoder.decode(argv[i], enc);
                } catch (Exception e) { }
            }
        }
    }

    /* ... */
}
```

***Example:***

![Unicode command-line arguments](etc/img/unicode-args.png)

Please refer to the file **`example/example.java`** for the *complete* example code!

## JAR file name

Be aware that the same problem of “mangled” Unicode characters applies when the path of the JAR file is passed to the Java executable. In other words, the Java runtime *fails* to execute any JAR files whose path – file name or any directory name in the path – contains any Unicode characters that cannot be represented in the computer's *local* ANSI codepage! Unfortunately, we can **not** encode the path of the JAR file as we do with the other command-line arguments, because the Java executable requires the path of the JAR file to be passed in a non-encoded form.

Therefore, it is recommended to ***only*** use ASCII characters in the name of your JAR file and in the “install” path !!!

# Command-line options

The launcher executable recognizes the following “special” command-line options:

* **`--l5j-about`**:
  Display Launch5j about dialogue; includes version information and build configuration

* **`--l5j-slunk`**:
  Enable experimental “slunk” mode; this is for experts only!

# Downloads

Official **Launch5j** download mirrors:

* <https://github.com/lordmulder/Launch5j/releases>

* <https://sourceforge.net/projects/muldersoft/files/Launch5j/>

* <https://bitbucket.org/muldersoft/launch5j/downloads/>

It is *highly recommended* to download Launch5j only from one of the mirrors listed above. We are **not** responsible for the integrity and trustworthiness of Launch5j downloads you may have received from other locations!

## Source code

**Launch5j** source code is available via [Git](https://git-scm.com/):

* `git clone https://github.com/lordmulder/Launch5j.git`

* `git clone https://bitbucket.org/muldersoft/launch5j.git`

* `git clone https://gitlab.com/lord_mulder/launch5j.git`

# Build instructions

In order to build **Launch5j** from the sources, it is recommended to use the [*GNU C Compiler* (GCC)](https://gcc.gnu.org/) for Windows™, as provided by the [*Mingw-w64*](http://mingw-w64.org/) project. Other C compilers may work, but are **not** officially supported.

Probably the most simple way to set up the required build environment is by installing the [**MSYS2**](https://www.msys2.org/) distribution, which includes *GCC* (Mingw-w64) as well as all the required build tools, such as *Bash*, *GNU make* and *Git*.

Please make sure that the essential development tools and the MinGW-w64 toolchains are installed:

    $ pacman -S base-devel git
    $ pacman -S mingw-w64-i686-toolchain mingw-w64-x86_64-toolchain

Once the build environment has been set up, just run the provided Makefile:

    $ cd /path/to/launch5j
    $ make

*Note:* In order to create 32-Bit or 64-Bit binaries, use the `mingw32` or `mingw64` sub-system of MSYS2, respectively.

# Contact

**Launch5j** was created by LoRd_MuldeR <<mulder2@gmx.de>>.

For help and support, please visit:
<https://github.com/lordmulder/Launch5j/issues>

# Acknowledgment

This project is partly inspired by the “Launch4j” project, even though it has been re-written from scratch:
<https://sourceforge.net/p/launch4j/>

# License

This work has been released under the MIT license:

    Copyright 2023 LoRd_MuldeR<EMAIL_ADDRESS>
    Permission is hereby granted, free of charge, to any person obtaining a copy of
    this software and associated documentation files (the "Software"), to deal in
    the Software without restriction, including without limitation the rights to
    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
    the Software, and to permit persons to whom the Software is furnished to do so,
    subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

     IN NO EVENT SHALL THE AUTHORS OR
    COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

[∎](https://www.youtube.com/watch?v=EfbbjY9MlQs)


text:
---
id: 210
title: Becta publish learning services framework agreement
date: 2006-02-28T21:46:51+00:00
author: Miles Berry
layout: post
comments: true
guid: http://milesberry.net/?p=210
permalink: /2006/02/becta-publish-learning-services-framework-agreement/
categories:
  - Uncategorized
---
The full text of the framework agreement for those wishing to supply learning platforms to local authorites and RBCs is on the <acronym title="Official Journal of the European Union">OJEU</acronym> website, try [here](http://ted.publications.eu.int/official/ojs/tender/EN/2006043062.html).<!--more-->

Key facts are that those wishing to tender need net worth in excess of Â£700,000, a Dun & Bradstreet minimum risk indicator of at least 3 (!?), and three years of audited accounts, although these criteria may be relaxed in the case of consortia of SMEs. They’ll also need to provide a history of major education sector contracts and successful learning platform implementations.

It seems obvious to me that RBCs and Local Authorities would get far better [value for money](http://www.becta.org.uk/corporate/publications/documents/BEC5606_Full_report18.pdf) by hosting solutions like Moodle and Elgg in-house, and using the funding to pay for development, support, training and content, rather than paying towards licence fees, profits and dividends.


text:
# Ajaxify Rails [![Build Status](https://secure.travis-ci.org/ncri/ajaxify_rails.png)](http://travis-ci.org/ncri/ajaxify_rails)

No more full page reloads for your Rails app! Yay!

Automatically makes your app loading content in the background via Ajax.

Works by turning all internal links into Ajax links that trigger an update of the page's content area.
Also form submissions are automatically turned into Ajax requests.

Features:

- Uses the html5 history interface for changing the url and making the browser's back and forward buttons work with Ajax.
- Falls back to a hash based URL approach for browsers without the history interface (like Internet Explorer version <10).
- Hash based and non-hash URLs are interchangeable.
- Transparently handles redirects and supports page titles and flash messages.
- Tested with Chrome, Firefox, Safari and Internet Explorer 8+.

Demo: http://ajaxify-demo.herokuapp.com/ (the first page load might take a while, as heroku needs to spin up a dyno)

Demo source: https://github.com/ncri/ajaxify_rails_demo_app

Inspired by the pjax_rails gem (https://github.com/rails/pjax_rails).

## Requirements

- Ruby 1.9 and the asset pipeline,
- jQuery,
- Your app doesn't use named anchors (#). Named anchors can't be correctly represented in the fallback hash based url scheme.

## Installation

Add this line to your application's Gemfile:

    gem 'ajaxify_rails', :github => 'udayakiran/ajaxify_rails'

And then execute:

    $ bundle

In your application.js file add:

    //= require ajaxify_rails

## Usage

Call `Ajaxify.init()` in your layout's javascript.
Do this as early as possible to ensure Ajaxify's interchangeable url schemes (history api vs. hash based urls)
work most effectively.

The later you call `init()`, the later potential redirects from one scheme to another are performed,
which means the more unnecessary work the browser has to do.

### Content Area

Ajaxify assumes that your app has a content container html tag with the id `main`.
This tag is the container wrapping the yield statement in your layout.
If yield doesn't have a wrapper in your app yet, you need to supply one to get ajaxification working:

    #main
      = yield

You can set the content container of your app when initializing Ajaxify:

    Ajaxify.init
      content_container: 'content_container_id'

or later using `set_content_container`:

    Ajaxify.set_content_container('content_container_id')

### Loader Animation

You probably like to have a loader image to be displayed to the user while content loads via Ajax.
This is simple. Ajaxify automatically inserts a loader div with the class `ajaxify_loader` into
the content wrapper before starting an Ajax request. So just supply styles for `.ajaxify_loader` in your css, with an
animated gif as a background.

### Page Title

If you define a method called `page_title` in your application controller, returning the current page's title, Ajaxify will
use it to automatically update the title tag after the main content has changed.

### Navigation and other Layout Updates

It's a common use case to have a navigation that needs to change its appearence and possibly functioning when the user navigates
to a different section of the page. Ajaxify provides a success callback that is triggered after successful
updates of the page's main content. Just bind to the `ajaxify:content_loaded' event and make your layout changes:

    $(document).on 'ajaxify:content_loaded', ->
      # update navigation and/or other layout elements

### Flash Messages

Ajaxify correctly displays your flash messages after ajaxified requests.
By default, only `flash[:notice]` is supported. If you are using for example `flash[:warning]` as well you have to add the flash_types
option to the `Ajaxify.init()` call:

    Ajaxify.init
      flash_types: ['notice', 'warning']

Also make sure that you supply invisible wrapper tags in your layout for each flash type you use, with the id set to the type, e.g.:

    #notice{ style: "#{'display:none' unless flash[:notice]}" }
      = flash[:notice]

### Full Page Reloads

Sometimes requests change the layout of the page so significantly that loading only the main content via Ajax
and doing some minor layout tweaks here and there are simply not sufficient.

There might also be links and forms which already have their own Ajax functionality.

For these cases you can turn off Ajaxify, by simply adding the class `no_ajaxify` directly to links or forms:

    = link_to 'Change everything!', re_render_it_all_path, class: 'no_ajaxify'

### Root Redirects

Sometimes you need to redirect on the root url.

For example you might have a localized application with the locale inside the url.
When a user navigates to `your_domain.com` he/she gets redirected to e.g. `your_domain.com/en/`. This works fine in browsers supporting
the html 5 history api. However, for browsers without the history api like Internet Explorer before version 10, Ajaxify needs hints
about your url structure to not get confused (it creates endless redirects otherwise!). You need to explicitly supply all possible root
paths.

Example: if your app's root url potentially redirects to `your_domain.com/en/` and `your_domain.com/de/`
you need to hint Ajaxify like this:

    Ajaxify.init
      base_paths = ['de', 'en']

Important: `Ajaxify.base_paths` need to be set before `Ajaxify.init()` is called!

### Extra Content

Sometimes you need to do non trivial modifications of the layout whenever the content in the main content area of your site changes.
Ajaxify allows you to attach arbitrary html to ajaxified requests. This extra html is then stripped from the main content
that is inserted into the content area. But before that a callback is triggered which can be used to grab the extra content and do something with it.
To use this feature you need to provide a method `ajaxify_extra_content` in your ApplicationController:

    def ajaxify_extra_content
      ... your extra html ...
    end

For example you could provide html for a widget in the layout like this:

    def ajaxify_extra_content
      "<div id='my_fancy_widget_html'> some html </div>"
    end

And then, on the client side bind to the `ajaxify:content_inserted` event and select the widget html via `#ajaxify_content`:

    $(document).on 'ajaxify:content_inserted', ->
      $('#my_fancy_widget').html $('#ajaxify_content #my_fancy_widget_html').html()

Tip: you can call view helpers to render extra content from within your controller using the view_context:

    def ajaxify_extra_content
      view_context.my_fancy_widget
    end

### Ajaxify Events

Ajaxify provides a few jQuery events you can bind to:

* `ajaxify:before_load` => Triggered before the ajaxify request is started. Params: `url`.
* `ajaxify:content_loaded` => Triggered after an ajaxify request finished successfully. Params: `data, status, jqXHR, url`.
* `ajaxify:content_inserted` => Triggered after an ajaxify request finished but before extra content is stripped from the response.
* `ajaxify:flash_displayed` => Triggered after a flash message is displayed. Parameters: `flash_type`.
* `ajaxify:load_error` => Triggered if the ajaxify request goes wrong. Parameters: `data, status, jqXHR, url`.

### Javascript

In addition to calling your javascript e.g. in a dom ready event handler (or in your layout), you should also
call it in an `ajaxify:content_loaded` event handler, to make sure it is executed after content has
loaded via Ajaxify.

### Toggle Ajaxify

You can temporarily deactivate Ajaxify by calling `Ajaxify.activate(false)`. You can switch it on again with `Ajaxify.activate()`.
Note that `Ajaxify.activate` has to be called before the DOM is ready. Alternatively, you can set the `active` option to false when initializing Ajaxify to temporarily disable ajaxification, e.g.

    Ajaxify.init
      active: false

### Scrolling

By default, ajaxify scrolls to the top of the screen when you click on a link or submit a form.
You can change this default behavior by setting 'scroll_to_top' to false on init.

    Ajaxify.init
      scroll_to_top: false

You can also change the setting for individual links by adding classes:

    = link_to "Scroll to top", scroll_to_top_path, class: 'scroll_to_top'
    = link_to "Don't scroll", no_scroll_path, class: 'no_scroll_to_top'

### Loader animation

By default, ajaxify displays a loader animation when you click on a link or submit a form.
You can change this default behavior by setting 'display_loader' to false on init.

    Ajaxify.init
      display_loader: false

You can also change the setting for individual links by adding classes:

    = link_to "Display loader", display_loader_path, class: 'display_loader'
    = link_to "Don't display loader", no_display_loader_path, class: 'no_display_loader'

### Expiring assets after changes -

Say, you have made some changes to the assets they are not reloaded after the deployment till the user refreshes the whole page. This problem is fixed by the gem by using the asset files' digest and forcing whole page refersh on detecting an asset change. The only change needed for this to work is to make sure the below option to true in your envionment file (staging.rb/development.rb/production.rb)

    Rails.application.config.assets.digest = true

### Reloading the whole page when any layouts/app logic changes -

Say you have made the changes to some view files and after the server restart, the already opened pages are required to reload whole page instead with ajax, there is a way provided for this. You ll have to just assign array of those filenames along with some digest.

    Rails.application.config.layout_digests = ['xyz.haml-efegegegega787878']

To create this list, following code can be added in an initializer file.

    	FILES_TO_BE_OBSERVED = [ "app/views/layouts/_header.html.haml", "app/views/layouts/_logo.html.haml"]

	digests = []
	FILES_TO_BE_OBSERVED.each do |filename|
	  begin
	    digests << Digest::SHA256.file(filename).hexdigest
	  rescue
	    next
	  end
	end

	Rails.application.config.layout_digests = Digest::MD5.hexdigest(digests.join)

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Added some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request


text:
## E1130 (invalid-unary-operand-type)

### :x: Problematic code:

```python
foo = int
bar = - foo
```

### :heavy_check_mark: Correct code:

```python
foo = 1
bar = 10
bar -= foo
```

### Rationale:

Emitted when a unary operand is used on an object which does not support this
type of operation.

### Related resources:

- [Issue Tracker](https://github.com/PyCQA/pylint/issues?q=is%3Aissue+%22invalid-unary-operand-type%22+OR+%22E1130%22)

repository: aidenmitchell/pylint-errors-simplified

branch_name: refs/heads/main

repo_name: aidenmitchell/pylint-errors-simplified


text:
# Customer Last Presence

Save the last date of the customer's presence

### Manually

* Copy the module into ```<thelia_root>/local/modules/``` directory and be sure that the name of the module is CustomerLastPresence.
* Activate it in your thelia administration panel

### Composer

Add it in your main thelia composer.json file

```
composer require thelia/customer-last-presence-module:~0.1.0
```

## Usage

You just have to activate this module

repository: thelia-modules/CustomerLastPresence

repo_name: thelia-modules/CustomerLastPresence


text:
LACosmic Wrapper
================

Author: C. Gosmeyer, 2015

Last Updated: 29 Sep. 2015

About
-----

The script `run_lacosmic.py` wraps the IRAF task `LACosmic`, written by Pieter G. van Dokkum (http://www.astro.yale.edu/dokkum/lacosmic/). The wrapper is tweaked specifically for Hubble WFC3/UVIS FITS-format images of single white dwarf stars. If you use it for other targets/instruments, expect some experimentation!

It generates cosmic-ray cleaned FITS (`*clean.fits`) and the cosmic-ray mask FITS  (`*mask.fits`), and a diagnostic PNG file that displays on a single page the original image, the mask, and the cosmic-ray cleaned image.  It presently assumes the source is at the center (usually true in my white dwarf data) so it also displays ‘zoomed-in’ panels of the image center.  Using this PNG you can quickly diagnose whether `LACosmic` did a good job masking the cosmic-rays or did poorly enough that you need adjust parameters and run the script again.

There is, in fact, a Python version, which is faster than IRAF (yes, crazy, I know!).  But unfortunately it is not smart about how it handles the headers of multi-extension FITS. Besides that caveat, the output images of both versions look the same in all my tests.  On a distant future day I may fix the Python version and incorporate it into the wrapper.

Also included in this package are a script that iterates through different permutations of parameters so that you can with relative ease find the best for your WFC3/UVIS data. This script is named `run_lacosmic_tester.py`.

See the doc strings for further information on inputs and outputs for `run_lacosmic.py` and `run_lacosmic_tester.py`.

Install ‘lacosmic’ Package
---------------------------

1. git clone the ‘lacosmic’ package to desired location

2. To install the package, type

    > make setup

3. Finally add the PYTHONPATH to your .cshrc file with something like

    setenv PYTHONPATH ${PYTHONPATH}:/your/path/to/lacosmic/

If the installation went smoothly, you should have the following in
the `lacosmic` directory:
   `__init__.py`
   `count_masked_pixels.py`
   `init_setup_lacosmic.py`
   `lacos_im.cl`
   `lacosmic_tools.py`
   `run_lacosmic.py`
   `run_lacosmic_tester.py`
   `examples/`

Setup ‘lacosmic’ Package
--------------------------

Actually, as long as you ran the makefile, you shouldn't need to do anything more. The ‘make setup’ command runs `setup.py` and  `init_setup_lacosmic.py`, which does the following:

1. Creates ‘set_paths.py’, which just contains a dictionary of the absolute
   path to the directory where you put `lacosmic`.

2. Creates ‘img_scale.py’, which is written from a script available on the
   internet. I did not write it so I did not include it in the `lacosmic`
   package.

You may, after an initial run, need adjust for your different filters the
    ``LACosmic`` parameters in the `run_lacosmic.py` function
    `lacosmic_param_dictionary`. You can find these parameters by your own
    trial and error or by using an already-built tester, `run_lacosmic_tester.py`.

Run
---

Installation and setup should ideally need be done only once. Now you
are free to run the LACosmic wrapper on a whim. Hooray!

1. To run the bare `run_lacosmic.py`, cd into the directory containing the
   FLTs you want cosmic ray cleaned.  If your PYTHONPATH is correct, then
   you need just do

   > python run_lacosmic.py

2. Wait. For a WFC3/UVIS subarray, it takes 30-40 seconds each. You might speed it
   up by decreasing the ‘niter’ param. (By default it is set to the highest, 5).

3. An error-free run should have created the following directories:

   flt_cleans/
   flt_masks/
   png_masks_cleans/

   Containing, respectively, for each of your original FLTs,

   <rootname>.clean.fits
   <rootname>.mask.fits
   <rootname>.png

   The .clean.fits file is the cleaned FLT with which you want to do your
   analyses.

4. But first look through all the diagnostic plots in ‘png_masks_cleans’.
   If you see that LACosmic "blew up" (overflags and masks pixels) on an
   image, move its clean, mask, and diagnostic plot to a ‘flags’
   directory. Then adjust parameters and re-run. You can compare your new
   runs with the old you stored in ‘flags’.

   See the plots in `examples` for good and bad runs. All images of the
   (post-flashed!) white dwarf GRW+70 in the WFC3/UVIS filter F218W.

‘good.png’ — Close to what you want to see. Only cosmic rays masked. ‘sigclip’
    appropriately high to account for post-flash.
‘center_overflagged.png’ — The star’s center is masked. Try increasing ‘sigclip’
     and ‘objlim’.
‘sigclip_too_low.png’ — Background flagged everywhere! Try increasing ‘sigclip’
     to about 9.5.

   Sometimes LACosmic blows up for no reason, no matter how you adjust the
   parameters.   But if more than ~5% are getting over-
   flagged in the PSF or the background, you’ll probably need to toss out this
   run and start again with adjusted parameters. See Tips Section below.

Tips
-----

LACosmic’s four parameters are
    sigclip : Detection limit for cosmic rays.
    sigfrac : Detection limit for adjacent pixels.
    objlim : Max number of objects desired in image.
    niter : Number of iterations of cosmic ray finder.

In general, for the standard white dwarf GRW+70, I use
    sigclip = 5.5 (9.5 if post-flashed)
    sigfrac = .3 (I rarely vary this)
    objlim = 2 or 5
    niter = 5  (Also rarely vary)

Narrow band filters generally work better with ‘sigclip’ about 4.5.
Long pass filters generally work better with ’sigclip’ > 5.5.

If you notice LACosmic is over-flagging pixels

1.
   For post-flashed images, you may need bump the 'sigclip' up to near
   10.0. Non-post-flashed images are good around 'sigclip' 5.0, 5.5.

2. Increase ‘sigclip’ even if not post-flashed.

3. Increase ‘objlim’.

If you notice it is not flagging /enough/ pixels

1. Decrease ‘objlim’.

2. Decrease ‘sigclip’.

You’ll find that you’re more often over-flagging than under-flagging.

repository: cgosmeyer/lacosmic

repo_name: cgosmeyer/lacosmic


text:
# PREPHub Webpage

### This is the code for the website that we will use to connect people in disaster zones to emergency responders.

##Installation
1. Git clone or install this repo
2. Navigate into the main folder and run 'npm install'
3. Then run 'npm start'.

Website should be active on localhost:5555

repository: PREPHUB-Wifi/PREPHUBwifi-frontend

repo_name: PREPHUB-Wifi/PREPHUBwifi-frontend


text:
# About

## What is Sortier?

Sortier is a code sorting tool with support for:

- Javascript ES6+
- JSX
- Typescript
- Flow
- HTML
- JSON
- More being added!

It reads the source code and reorders the contents and ensures that all source code has the consistent ordering.

Well if two developers add the same property you will often get a merge conflict or worse no conflict at all! Since sortier sorts and orders the properties, it makes it easier for git to find merge issues along with visually to find duplicates when debugging issues.

Further, because the values are now sorted, it's faster for developers to read and get to the piece of information they intended to find
So what exactly gets sorted?

This varies language to language and as more features get added on, I'm sure more things will be sorted over time. Some examples of what will be sorted are:

- HTML
  - Attributes
- Javascript/Flow/Typescript
  - Properties within interfaces
  - Properties within objects
  - Properties within types
  - Import statements and specifiers
  - Export statements and specifiers
  - Case statements within a switch
  - Union definitions
  - Some binary expressions
- JSX
  - Properties within an element
- JSON files
  - Properties

repository: snowcoders/sortier

gha_language: TypeScript

repo_name: snowcoders/sortier


text:
# Relayed Messaging Authentication: Simple WebToken
## Requires
* Visual Studio 2010
## License
* Apache License, Version 2.0
## Technologies
* Microsoft Azure
* Service Bus
## Topics
* Service Bus
## IsPublished
* True
## ModifiedDate
* 2011-11-15 05:20:19
## Description

Introduction

This sample demonstrates how to use a simple web token credential to authenticate with the Service Bus.

The sample is similar to the Echo sample, with a few changes. Specifically, this sample adds a behavior in the ServiceHost (service) and ChannelFactory (client) applications.

Prerequisites

 If you haven't already done so, please read the release notes document that explains how to sign up for a Windows Azure account and how to configure your environment.

Service

Please refer to the Echo sample for information about how the service is defined and configured.

The service authenticates with the Service Bus using a SimpleWebToken
credential. It uses a helper method ComputeSimpleWebTokenString(string issuerName, string issuerSecret) to compute the string that is expected by TransportClientEndpointBehavior.

Client

Please refer to the Echo sample for information about how the client is defined and configured.

In this sample, both the client and the service use the same credential; therefore, no additional steps are required to grant the client access to listen or to send messages to the service through the Service Bus.  By default, a credential is granted
 with Listen, Send, and Manage privileges within its own Service Bus service namespace.  If a client is using a different credential than the service, a specific Access Control rule is needed for a client credential to gain Listen,
 Send or Manage privileges in the Service Bus service namespace for the service.  For more information about creating Access Control rules, please see the
ManagementService sample from the
Access Control Samples .

The client also authenticates with the Service Bus using a SimpleWebToken
credential. It uses the same ComputeSimpleWebTokenString(string issuerName, string issuerSecret) method to compute the web token string.

Building and Running the Sample

First, build the solution in Visual Studio or from the command line. To run the application, do the following:

From a command prompt, run the service (Service\bin\Debug\Service.exe).

When prompted, type the service namespace, the issuer name (e.g. "owner") and the issuer secret key with which you want the service to run. When authorized, the service indicates that it is listening at the configured address.

From another command prompt, run the client (Client\bin\Debug\Client.exe).

When prompted, type the issuer name (e.g. "owner"), the issuer secret key and the service namespace with which you want the client to connect. Enter a line of text to send to the service, then press Enter.

When finished, press Enter to exit the client and the service.

Expected Output – Service

Your Service Namespace: <service-namespace>

Your Issuer Name: <issuer-name>

Your Issuer Secret: <issuer-secret>

Service address: sb://<service-namespace>.servicebus.windows.net/SimpleWebTokenAuthenticationService/

Press [Enter] to exit

Echoing: a

Echoing: b

Echoing: c

Expected Output – Client

Your Service Namespace: <service-namespace>

Your Issuer Name: <issuer-name>

Your Issuer Secret: <issuer-secret>

Enter text to echo (or [Enter] to exit):

a

Server echoed: a

b

Server echoed: b

c

Server echoed: c

repository: techbuzzz/Samples-archive-msdn-products

path: /Windows Azure Product Team/Relayed-Messaging-Authentication-Simple-WebToken-13968/Readme.md

repo_name: techbuzzz/Samples-archive-msdn-products


text:
# Harmony JS-SDK Documentation

## [CLICK ME!!](https://harmony-js-sdk-doc.s3-us-west-1.amazonaws.com/index.html) to see the documentation

# metaDocumentation
## Summary
The following content demonstrate how to generate our documentation!

## Step 1: Generate Documentation

### Introduction of TypeDoc
[TypeDoc is used to generate HTML](https://typedoc.org/api/index.html)
> See [TypeDoc command line arguments](https://typedoc.org/guides/options/), to understand how to use them.
> Using `typedoc --help` to see them
>
> **For example:**
> `typedoc --name <Name>` to set the name of header
> `typedoc --theme <default | minimal | path/to/theme>` to set the theme of documation
> `typedoc --readme <path/to/readme | none>` path to readme file that should be displayed on the index page.
> `typedoc --ignoreCompilerErrors` Should TypeDoc generate documentation pages even after the compiler has returned errors?

### Install TypeDoc
Local installation (prefered)
```
$ npm install typedoc --save-dev
```

Golbal CLI installation
```
$ npm install --global typedoc
```

### Install Environemnt
```
$ npm install
```

### Generate HTML
```
$ cd docs
$ npx typedoc --out ./build ../packages/ --ignoreCompilerErrors --theme default --name Harmony_SDK_Doc --readme ../README.md
```

### See the generated doc at local

>open the `index.html` under the path `sdk/docs/build/index.html`

## Step 2: Deploy on AWS (harmony core only!)

### Create an AWS s3 bucket
Actually, there are just two points needed!
1. Create an AWS S3 bucket, **UNCHECK** `Block all public access`
2. Put the files into the bucket, and set the **public permission** to `Grant public read access to this object(s)`

### Method 1: Use Console

[Here](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html) is the documentation of AWS, just follow it!

>Don't forget the two points mentioned above

### Method 2: Use AWS CLI

Reference: [AWS CLI documentation](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html)

If you have never used AWS CLI, you need follow these to set up your environment first!
- [Install the AWS CLI version 1](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv1.html)
- [Configuring the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)

After that, use AWS CLI to do following

1. Create a Bucket
```
aws s3 mb s3://harmony-js-sdk-doc
```

2. List all buckets you have created
```
aws s3 ls
```

3. Uploade the files into bucket
```
$ cd build
$ aws s3 cp ./ s3://your-bucket-name --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --recursive
```
Here is some explanations
> **./account**
> the path of folder which we want to upload
>
> **s3://harmony-js-sdk-doc**
> the bucket name on AWS S3
>
> **--grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers**
> Grant read access to all user
>
> **--recursive**
> Command is performed on all files or objects under the specified directory or prefix.

4. Open the folder in S3 bucket and find `index.html`, get the
`Object URL`, then make it public!

repository: harmony-one/sdk

repo_name: harmony-one/sdk


text:
*   Add `Rugged::Repository#cherrypick`.

    *Arthur Schreiber*

*   Add `Rugged::Repository#descendant_of?`

    *Jake Douglas*

*   `Rugged::Index#read_tree` now actually checks that the given object is a
    `Rugged::Tree` instance.

    Fixes #401.

    *Andy Delcambre*

*   Add `Rugged::Repository#expand_oids`.

    This allows expanding a list of shortened SHA1 strings, optionally restricting
    the expansion to a specific object type.

    *Vicent Martí*

*   Add `Rugged::Remote#check_connection`.

    This is useful if one needs to check if it is possible to fetch/push
    from/to the remote.

    Basically, it is analogue to `git fetch --dry-run` and `git push --dry-run`.

    *Dmitry Medvinsky*

*   Remove defunct `Rugged::Diff::Line#hunk` and `Rugged::Diff::Line#owner`.

    Fixes #390.

    *Arthur Schreiber*

*   Remove `Rugged::Diff#tree` and change `Rugged::Diff#owner` to return the
    repository that the `Rugged::Diff` object belongs to.

    We need to keep a reference from the `Rugged::Diff` to the repository to
    ensure that the underlying libgit2 data does not get freed accidentally.

    Fixes #389.

    *Arthur Schreiber*

*   Add `#additions` and `#deletions` to `Rugged::Patch`.

    *Mindaugas Mozūras*

repository: jakobjanot/rugged

repo_name: jakobjanot/rugged


text:
---
layout:     post
title:      Logging with Spring Boot - Logback, SLF4j and LOG4j2
date:       2017-12-12 12:31:19
summary:    Learn how to log effectively with Spring Boot. We will look at Spring Boot Starter for Logging and Spring Boot starter for log4j2.
categories:  SpringBoot
permalink : /logging-with-spring-boot-logback-slf4j-and-log4j
---

Learn how to log effectively with Spring Boot. We will look at Spring Boot Starter for Logging. We will look at the defaults in Spring Boot for Logging - Logback and SLF4J. We will also looking at the Spring Boot starter for log4j2.

## Free Courses - Learn in 10 Steps

- [FREE 5 DAY CHALLENGE - Learn Spring and Spring Boot](https://links.in28minutes.com/SBT-Page-Top-LearningChallenge-SpringBoot){:target="_blank"}
- [Learn Spring Boot in 10 Steps](https://links.in28minutes.com/in28minutes-10steps-springboot){:target="_blank"}
- [Learn Docker in 10 Steps](https://links.in28minutes.com/in28minutes-10steps-docker){:target="_blank"}
- [Learn Kubernetes in 10 Steps](https://links.in28minutes.com/in28minutes-10steps-k8s){:target="_blank"}
- [Learn AWS in 10 Steps](https://links.in28minutes.com/in28minutes-10steps-aws-beanstalk){:target="_blank"}

## Default Logging Framework with Spring Boot

Spring boot provides a default starter for logging - `spring-boot-starter-logging`. It is included by default in `spring-boot-starter` which is included in all other starters.

> This means whenever you use any starters like `spring-boot-starter-web` or `spring-boot-starter-data-jpa`, you get logging for free!

Let's look at what is present in the Logging Starter.
```
<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
  <version>1.2.3</version>
  <scope>compile</scope>
</dependency>
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-to-slf4j</artifactId>
  <version>2.9.1</version>
  <scope>compile</scope>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>jul-to-slf4j</artifactId>
  <version>1.7.25</version>
  <scope>compile</scope>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>log4j-over-slf4j</artifactId>
  <version>1.7.25</version>
  <scope>compile</scope>
</dependency>

```

As you can see the default logging framework is Logback with SLF4j as implementation.

By default, all logging goes to console.

### Configure Logging Levels

In application.properties, we can use the "logging.level" prefix to set logging levels.

```
logging.level.some.package.path=DEBUG
logging.level.some.other.package.path=ERROR
```

Root logging level can be configured as shown below
```
logging.level.root=WARN
```
### Configuring a Log File

You can configure a log file by using logging.file property in application.properties. The logging here would be in addition to the logging in console.

```
logging.file=\path_to\logfile.log
```

### Custom configuration using logback.xml
Spring Boot will pick up all custom configuration using logback.xml as long as it is in the application class path.

### Example code

```
LOGGER.trace("Your log - {}", value);
LOGGER.debug("debug - {}", value);
LOGGER.info("info- {}", value);
LOGGER.warn("warn - {}", value);
LOGGER.error("error - {}", value);
```

## Using Log4j2 for logging with Spring Boot

We would need to exclude the dependency on `spring-boot-starter-logging` and add a dependency on `spring-boot-starter-log4j2`.

```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>
```

Let's take a quick look at the dependencies in log4j2 starter.

```
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-slf4j-impl</artifactId>
  <version>2.9.1</version>
  <scope>compile</scope>
</dependency>
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-api</artifactId>
  <version>2.9.1</version>
  <scope>compile</scope>
</dependency>
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.9.1</version>
  <scope>compile</scope>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>jul-to-slf4j</artifactId>
  <version>1.7.25</version>
  <scope>compile</scope>
</dependency>
```

### Custom configuration using log4j2.xml
Spring Boot will pick up all custom configuration using log4j2.xml as long as it is in the application class path.

You also have the option of using YAML or JSON with Log4j2.
- YAML - log4j2.yaml or log4j2.yml
- JSON - log4j2.json or log4j2.jsn

However, you would need to include the appropriate dependency to handle yaml(jackson-dataformat-yaml) or json(jackson-databind).


text:
BaseController HTTP
=====================

A simple HTTP server wrapper used by BaseController

License
---------

BaseController is released on the BSD 2-clause license. The product is not suitable for consumer use.

You can get the license in "license.txt" file available in this repository.

repository: AgoraTech/node-basecontroller-http

repo_name: AgoraTech/node-basecontroller-http


text:
# lnch - X window manager and launcher for bfst terminal

    The source is based on tinywm and dwm.

Installation:

    make

    sudo cp lnch /bin

    lnch & disown

Features:

    -   Mouse is used to move or resize a client window

    -   Hotkey to launch a new terminal

    -   Add a border around client window

    -   Hotkey to position a client window

    -   Hotkey to switch focus between clients

    -   Filtering of X errors

    -   Handle window manager events to fix Firefox

Hotkeys:

    [ q ] [ w ] [ e ]
      |     |     |
      |     |     +---------- Position window in right quadrants
      |     +---------------- Position window in next monitor
      +---------------------- Position window in left quadrants

    [ a ] [ s ] [ d ]
      |     |     |
      |     |     +---------- Focus window in right monitor
      |     +---------------- Focus next window in current monitor
      +---------------------- Focus window in left monitor

    [ z ] [ x ] [ c ]
      |     |     |
      |     |     +---------- Position window to pointer quadrant
      |     +---------------- Spawn new terminal
      +---------------------- Resize current window to 80x25

Not implemented yet:

    -   properties

    -   hints

    -   fullscreen atom

    -   Cursor shapes

    -   Kill of client

    -   Clean exit

    -   Colors for focus

    -   scan of existing clients


text:
# Compath

Compath generates a guide of directory structure in the project.

## Installation

    $ gem install compath

## Usage

    $ compath

It creates or updates `.compath.yml`.

```yaml
---
bin/:
exe/:
lib/**/*:
spec/:

...
```

The top level object of yaml is mapping. Each key of objects means path, and each value of objects means description.
Additional convention of configuration is that the path (key) which is end with `**/*` or `*` tells Compath to stop scanning of children of the directory.

Initial generated config has keys of only top level paths.
With the following changes of `.compath.yml`, `compath` will also scan files of `lib/` directory.

```yaml
---
bin/:
exe/:
lib/:   # Removed `**/*`
spec/:

...
```

It will be updated to the following content by running `compath`.

```yaml
---
bin/:
exe/:
lib/:
lib/compath/:
spec/:

...
```

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/meganemura/compath.

## License

The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

repository: meganemura/compath

gha_language: Ruby

repo_name: meganemura/compath


text:
# Observator

[![Version](https://img.shields.io/cocoapods/v/Observator.svg?style=flat)](https://cocoapods.org/pods/Observator)
[![Platform](https://img.shields.io/cocoapods/p/Observator.svg?style=flat)](https://cocoapods.org/pods/Observator)

Observator is a simple global data sharing mechanism for Swift. A single class dependency that helps you to create generic singleton wrappers around a specific type, with built-in notitifcations. This setup allows you to read and write data in different components of your app asynchronously.

## Example

Basic usage:

```swift
// Define your custom observator subclass:
class CityName: Observator<String> {}

// Listen for data modification:
CityName.shared.subscribe(self, selector: #selector(cityNameChanged))

// Update the stored value:
CityName.shared.data = "Helsinki"
```

Advanced features:

```swift
// You can override some methods in the observator subclass
// to automatically transform the stored data
class CityName: Observator<String> {
    override func readTransform(_ input: String) -> String {
        return "\(input) Finland"
    }
}

// Which should return on access: "Helsinki Finland"
CityName.shared.data = "Helsinki"

// It also supports subclasses of a customized observator
class DepartureCity: CityName {}
class DestinationCity: CityName {}

// Should return on access: "Tampere Finland"
DepartureCity.shared.data = "Tampere"
// Should return on access: "Oulu Finland"
DestinationCity.shared.data = "Oulu"

// Observator can be also used to store the data fetching and
// processing logic of custom types.
// You can create a generic subclass with the shared data management
// features and do the fetching in specialized subclasses.
class APIObservator<T>: Observator<T> {
    let session = URLSession(configuration: .default)
    let baseURL = URL(string: "...")!
}
class CustomerList: APIObservator<[Customer]> {
    func fetchCustomers() {
        session.dataTask(with: baseURL) { (data, _, _) in
            if let data = data {
                self.data = try? JSONDecoder().decode([Customer].self, from: data)
            }
        }
    }
}
```

## Installation

Manual: Just copy `Observator.swift` into your project.

Cocoapods: Observator is available through [CocoaPods](https://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'Observator'
```

repository: endanke/Observator

repo_name: endanke/Observator


text:
bootstrap-datepicker
============

Meteor packaging of bootstrap-datepicker 1.3.0

This package is MIT Licensed. Do whatever you like with it but any responsibility for doing so is your own.

All rights to bootstrap-datepicker are with the original author.

See: http://eternicode.github.io/bootstrap-datepicker/

Example
============
in handlebars template

    Template.mytemplate.rendered = function() {
      this.$('.datepicker').datepicker();
    }

in html

     <input type="text" class="datepicker">

repository: deepwell/meteor-bootstrap-datepicker

gha_language: CSS

repo_name: deepwell/meteor-bootstrap-datepicker


text:
---
layout: default
---

# 1994-07-06 - Re: Windows for Workgroups 3.11

## Header Data

From<EMAIL_ADDRESS>(Timothy C. May)

To<EMAIL_ADDRESS>(Andrzej Bursztynski)

Message Hash: 396e73744faf0c833758d7f8534947691a1a6ca9ba30452b2c54f17048f45623

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1994-07-06 17:16:09 UTC

Raw Date: Wed, 6 Jul 94 10:16:09 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Timothy C. May)
Date: Wed, 6 Jul 94 10:16:09 PDT
To<EMAIL_ADDRESS>(Andrzej Bursztynski)
Subject: Re: Windows for Workgroups 3.11
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Andrzej Bursztynski wrote:

> Just wonder if anyone had a closer look at the "Advanced security" option
> built in the Microsoft Windows for Workgroups 3.11. You can use a soft
> of a public/private key when sending a mail via fax (Class 1) driver
> Micrsoft Fax at Work. The key seems to be quite short and I wonder if that's
> a real secure solution comparing eg. to PGP?
>

Like the guy from Microsoft, I don't know specifically what's in
Microsoft Windows for Workgroups 3.11.

But something to remember is that RSA Data Security Inc. has been
concentrating on signing deals with Microsoft, Apple, Lotus, IBM,
WordPerfect, Oracle, etc., to include strong crypto in their products.

I don't happen to know if Windows for Warehouses (er, Workgroups)
contains RSA, but it wouldn't surprise me at all. Anyone know?

That we are comparing commercial crypto to "a real secure solution"
like PGP, as in the question Andrzej asked, is an ironic twist.

--Tim May

--
..........................................................................
Timothy C. May         | Crypto Anarchy: encryption, digital money,
<EMAIL_ADDRESS>     | anonymous networks, digital pseudonyms, zero
408-688-5409           | knowledge, reputations, information markets,
W.A.S.T.E.: Aptos, CA  | black markets, collapse of governments.
Higher Power: 2^859433 | Public Key: PGP and MailSafe available.
"National borders are just speed bumps on the information superhighway."

{% endraw %}
```

## Thread

+ Return to [July 1994](/archive/1994/07)

+ Return to "[Adam Shostack <adam@bwh.harvard.edu>](/authors/adam_shostack_adam_at_bwh_harvard_edu_)"
+ Return to "[Derek Atkins <warlord@MIT.EDU>](/authors/derek_atkins_warlord_at_mit_edu_)"
+ Return to<EMAIL_ADDRESS>(Andrzej Bursztynski)](/authors/psee_at_sam_nask_com_pl_andrzej_bursztynski_)"
+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_netcom_com_timothy_c_may_)"

+ 1994-07-06 (Wed, 6 Jul 94 02:49:33 PDT) - [Windows for Workgroups 3.11](/archive/1994/07/05f4b910386856448aa59fa65b24474cf119ec9c8f28cc7e1fe67fb0df49febd) -<EMAIL_ADDRESS>(Andrzej Bursztynski)_
  + 1994-07-06 (Wed, 6 Jul 94 04:20:34 PDT) - [Re: Windows for Workgroups 3.11](/archive/1994/07/2b07497a9f4eec99167fccdbef860917510864fc2a24836309fd75d4b901670c) - _Derek Atkins<EMAIL_ADDRESS>  + 1994-07-06 (Wed, 6 Jul 94 10:16:09 PDT) - Re: Windows for Workgroups 3.11 -<EMAIL_ADDRESS>(Timothy C. May)_
    + 1994-07-06 (Wed, 6 Jul 94 11:34:40 PDT) - [Re: Windows for Workgroups 3.11](/archive/1994/07/52499954a27dac90d916e683738ed58ceb8f55a5e52aa235489d85cefd856ee0) - _Adam Shostack<EMAIL_ADDRESS>


text:
## RobotlegsUpDownPlugin

Still in design stages.

Looking to have two actions with default keys assigned.

Using the Shift key as well, users can limit the resultant 'Jump-To' to only those items marked.

**[!]** marks items implemented in this checkin

## Limiting Jump To

If the Jump-To list has no entries, I want to show some kind of non-intrusive error.

If the Jump-To list finds 1 item, we jump to that.

If the Jump-To list finds > 1 item, we show a list of jump items.

## Actions and Contexts

### UP

Up is mapped to **Ctrl-Alt-Up** and means "Move up in the tier heirarchy"

It has several "contexts" as defined in org.robotlegs.plugins.upDown.chain

#### Mediator Context

1. Find View (Shift)
    1. Check for __view__ property **[!]**
    1. Use simple regex of class, (WidgetMediator looks for WidgetView and Widget, in that order)
1. Find Injected Views
    1. List any Display Tree Object (Sprite?) marked by [Inject] in this mediator

#### Event context

Finds EventDispatch references in classes and lists those

1. Find EventDispatcher In Mediators
1. Find EventDispatcher In Commands
1. Find EventDispatcher In Actors
1. Find EventDispatcher elsewhere

#### Command Context

1. Find Event
    1. check for __event__ property
1. Find Injected Events
    1. List any events marked with [Inject] in this command

#### Actor Context

1. Find actor reference in Command
1. Find actor reference in Mediator
1. Find actor reference in Views

### DOWN

#### View Context

1. Find Mediator (SHIFT)
    1. Find mediators that have a view property matching this class **[!]**
1. Find DispatchEvent
    1. Find any eventDispatchers and list the event references - this may not be helpful at all in views.
1. Find Actor
	1. Find any Actor References in the View

#### Mediator Context

1. Find DispatchEvent
    1. Find any eventDispatchers and list the event references.
1. Find Actor
	1. Find any Actor References in the Mediator

#### Event Context

1. Find Command (SHIFT)
    1. Find commands that have this event reference in the __event__ property
1. Find EventListener
    1. Find anything that listens for this event

#### Command Context

1. Find Injected Actors (SHIFT)
    1. Find any Actor injected into this command
1. Find DispatchEvent
    1. Find any eventDispatchers and list the event references.

#### Actor Context
1. Find DispatchEvent
    1. Find any eventDispatchers and list the event references.

### Identifying Contexts

Context does not refer to the RL Context class. In fact this plugin does nothing with this class as
it would be way too difficult to track down complex mappings. Instead the plugin uses conventions to identify contexts.

* **View** extends sprite?
* **Mediator** extends/implements ...
* **Event** extends flash.event
* **Command** extends/implements ...
* **Actor** extends/implements ...

## TODO

1. Implement Context Identifiers
1. Implement Strategies for each context
1. Create sample code that tests all of the context behaviours

repository: squeedee/RobotlegsUpDownPlugin

extension: markdown

repo_name: squeedee/RobotlegsUpDownPlugin


text:
## Foiled Lay Abouts

>Progress is made by lazy men looking for easier ways to do things
>
>__
>
>Robert A. Heinlein

---
= data-y="-500" data-rotate-x="45"
### the Lazy

Some people like to work. Some think this is a
horrible idea. These may look at what they are
doing and decide they never want to do it
again. All thats left is to figure out how.

---
= data-x="1000" data-y="900"
### the Wheel

Given the choice between carrying something and
having something else carry somthing somebody
decided it wasn't their job.

![wheel-india](scripting-Stone_Wheel_Juggernaut_The_Sun_Temple_Konarak_India.jpg)
![wheel-postelwait](scripting-stone-wheel-carolyn-postelwait.jpg)
![wheel-stone](scripting-2564767466_d481cfaed9.jpg)

---
= data-x="2500" data-y="0" data-scale="2"
### Language

Given the choice between pantomime and forcing
other people to remember sounds. somebody pounded
sound and symbols into somebody elses head.

![language-def-in-dictionary](./langauge.jpg)
![language-microphone](./Microphones.jpg)
![language-faded-word-ovelay](./language-of-the-future.jpg)

---
= data-x="2362" data-y="-475" data-scale="0.2"
### And so on

Somebody decided on a

- transistor
- a circuit
- assembly
- programming and scripting

---
= data-x="2312" data-y="-490" data-scale="0.05"

transistors hold a single charge or binary digit

---
= data-x="2312" data-y="-477" data-scale="0.05"
circuits have collections of connected transistors

---
= data-x="2312" data-y="-464" data-scale="0.05"
assembly translates to binary

---
= data-x="2312" data-y="-452" data-scale="0.05"
programming and scripting translates to assembly

---
= data-x="2000" data-y="-400" data-scale="0.1"
### Still working

So somebody decided is wasn't there job and made
something to do it for them. Making programs that
merely repeat these things over and over for
people who would rather have it done elsewhere. So
to do less ... they do more now ... and later they
do it again.

--

-Program(s/ing) (are/is) for lazy people.

--

-Scripting is for even lazier people.

---
= data-x="1250" data-y="-800" data-scale="1"
### Scripting

The difference between scripting and programming
is contested and an actual definition is hard to
come by but generally:

- scripting is easier than coding primarily because it is not compiled.
- compiling is usually a single command or button ... which adds up (^^)
- there are areas where scripting is done regularly and I count roughly 3 of these

---
= data-x="348" data-y="-1000" data-z="-557" data-rotate-y="-45"
### the Server

- servers are just computers generally that do very specific tasks
    - web pages, applications, deliver files etc.
- power users are generally in charge of these computers and find they do many things over and over much like a cook
- to some extent these steps can be written like small recipies that make themselves
- some times these recipies aren't so small ... usually they grow like weeds

---
= data-x="148" data-y="-1200" data-z="-1617" data-rotate-y="-90"
### the Program

programs will some times expose certain levels of
thier internal functions so they can be used to
automate tasks.

- small command line programs tend to have everything exposed but thats all they do
- excell/office exposes some but not all of its fuctionality in a very kludgy way and mostly internally
- 3d rendering programs take such commands to preform specific tasks
- some text editors expose every functionality to the user

---
= data-x="705" data-y="-1300" data-z="-2419" data-rotate-y="-135"
### Every Where

Scripting languages attempt to expose the entire
computer in an 'easy' way to the user. As more
computers invade our spaces these will become more
and more accessible to scripting.

---
= data-x="1665" data-y="-1400" data-z="-2619" data-rotate-y="-180"
### Text Editors

Among programmers there is fierce debate about the
one true text bashing device. I suspect most
merely use the one they like and expect others to
do the same. However, to established text editors
there are intrinsic philosophies. Most have been
watered down over time. We will be looking at
extensible text editors.

---
= data-x="2567" data-y="-1500" data-z="-2062" data-rotate-y="-225"
### vi

vi is according to wikipedia the shortest
unambigous abbreviation for visual in ex an even
more ancient text editor. vi has descended through
many incarnations to be most popular in vim.

- philosopy
- key power
- modes
- scripting
- macros

http://www.vim.org/

---
= data-x="2567" data-y="-1500" data-z="-2062" data-rotate-y="-225" data-scale=".5"
### vi

- originally derived its philosopy from being small and fast and powerful ala unix
- derives its power from shortest keystrokes
- in vi there are several modes that make all the keys do diffent things
- it uses a scripting language based on c syntax, c is an old programing language
- very accessible macros as well which limit the need for scripting

---
= data-x="2717" data-y="-1600" data-z="-952" data-rotate-y="-270"
### emacs

emacs borrows letters from Editable MACroS and was
written to edit code directly as its inspiration
did. It has also had several incarnations and is
most poplar in its gnu emacs form.

- philosophy
- scripting
- modes
- chords
- macros

http://www.gnu.org/software/emacs/

---
= data-x="2717" data-y="-1600" data-z="-952" data-rotate-y="-270" data-scale=".5"
### emacs

- it derives its philosopy from being powerful and exposing all its self-documenting features ala ai
- it uses what is traditionally called the kitchen sink methodology and preforms a raft of tasks besides text editing
- it uses a form of lisp, a very old and powerful programming language
- has another form of modes based of file type
- extensive use of 'chords' to preform the same functions as vi
- also has very accessible macros

---
= data-x="2160" data-y="-1600" data-z="-150" data-rotate-y="-315"
### others

python

- codeEditor(ide) http://wiki.wxpython.org/index.cgi/PythonCardEditor
- editra http://www.editra.org/
- emacs-pymacs http://flownet.com/gat/jpl-lisp.html
- vim http://www.tummy.com/Community/Presentations/

ruby

- redcar(ide) http://redcareditor.com/

---
= data-x="1250" data-y="-1700" data-z="0" data-rotate-y="-360" data-scale='1'
### Languages

- python
- ruby
- perl
- javascript
- lisp

---
= data-x="1015" data-y="-1860" data-z="-150" data-rotate-y="-360" data-scale='.3'
### python
> Python's goal is regularity and readability, not succinctness.
>
> Paul Prescod

- mandated white space formatting
- very intuitive
- attaches to everything

---
= data-x="990" data-y="-1790" data-z="-150" data-rotate-y="-360" data-scale='.27'
### ruby
> we need to focus on humans, on how humans care about doing programming
>
> Matz

- very intuitive object system based on small talk
- easy to program
- in vogue for web programming although does much more

---
= data-x="985" data-y="-1715" data-z="-150" data-rotate-y="-360" data-scale='.27'
### perl
- very powerful regular expression
- lives and breathes text
- cryptic syntax

---
= data-x="1045" data-y="-1660" data-z="-150" data-rotate-y="-360" data-scale='.325'
### javascript

- lingua franca of the web
- client and server side now
- html5 doom

---
= data-x="985" data-y="-1601" data-z="-150" data-rotate-y="-360" data-scale='.27'
### lisp

- simple but different syntax
- code allows itself to be rewritten
- read eval print loop

---
= data-x="348" data-y="-1800" data-z="-557" data-rotate-y="-405"
### what am i

i was written in a modified form of markdown and
then converted with ruby to html and javascript.


text:
name: Angular_Development_with_TypeScript_Second_Edition
isbn:<PHONE_NUMBER>
isbn13:<PHONE_NUMBER>348
title: [Angular Development with TypeScript, Second Edition](http://a.co/d/esS707t)
author: Yakov Fain
author: Anton Moiseev
publisher: Manning
year: 2018
acquired: 2018-11-30

A book on [Angular](https://angular.io/).  TypeScript should be interesting
too.


text:
# apost

Interval Arithmetic library with aposteriori error computation.

### Installation

Install dependencies [FLINT](http://www.flintlib.org/) C library with [Arb](http://fredrikj.net/arb/) module. See instructions [here](http://fredrikj.net/arb/setup.html#installation-as-part-of-flint). FLINT also depends on the MPIR/GMP and MPFR libraries.

You also should have C++11 compiler.

To build and install apost library use:
```sh
$ git clone https://github.com/VladimirGl/apost
$ cd apost
$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install
```

### Examples

There are several examples in example file. After compilation them can be found in build/bin folder.

### Library usage example

Then you can build your own programs. Example program:

```c++
#include "apost.h"

#include <iostream>

using namespace interval;
using namespace apost;

using IntervalVar = ProxyInterval<ArbInterval>;
using IntervalResult = ProxyIntervalResult;

int main() {
    IntervalVar x0(ArbInterval(1, 0.01));
    IntervalVar x1(ArbInterval(2, 0.03));
    controller.init();

    IntervalVar x2 = x0 * x0;
    IntervalVar x3 = x1 * x0;
    IntervalVar x4 = x3 / x2;

    IntervalResult x5;
    x5 = x4;

    std::cout << x5 << std::endl;
}
```
Build and run:
```sh
$ g++ main.cpp -std=c++11 -lapost -lflint
$ ./a.out
```

repository: VladimirGl/apost

repo_name: VladimirGl/apost


text:
# dynv6-rs

A CLI to interact with the [dynv6](https://dynv6.com) API.

This repository also contains a library you can use to interact with the dynv6 api within your application. It is based
on [ureq](https://lib.rs/ureq), so no async.

Bonus : a tool to fulfill the let's encrypt dns challenge (using `exec` from lego). I use this with my traefik instance
to provision let's encrypt certificate automatically.

## Building

```shell
$ cargo build --release
```

## Usage

```shell
$ dynv6 help
```


text:
[![](https://img.shields.io/badge/Wahoo-Package-00b0ff.svg?style=flat-square)][Wahoo]
![](https://img.shields.io/badge/License-MIT-707070.svg?style=flat-square)

# :cherries: [_fasd_](https://github.com/clvv/fasd)
> Fasd (pronounced similar to "fast") is a command-line productivity booster. Fasd offers quick access to files and directories for POSIX shells. It is inspired by tools like autojump, z and v.

Fasd Package for [Wahoo][Wahoo] / [fish](fishshell.com).

## Install
> _Note_: You need to have `fasd` installed prior to loading Wahoo.

On OSX `homebrew` has a keg for `fasd`:

```fish
brew install fasd
```

Finally, add the package to Wahoo:

```fish
wa g fasd
```

> For compatibility with `autojump` and for the sake of simplicity the actual function is bound to `j`.
> Please keep in mind that `fasd` will only autojump into directories you have `cd`'ed to before.

# License

[MIT](http://opensource.org/licenses/MIT) © [Tom Hensel][Author]

[Author]: https://github.com/gretel
[Wahoo]: https://github.com/bucaran/wahoo

repository: bjartek/pkg-fasd

repo_name: bjartek/pkg-fasd


text:
# Fragment Audio Server launcher

A [wxWidgets](https://www.wxwidgets.org/) launcher for [Fragment Audio Server](https://github.com/grz0zrg/fas) built for the [Fragment Synthesizer](https://github.com/grz0zrg/fsynth), a [web-based Collaborative Spectral Synthesizer](https://www.fsynth.com)

This program should compile on most platforms.

The [Fragment Audio Server](https://github.com/grz0zrg/fas) executable should be put alongside the launcher application.

## Description

This program is a simple native launcher which provide an easy to use interface to start the Fragment Audio Server, the launcher also provide a convenient way to configure the audio server for individual sessions and provide a direct way to launch the web. application pre-linked with the native audio server by passing **?fas=1** as a web. argument.

## Package

A .deb package is available in the **package** folder along with the [Debreate](https://antumdeluge.github.io/debreate-web/) file project used to build the package for the amd64 platform, this package bundle the audio server and the launcher, this is the solution distributed on the Fragment homepage.

## Build

This program was made with the [CodeLite IDE](https://codelite.org/) to ease the process of creating the wxWidgets UI with [wxCrafter](https://wxcrafter.codelite.org/).

Requirements :

 * [PortAudio](http://www.portaudio.com/download.html)
 * [wxWidgets](https://www.wxwidgets.org/)
 * [tiny-process-library](https://github.com/eidheim/tiny-process-library)

This also make use of [SQLite](https://www.sqlite.org/) (this is bundled)

### Linux

This is easily compiled under GNU/Linux systems with the "Debug" or "Release" CodeLite target.

### Cross-compiling for Windows under Linux

The launcher was successfully built for Windows systems under Linux (Ubuntu) by using the **mingw-w64** package, **x86_64-w64-mingw32** was tested successfully, the following guide will be written for this target but there should be minor changes needed for other targets.

A CodeLite target named "Release_WinCross" contain the configuration needed to build the application for Windows via cross-compilation.

There may be some issues building the needed libraries so here are some hints

- CodeLite may not detect automatically the compiler environment so you must add it manually via the build settings (for example, mine was located at /usr/x86_64-w64-mingw32)

#### Cross-compiling wxWidgets

Download the library somewhere (a folder named **cross** for example)

##### Configure step

`./configure --host=x86_64-w64-mingw32 --build=x86_64-linux CFLAGS='-I/usr/share/mingw-w64/include/ -I/home/julien/crosscompile/wxWidgets/lib/wx/include/x86_64-w64-mingw32-msw-unicode-3.1 -I/home/julien/crosscompile/wxWidgets/include -D_FILE_OFFSET_BITS=64 -DWXUSINGDLL -D__WXMSW__'`

Then `make` & `sudo make install`

#### Cross-compiling PortAudio (with wmme/dx/asio support)

Download the library somewhere (a folder named **cross** for example)

Download the ASIO SDK (you will need to modify the ASIO SDK path appearing in the configure step below)

##### Configure step

`./configure --host=x86_64-w64-mingw32 --build=x86_64-linux CFLAGS='-I/usr/share/mingw-w64/include/ -D_FILE_OFFSET_BITS=64 -DWXUSINGDLL -D__WXMSW__' --with-asiodir=/home/julien/crosscompile/ASIOSDK2.3/ --with-winapi=wmme,directx,asio`

Then `make` & `sudo make install`

#### Cross-compiling tiny-process-library

Download the library somewhere (a folder named **cross** for example)

##### Compilation step

`/usr/bin/x86_64-w64-mingw32-g++ -O2 -std=c++11 -D_WIN32 -D_WINCROSS_w64 -I/usr/x86_64-w64-mingw32/include -c process.cpp`

`/usr/bin/x86_64-w64-mingw32-g++ -O2 -std=c++11 -D_WIN32 -D_WINCROSS_w64 -I/usr/x86_64-w64-mingw32/include -c process_win.cpp`

##### Library step

`/usr/bin/x86_64-w64-mingw32-ar crf libtiny-process-library.a process_win.o`

##### Incomplete support for < thread > and < mutex > and UNICODE problems

Some issues may arise when compiling tiny-process-library due to missing C++11 thread and mutex library and unicode support, this can be solved by using [mingw-std-threads](https://github.com/meganz/mingw-std-threads) headers and by undefining unicode.

In **process.hpp** replace #include <mutex> and #include <thread> by

`#ifdef _WINCROSS_w64`
`#include <windows.h>`
`#include "mingw.mutex.h"`
`#include "mingw.thread.h"`
`#undef UNICODE`
`#else`
`#include <mutex>`
`#include <thread>`
`#endif`

## Screenshots

[![FAS launcher](https://www.fsynth.com/data/fas_launcher.png)](https://github.com/grz0zrg/fas_launcher)


text:
django-geocodemonkey
====================

Geocodemonkey is a package that implements a thin layer ontop of the wonderful Geopy geocoders.

The goal is to adapt these tools for easily integrating common points in the Django framework.  This includes an integration with the Django cache layer to cache common queries, and tools for integrating geocoded data with Django models and Haystack search indexes.

Geocodemonkey is also designed for simple configuration and the ability to easily leverage multiple geocoding APIs simultaneously.

repository: loftylabs/django-geocodemonkey

repo_name: loftylabs/django-geocodemonkey


text:
# Pure Zip

A pure rust implementation for reading ZIP archives. This is a work in progress
for now. I needed a Zip library in Rust and the most active library on crates
right now isn't maintained and isn't compatible with the archives I've been
receiving.

Initial goals are to being able to reliably read all the Zip files I have. Once
it seems to be stable and well covered for reading I'll add writing of archives
as well, most of the primitives will already be there for it.

I'm currently not taking contributions and don't recommend either using this
for a reference or in your codebase until I have something stabilized.


text:
Here's a [reference link][1].

[1]: http://parsedown.org

Here's [one] [2] with an alternative syntax.

[2] :http://parsedown.org

Here's [one][3] on the next line.
[3]: http://parsedown.org

Here's [one][4] on 2 lines.

[4]:
http://parsedown.org

Here's [one][5] with a different URL.

[5]: http://parsedown.org/tests/

Here's [one][the website] with a semantic name.

[the website]: http://parsedown.org

Here's [one][404] with no definition.

Here's an image: ![Markdown Logo][image]

[image]: https://raw.github.com/dcurtis/markdown-mark/master/png/32x20-solid.png

repository: coolsou/parsedown

repo_name: coolsou/parsedown


text:
# Obtain SUGG dataset
    sh download.sh

# Reference
The dataset is obtained from **[Identifying Helpful Sentences in Product Reviews (NAACL 2021)](https://aclanthology.org/2021.naacl-main.55.pdf)**.

repository: rit-git/tagging

gha_language: Python

repo_name: rit-git/tagging