text:
# SPQA
## Scala/Play Quality Assurance
Library of utilities support unit testing, supporting:
* Scala
* Play Framework
* Akka
* RabbitMq
* Databases

These utilities are intended to simplify the writing of unit tests for system using the above tech stack.

## Getting Started
### Prerequisites
SBT Build tools
Scala compiler
### Installation
Add the following to your SBT build file:
```
resolvers ++= Seq(
  "FoodCloud Repo" at "https://mymavenrepo.com/repo/epUeOhkU5rYeKp6iIU07/")

libraryDependencies += "org.foodcloud" %% "metro-spqa" % "0.1"
```

## The Utilties
### AMQP
Test utilities for working with AMQP messages queues
#### QPIDBroker
In-memory AMQP broker implemented with Apache Qpid
#### AmqpPublisher
Utility to publish messages to a queue
#### AmqpQueueListener
Utility to read messages from a queue

### HTTP
#### HttpStubServer
In-memory
### Play Framework
#### MessageBuilder
#### TestLogger
#### TestCache

## Library structure

```
spqa/
+--build.sbt              The main sbt build script
+--src/                   All sources
   +---/main
        +---/scala        Scala Standard Library
            +---/amqp     AMQP queue utilities
            +---/http     HTTP server utilities
            +---/play     Play framework utilities
+--test/                  The Scala test suite
   +---/resources         Sample configurations used by the tests
   +---/scala             Test sources
        +---/http         HTTP units tests / usage samples
        +---/queues       AMQP units tests / usage samples
```

## Copyright and licensing
##### Copyright 2018 © FoodCloud

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

<https://www.apache.org/licenses/LICENSE-2.0>

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

[Dependancy Licenses](https://github.com/foodcloud/spqa/blob/master/metro-spqa-licenses.md)

repository: nahrungswolke/spqa

repo_name: nahrungswolke/spqa


text:
# DocPub configuration

**DocPub** is configured using `docpub.conf` file at the root of the project.

Complete example with all available settings looks like this, but you'll need
to specify only a few settings specific for your project:

```javascript
{
    "username"<EMAIL_ADDRESS>    "token": "abc123def456ghi789",
    "url": "example.zendesk.com",
    "rendering": {
        "highlight": true
    }
}
```

## Available settings

### Generic settings:

* `username` (required, string) — name of ZenDesk user with documentation publish access rights.
  On ZenDesk, this user would be displayed as documentation publisher.

* `token` (required, string) — access token of the user above.

* `url` (required, string) — fully qualified URL of your `ZenDesk` space. Please note, that this should
  be only base URL, path shall not be included. Example: `example.zendesk.com`

### Rendering settings

Rendering settings are controlling Markdown to HTML conversion process. Mostly control appearance,
but may add impact on resulting HTML structure too.

Settings list:

* `highlight` (optional, boolean) - should highlighting be applied to code block in markdown or not.
  If enabled, will add HTML markup and CSS classes provided by [highlight.js](https://highlightjs.org).
  Please note, that stylesheets themselves will be neither linked nor inlined into
  the resulting HTML because, by default, such content considered as unsafe and
  stripped out by ZenDesk. Stylesheets shall be added separately to the ZenDesk template.
  Default option value: `true`.

## Overriding settings

All options can also be overridden via command-line flags or environment
variables. Priorities are the following:

* command-line option has the highest priority. It overrides environment
  variable and config file value.

* environment variable has second priority. It overrides config file value.

* config file value has the lowest priority.

* if no command-line option, environment variable or config file option
  specified, default is used.

To override config setting with CLI option, convert full option path to
`--kebab-case`. For example, if you want publish documents to different ZenDesk
space, call:

```sh
docpub --url http://example.com
```

To disable code highlighting in resulting HTML, you may do following:

```sh
docpub --rendering-highlight=false
```

To override setting with environment variable, convert its full path to
`snake_case` and add `docpub_` prefix. Above examples can be rewritten to use
environment variables instead of CLI options:

```
docpub_url=http://example.com docpub
docpub_rendering_highlight=false docpub
```

license: MIT

repository: agnaranjo/docpub

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: agnaranjo/docpub


text:
## Minecraft Fabric 1.16 - Supercraft (beta)
The complete source code for an upcoming mod known as Supercraft. It implements features from Enhancedcraft and Ultracraft mods. We're also adding more features as we update. This mod requires the Fabric API.

This mod is currently in beta, and bugs may be present in this version. Please back up your worlds before running this mod.

### Connect With Me:

[<img align="left" alt="DieselDorky16 | YouTube" width="22px"<EMAIL_ADDRESS>/>][youtube]

---

### 📺 Latest YouTube Videos

_Nothing new in the past two weeks..._

---

[youtube]: https://youtube.com/DieselDorky16


text:
# MMM-Modal Changelog

## [1.1.0]

### Fixed

* [Update dom on modal close](https://github.com/fewieden/MMM-Modal/pull/7)

### Added

* Added github workflows

### Removed

* TravisCI integration

## [1.0.1]

### Fixed

* Modal positioning
* Blur on render error

### Added

* [List of depending modules](https://github.com/fewieden/MMM-Modal/wiki/Depending-Modules)
* Callback option after render for developers

### Changed

* ESLint ruleset from `airbnb` to `recommended`
* Moved nunjuck templates in separate directory
* node versions for travis

### Removed

* doclet integration

## [1.0.0]

* js module
* dialogs
* voice support
* touch support
* nunjuck templates
* developer guide
* github templates
* linter and project configuration

repository: fewieden/MMM-Modal

gha_language: JavaScript

gha_license_id: MIT

repo_name: fewieden/MMM-Modal


text:
# Model

Import Format: `JSON`

### Template

@TODO

### Major
- ID
    - Unique
    - Self-Assigned
    - integer

- Major Code
    - String
    - `CSCI`

- Full name
    - String
    - `Computer science`

### Course
- ID
    - Unique
    - Self-Assigned
    - integer

- Course Code
    - String
    - Unique
    - `IHSS-1964`

**For course type `IHSS`, etc, use computed value to identify them.**

- Course Name
    - String
    - `Are Human Rational?`

- Course Prerequisit
    - Object
        - Major array[int]
        - Course array[mixed]
        Somehow tricky, since some of them are optional. AND|OR|MAJOR|, etc
        Using `|` for `OR` TYPE
            - `123|321`
        - Grade limit
            - array[int]
            - White list
            - `1` // For freshmen only

- Offering at
    - array[string]
    - `Spring, Fall, etc`

- Course Credit
    - integer
    - `4

### Semester

- Contain several courses.
- Sum() all courses' credits.

branch_name: refs/heads/dummy

gha_language: Vue


text:
# K-young's "Robo Advisor"

## Summary

Welcome to Robo-Advisor Investment Tool developed by K-young. This "Robo Advisor" project will make recommendation on stock purchase or sell based on the pre-implemented logic. The data is updated on real-time basis using AlphaVantage Stock Market API. If the stock information matches with one of the recommendation logics, the system will give you the investment recommendation such as `"BUY"` or `"SELL"`. If there is no recommendation logic applied, you will receive `"STAY"` recommendation.

## Set-up

### Prerequisites

It is recommended to set up a virtual environment to ensure Python runs under the following prerequisites:
  + Anaconda 3.7
  + Python 3.7
  + Pip

### Installation

Install pip command to install the packages required to run the program. You can run the following command in command line:
```
pip install pytest # (only if you'll be writing tests)
pip install -r requirements.txt
```

The required packages are as follows:
```
requests
python-dotenv
```

### AlphaVantage API

As the program fetches real-time stock information using AlphaVantage API, the user needs API Key to use the API and run the program. Please [obtain an AlphaVantage API Key](https://www.alphavantage.co/support/#api-key) (e.g. "abc123") in the link.

After obtaining an API Key, you need to input your API Key in the file ".env" to specify your real API Key like below:

    ALPHAVANTAGE_API_KEY="abc123"

Please note that the ".env" is ignored from the version control using [].gitignore](/.gitignore) file for security purpose. ".gitignore" prevents the ".env" file and its secret credentials from being tracked in version control.

## Usage

### Run the app

Use your text editor or the command-line to run the recommendation script like below:

```py
python app/robo_advisor.py
```

Please make sure to run the app in the internet connected. Otherwise you would not be able to fetch the data and see an alert message to go online.

The system will parse the latest price information of the stock you input. Please make sure you input the valid stock symbols such as (e.g. `"MSFT, AAPL, GOOG, AMZN"`). If you input invalid stock symbols `containing numbers`, symbols `exceeding 5 characters`, or `do not input`, the system will generate error messages until you input valid inputs.

Price information will be stored in the 'data' directory as CSV file and each file is named with corresponding to the given stock symbol (e.g. "data/prices_msft.csv, "prices_aapl.csv", etc.).

### Testing

The program has the function to run automated test to see if the program runs as designed.

Firstly, you need to nstall pytest if you do not install pytest package in the virtual environment.
    (Note: This is the first time only. You do not need to run this next time.):

```sh
pip install pytest
```

After the installation, you can run the pytest with the simple script like below:
```sh
pytest
```

The designed tests are as follows:
```sh
test_to_usd
-> Test various scenarios to ensure the price formatting function displays a dollar sign,
   two decimal places, and a thousands separator.

test_get_response
-> Test to ensure the function returns the expected response data in a usable format
   (i.e. a dictionary with keys "Meta Data" and "Time Series (Daily)").
```

## Recommendation Logic

The followings are the recoomendation logic on the stocks you input:

  1. Logic 1 - BUY when latest high exceeds last 10-day average high by 3%
  2. Logic 2 - SELL when latest low is less than last 10-day average low by 1.5%
  3. Logic 3 - BUY when close price increases three days in a row
  4. Logic 4 - BUY when latest close price exceeds last 10-day average high
  5. Logic 5 - SELL when latest close price is less than last 10-day average low

If the stock meets one of the recommendation, the system will dsiplay the recommended decision of `"BUY"` or `"SELL"`. Logic 1 through 5 is implemented in sequence depending on the importance or impact of recommendation. For example, the stock `"AMZN"` matches the recommendation logic 1 and 3, the system will give you `"BUY"` decision with the reason of `Logic 1 - BUY when latest high exceeds last 10-day average high by 3%`.

If there is no matching recoomendation logic, you will see `"Stay"` (a.k.a. No Recommendation) recoomendation.

More recommendation logics will be implemented in the following versions. If you have any great idea on the recommendation logic, please feel free to reach out to me. K-young will be more than happy to implement the logic in the Robo-Advisor.

## [License](/LICENSE.md)

Hope the tool helps your wise investing! Thank you for using!


text:
# ComponentDifferenceDTO

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**componentType** | **String** | The type of component |  [optional]
**componentId** | **String** | The ID of the component |  [optional]
**componentName** | **String** | The name of the component |  [optional]
**processGroupId** | **String** | The ID of the Process Group that the component belongs to |  [optional]
**differences** | [**List<DifferenceDTO>**](DifferenceDTO.md) | The differences in the component between the two flows |  [optional]


text:
# UI5 task for finding and fixing JavaScript problems using ESLint

![GitHub](https://img.shields.io/github/license/faebulicious/ui5-task-eslint)
![npm](https://img.shields.io/npm/v/ui5-task-eslint)

UI5 task for finding and fixing problems using ESLint in all javascript files of your project

## Install

```bash
npm install ui5-task-eslint --save-dev
```

## Configuration options (in `$yourapp/ui5.yaml`)

- debug: true|false
  Verbose logging
- autoFix: true|false
  Enable Auto-fixing

## Usage

1. Define the dependency in `$yourapp/package.json`:

```json
"devDependencies": {
    // ...
    "ui5-task-eslint": "*"
    // ...
},
"ui5": {
  "dependencies": [
    // ...
    "ui5-task-eslint",
    // ...
  ]
}
```

> As the devDependencies are not recognized by the UI5 tooling, they need to be listed in the `ui5 > dependencies` array.

2. configure it in `$yourapp/ui5.yaml`:

```yaml
builder:
  customTasks:
    - name: ui5-task-eslint
      afterTask: replaceVersion
      configuration:
        debug: false
        autoFix: true
```

## How it works

The task runs ESLint for all your javascript files based on your ESLint configuration.

Auto-fixing of problems is **not** enabled by default.

```bash
WARN builder:custom:eslint 🧹 ESLint check passed with warnings (1): BaseController.js
ERR! builder:custom:eslint 🧹 ESLint check failed (2): Overview.controller.js
ERR! builder:custom:eslint 🧹 ESLint check failed with 2 Errors and 1 Warnings
```

## License

This work is licensed under the [MIT License](./LICENSE).

branch_name: refs/heads/main


text:
---
hrs_structure:
  division: '1'
  volume: '6'
  title: '19'
  chapter: 329B
  section: 329B-1
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0329B-0001
    parent: HRS0329B
    name: 329B-1 Purpose
weight: 44005
title: Purpose
full_title: 329B-1 Purpose
---
**[§329B-1] Purpose.** The purpose of this chapter is to ensure that appropriate and uniform substance abuse test procedures are employed throughout the State, to protect the privacy rights of persons tested, and to achieve reliable and accurate results. [L 1990, c 236, pt of §1]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
GNUstep Android Toolchain
=========================

This project comprises a collection of scripts to build a GNUstep toolchain for Android. The toolchain can then be used in an Android project to compile and run Objective-C code using the Foundation and CoreFoundation libraries.

The toolchain is built using the tools provided by the standard Android SDK (installed e.g. via [Android Studio](https://developer.android.com/studio)), plus a custom NDK using the latest Clang prebuilt from Google (required to work around bugs in the older Clang version shipping with the official NDK which prevent usage of the gnustep-2.0 Objective C runtime).

The toolchain is set up to target Android API level 21 (5.0 / Lollipop) and supports all common Android ABIs (armeabi-v7a, arm64-v8a, x86, x86_64).

Libraries
---------

The toolchain currently compiles the following libraries for Android:

* [GNUstep Base Library](https://github.com/gnustep/libs-base) (Foundation)
* [GNUstep CoreBase Library](https://github.com/gnustep/libs-corebase) (CoreFoundation)
* [libobjc2](https://github.com/gnustep/libobjc2) (using gnustep-2.0 runtime)
* [libdispatch](https://github.com/apple/swift-corelibs-libdispatch) (official Apple release from the Swift Core Libraries)
* [libcxxrt](https://github.com/pathscale/libcxxrt) (for Objective-C++ exception support)
* [libffi](https://github.com/libffi/libffi)
* [libxml2](https://github.com/GNOME/libxml2)
* [libxslt](https://github.com/GNOME/libxslt)
* [ICU](https://github.com/unicode-org/icu)

Requirements
------------

Supported host platforms are macOS and Linux.

You must have [Android Studio](https://developer.android.com/studio), and have the following options installed in the SDK Manager:

* CMake _– version <IP_ADDRESS>88404 as specified in [sdkenv.sh](env/sdkenv.sh)_

Additionally the following packages are required depending on your system.

**macOS**

Install required packages via [Homebrew](https://brew.sh):

```
brew install git-lfs cmake autoconf automake libtool pkg-config
git lfs install
```

**Linux**

Install required packages via APT:

```
sudo apt install git git-lfs curl cmake make autoconf libtool pkg-config texinfo python3-distutils
git lfs install
```

Please note that you need to have CMake version 3.15.1 or later ([for libdispatch](https://github.com/apple/swift-corelibs-libdispatch/blob/master/CMakeLists.txt#L2)).

Usage
-----

Run the [build.sh](build.sh) script to build the toolchain:

```
Usage: ./build.sh
  -r, --rev NDK_REVISION     NDK revision (default: r20)
  -c, --clang CLANG_VERSION  Clang prebuilt release (default: r353983c1)
  -n, --ndk NDK_PATH         Path to existing Android NDK (default: ~/Library/Android/android-ndk-r20-clang-r353983c1)
  -a, --abis ABI_NAMES       ABIs being targeted (default: "armeabi-v7a arm64-v8a x86 x86_64")
  -l, --level API_LEVEL      Android API level being targeted (default: 21)
  -b, --build BUILD_TYPE     Build type "Debug" or "Release" or "RelWithDebInfo" (default: RelWithDebInfo)
  -u, --no-update            Don't update projects to latest version from GitHub
  -c, --no-clean             Don't clean projects during build (e.g. for building local changes, only applies to first ABI being built)
  -p, --patches DIR          Apply additional patches from given directory
  -o, --only PHASE           Build only the given phase (e.g. "gnustep-base", requires previous build)
  -h, --help                 Print usage information and exit
```

The toolchain automatically downloads and installs the NDK and prebuilt Clang release (via [install-ndk.sh](install-ndk.sh)), and builds and installs the GNUstep toolchain into the following location (`$GNUSTEP_HOME`):

* macOS: `~/Library/Android/GNUstep`
* Linux: `~/Android/GNUstep`

The build for each supported ABI is installed into its separate subfolder at that location (both libraries and header files differ per ABI).

To use the toolchain from an Android project, you can use `$GNUSTEP_HOME/$ABI_NAME/bin/gnustep-config` to obtain various flags that should be used to compile and link Objective-C files, e.g.

* `gnustep-config --variable=CC`
* `gnustep-config --objc-flags` (or `--debug-flags`)
* `gnustep-config --base-libs`

Call `gnustep-config --help` to obtain the full list of available variables.

You may also want to configure your app’s build environment to use the custom NDK (e.g. in Android Studio), which is installed into the following location:

* macOS: `~/Library/Android/android-ndk-<NDK_REVISION>-clang-<CLANG_VERSION>`
* Linux: `~/Android/android-ndk-<NDK_REVISION>-clang-<CLANG_VERSION>`

Examples
--------

The [android-examples](https://github.com/gnustep/android-examples) repository contains example projects using this project.

Acknowledgements
----------------

Based on original work by Ivan Vučica.

repository: ClarkGuan/tools-android

repo_name: ClarkGuan/tools-android


text:
---
layout: default
---

# Courses and more

This is course is designed for **Acatlan Faculty of Higher Studies**
students, however this website could be used for more people, but
some information complimentary it will not available, since I usually
implement more documentation in
[SEA UNAM](https://sea.acatlan.unam.mx/){:target="_blank"},
[code](https://code.org/){:target="_blank"}, [tech.io](https://tech.io/){:target="_blank"}, [repl.it](https://repl.it){:target="_blank"} ad more; and tests, quizes and more should be found
[kahoot](https://kahoot.com/){:target="_blank"} and others.

Next you find information about courses, activities and important
messages for FES-Acatlan community.

## To know more about...
1. [Basic Programming with C](./mrkdwn/prgrmminCBsc.html)
- [Part I](./mrkdwn/PartI/readme.md)
- [Part II](./mrkdwn/PartII/readme.md)
- [Part III](./mrkdwn/PartIII/readme.md)
- [Part IV](./mrkdwn/PartIV/readme.md)
- [Part V](./mrkdwn/PartV/readme.md)
- [Part VI](./mrkdwn/PartVI/readme.md)
- [Part VII](./mrkdwn/PartVII/readme.md)

1. [Activities](./mrkdwn/activities.html)
1. [Important messages](./mrkdwn/messages.html)


text:
`isolated-runtime` is a library that provides a secure, performant and dev-friendly approach for running untrusted JS code in an isolated context.

## Why untrusted code?
You might be offering your users to customize your product using custom JS code that will run for certain system events, provide a complete serverless solution for their code, or allow them to create their own rules engine based on JS objects and statements - whatever that might be, all of the scenarios above involve accepting JS code from the user and executing it on your own servers. That might pose a huge security risk in case you don't enforce any limitations on that code, unless you run it within some sort a sandbox - an isolated runtime-context that will prevent it from accessing or modifying undesired resources.

## Key concepts
The driving idea behind `isolated-runtime` is having the untrusted code as files deployed to some filesystem, then having `isolated-runtime` load a module from one of those files, and executing a function from that module with the provided arguments, returning a Promise that resolves to the function's return value. The function's runtime-context is isolated from the host's one, and even better - multiple instances of the same function can be run without clashing with each other via global state.

## Usage examples
For more examples, see the [examples](examples.md) page.

Assume the following file structure (with the `modules` folder represented code submitted from an untrusted source):

```
├───index.js
├───modules
│   ├─module1.js
│   ├─module2.js
```

```js
// module1.js

function a() {
  global.a = 1
  return global.a
}

// module2.js
function b() {
  return global.a
}

// index.js
const { IsolatedRuntime } = require("isolated-runtime");
const runtime = new IsolatedRuntime();

global.a = 3

const result1 = await runtime.run({
  folder: path.resolve('./modules')
  file: "module1.js",
  funcName: "a",
  args: []
});

console.log('result1: ', result1)
console.log('global.a: ', global.a)

const result2 = await runtime.run({
  folder: path.resolve('./modules')
  file: "module2.js",
  funcName: "b",
  args: []
});

console.log('result2: ', result2)
console.log('global.a: ', global.a)

```
The code above will print:
```
result1: 1
global.a: 3
result2: undefined
global.a: 3
```

Note that `global.a` was never modified by any of the invocations - since each got its own fresh, sandboxed version of `global` - completely detached from the `global` scope in `index.js`.

## Malicious behavior
With untrusted code comes untrusted behavior - imagine such code performs a `process.exit()` or `while (true) {}` statenents - in both cases someone is trying to abort or halt the main process hosting the untrusted code runtime. To eliminate that risk, we've combined two different concepts:
1. Context isolation - `process` is not availble in the untrusted code's runtime context (i.e., is not a variable that can be referenced in its closure).
1. Host-process isolation - `while (true) { }` cannot be blocked beforehand, but since the untrusted code is being run inside a thread - the infinite loop will only block that thread, and will eventually result in a timeout exception aborting the execution. That way, no untrusted code can affect the host *process* itself.

## Getting Started
Install isolated-runtime:

```npm install --save isolated-runtime```

In your script (that can be anything from a cli-tool up to a fully-blown Express-base Node server):

```js
const { IsolatedRuntime } = require("isolated-runtime");

const runtime = new IsolatedRuntime(/* options */);
const result = await runtime.run({
  folder: "/path/to/folder"
  file: "relative/path/to/file",
  funcName: "functionName",
  args: [/* function arguments */]
});
```

repository: wix-incubator/isolated-runtime

repo_name: wix-incubator/isolated-runtime


text:
# How to update the lacros binary manually

There are two steps to updating the lacros binary manually. The first is to
get (build or download) a tarball with the necessary files. The second is
to upload it to GCS and update `lacros_binary.tar.external` to point to the
new tarball.

It is recommended to use a fishfood build because it's guaranteed to have been
compiled correctly.

## Creating the lacros tarball
### Using an existing fishfood build (recommended)

Run the following commands to grab the latest fishfood build and convert it
into a tarball usable by the Tast tests.

```sh
export BUILD=`gsutil.py ls gs://chrome-lacros-fishfood/x86_64 | sort | tail -n 1`
gsutil.py cp ${BUILD%%/}/lacros.zip /tmp/lacros_binary.zip
unzip /tmp/lacros_binary.zip -d /tmp/lacros_binary
tar -cf /tmp/lacros_binary.tar -C /tmp lacros_binary
```

### Building manually (not recommended)

1. Build lacros. Make sure dcheck_always_on=false.

```sh
ninja -C out/Lacros -j 16000 -l 400 chrome
```

2. Create a tarball with the needed lacros files.

```sh
export LACROS_OUTDIR=<your out dir> # e.g. out/Lacros
cd $LACROS_OUTDIR
mkdir /tmp/lacros_binary
cp -r {chrome,nacl_helper,nacl_irt_x86_64.nexe,locales,*.pak,icudtl.dat,snapshot_blob.bin,swiftshader,crashpad_handler,WidevineCdm} /tmp/lacros_binary
tar -cf /tmp/lacros_binary.tar -C /tmp lacros_binary
```

The content of the tarball should be a single 'lacros_binary' directory with the
files inside.

3. Optionally test the lacros binary locally:

```sh
export CROS_DIR=<your chromeos dir> # e.g. /src/cros
cp /tmp/lacros_binary.tar $CROS_DIR/src/platform/tast-tests/src/chromiumos/tast/local/bundles/cros/lacros/data
rm $CROS_DIR/src/platform/tast-tests/src/chromiumos/tast/local/bundles/cros/lacros/data/lacros_binary.tar.external
```
Then from inside the ChromiumOS chroot:

```sh
tast run <dut> lacros.Basic
```

Make sure to delete the local binary after you are done with it, otherwise the
remote binary won't be used later when you try to test that everything worked:

```sh
rm $CROS_DIR/src/platform/tast-tests/src/chromiumos/tast/local/bundles/cros/lacros/data/lacros_binary.tar
```

## Testing and updating the lacros tarball
1. Update the lacros_binary.tar.external file:

```sh
export DATECODE=`date +"%Y%m%d"`
sha256sum /tmp/lacros_binary.tar
wc -c /tmp/lacros_binary.tar
echo lacros_binary_$DATECODE.tar
```

Copy-paste the SHA-256 sum and size in bytes of the file into
`$CROS_DIR/src/platform/tast-tests/src/chromiumos/tast/local/bundles/cros/lacros/data/lacros_binary.tar.external`.
Update the URL as well to the one with the correct filename.

2. Upload the new file to GCS.

```sh
export DATECODE=`date +"%Y%m%d"`
gsutil.py cp /tmp/lacros_binary.tar gs://chromiumos-test-assets-public/tast/cros/lacros/lacros_binary_$DATECODE.tar
```

3. Test that Tast tests can pass with the new tarball:

```sh
tast run <dut> lacros.Basic
```

4. Upload a CL updating the `lacros_binary.tar.external` file.


text:
# Note

## Kernel
The kernel can be executed by calling
```
kernel_name<<<grid,block>>>(arguments);
```
where `gird` and `block` are the `dim3` variables we talked about in [Grid and block](../grid_and_block/README.md). It's important to note that the calling of kernel is a **_asynchronous process_** respect to the host function. That means the control returns to the host function right after the call of kernel. To wait for the kernel, one can use the `cudaDeviceSynchronize()` function. This will block the host process to wait for the kernel. Some other CUDA API has implicit synchronization. For example, `cudaMemcpy` starts copying after all kernel calls are finished.

There are three qualifiers for a kernel.

| Qualifier      | Execution | Callable                            |
| ---            | ---       | ---                                 |
| \_\_global\_\_ | device    | host or device(requires comp > 3.0) |
| \_\_device\_\_ | device    | device only                         |
| \_\_host\_\_   | host      | host only                           |

A kernel can be declared as both `host` and `device`:
```
__device__ __host__ kernel(){}
```
Several restrictions on the kernels:
- Acceess to device memory **memory**
- Kernel on in CUDA must have `void` return type.

The result from the GPU can be verified by comparing it with the result from the CPU. Two userful to debug
- Use `printf` function with Fermi and later architecture GPU
- Assign `grid=1` and `block=1` such that the kernel runs as `kernel<1,1>`. It works as a sequential function now.

## Error handling
Most of the CUDA runtime API has return type of `cudaError_t` (at least in my knowledge), so we can define a macro handle the error.
```c
#define CHECK(call)\
{\
	const cudaError_t error=call;\
	if(error!=cudaSuccess)\
	{\
		printf("Error: %s:%d, ", __FILE__, __LINE__);\
		printf("code:%d, reason: %s\n",error,cudaGetErrorString(error));\
		exit(1);\
	}\
}
```
In case you are not familiar with Macro just like I was,`__FILE__` returns the file which is being executed and `__LINE__` returns the line that the program is being executed. Besides these two, `__func__` is also available.

To use the error handling macro, simply wrap the CUDA function with the `CHECK()` macro:
```C
CHECK(cudaMemcpy(h_C, d_C,sizeof(float),cudaMemcpyDeviceToHost));
```
It can also be used to check the kernel:
```C
kernel<<<grid,block>>>();
CHECK(cudaDeviceSynchronize());
```


text:
tivo
====
This graph will plot the used disk space on a TiVo DVR.  The value is derived by
polling the TiVo for all program information since there is no API exposed by
the unit iself to get disk space used.

Sample Graph
------------
![Graph of tivo](https://raw.githubusercontent.com/cookieguru/munin-plugins/screenshots/tivo.png)

Requirements
------------
A recent version of PHP with the BC Math, cURL, and SimpleXML extensions
installed.  How extensions are installed depends on your platform.  A step below
will test to make sure the necessary extensions are installed on your system.

Installation Instructions
-------------------------
```bash
#Download the plugin
sudo wget https://raw.githubusercontent.com/cookieguru/munin-plugins/master/tivo/tivo -O /usr/share/munin/plugins/tivo
```
Edit lines 3 and 4 to set `IP` and `MAK` (Media Access Key)
```bash
#Add execution permissions
sudo chmod +x /usr/share/munin/plugins/tivo
#Create a cache file
sudo touch /var/cache/munin/tivo
#Set owernship
sudo chmod nobody.munin /var/cache/munin/tivo
#Make sure dependencies are installed (this should print "yes")
sudo munin-run tivo autoconf
#Install the plugin
sudo ln -s /usr/share/munin/plugins/tivo /etc/munin/plugins/tivo
#Restart munin-node
sudo /etc/init.d/munin-node restart
#Optionally, test the output
sudo munin-run tivo config
sudo munin-run tivo
```

A cache file stores the date the Now Playing list last changed (according to the
TiVo DVR).  If the recordings haven't changed, the last known size is returned.
The retreival of the information for every program can take several seconds, and
fetching data again would unnecessarily delay graph generation.

TiVo Suggestions are not included in the total because they are automatiaclly
removed to make space AND because they would be counted towards used space while
they are recording.  The TiVo's API only indicates that a program is recording,
not that it is recording a suggestion.  This also means in-progress recordings
are not shown in the total because they can't be differentiated between
in-progress suggestions being recorded.

repository: cookieguru/munin-plugins

repo_name: cookieguru/munin-plugins


text:
![master](https://github.com/openfido/hipas-converters/workflows/master/badge.svg)

# HiPAS Converters for OpenFIDO

This repository contains the OpenFIDO code needed to use the HiPAS converters.  To use these converters in OpenFIDO, do the following

1. Login to [OpenFIDO](https://app.openfido.org) in your favorite web browser
2. Click on [PIPELINES](https://app.openfido.org/pipelines) on the left-side panel.
3. If `HiPAS Converters` is not displayed in the main panel, click on `+ Add Pipeline` on the top panel. Enter the [Recommended pipeline settings](http://docs.gridlabd.us/index.html?owner=openfido&project=hipas-converters&branch=master&folder=&doc=/Recommended_pipeline_settings.md) below to create the pipeline, and click `Add Pipeline`.
4. Click `View Runs` for `HiPAS Converters`, and click `+ Start Runs`.  Upload your input files and click `Start Run`.
5. When the run is complete, download the output files, or right-click to copy the link to use the URL endpoint in another tool.

# See also

* [Online docs](http://docs.gridlabd.us/index.html?owner=openfido&project=hipas-converters&branch=master&folder=&doc=/README.md)
* [HiPAS Converters](https://github.com/slacgismo/gridlabd-converters)

repository: openfido/hipas-converters

repo_name: openfido/hipas-converters


text:
# Python Language Server

[![Circle CI build status](https://circleci.com/gh/spyder-ide/spyder-pyls.svg?style=shield)](https://circleci.com/gh/spyder-ide/spyder-pyls)
[![Appveyor build status](https://ci.appveyor.com/api/projects/status/dicdkl5kbjtrcw59?svg=true)](https://ci.appveyor.com/project/spyder-ide/spyder-pyls)
[![license](https://img.shields.io/github/license/spyder-ide/spyder-pyls.svg)](./LICENSE.txt)
[![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public)<br>
[![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
[![OpenCollective Sponsors](https://opencollective.com/spyder/sponsors/badge.svg?color=blue)](#sponsors)

A Python 2.7 and 3.5+ implementation of the [Language Server Protocol](https://github.com/Microsoft/language-server-protocol).

## Installation

The base language server requires [Jedi](https://github.com/davidhalter/jedi) to provide Completions, Definitions, Hover, References, Signature Help, and Symbols:

``pip install spyder-pyls``

If the respective dependencies are found, the following optional providers will be enabled:

* [Rope](https://github.com/python-rope/rope) for completions and renaming
* [Pyflakes](https://github.com/PyCQA/pyflakes) linter to detect various errors
* [McCabe](https://github.com/PyCQA/mccabe) linter for complexity checking
* [pycodestyle](https://github.com/PyCQA/pycodestyle) linter for style checking
* [pydocstyle](https://github.com/PyCQA/pydocstyle) linter for docstring style checking (disabled by default)
* [autopep8](https://github.com/hhatto/autopep8) for code formatting
* [YAPF](https://github.com/google/yapf) for code formatting (preferred over autopep8)

Optional providers can be installed using the `extras` syntax. To install [YAPF](https://github.com/google/yapf) formatting for example:

`pip install 'spyder-pyls[yapf]'`

All optional providers can be installed using:

`pip install 'spyder-pyls[all]'`

If you get an error similar to `'install_requires' must be a string or list of strings` then please upgrade setuptools before trying again.

`pip install -U setuptools`

## 3rd Party Plugins

Installing these plugins will add extra functionality to the language server:

* [pyls-mypy](https://github.com/tomv564/pyls-mypy) Mypy type checking for Python 3
* [pyls-isort](https://github.com/paradoxxxzero/pyls-isort) Isort import sort code formatting
* [pyls-black](https://github.com/rupert/pyls-black) for code formatting using [Black(https://github.com/ambv/black)

Please see the above repositories for examples on how to write plugins for the Python Language Server. Please file an
issue if you require assistance writing a plugin.

## Configuration

Configuration is loaded from zero or more configuration sources. Currently implemented are:

* pycodestyle: discovered in `~/.config/pycodestyle`, `setup.cfg`, `tox.ini` and `pycodestyle.cfg`
* flake8: discovered in `~/.config/flake8`, `setup.cfg`, `tox.ini` and `flake8.cfg`

The default configuration source is pycodestyle.

## Language Server Features

* Code completion

![Screenshot of Spyder's code completion](./resources/spyder_code_completion.png)

* Code linting (Warnings and errors)

![Screenshot of Spyder's linting info](./resources/spyder_linting.png)

## Development

To run the test suite:

``pip install .[test] && tox``

## Develop against Spyder

The Python language server can be developed against a local instance of Spyder IDE.

1. Install it with `pip install -e .`
2. Start Spyder in debug mode (`python bootstrap.py --debug`)
3. Check logs for both client and server in `~/.spyder-py3/lsp-logs`

## License

This project is made available under the MIT License.

## Sponsors

Spyder is funded thanks to the generous support of

[![Quansight](https://static.wixstatic.com/media/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png/v1/crop/x_0,y_9,w_915,h_329/fill/w_380,h_128,al_c,usm_0.66_1.00_0.01/095d2c_2508c560e87d436ea00357abc404cf1d~mv2.png)](https://www.quansight.com/)[![Numfocus](https://i2.wp.com/numfocus.org/wp-content/uploads/2017/07/NumFocus_LRG.png?fit=320%2C148&ssl=1)](https://numfocus.org/)

and the donations we have received from our users around the world through [Open Collective](https://opencollective.com/spyder/):

[![Sponsors](https://opencollective.com/spyder/sponsors.svg)](https://opencollective.com/spyder#support)

repository: spyder-ide/spyder-pyls

branch_name: refs/heads/develop

gha_language: Python

repo_name: spyder-ide/spyder-pyls


text:
# laravel-stock-market

## Exercise
The investor John T. Thompson has shares in companies around the world.
Since John likes to travel he is also constantly searching for new opportunities.
To be able to compare stock prices  over different markets from anywhere in the world, John would like
to have a web application that  helps him to decide which stocks are interesting for him.

Currently John´s focus is on stocks that are traded on the following markets::
1. New York Stock Exchange
1. London Stock Exchange
1. Hong Kong Stock Exchange
1. Shanghai Stock Exchange
1. Deutsche Börse Frankfurt Your task consists of multiple steps.

Please read the whole document before beginning to avoid  any surprises while y ou work on the exercise.

### The business logic
Please help John building a n application for him that can do the following things:
1. Possibility to create new company profiles in the system
1. Add company stocks and corresponding prices to an exchange market
    1. no historical values need to be saved (one current stock value is sufficient)
    1. all markets will use the same currency
1. Display reports of t he stock and company exchanges (details on the second part)

For the implementation, you can use following, simplified context for financial markets:

Companies can trade different types of stock (typically common stock and preferred stock) on  multiple markets.
The company can choose individually per market, whether both, neither or just  one of the stock types is traded.
Each market has their own trade value for stock traded on their exchange

### The frontend
John is a businessman a nd does not know how to access databases.
Please help him by creating  multiple forms so that he is able to enter company profiles and add stock to the company and  markets.
Since he would also like to see different key figures please create dashboards showing  the following information.
1. Overview of all companies and what stock they have on which markets
1. Overview of all stock exchanges and what companies stock is traded there
1. The possibility to see the currently highest trade value and corresponding markets

## Installation

```shell
git clone https://github.com/javadmalek/laravel-stock-market.git
cd laravel-stock-market
composer install
```

```shell
php artisan key:generate
Create a database and inform .env
php artisan migrate --seed      to create and populate tables
php artisan serve               to start the app on http://localhost:8000/
```
- Config .env file

## Project structure

       .
       ├── app                          # The app directory, as you might expect, contains the core code of your application.
       │    └── Console                 # The Events directory, as you might expect, houses event classes. Events may be used to alert other parts of your application that a given action has occurred, providing a great deal of flexibility and decoupling.
       │    └── Events                  # This directory does not exist by default, but will be created for you by the event:generate and  make:event Artisan commands.
       │    └── Exceptions              # The Exceptions directory contains your application's exception handler and is also a good place to place any exceptions thrown by your application.
       │    └── Http                    # The Http directory contains your controllers, middleware, and form requests.
       │    └── Jobs                    # The Jobs directory, of course, houses the queueable jobs for your application. Jobs may be queued by your application or run synchronously within the current request lifecycle.
       │    └── Listeners               # This directory does not exist by default, but will be created for you if you execute the  event:generate or make:listener Artisan commands.
       │    └── Policies                # This directory does not exist by default, but will be created for you if you execute the make:policy Artisan command.
       │    └── Providers               # The Providers directory contains all of the service providers for your application.
       │
       ├── bootstrap                    # The bootstrap directory contains a few files that bootstrap the framework and configure autoloading, as well as a cache directory that contains a few framework generated files for bootstrap performance optimization.
       │
       ├── config                       # The config directory, as the name implies, contains all of your application's configuration files.
       │
       ├── database                     # The database directory contains your database migration and seeds.
       │
       ├── public                       # The public directory contains the front controller and your assets (images, JavaScript, CSS, etc.).
       │
       ├── resources                    # The resources directory contains your views as well as your raw, un-compiled assets such as LESS, SASS, or JavaScript.
       │
       ├── storage                      # The storage directory contains your compiled Blade templates, file based sessions, file caches, and other files generated by the framework. This directory is segregated into app, framework, and  logs directories.
       │    └── storage/app/public      # The storage/app/public directory may be used to store user-generated files, such as profile avatars, that should be publicly accessible.
       │
       ├── Tests                        # The tests directory contains your automated tests. An example PHPUnit is provided out of the box.
       │
       ├── Vendor                       # The vendor directory contains your Composer dependencies.
       │
       ├── CONTRIBUTORS.md
       ├── composer.json
       ├── server.php
       ├── README.md
       └── TODO.md

repository: javadmalek/laravel-stock-market

repo_name: javadmalek/laravel-stock-market


text:
# flashes

[![Latest Version on Packagist][ico-version]][link-packagist]
[![Software License][ico-license]](LICENSE.md)
[![Build Status][ico-travis]][link-travis]
[![Total Downloads][ico-downloads]][link-downloads]

This is a package for flash messages in Laravel 5.  It is based off of a tutorial by Jeffrey Way at [Laracasts](http://github.com/laracasts). More documentation coming soon.

## Install

In `app/config/app.php`, add the following lines:

In the *providers* array
````php
jstelz\Flashes\FlashesServiceProvider::class,
````

In the *aliases* array
````php
jstelz\Flashes\Flashes::class,
````

## Usage

``` php
Flashes::info('This is an informational message');
Flashes::success('This is a success message');
Flashes::warning('This is a warning message');
Flashes::error('This is an error message');
```

## Contributing

Please see [CONTRIBUTING](CONTRIBUTING.md) and [CONDUCT](CONDUCT.md) for details.

## Credits

- [Jason][link-author]
- [All Contributors][link-contributors]

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

[ico-version]: https://img.shields.io/packagist/v/jasonstelzer/flashes.svg?style=flat-square
[ico-license]: https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square
[ico-travis]: https://img.shields.io/travis/thephpleague/flashes/master.svg?style=flat-square
[ico-downloads]: https://img.shields.io/packagist/dt/jasonstelzer/flashes.svg?style=flat-square

[link-packagist]: https://packagist.org/packages/jasonstelzer/flashes
[link-travis]: https://travis-ci.org/thephpleague/flashes
[link-downloads]: https://packagist.org/packages/jasonstelzer/flashes
[link-author]: https://github.com/jasonstelzer
[link-contributors]: ../../contributors

repository: jstelz/flashes

repo_name: jstelz/flashes


text:
---
title: Du cinquième siècle à la cinquième répupublique
date: 2017-02-14T19:11:10.000Z
author: RAW Graphs Team
layout: gallery_project
submitted_by:
  - Clara Dealberto & Jules Grandin
author_personal_page:
  - 'http://www.claradealberto.com'
visual_models_used:
  - Circular Dendrogram
  - Scatterplot
  - Treemap
external_link:
  - 'http://goumprod.com/dirigeants-france/'
image: ./gallery-images-3.png
path: /gallery_project/du-cinquieme-siecle-a-la-cinquieme-repupublique/
---

  The website is a collection of interactive infographics about all the men who ruled France, starting with Clovis in 481 and ending with François Hollande in 2016. We represented various datas including places of birth and death, time spent as a ruler, facial hair, ways of dying etc.


text:
# compliance-cases-api
Part of the MDTP Protect Connect APIs

## Running the service
To run the service, in the repository's main directory, run ```sbt run```
This service is intended to run on port 7052
You need to be a standard application to be able to use this API.

### Routes
    POST /case

Validates payload with the schema provided; sends it on if payload matches schema. Requires header:

Header | Content
-------|--------
CorrelationId | UUID

Possible responses:

Status | Message | description
-------|--------|----------
202 | - | Message has been received and is passed on.
400 | Invalid payload           | There is something wrong with the request body. response has a sequence of invalid fields
400 | Invalid correlation ID    | Correlation id is invalid
400 | Missing correlation ID    | Correlation id is missing
401 | Unauthorised              | You are either not a standard application or you are not allow listed
500 | Internal server error     | Something bad has happened

### License

This code is open source software licensed under the [Apache 2.0 License]("http://www.apache.org/licenses/LICENSE-2.0.html").

repository: hmrc/compliance-cases-api

gha_language: Scala

repo_name: hmrc/compliance-cases-api


text:
#Xcode Logger

Xcode Logger `version 0.1` is a simple and colorful console output library based on the [Xcode Colors](https://github.com/robbiehanson/XcodeColors) plugin for Xcode IDE which works great in multi-threaded environments.

---
Xcode Logger is tested on iOS 7 and 8, and requires ARC. Released under the [MIT License](https://github.com/codeFi/XcodeLogger/blob/master/LICENSE).
![Xcode Colors]
(http://i62.tinypic.com/15hk5y9.png)

It has multiple schemes of logging (`macros`) with automatic log scheme switching based on the selected build schemes. It ships by default as plug-and-play for the following schemes:
 - DEBUG
 - DEVELOPMENT
 - DEBUG and DEVELOPMENT (a common logger for both schemes)
 - RELEASE (disables every logger except `XLog` which replaces `NSLog`)

Every log scheme accounts for multiple scenarios, so there's a logging function (`macro`) for each of the following:
 - Simple logger with or without header information
 - Information logger
 - Highlight logger
 - Warning logger
 - Error logger

##How to install

1. Download or clone the repository. If you don't have `XcodeColors` plugin installed, now it's a good time to [install it](https://github.com/robbiehanson/XcodeColors).

2. After installing  and testing the `XcodeColors` plugin, add `XcodeLogger` and `XcodeLogger+BuildSchemes` category `.h` and `.m` files to your project.
![Copy Xcode Logger into your project]
(http://i60.tinypic.com/s6hb9v.jpg)

3. If you don't have any custom build schemes for your project, you should add `RELEASE`, `DEBUG` and `DEVELOPMENT` schemes or just two of them based on the same configurations. If you're new to this, be sure your schemes are running with the correct configurations even though `Xcode Logger` doesn't depend on the running config.

4. In order for the library to determine your currently running scheme you'll need to add a value for a `key` (default is `RunningScheme`) in your `info.plist` file at runtime so go to your `info.plist` file and add a key named `RunningScheme` of type `String`.
![Info.plist Key](http://i61.tinypic.com/r1c2ea.jpg)
The following script will provide that value at runtime:

		/usr/libexec/PlistBuddy -c "Set :RunningScheme \"$SCHEME_NAME\"" "$PROJECT_DIR/$INFOPLIST_FILE"

	Add the script above to your every build scheme under `Build` > `Pre-actions`. Be sure to select a **target** from which to build from!
![Add the script to your schema]
(http://i61.tinypic.com/2m6vbf8.jpg)

5. Change the values of `static NSString *const DEBUG_SCHEME` and `static NSString *const DEVELOPMENT_SCHEME` string constants in `XcodeLogger+BuildSchemes.h` to match the names of your build schemes.
![Change these constants]
(http://i60.tinypic.com/2i1folh.jpg)

##How to use
You can use `Xcode Logger` by simply importing in your classes either `XcodeLogger.h` if you want only `XLog` or `XcodeLogger+BuildSchemes.h` if you want `scheme-dependant` loggers.

After you've done that you simply call the `macros` where you need them as you would do with `NSLog`.

These are the loggers:

> `NSLog`'s replacement `XLog` which runs independently from the running scheme:

* **XLog()** - a simple logger with an information header.
* **XLog_NH()** - a simple logger without a header.
* **XLog_INFO()** - a general purpose information logger.
* **XLog_HIGHLIGHT()** - a general purpose information and highlight logger.
* **XLog_WARNING()** - a logger for special situations like warnings.
* **XLog_ERROR** - a logger for errors.

>`DLog` which is meant to run only on a `DEBUG` scheme:

* **DLog()**
* **DLog_NH()**
* **DLog_INFO()**
* **DLog_HIGHLIGHT()**
* **DLog_WARNING()**
* **DLog_ERROR()**

> `DEVLog` which is meant to run only on a `DEVELOPMENT` scheme:

* **DEVLog()**
* **DEVLog_NH()**
* **DEVLog_INFO()**
* **DEVLog_HIGHLIGHT()**
* **DEVLog_WARNING()**
* **DEVLog_ERROR()**

> `DDVLog` which is meant to run only on both `DEBUG` and `DEVELOPMENT` schemes:

* **DDVLog()**
* **DDVLog_NH()**
* **DDVLog_INFO()**
* **DDVLog_HIGHLIGHT()**
* **DDVLog_WARNING()**
* **DDVLog_ERROR()**

> The info headers contain the following informations (in order):

{_logger info_} ( _timestamp_ )=> [> _memory address of self_ <]: _file name_ :[ _line number_ ]:[> _the method which called the logger_ <]**

----

You're more than welcome to fork and improve this software!

repository: sadisasha/XcodeLogger

repo_name: sadisasha/XcodeLogger


text:
---
layout: post
title:  "Chat Vote Go"
date:   2017-05-26 17:42:14 -0400
---

This is my final project at Flatiron school. There were no constraints about this project. The only requirements were to use Rails, React, and Redux.
I decided to make the app where people can connect in private chat rooms, create suggestions for where to go, and vote for the best. All these features must be 'live', which means instant response to all participants of a chat room.

- **About Back End**

Firstly, I started with non-living version of the app to make sure that all was working as expected.

I implemented authentication system using expiring JWT (Javascript Web Token). When users log in to the system, they get unique tokens which represent them. JWT consists of 3 parts: header, payload, and signature to confirm authenticity of this token. In my case I store user id and nickname as payload (note that this information is public and can be used anywhere). After receiving this JWT on the client side, it must include this token in every request under Authorization header. This way the server can determine the user.

When users sign up, they can upload they avatars (with preview on the page). I implemented it using `Amazon S3` storage (as in [Study Helper](http://aleksandr-rogachev-blog.com/2017/04/22/study_helper_part_2/) project).

The main part: users can create private chatrooms and invite other users (guests) in them. Each chatroom consists of 3 parts: chatting itself, managing suggestions, and voting for them. So each chatroom has one owner and many guests (many to many relationships). Each participant can create messages, suggestions, and vote. In order to implement voting mechanism I used `activerecord_reputation_system` gem. It is really helpful.

And now the most interesting part: live chatrooms. I think the best way to implement it is to use `Websockets`. Rails (from Rails 5) created full stack `ActionCable` library (relief that front end part is available independently in npm). It implements all labor-intensive concepts of websockets, so we can easily start developing our own ideas. The main idea of websockets is to create connections between clients and server. After creating these connections server can send (broadcast)  data to all subscribers without requests. In ActionCable implementation, each client can have only one connection (cable) and several channels. Client-side code should make a request to create a cable, and it can subscribe to different channels.

In Chat Vote Go I have 2 types of channels: chatrooms messages and chatrooms suggestions (for each chatroom). So clients can create chatroom messages and suggestions independently. Voting system doesn't need the third channel. Suggestions channel handles it: when clients send voting requests, this channel performs necessary work and broadcasts two suggestions: voted and unvoted.

In order to create connection, server needs to authenticate and authorize a user. So it needs JWT. And here is the problem: websockets don't allow custom headers like Authorization! For now I've made not the best decision: send it as a query in URL. It's not really secure. So I will solve this problem later.

- **About Front End**

This was the hardest part! It was really tough to correctly understand all concepts of Redux. In order to do that I watched all [30](https://egghead.io/courses/getting-started-with-redux) + [27](https://egghead.io/courses/building-react-applications-with-idiomatic-redux) videos (even several times) of Dan Abramov (creator of Redux). They are extremely helpful. So I tried to build Idiomatic Redux. However, my app is not purely Redux: I don't keep ALL data in the store. Some UI variables and form inputs values are stored in local states of components. I think that this is the right decision: Store should care only about shared (between components) and important data.

I tend to normalize data from the server to use it effectively in Redux store. It means, for example, that chatroom object doesn't contain an array of messages object. It contains an array of messages ids. Message is an independent entity (think of it like of database), so it is stored separately from chatrooms in the form of `{ id: messageData }`:

```javascript
{
  1: { message1Data },
  2: { message2Data },
  ...
}
```

This approach to the application simplifies and clarifies programming when it gets really complex and dynamic. I think there are two main benefits: we can easily modify elements without worrying about other entities and we can effectively cache elements for significant performance boost (from the UI point of view).

So I have 6 main entities in the store:

- auth (contains authentication and ActionCable info)
- users (contains normalized users info)
- chatrooms
- messages
- suggestions
- flashMessages

In my app you can choose chatroom (or user, if you are looking for users) from the list in the sidebar. In Redux store it corresponds to the object with basic info about users (id, title). When you click on a specific chatroom, the app makes a request to the server to get full info. It leads to updating the certain record in chatrooms object.  However, app still makes a request, in case something changes on the server.

In order to visualize voting results, I use `Recharts` library (based on D3) to show pie chart.

The other important part of Idiomatic Redux is to use Selectors. Your app should not know about the shape of your store. It's the job of reducers. So reducers should have so called selectors, or getters (functions) to obtain certain slices of state or perform some calculations before returning. With the use of selectors you can easily change the shape of your store without touching your components.

When the user logs in, front end app makes a request to establish Websocket connection with server.

After that, if the user visits certain chatroom page, app makes a request to subscribe to 2 channels: chatrooms messages and suggestions. If he/she changes chatroom, app unsubscribes from the current chatroom and subscribes to the new chatroom.

I also want to notice that users can create suggestions in two modes: custom suggestion and search for suggestions. I implemented searching suggestions and getting details about them with Google Places API.

Well, it was a few words about interesting parts of my application. I'm really happy with the results. For now, I haven't found an app with the similar functionality. I hope it can be helpful.

It means that I almost finished Flatiron school! It was really immersive, exciting, and hard. Flatiron is an amazing school. I'm even slightly sad that it comes to the end. But I have to move on and start my carrier! Hope it will give me even more emotions :)

[Github Front End](https://github.com/AleksandrRogachev94/chat-vote-go-frontend)

[Github Back End](https://github.com/AleksandrRogachev94/chat-vote-go-backend)

[Website](https://chatvotego.herokuapp.com)

![chat](https://s3.amazonaws.com/my-docs-bucket/chat.png)

![vote](https://s3.amazonaws.com/my-docs-bucket/vote.png)

extension: markdown


text:
# picontrol-rs

Rust version of the PiControl driver for the Revolution Pi.

## An example: pitestrs

A command line tool to control the Pi Control process image is in the file [pitestrs.rs](src/bin/pitestrs.rs).
The executable can be cross-compiled by launching `./build_pi.sh`.
See below how to enable cross compilation.

## How to generate the Rust FFI bindings to C

1. Use bindgen binary directly:

   ```bash
   TARGET=armv7-unknown-linux-gnueabihf bindgen -o src/picontrol.rs kunbus/interface/piControl/wrapper.h  -- -I`pwd`/kunbus/interface/piControl
   ```

2. Use bindgen with a build.rs file

## Rust cross-compilation

### Cross project with Docker

See: https://github.com/rust-embedded/cross

### Same operating system

See: https://medium.com/@wizofe/cross-compiling-rust-for-arm-e-g-raspberry-pi-using-any-os-11711ebfc52b

```bash
source $HOME/.cargo/env

sudo apt-get install -qq gcc-arm-linux-gnueabihf
rustup target add armv7-unknown-linux-gnueabihf
```

Configure Cargo for cross-compilation

```bash
mkdir -p ~/.cargo
# > should not be included when pasting
cat >> ~/.cargo/config << EOF
[target.armv7-unknown-linux-gnueabihf]
linker = "arm-linux-gnueabihf-gcc"
EOF

# you may need to install this on Ubuntu 18.06
sudo apt-get install g++-multilib libc6-dev-i386
sudo apt-get install -qq gcc-arm-linux-gnueabihf
```

You can now compile:

```bash
cargo build --target=armv7-unknown-linux-gnueabihf
```

repository: mezzato/picontrol-rs

repo_name: mezzato/picontrol-rs


text:
---
nav_id: MAIN_GET_OPA
layout: default

title: Get Open Policy Agent
---

{% contentfor header %}

# Get Open Policy Agent
{: .opa-header--minor-title}

The binary releases for 64-bit Linux and Mac are available for download here. For other releases of OPA see the [GitHub Releases](https://github.com/open-policy-agent/opa/releases) page.
{: .opa-header--text}

  * [64-bit Linux](https://github.com/open-policy-agent/opa/releases/download/v0.4.8/opa_linux_amd64){: .opa-header--download-list--link}
  * [64-bit Mac OS X](https://github.com/open-policy-agent/opa/releases/download/v0.4.8/opa_darwin_amd64){: .opa-header--download-list--link}
  * [Go Source](https://github.com/open-policy-agent/opa/archive/v0.4.8.tar.gz){: .opa-header--download-list--link}
  {: .opa-header--download-list}

{% endcontentfor %}

{% contentfor body %}

## 64-bit Linux

```shell
$ curl -L https://github.com/open-policy-agent/opa/releases/download/v0.4.8/opa_linux_amd64 > opa
$ chmod u+x opa
$ ./opa version
```

## 64-bit Mac OS X

```shell
$ curl -L https://github.com/open-policy-agent/opa/releases/download/v0.4.8/opa_darwin_amd64 > opa
$ chmod u+x opa
$ ./opa version
```

## Docker Image (64-bit Linux)
```shell
$ docker run openpolicyagent/opa:0.4.8 version
```

{% endcontentfor %}

repository: timothyhinrichs/opa

gha_language: Go

repo_name: timothyhinrichs/opa


text:
# jack
Chop through that Git log wicked fast

**jack** is an interactive drop-in replacement for `git log`.  It allows you to view a list of commits and "quick-look" their changes right from the command line.  `git log`'s filtering and logging flexibility is so much better than almost all GUI apps, so in most cases, this will be a much faster way to review a series of commits/changes.

## Installation
```
npm i -g jack-cli
```

## Usage
### Generating a list
Use normal `git log` syntax.  **jack** just calls `git log` and passes all arguments.
```
jack 00ca1d8efd20^..head

jack -n 100
```

### Global Key Commands:
- **Exit jack:**                                `q | esc | ctrl + c`
- **Show/hide this help dialog:**               `?`
- **Cherry-pick commit to current branch:**     `c`
- **Open changed files in default editor:**     `o`
- **Copy current commit's SHA to clipboard:**   `y`

### Navigation Key Commands:

#### List view
- **Select next item:**                         `down | j`
- **Select previous item:**                     `up | k`
- **Go to Commit View (git show the commit):**  `space | enter`

#### Commit view
- **View next commit:**                         `shift + down | shift + j | `right
- **View previous commit:**                     `shift + up | shift + k | left`
- **Return to List View:**                      `space | enter`
- **Navigating commit content:**
    + **Scroll up:**                            `up | k`
    + **Scroll down:**                          `down | j`
    + **Scroll up half screen:**                `ctrl + u`
    + **Scroll down half screen:**              `ctrl + d`
    + **Scroll up full screen:**                `ctrl + b`
    + **Scroll down full screen:**              `ctrl + f`
    + **Scroll to top:**                        `g`
    + **Scroll to bottom:**                     `shift + g`

## Limitations
It's not currently recommended to use **jack** with really big logs (> 2000 commits), as performance starts to suffer in the list view with that many items.  This is mostly due to the interface itself, but we'll work to make it as performant as possible.  In the meantime, hopefully you're not in a situation where you have to review more than 2000 commits at a single time :)

repository: natecavanaugh/jack

repo_name: natecavanaugh/jack


text:
This repository contains all the documentations related Humix project, which includes
* Humix Setup Guide ( English )
* Humix Setup Guide ( Chinese )
* Module Development Guide (TBD)
* Humix Meetup Slides

# Available Modules

Currently the only core module is [humix-dialog-module](https://github.com/project-humix/humix-dialog-module), which provides speech-recognition and text-to-speech capability.

There are other modules that under development, will post it here when generally available.

repository: project-humix/humix-docs

repo_name: project-humix/humix-docs


text:
# Sitelink Generator

[Search.gov](https://search.gov) powers the search box on 1,500 government websites.

This sitelink generator "decorates" organic web results to provide additional, value-added links to help searchers find what they're looking for.

See the sample results page below that shows sitelink-generated links for EDGAR filings for a search on *apple* on SEC.gov.

![Sitelink-generated links for EDGAR filings on SEC.gov](https://9fddeb862c037f6d2190-f1564c64756a8cfee25b6b19953b1d23.ssl.cf2.rackcdn.com/sitelink.png "Sitelink-generated links for EDGAR filings on SEC.gov")

## Installation

Add sitelink_generator to your `Gemfile` and `bundle install`:

```ruby
gem 'sitelink_generator'
```

## Available Generators

[Available generators](lib/sitelink_generator/generators/) include:

* [SecEdgar](lib/sitelink_generator/generators/sec_edgar.rb)

## Usage

```ruby
require 'sitelink_generator'

url = 'http://www.sec.gov/Archives/edgar/data/1577552/000119312514184994/d709111df1.htm'
SitelinkGenerator::SecEdgar.generate url
#=> [{:title=>"Full Filing",
#     :url=>"http://www.sec.gov/Archives/edgar/data/1577552/0001193125-14-184994-index.htm"},
#    {:title=>"Most Recent Filings for this Company",
#     :url=>"http://www.sec.gov/cgi-bin/browse-edgar?CIK=1577552&Find=Search&action=getcompany&owner=exclude"}]
```

## Supported Ruby Versions

* Ruby 2.1

## Feedback

If you think you found a bug in SitelinkGenerator, you can [submit an issue](https://github.com/GSA/sitelink_generator/issues/new).


text:
{{{
"title": "Error When Creating a Provider Outside Territory",
"date": "02-20-2017",
"author": "Ben Swoboda",
"attachments": [],
"contentIsHTML": false
}}}

<iframe width="560" height="315" src="https://player.vimeo.com/video/204243434" frameborder="0" allowfullscreen></iframe>

### Introduction

Lumen Cloud is limited by contract with Microsoft to sell Azure only to specific countries. This tutorial demonstrates the alert message that will display if the Lumen Cloud billing address linked to an admin account is outside the territory permitted by Microsoft.

### Billing Address Must Match Territory

The following error will appear if the Lumen Cloud billing address associated with the user and account alias is outside the territory allowed by our contract with Microsoft.

![Cloud Application Manager Error: Outside of Territory](../../images/cloud-application-manager-territory2.png)

Here's how you might arrive at this error message. After you log into [Cloud Application Manager](https://www.ctl.io/cloud-application-manager), click the **Provider** tab on the top toolbar.

![Cloud Application Manager Create New Provider](../../images/cloud-application-manager-error3.png)

Then click **New Provider** on the left navigation bar.

Select **Microsoft Azure** to build a customer account in the current Microsoft Azure. Note: this is the new Azure, not the classic Azure. The dialog box that appears will enable you to create a new Azure customer account. Add a name for the account and select the **Create a new Azure Subscription** option.

![Cloud Application Manager New Provider Details](../../images/cloud-application-manager-error4.png)

### The Exception Message

If the Lumen Cloud billing address associated with the user and alias is outside the territory given to us by Microsoft, you will see this error message letting you know we are not permitted to offer the product to you.

"Thank you for your interest in Integrated Azure. Our apologies, but we are not able to provide that functionality for your account. Please submit a support request if you would like us to review your situation in further detail."

If you send us a ticket we will review your case.

![Cloud Application Manager Error: Account Outside of Terrritory](../../images/cloud-application-manager-territory2.png)

### Contacting Cloud Application Manager Support

We’re sorry you’re having an issue in [Cloud Application Manager](https://www.ctl.io/cloud-application-manager/). Please review the [troubleshooting tips](troubleshooting-tips.md), or contact [Cloud Application Manager<EMAIL_ADDRESS>with details and screenshots where possible.

For issues related to API calls, send the request body along with details related to the issue.

In the case of a box error, share the box in the workspace that your organization and Cloud Application Manager can access and attach the logs.
* Linux: SSH and locate the log at /var/log/elasticbox/elasticbox-agent.log
* Windows: RDP into the instance to locate the log at ProgramDataElasticBoxLogselasticbox-agent.log

repository: AnthonyHakim/PublicKB

gha_license_id: NOASSERTION

repo_name: AnthonyHakim/PublicKB


text:
# Proton — Ruby Electron — Desktop app using Ruby and Node!

Ruby Electron is an experimental work. As an open source project, it should provide a full port of [Electron](https://electronjs.org), the perfect web desktop app framework. Some parts are currently working, but everything needs more work. As time is passing, more and more features will be added, and examples will be provided in the future. [They can be found here](https://github.com/ghivert/proton-sample-apps).

Right now, Proton can be bundled as a gem, but is not purposefully. It is still at a really early stage, and eveything can change or break previous code at any moment. When stable, Proton will be released on RubyGems.

## How does it work ?

Ruby Electron makes its magic with help of Node.js and [Opal](http://opalrb.com). Opal is a transpiler from Ruby to JavaScript. It has few limitations like non mutable string. Otherwise it provides a full transpiler. More details can be found on the page of the project.
Providing Electron to Ruby users, Proton makes extensive use of Electron, by providing a Ruby-like library.

## How to compile ?

```
git clone https://github.com/ghivert/proton.git
cd proton
gem build proton.gemspec
gem install ./proton-0.1.0.gem
```

## How can I use it ?

Once you cloned and locally installed the gem, you can simple use `proton main.rb` on a correct file (see the examples or sources). Everything is automated to give the perfect Proton experience !

## Remarks ?
### PR ? Contributing ?
PR are welcome. :) You can else mail me, or come and contribute if you like the project and want to help ! Any help is welcome, even docs !

### Tests
"Hey guy, you're not writing tests!" I know. Proton is mainly a POC as for now, and shouldn't be used into production. If the project goes on, Spectron will probably be used.

### Issues
Any issues ? Let me know, I'll fix it as soon as I can !

## Licence

MIT Licence. Enjoy the work.

## Why ?

Because it's both fun and useful. Electron rocks. Ruby rocks.

Ruby + Electron = <3

## Support on Beerpay
Hey dude! Help me out for a couple of :beers:!

[![Beerpay](https://beerpay.io/ghivert/proton/badge.svg?style=beer-square)](https://beerpay.io/ghivert/proton)  [![Beerpay](https://beerpay.io/ghivert/proton/make-wish.svg?style=flat-square)](https://beerpay.io/ghivert/proton?focus=wish)

repository: rubycoder/proton

repo_name: rubycoder/proton


text:
---
brfc: true
title: bsvalias Payment Addressing (PayTo Protocol Prefix)
author: andy (nChain)
version: 1
---
# PayTo Protocol Prefix

{{yfm}}

The PayTo Protocol Prefix specification defines the URI prefix `payto:` to mean _launch a paymail payment to the specified paymail handle_. Additional query string parameters _MAY_ be included; these are defined below.

paymail client implementers _SHOULD_ ensure that their application is registered with the target device operating system as a protocol/deeplink handler for the `payto:` protocol prefix.

## Full Specification

```
payto:<receiver>?amount=<amount>&purpose=<purpose>
```

| Token | Required | Description |
|-|-|-|
| `receiver` | ✓ |<EMAIL_ADDRESS>formatted paymail handle, for example<EMAIL_ADDRESS>|
| `amount` | | Integer number of satoshis to be paid. |
| `purpose` | | Human-readable description of the purpose of the payment  |

## Capability Discovery

This specification governs client-side behaviour. No specific capabilities are delivered by paymail implementations.

repository: wireturn/bsv

repo_name: wireturn/bsv


text:
# Lawndart

A unified, asynchronous, easy-to-use library for offline-enabled
browser-based web apps. Kinda sorta a port of Lawnchair to Dart,
but with Futures and Streams.

Lawndart uses Futures to provide an asynchronous, yet consistent,
interface to local storage, indexed db, and websql. This library is designed
for simple key-value usage, and is not designed for complex transactional
queries. This library prefers simplicity and uniformity over expressiveness.

You can use this library to help deal with the wide array of client-side
storage options. You should be able to write your code against the Lawndart
interface and have it work across browsers that support at least one of the
following: local storage, indexed db, and websql.

# Example

```dart
// Picks the best store available.
var db = await Store.open('simple-run-through', 'test');

await db.open();
await db.nuke();
await db.save('world', 'hello');
await db.save('is fun', 'dart');

var value = await db.getByKey('hello');

querySelector('#text').text = value;
```

See the example/ directory for more sample code.

# Choosing the best storage option

This is now made easy for you. Simply create a new instance of Store:

```dart
var store = await Store.open('dbName', 'storeName');
```

The factory constructor will try IndexedDB, then WebSQL, and then finally
local storage. Of course, you can perform your own logic to choose which
option works for you.

# API

`Future Store.open()`
Opens the database and makes it available for reading and writing.

`Future nuke()`
Wipes the database clean. All records are deleted.

`Future save(value, key)`
Stores a value accessible by a key.

`Future getByKey(key)`
Retrieves a value, given a key.

`Stream keys()`
Returns all keys.

`Stream all()`
Returns all values.

`Future batch(map)`
Stores all values and their keys.

`Stream getByKeys(keys)`
Returns all values, given keys.

`Future exists(key)`
Returns true if the key exists, or false.

`Future removeByKey(key)`
Removes the value for the key.

`Future removeByKeys(keys)`
Removes all values for the keys.

# Usage

Most methods return a Future, like `open` and `save`.
Methods that would return many things, like `all`, return a Stream.

# Supported storage mechanisms

* Indexed DB - Great choice for modern browsers
* WebSQL - Well supported in mobile WebKit browsers, not in Firefox
* Local Storage - Only 5MB, slow, more-or-less universal
* Memory - Good for testing

You can consult [Can I Use?](http://caniuse.com) for a breakdown of browser
support for the various storage technologies.

# Install

Lawndart is a pub package. To install it, and link it into your app,
add lawndart to your pubspec.yaml. For example:

```yaml
name: your_cool_app
dependencies:
  lawndart: any
```

If you use Dart Editor, select your project from the Files view, then go
to Tools, and run Pub Install.

If you use the command line, ensure the Dart SDK is on your path, and
the run: `pub install`

# Support

Lawndart is hosted at https://github.com/sethladd/lawndart

You can file issues at https://github.com/sethladd/lawndart/issues

API docs at http://sethladd.github.com/lawndart/

This library is open source, pull requests welcome!

# Authors

* Seth Ladd<EMAIL_ADDRESS>
# License

```no-highlight
Copyright 2015 Google

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

repository: denniskaselow/lawndart

repo_name: denniskaselow/lawndart


text:
# coreMQTT Client Library

This repository contains the coreMQTT library that has been optimized for a low memory footprint.  The coreMQTT library is fully compliant with the [MQTT 3.1.1](http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/mqtt-v3.1.1.html) standard.  It has no dependencies on any additional libraries other than the standard C library, a customer-implemented network transport interface, and *optionally* a user-implemented platform time function.  This library is distributed under the [MIT Open Source License](LICENSE).

This library has gone through code quality checks including verification that no function has a [GNU Complexity](https://www.gnu.org/software/complexity/manual/complexity.html) score over 8, and checks against deviations from mandatory rules in the [MISRA coding standard](https://www.misra.org.uk/MISRAHome/MISRAC2012/tabid/196/Default.aspx).  Deviations from the MISRA C:2012 guidelines are documented under [MISRA Deviations](MISRA.md). This library has also undergone both static code analysis from [Coverity static analysis](https://scan.coverity.com/), and validation of memory safety and proof of functional correctness through the [CBMC automated reasoning tool](https://www.cprover.org/cbmc/).

## MQTT Config File

The MQTT client library exposes build configuration macros that are required for building the library.
A list of all the configurations and their default values are defined in [core_mqtt_config_defaults.h](https://github.com/FreeRTOS/coreMQTT/blob/master/source/include/core_mqtt_config_defaults.h).
To provide custom values for the configuration macros, a custom config file named `core_mqtt_config.h` can be
provided by the application to the library.

By default, a `core_mqtt_config.h` custom config is required to build the library. To disable this requirement
and build the library with default configuration values, provide `MQTT_DO_NOT_USE_CUSTOM_CONFIG` as a compile time preprocessor macro.

**Thus, the MQTT library can be built by either**:
* Defining a `core_mqtt_config.h` file in the application, and adding it to the include directories list of the library
**OR**
* Defining the `MQTT_DO_NOT_USE_CUSTOM_CONFIG` preprocessor macro for the library build.

## Building the Library

The [mqttFilePaths.cmake](https://github.com/FreeRTOS/coreMQTT/blob/master/mqttFilePaths.cmake) file contains the information of all source files and the header include path required to build the MQTT library.

As mentioned in the previous section, either a custom config file (i.e. `core_mqtt_config.h`) OR `MQTT_DO_NOT_USE_CUSTOM_CONFIG` macro needs to be provided to build the MQTT library.

For a CMake example of building the MQTT library with the `mqttFilePaths.cmake` file, refer to the `coverity_analysis` library target in [test/CMakeLists.txt](https://github.com/FreeRTOS/coreMQTT/blob/master/test/CMakeLists.txt) file.

## Building Unit Tests

### Checkout CMock Submodule
By default, the submodules in this repository are configured with `update=none` in [.gitmodules](.gitmodules) to avoid increasing clone time and disk space usage of other repositories (like [amazon-freertos](https://github.com/aws/amazon-freertos) that submodule this repository.

To build unit tests, the submodule dependency of CMock is required. Use the following command to clone the submodule:
```
git submodule update --checkout --init --recursive --test/unit-test/CMock
```

### Platform Prerequisites

- For running unit tests
    - **C90 compiler** like gcc
    - **CMake 3.13.0 or later**
    - **Ruby 2.0.0 or later** is additionally required for the CMock test framework (that we use).
- For running the coverage target, **gcov** and **lcov** are additionally required.

### Steps to build **Unit Tests**

1. Go to the root directory of this repository. (Make sure that the **CMock** submodule is cloned as described [above](#checkout-cmock-submodule))

1. Run the *cmake* command: `cmake -S test -B build -DBUILD_CLONE_SUBMODULES=ON `

1. Run this command to build the library and unit tests: `make -C build all`

1. The generated test executables will be present in `build/bin/tests` folder.

1. Run `cd build && ctest` to execute all tests and view the test run summary.

## Reference examples

The AWS IoT Embedded C-SDK repository contains demos of using the MQTT client library [here](https://github.com/aws/aws-iot-device-sdk-embedded-C/tree/master/demos/mqtt) on a POSIX platform. These can be used as reference examples for the library API.

## Generating documentation

The Doxygen references were created using Doxygen version 1.8.20. To generate the
Doxygen pages, please run the following command from the root of this repository:

```shell
doxygen docs/doxygen/config.doxyfile
```

gha_language: C


text:
---
layout: relation
title: 'mark'
shortdef: 'marker'
udver: '2'
---

In Irish the `mark` label is used for infinitive markers and for subordinate conjunctions.
Note that subordinate conjunctions are attached to the head of the complement clause (not the matrix clause as is the case in the Irish Dependency Treebank). In Irish, we also have a language sub-type label [mark:prt](https://universaldependencies.org/ga/dep/mark-prt.html).

### Examples

#### Subordinate conjunctions

_Cé go ndeachaigh sé thar fóir leis an tuairim sin , is cinnte go raibh mórán scríobhneoirí Béarla den bharúil chéanna_ `Although he went overboard with that opinion , it was certain that many English writers had the same opinion'

~~~ sdparse
Cé go ndeachaigh sé thar fóir leis an tuairim sin , is cinnte go raibh mórán scríobhneoirí Béarla den bharúil chéanna \n Although that went he over board with the opinion DEM , is certain that was many writers English of_the opinion same
mark(ndeachaigh, Cé)
advcl(is, ndeachaigh)
~~~

_ní raibh cuimhne chruinn againn ar a chéile, ach ghlacamar leis_ 'We do not have a clear memory of eachother, but we accepted it'

~~~ sdparse
ní raibh cuimhne chruinn againn ar a chéile, ach ghlacamar leis \n not was memory clear we_have of_eachother, but we_accepted it
mark(ghlacamar, ach)
advcl(raibh, ghlacamar)
~~~

_Ba ar Mháirín a smaoiníodh sé nuair a d' fheicfeadh sé iad_ `He would think of Máirín when he would see them'

~~~ sdparse
Ba ar Mháirín a smaoiníodh sé nuair a d' fheicfeadh sé iad \n Was on Máirín that would_think he when [] [] would_see he them
mark(fheicfeadh, nuair)
~~~

Note that the coordinating conjunction _agus_ ('and') may function as a subordinating conjunction when it is used to introduce a subordinating clause usually headed by a noun, as shown in the example below. In cases such as this one, _agus_ is labelled `mark`.

_Sa bhliain san ghaibh na Turcaigh François de Vic agus é ar thuras go dtí Vín._ `The Turkish Army apprehended François de Vic while he was on a trip to Vienna.'

~~~ sdparse
ROOT Sa bhliain san ghaibh na Turcaigh François de Vic agus é ar thuras go dtí Vín \n In_the year that got the Turkish François de Vic and he on trip to [] Vienna
mark(é, agus)
root(ROOT, ghaibh)
advcl(ghaibh, é)
~~~

#### With copular 'ná'

Note that the clause that follows ‘ná’ is an adverbial clause in certain cases like the example below.

_Is lú fós a bhí radacachas go forleathan in ollscoileanna na hÉireann ná mar a Bhí thar lear._ '  'There is less widespread radicalism in Irish universities than abroad.'

~~~ sdparse
Is lú fós a bhí radacachas go forleathan in ollscoileanna na hÉireann ná mar a Bhí thar lear. \n (COP)is less that radicalsim widespread in universities of Ireland than there_was abroad
cop(lú, Is)
mark(Bhí, ná)
advcl(Bhí, lú)
~~~

#### Infinitive marker

_Caithfidh mé sin a fhoghlaim_ `I will have to learn that'

~~~ sdparse
Caithfidh mé sin a fhoghlaim \n will_have I that to learn
mark(fhoghlaim, a)
~~~

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

gha_language: HTML

repo_name: UniversalDependencies/docs


text:
Qwervoragrams
=============
Qwervoragrams are (I have decided) sets of word that can be typed on
(at least) two different keyboard layouts using the same keystrokes.

The word is a portmanteau of 'qwerty', 'Dvorak', and 'anagram'.

This repo contains a scala application that finds qwervoragrams from a
file containing a list of words. It only finds qwerty-Dvorak qwervoragrams.

Findings
--------
Here are some of the better qwervoragrams (of the form "qwerty word,
Dvorak word"):

* flossy, unroof
* kodak, treat
* hoard, drape
* maid, mace
* raid, pace
* malt, many
* lard, nape
* goal, iran
* Noah, Brad
* boat, xray
* Isis, Coco
* maud, mage
* idol, cern
* roam, pram
* paid, lace
* sods, oreo
* soap, oral
* slid, once
* card, jape

There are also a few examples where the Dvorak word is the same as
the qwerty word:

* mama
* mmmm

These are called Homoqwervoragrams.

Full output from the application can be found in the file `output/qwerverograms.txt`.

Future research
---------------
Investigation into qwervoragram phrases or sentences, or
even runnable source code may be interesting.

Or pointless.

Contributions
-------------
Thanks to [SCOWL and friends][scowl] for the word list. See `res/README`
and `res/README_SCOWL` for more info.

Thanks to [wikipedia][wiki-dvorak-encoding] for the qwerty-Dvorak conversion.

[scowl]: http://wordlist.aspell.net/
[wiki-dvorak-encoding]: https://en.wikipedia.org/wiki/Dvorak_encoding

license: Unlicense

repository: RichardOfWard/qwervoragrams

repo_name: RichardOfWard/qwervoragrams


text:
# IntersightClient::UuidpoolUuidLeaseAllOf

## Properties

| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **class_id** | **String** | The fully-qualified name of the instantiated, concrete type. This property is used as a discriminator to identify the type of the payload when marshaling and unmarshaling data. | [default to 'uuidpool.UuidLease'] |
| **object_type** | **String** | The fully-qualified name of the instantiated, concrete type. The value should be the same as the 'ClassId' property. | [default to 'uuidpool.UuidLease'] |
| **uuid** | **String** | UUID Prefix+Suffix numbers. | [optional] |
| **assigned_to_entity** | [**MoBaseMoRelationship**](MoBaseMoRelationship.md) |  | [optional] |
| **pool** | [**UuidpoolPoolRelationship**](UuidpoolPoolRelationship.md) |  | [optional] |
| **pool_member** | [**UuidpoolPoolMemberRelationship**](UuidpoolPoolMemberRelationship.md) |  | [optional] |
| **universe** | [**UuidpoolUniverseRelationship**](UuidpoolUniverseRelationship.md) |  | [optional] |

## Example

```ruby
require 'intersight_client'

instance = IntersightClient::UuidpoolUuidLeaseAllOf.new(
  class_id: null,
  object_type: null,
  uuid: null,
  assigned_to_entity: null,
  pool: null,
  pool_member: null,
  universe: null
)
```

repository: xlab-si/intersight-sdk-ruby

gha_language: Ruby

repo_name: xlab-si/intersight-sdk-ruby


text:
# es6-class-minify

Package to minify ES6 classes and objects.

Current minifiers cannot minify ES6 class fields and member functions.
This is because they are not able to track the class when a method is called on an object.

This package provides a simple way to minify class fields and members by
manually prefixing the name with a `_`.
This package will rename all fields and members in a class and all corresponding
accesses on an object.
This package does not need to track which object is an instance of which class,
because it can simply rename all usages of a field or method prefixed by `_`.
The standard JavaScript definitions do not include such names, so built-in
names are never accidentally minified.

## Installation

```bash
npm install es6-class-minify
```

## Usage

Single file:

```javascript
import { ES6ClassMinify } from "es6-class-minify";

const es6ClassMinify = new ES6ClassMinify();
es6ClassMinify.minify("...");
```

## Example

Plain code:

```javascript
class Counter {
  _count = 0;

  _plus() {
    this._count++;
  }

  _get() {
    return this._count;
  }
}

const counter = new Counter();
counter._plus();
counter._plus();
console.log(counter._get());
```

Minified code:

```javascript
class Counter {
  a = 0;

  b() {
    this.a++;
  }

  c() {
    return this.a;
  }
}

const counter = new Counter();
counter.b();
counter.b();
console.log(counter.c());
```

All class members and fields are minified.
Other variables are not minified, since there are already very good minifiers
for those things.
You should use this package in addition to another classical minifier.


text:
# tparse

`Parse` will return the time corresponding to the layout and value.
It also parses floating point epoch values, and values of "now",
"now+DURATION", and "now-DURATION".

In addition to the duration abbreviations recognized by
`time.ParseDuration`, tparse recognizes various tokens for days,
weeks, months, and years, as well as tokens for seconds, minutes, and
hours.

Like `time.ParseDuration`, it accepts multiple fractional scalars, so
"now+1.5days-3.21hours" is evaluated properly.

## Documentation

In addition to this handy README.md file, documentation is available
in godoc format at
[![GoDoc](https://godoc.org/github.com/karrick/tparse?status.svg)](https://godoc.org/github.com/karrick/tparse).

## Examples

### ParseNow

`ParseNow` can parse time values that are relative to the current
time, by specifying a string starting with "now", a '+' or '-' byte,
followed by a time duration.

```Go
    package main

    import (
        "fmt"
        "os"
        "time"
        "github.com/karrick/tparse"
    )

    func main() {
        actual, err := tparse.ParseNow(time.RFC3339, "now+1d-3w4mo+7y6h4m")
        if err != nil {
            fmt.Fprintf(os.Stderr, "error: %s\n", err)
            os.Exit(1)
        }
        fmt.Printf("time is: %s\n", actual)
    }
```

### ParseWithMap

`ParseWithMap` can parse time values that use a base time other than "now".

```Go
    package main

    import (
        "fmt"
        "os"
        "time"
        "github.com/karrick/tparse"
    )

    func main() {
        m := make(map[string]time.Time)
        m["end"] = time.Now()

        start, err := tparse.ParseWithMap(time.RFC3339, "end-12h", m)
        if err != nil {
            fmt.Fprintf(os.Stderr, "error: %s\n", err)
            os.Exit(1)
        }

        fmt.Printf("start: %s; end: %s\n", start, end)
    }
```

### AddDuration

`AddDuration` is used to compute the value of a duration string and
add it to a known time. This function is used by the other library
functions to parse all duration strings.

The following tokens may be used to specify the respective unit of
time:

 * Nanosecond: ns
 * Microsecond: us, µs (U+00B5 = micro symbol), μs (U+03BC = Greek letter mu)
 * Millisecond: ms
 * Second: s, sec, second, seconds
 * Minute: m, min, minute, minutes
 * Hour: h, hr, hour, hours
 * Day: d, day, days
 * Week: w, wk, week, weeks
 * Month: mo, mon, month, months
 * Year: y, yr, year, years

```Go
    package main

    import (
        "fmt"
        "os"
        "time"

        "github.com/karrick/tparse"
    )

    func main() {
        now := time.Now()
        another, err := tparse.AddDuration(now, "+1d3w4mo-7y6h4m")
        if err != nil {
            fmt.Fprintf(os.Stderr, "error: %s\n", err)
            os.Exit(1)
        }

        fmt.Printf("time is: %s\n", another)
    }
```

### AbsoluteDuration

When you would rather have the `time.Duration` representation of a
duration string, there is a function for that, but with a
caveat.

First, not every month has 30 days, and therefore Go does not have a
`time.Duration` type constant to represent one month.

When I add one month to February 3, do I get March 3 or March 4?
Depends on what the year is and whether or not that year is a leap
year.

Is one month always 30 days? Is one month 31 days, or 28, or 29? I did
not want to have to answer this question, so I defaulted to saying the
length of one month depends on which month and year, and I allowed the
Go standard library to add duration concretely to a given moment in
time.

Consider the below two examples of calling `AbsoluteDuration` with the
same duration string, but different base times.

```Go
func ExampleAbsoluteDuration() {
    t1 := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)

    d1, err := AbsoluteDuration(t1, "1.5month")
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(d1)

    t2 := time.Date(2020, time.February, 10, 23, 0, 0, 0, time.UTC)

    d2, err := AbsoluteDuration(t2, "1.5month")
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(d2)
    // Output:
    // 1080h0m0s
    // 1056h0m0s
}
```

## Benchmark against goparsetime

```Bash
GO111MODULE=on go test -bench=. -tags goparsetime
```

repository: karrick/tparse

repo_name: karrick/tparse


text:
# fire-dashboard
 Global Fire Dashboard frontend

![dashboard](https://raw.githubusercontent.com/Global-Mapping-Hub/fire-dashboard/master/screenshot.png)

## Installation
```shell
git clone https://github.com/Global-Mapping-Hub/fire-dashboard.git
cd fire-dashboard
npm install
```

## Build
```shell
npm run build
```

## Development (webpack-dev-server)
```shell
npm run start
```

repository: Global-Mapping-Hub/fire-dashboard

repo_name: Global-Mapping-Hub/fire-dashboard


text:
Spree Promotion Variant Rule
============================

Currently with spree core you can select products to be included in a promotion, but you can't select specific variants of products.

This extension adds this functionality. However, right now there is no GUI for adding variants. You have to add them manually through the command line.

Eventually I'd like to see this functionality [merged into spree core](https://github.com/spree/spree/issues/2272) but I don't have the time to create the PR right now.

Adding Products on the Command Line
-----------------------------------

This is ugly hack for not having the time to write a proper GUI for this. Create the promotion, open up the rails console, then:

```
# find the promotion; use the ID in the admin URL
p = Spree::Promotion.find(8)

# get your list of variants
variants = [Spree::Variant.last]

# assuming you only have one rule
p.rules.first.variants = variants
```

Copyright (c) 2012 Michael Bianco, released under the New BSD License


text:
# Lucida

Lucida is a speech and vision based intelligent personal assistant.
Post to [Lucida-users](http://groups.google.com/forum/#!forum/sirius-users)
for more information and answers to questions. The project is released under [BSD license](LICENSE),
except certain submodules
contain their own specific licensing information. We would love to have your
help on improving Lucida, and see [CONTRIBUTING](CONTRIBUTING.md) for more
details.

repository: knkrth/lucida

repo_name: knkrth/lucida


text:
# GitSearch

#### 15-7-2019

#### By juliet muthee

## Description

An Application where you can search for a github user and get their details.
![alt text](https://github.com/juliet-jay/angular-gitHubSearch/blob/master/src/assets/gitSearchLanding.PNG "GitSearch Landing Image")

## Installation

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 8.0.3.

* Clone the repo
* Download the dependencies in the package.json using `npm install`
* Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files

## Code scaffolding

Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

## Build

Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `--prod` flag for a production build.

## Behaviour Driven Development

1.Feature:**Submit A User Name**

   As a user,you must be able to type a valid username to retrieve the user's data

  **Scenario:Search for a user**

     Given There is an a search field
     When i submit a valid user name
     Then the details section is revealed
     Then i can see details of the user i searched for

## Known Issues

* It cannot search for repos

## Technologies Used

* Angular8
* HTML
* CSS
* Typescript
* Bootstrap4
* Font-Awesome

## License

MIT (c) 2019

repository: Juliet-jay/Gitsearch

repo_name: Juliet-jay/Gitsearch


text:
# From Docker

You can get the official image from the docker repository :

```bash
docker pull maif/izanami
```

AND then run it

```bash
docker run -p "8080:8080" -e "FILTER_CLAIM_SHAREDKEY=averyrandomandsecretvalue" maif/izanami
```

you can also provide some ENV variable using the --env flag to customize your Izanami instance. Check the configuration documentation @see[here](../settings/settings.md)

repository: MAIF/izanami

repo_name: MAIF/izanami


text:
# dooper

A Python library for interfacing with SooperLooper. Requires pyliblo.

Tracks full state and provides interface to all loop commands. Almost a complete client, just missing changing loop count, saving sessions, and modifying midi bindings.

## Install

It's just a simple module, so place the folder somewhere in your Python path or copy/link `dooper.py` to your project folder.

## Examples

To connect to SooperLooper, query state and control loops:

```
from dooper import LooperThread

l = LooperThread()
l.start_server()

l.loops[0].state # Automatically converts the number SL uses to a string
l.loops[0].mute() # Hits mute for the first loop

l.selected_loop_num = 2
```

Here's how you might use dooper to add a feature to SooperLooper. Assuming here that we're working with an external sync source, this will stop recording four bars (in 4/4) after recording starts on a given loop. Some additional features to add would be catching the divide by zero error that occurs if there's no tempo set and canceling the timer if we cancel recording of the loop.

```
from threading import Timer
from dooper import LooperThread, state_codes

l = LooperThread()
l.start_server()

def auto_stop(args):
    if args[1] == 'state' and state_codes[args[2]] == 'Recording':
        bar_time = 1 / (l.tempo / 60) * 4
        wait1 = bar_time * 3.1
        Timer(wait1, l.loops[int(args[0])].record).start()

l.loop_callbacks.append(auto_stop)

while 1:
    time.sleep(1000)
```

repository: scottyeager/dooper

repo_name: scottyeager/dooper