text:
## About

:sparkles: A curated list of awesome articles, websites and resources about USB carrots. :sparkles:

## Contents

- [Applications](#applications)
- [Articles](#articles)
- [Books](#books)
- [Conferences](#conferences)
- [Meetups](#meetups)
- [Podcasts](#podcasts)
- [Talks](#talks)

## Applications

Applications to help with dealing with USB carrots.

## Articles

Articles, posts and papers on USB carrots.

## Books

Books that have USB carrots as the main theme.

## Conferences

Conferences spreading the word of the importance of USB carrot awareness.

## Meetups

Meetup groups all around the world focusing on USB carrots.

## Podcasts

Podcast episodes with USB carrots as the main theme.

## Talks

Talks and presentations about USB carrots and other testimonies and experiences.

## Contributing

## Adding to this list

Please ensure your pull request adheres to the following guidelines:

- Search previous suggestions before making a new one, as yours may be a duplicate.
- Make an individual pull request for each suggestion.
- Use **title-casing** (AP style).
- Use the following format: `[List Name](link)` - `Short description of the content or author of the resource`.
- Link additions should be added **ordered alphabetically**.
- New categories or improvements to the existing categorization are welcome (**in alphabetical order**).
- Check your spelling and grammar.
- Make sure your text editor is set to remove trailing whitespace.
- The pull request and commit should have a useful title.
- The body of your commit message should contain a link to the resource.

Thank you for your suggestions! :heart:

## License

[![CC0](http://mirrors.creativecommons.org/presskit/buttons/88x31/svg/cc-zero.svg)](https://creativecommons.org/publicdomain/zero/1.0/)

To the extent possible under law, [underyx](https://github.com/underyx) has waived all copyright and related or neighboring rights to this work.

repository: underyx/awesome-usb-carrots

repo_name: underyx/awesome-usb-carrots


text:
## Portfolio

---

### Web Scraping Projects

Scraper to collect Companies Information [Sample Data](https://github.com/AbdurRehman1234/web-scraping-projects/tree/master/Mr.sininternational)

---
Restaurants [Sample Data](https://github.com/AbdurRehman1234/web-scraping-projects/tree/master/MR.stan)

---
Google Maps Scraper [Sample Data](https://github.com/AbdurRehman1234/web-scraping-projects/tree/master/makeguiforscraper)

---

---

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
Introduction
-----------
Lambda (formerly FiftyOne) is a modern, high-definition theme for StepMania 5.x. It is designed to serve as the default theme for StepMania 5.1; it features a clean aesthetic with bold colors that reflects modern design trends, yet still maintains a suitable level of energy for a rhythm game. Under the hood, it's also a bit more future-proof than the previous theme, with certain screens featuring more prominent use of backend Lua code to replace legacy methods of rendering particular elements.

Progress
-----------
As of August 8, 2017, Lambda has been declared feature complete, and has been added to the StepMania source tree in its 5_1-new branch. Our priority right now is finding any possible bugs, performing final fit and finish tweaks, and possibly adding new sounds and music. This repository will continue to be updated with changes made to the "official" version in the StepMania source tree, and vice versa, so feel free to contribute on either repository.

Source code
-----------
Inkscape SVG source code is available for the majority of graphics created in the _src folder on the repository used to develop it, located at <https://github.com/ListenerJubatus/smtheme-fiftyOne> Some of the original mockups are also included for reference, although they are meant primarily for reference purposes due to changes in the theme's style since these mockups (such as the removal of rounded corners and increased use of chamfered edges and diamond motifs).

The main fonts are the current version of Roboto and Noto Sans <https://www.google.com/design/spec/resources/roboto-noto-fonts.html>, and Open Sans (although, preferably, Noto Sans should eventually be used in any location Open Sans is currently used). Certain accents make use of the fonts Overpass <http://overpassfont.org/> and Zeroes <http://www.dafont.com/zero-threes.font>

License
-----------
As it incorporates existing code from StepMania, and is intended to possibly be part of the main distribution, Lambda is licensed under the terms of the MIT License.

Notice about branches
-----------
The master branch, as of April 10, 2017, is now the 5.0 branch that was created by Riakodoadm, and the previous version has been moved to a new "5.2" branch. This mirrors the similar rollback that StepMania itself performed.

Since the new 5.1 is meant to be more compatible with 5.0.x, you no longer need a nightly build to run this theme.

license: MIT

repository: ListenerJubatus/smtheme-fiftyOne

gha_language: Lua

repo_name: ListenerJubatus/smtheme-fiftyOne


text:
# Blue Ocean Modular UX Widgets

## Packages

- **[ux-widget-framework](packages/ux-widget-framework)** - Contains both build-time tools to compile widgets, as well as runtime library code used by widgets themselves.
- **[pipeline-graph](packages/pipeline-graph)** - The PipelineGraph component used to show the results of a build in graphical form, from Blue Ocean.

## Building

### Yarn

1.  Clone the repo
2.  `cd blueocean-widgets`
3.  `yarn`
4.  `yarn bootstrap`
5.  `yarn dist`

### NPM

1.

gha_license_id: MIT


text:
#### Scripts
##### New: ShowIncidentIndicators
This script is used to display the indicators of an incident in an incident field of type Array. It can be used to select indicators from the incident in order to later perform some actions, like tagging the indicators for blocking via EDL.
This script is a field-display script, so it needs to be configured as such, when editing the incident field that will be used to display the indicators. (Available from Cortex XSOAR 6.5.0).

repository: demisto/content

gha_language: Python

repo_name: demisto/content


text:
# content-slider

[![Size](https://img.shields.io/github/size/astrocaleb/content-slider/dist/content-slider.min.js)](https://www.npmjs.com/package/@astrocaleb/content-slider)
[![npm](https://img.shields.io/npm/dw/@astrocaleb/content-slider)](https://www.npmjs.com/package/@astrocaleb/content-slider)

> Visually navigate between layered content without leaving the page.

## Getting started

```text
dist/
├── content-slider.js
├── content-slider.min.js
├── content-slider.css
└── content-slider.min.css
```

### Installation

```bash
# npm
npm i @astrocaleb/content-slider
```

In browser:

```html
<!-- not required unless `options.injectCSS` is set to `false` -->
<link href="/path/to/content-slider.css" rel="stylesheet">

<!-- not required if importing the `ContentSlider` module -->
<script src="/path/to/content-slider.js"></script>
```

## Usage

### HTML

This is the minimum markup required for using the default configuration.

```html
<div data-content-slider> <!-- Wrapper for this content slider instance -->
    <div data-cs-panes>   <!-- Content panes wrapper -->
        <div data-cs-pane data-breadcrumb-text="Pane 1">...</div>
        <div data-cs-pane data-breadcrumb-text="Pane 2">...</div>
    </div>
</div>
```

The following data attributes are required for each content slider instance:
- `data-content-slider` (only one per instance)
- `data-cs-panes` (only one per instance)
- `data-cs-pane` (as many as you need)
- *Only* if defining breadcrumb markup manually (see [examples](#examples-interactive-examples)):
  - `data-cs-breadcrumbs` (only one per instance)
  - `data-slider-breadcrumb` (as many as you need)

### JS

```js
const slider = new ContentSlider(selector, options);
```

- **selector** (optional, but *highly* recommended)
  - Type: `String`
  - Default: `'[data-content-slider]'`
  - This is the wrapper selector for this specific instance.
  - It's highly recommended this is defined because it's required if you were to have more than one `ContentSlider` instance on the same page or if you are defining options.

- **options** (optional)
  - Type: `Object`
  - The options to control the individual content slider instance. Check out the available [options](#options).

### CSS

By default, every instance of `ContentSlider` attempts to inject styles directly into the head of the document if they don't exist already. **Because of this** you just need to use `options.css` for updating styles. Custom CSS options are applied to all `ContentSlider` instances because the existing styles defined in the head are overwritten with the custom CSS options.

**Note:** As of this version, if you want more control over styling and want to define the CSS file yourself, an option of `injectCSS` will need to be set to `false` for every new `ContentSlider` instance.

CSS variables are used (take note for browser support), and they are defined using the `html` selector. You can override them by targeting `:root` and define custom variable values. Example:

```css
:root {
    --cs-link: #da0000;
    --cs-link-hover: #ff0f0f;
    --cs-background: transparent;
}
```

Here are the default CSS variables used:

```css
html {
    --cs-background: #FFF;
    --cs-separator: "\276F";
    --cs-link-hue: 204;
    --cs-link-saturation: 82%;
    --cs-link-lightness: 36%;
    --cs-link: hsl(var(--cs-link-hue), var(--cs-link-saturation), var(--cs-link-lightness));
    --cs-link-hover: hsl(var(--cs-link-hue), var(--cs-link-saturation), calc(var(--cs-link-lightness) + 10%));
    --cs-transition-speed: 0.35s;
}
```

## Examples ([interactive examples](https://astrocaleb.github.io/content-slider/))

### Automatic Breadcrumb Creation

If you don't want to worry yourself with defining the breadcrumb markup and would like it to be dynamically generated, this is the best configuration for you.

**Note:** A unique `id` is automatically generated for each pane (each `data-cs-pane` element) unless defined in the markup manually. The `id`s are used by the breadcrumbs by default.

#### HTML

```html
<div data-content-slider class="my-content-slider">
    <div data-cs-panes>
        <div data-cs-pane data-breadcrumb-text="Pane 1">...</div>
        <div data-cs-pane data-breadcrumb-text="Pane 2">...</div>
    </div>
</div>
```

#### JS

```js
import ContentSlider from '@astrocaleb/content-slider';

// All default options
const slider = new ContentSlider('.my-content-slider');

// OR

// Use options to change how the content slider instance operates
const slider = new ContentSlider('.my-content-slider', {
    progressiveBreadcrumbs: true,
    callback: function() {
        alert("Pane is now visible!");
    }
});
```

You can also manually trigger showing a content pane using the `id` for a given pane. This requires manually defining an `id` per pane (each `data-cs-pane` element). Example:

#### HTML

```html
<div data-content-slider class="my-content-slider">
    <div data-cs-panes>
        <div data-cs-pane id="pane-1" data-breadcrumb-text="Pane 1">...</div>
        <div data-cs-pane id="pane-2" data-breadcrumb-text="Pane 2">...</div>
    </div>
</div>
```

#### JS

```js
const slider = new ContentSlider('.my-content-slider');
slider.showContentSliderPane('#pane-2');
```

The `showContentSliderPane` method accepts a pane `id` (required) but also optionally accepts a callback function, which overrides the [default callback option](#callback) from the constructor.

```js
const slider = new ContentSlider('.my-content-slider');
slider.showContentSliderPane('#pane-2', function() {
    alert("This pane was triggered manually!");
});
```

### Manual Breadcrumb Creation

If you need more control over the breadcrumbs markup, this is the where you want to start. The `data-cs-breadcrumbs` (breadcrumb wrapper) and `data-slider-breadcrumb` (each breadcrumb element) data attributes are **required** regardless of custom markup.

#### HTML

```html
<div data-content-slider class="my-content-slider">
    <div data-cs-breadcrumbs>
        <span data-cs-breadcrumb>Pane 1</span>
        <span data-cs-breadcrumb>Pane 2</span>
        <span data-cs-breadcrumb>Pane 3</span>
    </div>
    <div data-cs-panes>
        <div data-cs-pane>...</div>
        <div data-cs-pane>...</div>
        <div data-cs-pane>...</div>
    </div>
</div>
```

#### JS

```js
const slider = new ContentSlider('.my-content-slider', {
    automaticBreadcrumbs: false
});
```

## Options

- [`callback`](#callback)
- [`motion`](#motion)
- [`injectCSS`](#injectCSS)
- [`startingIndex`](#startingIndex)
- [`breadcrumbsEnabled`](#breadcrumbsEnabled)
- [`automaticBreadcrumbs`](#automaticBreadcrumbs)
- [`progressiveBreadcrumbs`](#progressiveBreadcrumbs)
- [`css`](#css-1)

### callback

- Type: `Function`
- Default: no-op

Callback that fires immediately after a pane comes into view.

### motion

- Type: `Boolean`
- Default: `true`

Disable this option to change the sliding animation to be a fade instead. This is helpful for accessibility concerns.

### injectCSS

- Type: `Boolean`
- Default: `true`

If this option is changed, it needs to be changed for all instances of `ContentSlider`. Even one instance using the default setting will inject the CSS into the head of the document.

If this is disabled, [`options.css`](#css) is no longer respected and you will need to leverage the CSS variables yourself. See the section above with the [available CSS variables](#css).

### startingIndex

- Type: `Number`
- Default: `0`

Change which pane is visible at time of render. This is a regular zero-based index.

### breadcrumbsEnabled

- Type: `Boolean`
- Default: `true`

This option is respected only when `automaticBreadcrumbs` is `true`.

### automaticBreadcrumbs

- Type: `Boolean`
- Default: `true`

When this is disabled the breadcrumbs are not rendered automatically. `breadcrumbsEnabled` is ignored if this is disabled.

### progressiveBreadcrumbs

- Type: `Boolean`
- Default: `false`

By default all breadcrumbs will render automatically. If this is `true` then breadcrumbs only automatically render after the first pane. Currently the only breadcrumbs that will render for each pane after the first will be:
- First pane breadcrumb (actionable back to first pane)
- Current pane breadcrumb (static text)

This option is respected only when `automaticBreadcrumbs` is `true`.

### css

- Type: `Object`
- Default: `{}` (inherits/merges with values from `cssDefaults`)

These are the values defined in `cssDefaults`:
```js
linkHue: '204',
linkSaturation: '82%',
linkLightness: '36%',
link: 'hsl(var(--cs-link-hue), var(--cs-link-saturation), var(--cs-link-lightness))',
linkHover: 'hsl(var(--cs-link-hue), var(--cs-link-saturation), calc(var(--cs-link-lightness) + 10%))',
background: '#FFF',
separator: '\\276F', // Note the escaped backslash
transitionSpeed: 0.35 // seconds
```

**Note:** `transitionSpeed` is a number because of how it's used in the CSS string that's injected into the head of the document.

Example of the placeholder in the CSS template literal:

> ```js
> // ...
> transition: ${this.css.transitionSpeed}s all ease;
> // ...
> ```

`link` and `linkHover` are just colors and can be in any format.

Example of their placeholders in the CSS template literal:

> ```js
> html {
> // ...
> --cs-link: ${this.css.link};
> --cs-link-hover: ${this.css.linkHover};
> // ...
> }
> ```

And those CSS variables are used like this:

> ```js
> // ...
> [data-cs-breadcrumbs] [data-cs-breadcrumb] { color: var(--cs-link); }
> [data-cs-breadcrumbs] [data-cs-breadcrumb]:hover { color: var(--cs-link-hover); }
> // ...
> ```

## License

MIT

repository: AstroCaleb/content-slider

branch_name: refs/heads/main

repo_name: AstroCaleb/content-slider


text:
---
nav_order: 70
---

# Raspberry Pi

## raspi (common)
- stock raspbian buster
- `sudo apt update && sudo apt upgrade`
- `sudo apt install cmake clang xorg-dev`
- disable swap, have enough free ram (`sudo service lightdm stop`) and have a lot of patience (can take 10s of minutes)
  - or you can build on raspi4 & copy to other raspis
- sometimes you might need to:
  - `cd /usr/lib/arm-linux-gnueabihf`
  - `sudo ln -s libGL.so.1 libGL.so`
- setting `UV_THREADPOOL_SIZE` to lower value can help

## raspi 3
- Full KMS
- verify `glxgears -info` to show `Gallium` (`apt install mesa-utils`)

## raspi 4
- Fake KMS

repository: egasimus/graffiti

repo_name: egasimus/graffiti


text:
Daily Motivation

## Whaaat?!

A Chrome extension that displays a new motivational quote every time a new tab is opened and provides you with a fun interactive background to play with!

## Development

* Run `npm i`
* To change the JavaScript, make changes to `.js` files in `src/js` (`ES6` recommended).
* Run `npm run build` to transpile `ES6` into browser compatible `JS`.

repository: RohitLearner/Daily-Motivation

repo_name: RohitLearner/Daily-Motivation


text:
# FfcrmMingle

This Fat Free CRM plugin provides create and view functionality for Mingle tickets inside the CRM.

## Installation

Add ```ffcrm_mingle``` to your Fat Free CRM application Gemfile and run bundle install.

```gem 'ffcrm_mingle', :github => 'crossroads/ffcrm_mingle'```

## Setup

## Tests

## Bug Fixes / Contributions

Please open issues in the GitHub issue tracker and use pull requests for new features.

## License

MIT

## Authors

* Ben Tillman<EMAIL_ADDRESS>* Steve Kenworthy<EMAIL_ADDRESS>


text:
---
layout: post
author: apike
date: "2021-01-15 12:00:00 -08:00"
title: "Banana Split Bonanza"
topic: "Arik takes a second look at ye, Allen investigates a Sonic-related coverup, and we review an accent that doesn't exist. After the Fact: hypocrisy and synergy."
duration: "00:57:59"
length: 41798258
link: https://pinecast.com/listen/22461ee2-2354-498a-9cda-0ea6fd0a7544.mp3
summary: "Arik takes a second look at ye, Allen investigates a Sonic-related coverup, and we review an accent that doesn't exist. After the Fact: hypocrisy and synergy."
explicit: "no"

---

Arik takes a second look at "ye", Allen investigates a Sonic-related coverup, and we review an accent that doesn't exist. After the Fact: hypocrisy and synergy.

- [Ye olde](https://en.wikipedia.org/wiki/Ye_olde)
  - [Old English Latin alphabet](https://en.wikipedia.org/wiki/Old_English_Latin_alphabet)
  - [Anglo-Saxon runes](https://en.wikipedia.org/wiki/Anglo-Saxon_runes)
  - [Ultima Underground](https://en.wikipedia.org/wiki/Ultima_Underworld:_The_Stygian_Abyss)
  - [Thorn](https://en.wikipedia.org/wiki/Thorn_(letter))
  - [Old English writing](https://www.fluentin3months.com/old-english-writing/)
- [Up Up Down Down](http://upup.fm)
  - [Two Spies](https://playspies.com/)
- [Sonic the Hedgehog 3](https://en.wikipedia.org/wiki/Sonic_the_Hedgehog_3)
  - [Sonic 3's Carnival Night Zone music](https://www.youtube.com/watch?v=Zj25mMvK1FA&feature=youtu.be)
  - [Analogue](https://www.analogue.co/)
  - [Poorly drawn Sanic](https://knowyourmeme.com/memes/sanic-hegehog)
- [Is There a Place in America Where People Speak Without Accents?](https://www.atlasobscura.com/articles/is-there-a-place-in-america-where-people-speak-without-accents)
  - [Pacific Northwest English](https://www.babbel.com/en/magazine/pacific-northwest-english)
  - [General American English](https://en.wikipedia.org/wiki/General_American_English)
  - [Canadian raising](https://en.wikipedia.org/wiki/Canadian_raising)
  - [General American vs. Received Pronunciation](https://en.wikipedia.org/wiki/Comparison_of_General_American_and_Received_Pronunciation)

repository: apike/funfactfm

extension: markdown

gha_language: HTML

repo_name: apike/funfactfm


text:
# CuDNN Image Filtering via PyTorch
A tutorial for basic spatial filtering of imagery on the GPU using PyTorch. This is an easy way to complement and accelerate traditional numpy/scipy/OpenCV image processing or image synthesis workflows.

If you want to skip to the code, try running the associated notebook in Google Colab! It's free and let's you skip the installation steps below, and in a reproducable, GPU accelerated runtime environment. Click the badge!

[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/RyanHartzell/cudnn-image-filtering/blob/master/notebooks/CuDNN%20Image%20Filtering%20Tutorial%20Using%20PyTorch.ipynb)

## Installation

### Requirements

This project requires the following for GPU support:

* Python3.6 or greater
* An NVIDIA graphics card that supports CUDA 10 and is greater than ... in compute power (link to table of existing cards to aid user in checking)
* The ability to install necessary CUDA toolkits, libraries, and SDKs as needed by PyTorch

### Install CUDA/CUDA Toolkit, and CuDNN

https://developer.nvidia.com/cuda-toolkit

https://developer.nvidia.com/cudnn

The versions you install will inform which PyTorch local installation you should go with.

https://pytorch.org/

### Project installation and Virtual Environment Setup

*On Linux*

```bash
# Navigate to desired project location
cd my/project/directory

# Checkout project
git checkout https://github.com/RyanHartzell/cudnn-image-filtering.git
cd cudnn-image-filtering

# Set up Python virtual environment assuming Python 3.6 or greater (X below refers to your major revision of Python)
python3.X -m venv venv_gpufiltering
source venv_gpufiltering/bin/activate
pip install -r requirements.txt
```

*On Windows*

```shell
# Navigate to desired project location
chdir my/project/directory

# Checkout project
git checkout https://github.com/RyanHartzell/cudnn-image-filtering.git
chdir cudnn-image-filtering

# Set up Python virtual environment assuming Python 3.6 or greater (X below refers to your major revision of Python)
python3.X -m venv venv_gpufiltering
venv_gpufiltering/Scripts/activate.bat
pip install -r requirements.txt
```

## Execution

Run the Jupyter Notebook cell by cell from Jupyter!

```bash
jupyter notebook "notebooks/CuDNN Image Filtering Tutorial Using PyTorch.ipynb"
```

Or try running the notebook in a free, GPU accelerated Google Colab runtime as noted above!

repository: RyanHartzell/cudnn-image-filtering

gha_language: Jupyter Notebook

repo_name: RyanHartzell/cudnn-image-filtering


text:
Project Setup
-------------
1) Run "composer install" from command line to get vendor folder.

2) Run "php artisan key:generate" to set application key.

3) Provide write mode for "storage" folder.

4) Create a database & provide credentials in ".env" file. (Change .env.example to .env)

5) Run "php artisan migrate" from command line.
    This will create users table with all the fields needed for this application.

Application Architecture
------------------------
1) There are 2 user types:

    i)  User
    ii) Admin

2) Any user can register in this application and will be provided 'User' role.
    User will be displayed only "You are logged in!" message in home page.

3) For the first user to provide admin role manually change
    'role' field (datatype enum) in "users" table from '0' to '1'.

    This will provide the user an Admin role and now Home page will display all the existing users
    with the following functionality:
    User Role   -> This dropdown will change user status
    Edit        -> On click of this button, a modal with user details will be displayed.
    Delete      -> This will soft delete the user.

Project Architecture/Design
---------------------------
1) database/migrations/2014_10_12_000000_create_users_table.php -> This file is having "users" table schema to create in database.

2) Laravel provides user login & register authentication.
    Modified the following files as per the requirement of this application:

    i) resources/views/auth/register.blade.php      -> User registration page view file.
    ii) public/css/smart.css                        -> All the stylings for this application are added in this file.
    iii) public/scripts/smart.js                    -> All the jQuery codes for this application are added in this file.
    iv) app/Http/Controllers/Auth/AuthController.php-> This file is having server side validaiton for user registration & creates user after validation.
    v) resources/views/home.blade.php               -> This is the view file of home page.
    vi) resources/views/editUserDetails.blade.php   -> This is the view file for user details edit in modal.
    vi) app/Http/Controllers/HomeController.php     -> All the logics of this applicaiton are written in this controller.
    vii) app/User.php                               -> All the business logic of this application are written in this model.

3) Plugins used:

    i)  public/plugins/datatables   -> Datatables plugin is used to display user details.
    ii) public/plugins/datepicker   -> Bootstrap datepicker plugin is user for birthday selection.

References
----------
Regular expression for email & phone are taken from web.

API
---
This is not implemented.

repository: sabihk/smart

repo_name: sabihk/smart


text:
pcre2-sys
=========
Bindings for [PCRE2](https://www.pcre.org/).

[![Linux build status](https://api.travis-ci.org/BurntSushi/rust-pcre2.png)](https://travis-ci.org/BurntSushi/rust-pcre2)
[![Windows build status](https://ci.appveyor.com/api/projects/status/github/BurntSushi/rust-pcre2?svg=true)](https://ci.appveyor.com/project/BurntSushi/rust-pcre2)
[![](https://meritbadge.herokuapp.com/pcre2-sys)](https://crates.io/crates/pcre2-sys)

Dual-licensed under MIT or the [UNLICENSE](https://unlicense.org/).

### Documentation

https://docs.rs/pcre2-sys

### Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
pcre2-sys = "0.2"
```

and this to your crate root:

```rust
extern crate pcre2_sys;
```

### Notes

As a `-sys` crate, this exposes only the bindings to PCRE2 based on the header
file. The PCRE2 documentation itself should be consulted in order to use this
crate.

The bindings for this crate were generated for PCRE **10.31**. This crate
intends to track the current release of PCRE2.

The build script for this crate prefers dynamically linking with the host's
PCRE2 system library. If that isn't available or if static linking is desired,
then PCRE2 is built from source and statically linked.

Static linking will automatically happen for MUSL targets, but can be forced by
setting the `PCRE2_SYS_STATIC` environment variable to `1`. Similarly, if
`PCRE2_SYS_STATIC` is set to `0`, then static linking will be forcefully
disabled, even for MUSL targets.

Currently, this crate only supports `libpcre-8` where
`PCRE2_CODE_UNIT_WIDTH=8`.

This crate has been tested to work on Windows, Linux and macOS. Other platforms
may work, and PRs to support them are welcome.

If you're compiling this crate on Windows with the GNU toolchain, then you'll
need to make sure you have a compatible C compiler installed, such as the one
provided by the [mingw-w64](http://mingw-w64.org) project.

Set the `PCRE2_SYS_DEBUG` flag to forcefully enable debug symbols when doing a
static build, even when compiling in release mode.

license: MIT,Unlicense

detected_licenses: MIT Unlicense

gha_license_id: NOASSERTION


text:
# Peloton Contributors

This file is a partial list of people who have contributed to the Peloton
project.  If you have contributed a patch or made some other contribution to
Peloton, please submit a patch to this file to add yourself, and it will be
done!

## Active
* [Joy Arulraj](https://www.cs.cmu.edu/~jarulraj) (Carnegie Mellon University)
* [Andy Pavlo](https://www.cs.cmu.edu/~pavlo) (Carnegie Mellon University)

## Past
* [Ming Fang](https://www.cs.cmu.edu/~mingf) (Carnegie Mellon University)
* [Ziqiang Feng](http://www4.comp.polyu.edu.hk/~cszqfeng) (Hong Kong Polytechnic University)
* [Jinwoong Kim](http://dicl.unist.ac.kr/~jwkim) (Ulsan National Institute of Science and Technology)
* [Vivek Sengupta](https://www.linkedin.com/pub/vivek-sengupta/8b/189/8b7) (University of Southern California)
* Jiajun Wang (Carnegie Mellon University)
* Edward Yeo (Carnegie Mellon University)

repository: dvanaken/peloton-bwtree

repo_name: dvanaken/peloton-bwtree


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [@anglr/select](./select.md) > [NormalStateContext](./select.normalstatecontext.md)

## NormalStateContext interface

Context for template that is used within normal state plugin

<b>Signature:</b>

```typescript
export interface NormalStateContext
```

## Properties

|  Property | Type | Description |
|  --- | --- | --- |
|  [$implicit](./select.normalstatecontext._implicit.md) | [NormalState](./select.normalstate.md) | Instance of plugin itself |


text:
[![npm](https://img.shields.io/npm/l/es6-object-assign.svg)](https://www.npmjs.org/package/es6-object-assign)
[![npm](https://img.shields.io/npm/v/es6-object-assign.svg)](https://www.npmjs.org/package/es6-object-assign)

# ES6 Object.assign()

ECMAScript 2015 (ES2015/ES6) [Object.assign()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) polyfill and [ponyfill](https://ponyfill.com) for ECMAScript 5 environments.

The main definition of this package has been copied from the polyfill defined in the [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign).

## Installation

### NPM

```bash
npm install es6-object-assign
```

### Manual download and import

The package is also available as a UMD module (compatible with AMD, CommonJS and exposing a global variable `ObjectAssign`) in `dist/object-assign.js` and `dist/object-assign.min.js` (833 bytes minified and gzipped).

The versions with automatic polyfilling are `dist/object-assign-auto.js` and `dist/object-assign-auto.min.js`.

## Usage

**CommonJS**:

```javascript
// Polyfill, modifying the global Object
require('es6-object-assign').polyfill();
var obj = Object.assign({}, { foo: 'bar' });

// Same version with automatic polyfilling
require('es6-object-assign/auto');
var obj = Object.assign({}, { foo: 'bar' });

// Or ponyfill, using a reference to the function without modifying globals
var assign = require('es6-object-assign').assign;
var obj = assign({}, { foo: 'bar' });
```

**Globals**:

Manual polyfill:

```html
<script src="<your-libs-directory>/object-assign.min.js"></script>
<script>
  // Polyfill, modifying the global Object
  window.ObjectAssign.polyfill();
  var obj = Object.assign({}, { foo: 'bar' });
</script>
```

Automatic polyfill:

```html
<script src="<your-libs-directory>/object-assign-auto.min.js"></script>
<script>
  var obj = Object.assign({}, { foo: 'bar' });
</script>
```

Ponyfill, without modifying globals:

```html
<script src="<your-libs-directory>/object-assign.min.js"></script>
<script>
  var assign = window.ObjectAssign.assign;
  var obj = assign({}, { foo: 'bar' });
</script>
```

## License

The MIT License (MIT)

Copyright (c) 2017 Rubén Norte

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

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

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


text:
### [Mintty](https://mintty.github.io)

#### Install using Git

Alternatively, if you are a git user, you can install the theme and keep up to date by cloning the repo directly into your `~/.` directory.

    git clone https://github.com/dracula/mintty.git ~/.

#### Install manually

1.  Download using the [GitHub .zip download](https://github.com/dracula/mintty/archive/master.zip) option and unzip them
2.  Move the `.minttyrc` file to `~/.`

#### Activating theme

If you're already running a color scheme under Mintty, be sure to clear the relevant lines in your `~/.minttyrc`.

repository: dracula/mintty

repo_name: dracula/mintty


text:
# Containers

Timely's core isn't tied to a specific representation of data that flows along dataflow edges.
While some convenience operators make assumptions about the type of batches, the core infrastructure is generic in what containers are exchanged.
This section explains what containers are and what their contract with the Timely APIs is.

Many parts of Timely assume that data is organized into `Vec<T>`, i.e., batches store data as consecutive elements in memory.
This abstractions works well for many cases but precludes some advanced techniques, such as transferring translated or columnar data between operators.
With the container abstraction, Timely specifies a minimal interface it requires tracking progress and provide data to operators.

## Core operators

In Timely, we provide a set of `Core` operators that are generic on the container type they can handle.
In most cases, the `Core` operators are a immediate generalization of their non-core variant, providing the semantically equivalent functionality.

## Limitations

A challenge when genericizing Timely operators is that all interfaces need to be declared independent of a concrete type, for example as part of a trait.
For this reason, Timely doesn't currently support operators that require knowledge of the elements of a container or how to partition a container, with the only exception being the `Vec` type.

## A custom container

Let's walk through an example container that resembles a `Result` type, but moves the storage to within the result.

```rust
extern crate timely_container;

use timely_container::Container;

#[derive(Clone)]
enum ResultContainer<T, E> {
    Ok(Vec<T>),
    Err(E),
}

impl<T, E> Default for ResultContainer<T, E> {
    fn default() -> Self {
        Self::Ok(Default::default())
    }
}

impl<T: Clone + 'static, E: Clone + 'static> Container for ResultContainer<T, E> {
    type Item = Result<T, E>;

    fn len(&self) -> usize {
        match self {
            ResultContainer::Ok(data) => data.len(),
            ResultContainer::Err(_) => 1,
        }
    }

    fn is_empty(&self) -> bool {
        match self {
            ResultContainer::Ok(data) => data.is_empty(),
            ResultContainer::Err(_) => false,
        }
    }

    fn capacity(&self) -> usize {
        match self {
            ResultContainer::Ok(data) => data.capacity(),
            ResultContainer::Err(_) => 1,
        }
    }

    fn clear(&mut self) {
        match self {
            ResultContainer::Ok(data) => data.clear(),
            ResultContainer::Err(_) => {},
        }
    }
}
```

The type can either store a vector of data, or a single error.
Its length is the length of the vector, or 1 if it represents an error.

repository: avmi/timely-dataflow

repo_name: avmi/timely-dataflow


text:
## Install

```sh
yarn create hyperdom-app --jsx myapp # or npx create-hyperdom-app --jsx myapp
cd myapp
yarn install
```

Run dev server:

```sh
yarn dev
```

Open `http://localhost:5000`

## Hyperdom App

An object with a `render()` method is a valid hyperdom component (we call top level component an app). The one in your project looks like this:

<!-- tabs:start -->

#### ** Javascript **

_./browser/app.jsx_

[view code](/docs/codesandbox/get-started-init/browser/app.jsx)

It's mounted into the DOM in _./browser/index.js_:

[view code](/docs/codesandbox/get-started-init/browser/index.js)

[codesandbox](/docs/codesandbox/get-started-init)

#### ** Typescript **

_./browser/app.tsx_

[view code](/docs/codesandbox/get-started-init-ts/browser/app.tsx)

It's mounted into the DOM in _./browser/index.ts_:

[view code](/docs/codesandbox/get-started-init-ts/browser/index.ts)

[codesandbox](/docs/codesandbox/get-started-init-ts)

<!-- tabs:end -->

## State Management

It's rare to have to think about state management in Hyperdom. Just like React app, a Hyperdom app is often composed of multiple components. Unlike React though, Hyperdom does not _recreate_ them on each render - your app has total control over how long those components live. Another crucial difference is that Hyperdom always re-renders the whole app, no matter which component triggered an update.

This means you can use normal JavaScript objects to store state and simply refer to those objects in jsx.

## Events and Bindings

Hyperdom rerenders immediately after each UI event your app handles. There are two ways of handling UI events in hyperdom, event handlers (for things like mouse clicks) and input bindings (for things like text boxes).

## Event Handlers

Event handlers run some code when a user clicks on something. Let's modify our `App` class:

<!-- tabs:start -->

#### ** Javascript **

_./browser/app.jsx_

[view code](/docs/codesandbox/get-started-events/browser/app.jsx#L4)

[codesandbox](/docs/codesandbox/get-started-events)

#### ** Typescript **

_./browser/app.tsx_

[view code](/docs/codesandbox/get-started-events-ts/browser/app.tsx#L4)

[codesandbox](/docs/codesandbox/get-started-events-ts)

<!-- tabs:end -->

When "Next" link is clicked, the `onclick` handler is executed. After that, hyperdom re-renders (that is, calls the `render()` method, compares the result with the current DOM and updates it if needed).

Read more about Events [here](api#event-handler-on-attributes)

## Input Bindings

This is how we bind html inputs onto the state. Let's see it in action:

<!-- tabs:start -->

#### ** Javascript **

_./browser/app.jsx_

[view code](/docs/codesandbox/get-started-bindings/browser/app.jsx#L13)

[codesandbox](/docs/codesandbox/get-started-bindings)

#### ** Typescript **

  _./browser/app.tsx_

[view code](/docs/codesandbox/get-started-bindings-ts/browser/app.tsx#L19)

[codesandbox](/docs/codesandbox/get-started-bindings-ts)

<!-- tabs:end -->

Each time user types into the input, hyperdom re-renders.

Read more about Bindings [here](api#the-binding-attribute)

## Calling Ajax

The above examples represent _synchronous_ state change. Where it gets interesting though is how much trouble it would be to keep the page in sync with the _asynchronous_ changes. Calling an http endpoint is a prime example. Let's make one:

<!-- tabs:start -->

#### ** Javascript **

_./browser/app.jsx_

[view code](/docs/codesandbox/get-started-ajax/browser/app.jsx#L15)

[codesandbox](/docs/codesandbox/get-started-ajax)

#### ** Typescript **

_./browser/app.tsx_

[view code](/docs/codesandbox/get-started-ajax-ts/browser/app.tsx#L25)

[codesandbox](/docs/codesandbox/get-started-ajax-ts)

<!-- tabs:end -->

When "Have a beer" button is clicked hyperdom executes the `onclick` handler and re-renders - just like in the "Events" example above. Unlike that previous example though, hyperdom spots that the handler returned a promise and schedules _another_ render to be executed when that promise resolves/rejects.

Note how we take advantage of the two renders rule to toggle "Loading...".

## Composing Components

Our `App` class is getting pretty hairy - why not to extact a component out of it? Like that beer table:

<!-- tabs:start -->

#### ** Javascript **

_./browser/BeerList.jsx_

[view code](/docs/codesandbox/get-started-compose/browser/BeerList.jsx#L4)

And use it in the main app:

_./browser/app.jsx_

[view code](/docs/codesandbox/get-started-compose/browser/app.jsx#L3)

[codesandbox](/docs/codesandbox/get-started-compose)

#### ** Typescript **

_./browser/BeerList.tsx_

[view code](/docs/codesandbox/get-started-compose-ts/browser/BeerList.tsx#L4)

And use it in the main app:

_./browser/app.tsx_

[view code](/docs/codesandbox/get-started-compose-ts/browser/app.tsx#L4)

[codesandbox](/docs/codesandbox/get-started-compose-ts)

<!-- tabs:end -->

?> Since `this.beerList` is a component, we can specify it in place in the jsx. Hyperdom will implicitly call its `render()` method.

## Routes

Routing is essential in most non-trivial applications. That's why hyperdom has routing built in - so you don't have to spend time choosing and implementing one.

We are going to add new routes to the beer site: `/beers` - to show the beers table - and `/beer/:id` to show an individual beer. And, of course, there is still a `/` route.

First we need to tell hyperdom that this the routing is involved. We do this by mounting the app with a router:

<!-- tabs:start -->

#### ** Javascript **

_./browser/index.js_

[view code](/docs/codesandbox/get-started-routing/browser/index.js)

#### ** Typescript **

_./browser/index.ts_

[view code](/docs/codesandbox/get-started-routing-ts/browser/index.ts)

<!-- tabs:end -->

Next, let's define what the top level path `/` is going to render:

<!-- tabs:start -->

#### ** Javascript **

_./browser/app.jsx_

[view code](/docs/codesandbox/get-started-routing/browser/app.jsx#L4-L20)

#### ** Typescript **

_./browser/app.tsx_

[view code](/docs/codesandbox/get-started-routing-ts/browser/app.tsx#L4-L20)

<!-- tabs:end -->

The original `render()` method is gone. Two other special methods - `routes()` and (optional) `renderLayout()` - took its place. The former one is where the magic happens, so let's take a closer look. In a nutshell, `routes()` returns a "url -> render function" mapping. A particular render is invoked only if the current url matches. The "key" in that mapping is not actually a string url but a route definition. `routes.home()` in the above example is a route definition.

We declare those route definitions separately so that they can be used anywhere in the project:

<!-- tabs:start -->

#### ** Javascript **

_./browser/routes.js_

[view code](/docs/codesandbox/get-started-routing/browser/routes.js)

#### ** Typescript **

_./browser/routes.ts_

[view code](/docs/codesandbox/get-started-routing-ts/browser/routes.ts)

<!-- tabs:end -->

Route definition can also generate URLs strings. E.g. `routes.beer.href({id: 23})` returns `/beers/23`. This is how a link to `/beers` page looks in our example:

<!-- tabs:start -->

#### ** Javascript **

_./browser/app.jsx_

[view code](/docs/codesandbox/get-started-routing/browser/app.jsx#L35-L35)

#### ** Typescript **

  _./browser/app.tsx_

[view code](/docs/codesandbox/get-started-routing-ts/browser/app.tsx#L48-L48)

<!-- tabs:end -->

Apart from route definitions, there is one other thing that can be a part of the array returned from `routes()`. If you look closely at the above example, you'll notice `this.beerList` is also there.

This works because `this.beerList` itself a has a `routes()` and that's where our second path - `/beers` - is mapped onto a render. The pattern then repeats itself with `this.showBeer` plugging in the final `/beers/:id` path.

<!-- tabs:start -->

#### ** Javascript **

_./browser/BeerList.jsx_

[view code](/docs/codesandbox/get-started-routing/browser/BeerList.jsx#L3-L26)

_./browser/Beer.jsx_

[view code](/docs/codesandbox/get-started-routing/browser/Beer.jsx#L2-L40)

Here is the entire example on codesandbox:

[codesandbox](/docs/codesandbox/get-started-routing)

#### ** Typescript **

_./browser/BeerList.tsx_

[view code](/docs/codesandbox/get-started-routing-ts/browser/BeerList.tsx#L3-L26)

_./browser/Beer.tsx_

[view code](/docs/codesandbox/get-started-routing-ts/browser/Beer.tsx#L2-L43)

Here is the entire example on codesandbox:

[codesandbox](/docs/codesandbox/get-started-routing-ts)

<!-- tabs:end -->

When user navigates to the `/beers` page for the _first_ time, an `onload()` method is called by hyperdom (if provided). In our example, it performs an ajax request to fetch the data. Since the `onload` returns a promise, the UI will render again once the promise is resolved/rejected.

A similar `onload()` method is implemented on the `/beers/:id` page. Except, if we happen to navigate from the `/beers` page, it won't perform an ajax call, but instead draw from the list of beers fetched previously.

This is a pretty advanced setup as the app will only call the api once, no matter which page user happens to land on.

Speaking of `/beers/:id`, note how the `:id` parameter is bound onto a component property using `bindings` property. This is very similar to the input bindings we saw earlier.

?> Note how we use a custom `beerId` getter to coerce `:id` param into a number. That's because all url bindings produce string values.

Learn more about routing [here](api#routing)

## Testing

We've touched all hyperdom bases - there aren't that many! - and this is definitely enough to get you started. To help you keep going past that, `create-hyperdom-app` contains a fast, _full stack_ browser tests powered by [electron-mocha](https://github.com/jprichardson/electron-mocha) runner and [browser-monkey](https://github.com/featurist/browser-monkey) for dom assertions/manipulations. It's only a `yarn test` away.

repository: dongnguyenvie/hyperdom

repo_name: dongnguyenvie/hyperdom


text:
# FSM core

[![npm version](https://img.shields.io/npm/v/@opuscapita/fsm-workflow-core.svg)](https://npmjs.org/package/@opuscapita/fsm-workflow-core)
[![NPM Downloads](https://img.shields.io/npm/dm/@opuscapita/fsm-workflow-core.svg)](https://npmjs.org/package/@opuscapita/fsm-workflow-core)

Machine and its definition.

## How To Use

### Install package

Run `npm install @opuscapita/fsm-workflow-core` to get up and running.

### Use in code

```javascript
import { MachineDefinition, Machine } from '@opuscapita/fsm-workflow-core';
```

## Machine definition

Machine definition consists of:
- [schema](#schema)
- [actions](#action)
- conditions [guards](#guard-conditions) & [automatic](#automatic-conditions)

### Example

```javascript
const machineDefinition = new MachineDefinition({
  schema: {
    name: "invoice approval",
    initialState: "open",
    finalStates: ["approved"],
    states: [ // optional meta data for states
      {
        name: "open",
        description: "Open",
        // release guards specify if state can be released
        // if not specified then release is always allowed
        release: [
          {
            // if 'release[i].to' field is undefined then release guard is applied no matter what target state is
            guards: [ // just like in transitions
              {
                expression: "object.enabled === true"
              },
              {
                name: "someFunction",
                params: [
                  {
                    name: "param1",
                    value: 100
                  }
                ]
              }
            ]
          },
          {
            to: 'approved', // if 'to' is a string then the folling guards are checked only when trying to transit from 'open' to 'approved'
            guards: [...]
          },
          {
            to: ['approved', 'awaitingConfirmation'], // the same as with string, but for a list of target states
            guards: [...]
          }
        ]
      },
      { name: "approved", description: "Approved" }
    ],
    transitions: [
      {
          from: "open",
          to: "approved",
          event: "approve",
          // guards define weither this transition is available or not
          guards: [
            {
              "name": "validate",
              "params": [
                {
                  "name": "param1",
                  "value": "value1"
                },
                {
                  "name": "param2",
                  "value": "value2"
                }
              ]
            },
            // guards can also be simple expressions
            {
              "expression": "invoice.netAmount < 10000"
            }
          ],
          // actions are executed is sequence during transition; 'sendEvent' resolves only after all actions are finished
          actions: [
            {
              "name": "archive",
              "params": [
                {
                  "name": "param1",
                  "value": "value1"
                },
                {
                  "name": "param2",
                  "value": "value2"
                }
              ]
            }
          ],
          //automatic guards define if transition can be marked as automatic
          automatic: [
            {
                "name": "lastlyUpdatedMoreThan24hAgo",
                "params": [
                  {
                    "name": "param1",
                    "value": "value1"
                  },
                  {
                    "name": "param2",
                    "value": "value2"
                  }
                ],
                "negate": true
            }
          ]
      }
    ]
  },
  // actions can be synchronous or asynchronous (return Promise)
  actions: {
    archive: function({ param1, param2 }) {}
  },
  // conditions can be synchronous or asynchronous (return Promise)
  conditions: {
    validate: function({ param1, param2 }) {},
    lastlyUpdatedMoreThan24hAgo: function({ param1, param2 }) {}
  },
  objectConfiguration: {
    stateFieldName: "status",
    alias: "invoice",
    example: {
      "invoiceNo": "1111",
      "customerId": "wefwefewfew",
      "supplierId": "33333",
      "netAmount": 1000,
      "status": "reviewRequired"
    },
    schema: {
      {
        title: "Invoice",
        type: "object",
        properties: {
          invoiceNo: {
            type: "string"
          },
          customerId: {
            type: "string"
          },
          supplierId: {
            type: "string"
          },
          netAmount: {
            type: "number"
          },
          status: {
            type: "string"
          }
        },
        required: ["invoiceNo"]
      }
    }
  }
});
```

### Schema

Defines machine transitions and initialization options. Could be presented as oriented graph, where each node represents state and directed edges are used to represent transition from one state to another.

#### Transitions

In schema you needs to define an array of available machine transitions. Typically a transition is triggered by an _event_ and happens between _from_ and _to_ states. Optionally each transition can have _actions_, _guards_ and/or _automatic_ (conditions).

#### Initial state

You can define the initial state by setting the _initialState_ property:

```javascript
var machineDefinition = new MachineDefinition({
  schema: {
    name: 'sprint'
    initialState: 'start'
    transitions: [
      { from: 'start', event: 'run', to: 'finish' }
    ]
  }
});

const machine = new Machine({ machineDefinition });
machine.start({ object }).then(({ status: 'none' }) => {
  console.log(machine.currentState({ object }));
  // start
});
```

if initial state is not specified, then 'none' will be used (TBD)

#### Final states

You can define the final states (one or many) by setting the _finalStates_ property:

```javascript
var machineDefinition = new MachineDefinition({
  schema: {
    initialState: 'start',
    finalStates: ['finish'],
    transitions: [
      {from: 'start', event: 'run', to: 'finish'}
    ]
  }
});
```

### Code (Actions and Conditions(guards/automatic))

- [Actions & conditions configuration and usage](https://github.com/OpusCapita/fsm-workflow/blob/master/packages/editor/src/components/Actions/Readme.md)
- [Ideas & thoughts](actionsAndConditions.md)

#### Action

Actions (action = function) are executed during transition (not while leaving/entering state). Action references specific function by name. Action implemented separately from schema. Each action accepts named arguments explicitly defined in transition and implicit arguments like _object_, _from_, _to_, etc. During transition machine executes each action in defined order. Each action gets _actionExecutionResults_ argument which serves as an accumulator from perviously called actions, where each property is an action name and value is value returned by action.

#### Guard (conditions)

Guards are used to protect transitions. Guard works as 'if' condition.
Technically guard is defined the same way like as action, it is a function.
The difference is that it should always return boolean value (true or false).
Condition(function) result could be inverted if its property _negate_ is set to true.

Guards could be also _sync_ and _async_ functions. In case you want to implement async guard, pay additional attention
to the value resolved by a guard - it should be **only** boolean value. In case your guard rejects some value
(error or smth else) - it will be taken as an error and _findAvailableTransitions_ will be rejected with error.

Note: similar to [Spring State Machine Guards](http://docs.spring.io/spring-statemachine/docs/current/reference/htmlsingle/#configuring-guards)

#### Automatic (conditions)

Transition could be marked as automatic using corresponding property. It could be:
- true (boolean value) - e.g. this transition is always automatic
- array of conditions(functions, each return true or false), condition(function) result could be inverted if its property _negate_ is set to true

Check for whether object in current state has (at least one) automatic transition could be done via **[task manager](../task-manager)** (inside the application). Basing on evaluated results task manager will be able to take a decision to send event without user interaction.

## Stateful object as a process

Machine does not have own state, all the transitions are performed over object which state is changed by machine. Object is used by Machine as a mutable parameter passed to guards and actions.

```javascript
var machineDefinition = new MachineDefinition({
  schema: {
    initialState: 'start'
    finalStates: ['finish'],
    transitions: [
      { from: 'start', event: 'run', to: 'finish' }
    ]
  }
});

const object = { status: 'none' };
const machine = new Machine(machineDefinition);
machine.start({ object }).then(({ object }) => {
  console.log(machine.currentState({ object }));
  // start
  return machine.sendEvent({ object, event: 'start' })
}).then(({ object }) => {
  console.log(machine.currentState({ object }));
  // finish
});
```

## Object Workflow History

Machine configuration
```
var machine = new Machine({ history, ... });
```
**history** is a DAO that provides a possibility to create and read object workflow history records. You can find its API (and DB specific implementation) [here](https://github.com/OpusCapita/fsm-workflow/tree/master/packages/history).

Machine writes history records for all object transitions within the workflow.
It happens when you start workflow
```
machine.start({ object, user, description })
```
or you send an event
```
machine.sendEvent({ object, event, user, description })
```
In both cases, new history records are created.
Here
- **object** (required) - business object of the following structure
- **user** (required) - user identifier who initiated an event
- **description** (optional) - custom text that describes transition/object
All this info together is stored in workflow history.
Note: In case of **start** method call history fields **from** and **event** are filled with string value **NULL** (4 upper cases letters: N, U, L, L)

Machine provides possibility to get(search) history records via **getHistory** method:

Getting/searching specific workflow history. You can either search by:
- specific **object** history
- initiated by specific **user**
- additionally, you can restrict query using **finishedBy** to get history within a specific period of time.
```javascript
machine.getHistory(searchParameters, paging, sorting)
```
where
  - **searchParameters**
  ```javascript
  {
    object,
    user,                    // example: 'john.miller'
    finishedOn: {
      gte,                   // example: Date("2018-03-05T21:00:00.000Z")
      gt,                    // (syntax like 'today', 'yesterday', 'week ago' could be introduced later, if required)
      lt,
      lte
    }
  }
  ```
  - **paging**:
  ```javascript
  {
    max,                      // example: '25', default value: 100
    offset                    // example: '50', default value: 0
  }
  ```
  - **sorting**:
  ```javascript
  {
   by,                        // example: 'user', default value: 'finishedOn',
                              // possible values: ['event', 'from', 'to', 'user', 'description', 'finishedOn']
   order                      // example: 'asc', default value: 'desc'
  }
  ```
  as a result you get a promise that results into array of objects of the following structure:
  ```javascript
  {
    event,
    from,
    to,
    object: {
      businessObjectId,
      businessObjectType
    },
    user,
    description,
    finishedOn
  }
  ```

**Note:** while writing workflow object history or searching history records by
object machine uses configured **convertObjectToReference** callback to convert
real business object into reference object that has the following structure
**{businessObjType, businessObjId}**

### Debugging schema

In case one needs to find out why particular transitions are available or unavailable there's a lower-level function `MachineDefinition.inspectTransitions`. According to provided input params it returns all analyzed transitions with their guards and results of their evaluation. This helps to determine why particular transition was (un)available in particular case.

In case one needs to inspect `release guards` defined for states, there's `MachineDefinition.inspectReleaseConditions` function which is similar to `MachineDefinition.inspectTransitions`.

For details about these functions see `MachineDefinition.js` source.

## Machine
### API

```javascript
var machineDefinition = new MachineDefinition({ schema, conditions, actions })
// register workflow
var machine = new Machine(machineDefinition, context);

// start/initialize machine/workflow
machine.start({ object })

// returns a list of available transitions: {event, from, to, request..}, e.g. event
// request is used to pass parameters to guards for some dynamic calculation, e.g. when event availability depends
// on current user information as roles and etc.
machine.availableTransitions({ object })
// returns a list of available automatic transitions: {event, from, to, ..}, e.g. event
// if machine schema is adequate then there should be not more than 1 such transition
machine.availableAutomaticTransitions({})

// send 'event' and pass addition 'request' data that is posted by user/app
// returns promise, in case of successful transition then function will be called
// with one parameter that is an JSON with the following structure:
// - object - object in new state (the same reference that is passed as parameter)
machine.sendEvent({object, event, request})

machine.currentState({ object })     // gets current state
machine.is({ object, state})         // is object in state
machine.isInFinalState({ object })   // returns true iff object is in one of final states
machine.can({ object, event })       // whether event is available
machine.cannot({ object, event })    // whether event is not available
machine.canBeReleased({ object, to, request }) // weither object can be released from its current state; 'to' is an optional target state

// hooks (tbd)
machine.onStartTransition()   // returns promise
machine.onFinishTransition()  // returns promise
```

## Contributors

|  | [**Alexey Sergeev**](https://github.com/asergeev-sc)     |
| :---: | :---: |
|  | [**Daniel Zhitomirsky**](https://github.com/dzhitomirsky-sc) |
|  | [**Egor Stambakio**](https://github.com/estambakio-sc) |
|  | [**Andrei Mourzenkov**](https://github.com/amourzenkov-sc) |

## License

**OpusCapita FSM Workflow** is licensed under the Apache License, Version 2.0. See [LICENSE](./LICENSE) for the full license text.

repository: OpusCapita/fsm-workflow

gha_language: JavaScript

repo_name: OpusCapita/fsm-workflow


text:
# Resources

## icon*
The icons were generated from icon.svg file using https://romannurik.github.io/AndroidAssetStudio/index.html

Settings:
padding 15%

Settings for icon_with_background/*:
background color #11aad8, shape square, effect cast shadow

Settings for icon_without_background/*:
shape none

gha_language: Kotlin


text:
# Updating Your Data

So far, we've learned how to POST, GET, and DELETE data in our json-server database. In this chapter, we'll discuss how to edit our data with the PUT method.

We've come back to our application that stores lego creations. At this point, we can add new lego creations to our database and print them all to the DOM. We can also delete any lego creation we want. We have the following lego creation in our database:
```json
{
  "id": "1",
  "creator": "Emily Lemmon",
  "shape": "Boat",
  "creation": "Evil Ghost Pirate Ship"
}
```
We represented this data with a DOM component that looks like this:

```html
<section id="lego-creation-1">
  <h3> Evil Ghost Pirate Ship </h3>
  <p>Boat</p>
  <p>Emily Lemmon</p>
  <button class="edit-btn" id="edit-1">Edit</button>
  <button class="delete-btn" id="delete-1">Delete</button>
</section>

```

In general, we can think of edit functionality as a four step process:
1. The user clicks the edit button beside a single lego creation
1. A form pops up
1. The user enters some new information about that lego creation
1. The user clicks "save" on the edit form, and the new lego information is saved to the database

That means that we're going to be dealing with two distinct click events:
1. *Click Event One*: The user clicks the edit button to show the edit form
1. *Click Event Two*: The user clicks the save button on the edit form

Let's focus on one click event at a time.

## What happens when a user clicks the edit button?
When a user clicks the edit button, we need to show them an edit form so they can enter new information about their lego creation. We should auto-populate the fields of the edit form with the lego's current information. That way, if they decide not to change any of the fields, the old values will be saved.

Just like with our delete button, we can't add our event listener to the edit button directly because it's generated dynamically with JavaScript. Instead, we add it to the closest hard-coded ancestor in our HTML file.
```js
document.querySelector("body").addEventListener("click", (eventObject) => {
  // Check to see if the user clicked on something with a class of edit-btn
  if(eventObject.target.classList.contains("edit-btn")){
    const legoId = eventObject.target.id.split("-")[1] // "1"

    // the rest of our logic will go right here
  }
})
```

Once our event listener is working, we can use `event.target` to get our lego creation's id.
We'll use that id to make a GET request for that single lego creation's information.(We need this data to popualte the fields of our edit form.)

```js
const getSingleItem = (id) => {
  return fetch(`http://localhost:8088/${id}`)
  .then(response => response.json())
}
```
Once we have all the data for the single item we clicked on, we can pass it into a function that builds an edit form.

```js
const buildEditForm = singleLego =>
 `<form>
    <fieldset>
      <legend>Register Your Lego Creation:</legend>
      <label for="lego__creator">Creator:</label>
      <input id="lego__creator--edit" name="lego__creator" type="text" value=${singleLego.creator} autofocus />
      <label for="lego__creator">Shape:</label>
      <input id="lego__shape--edit" name="lego__creator" type="text" value=${singleLego.shape} autofocus />
      <label for="lego__creation">Creation:</label>
      <input id="lego__creation--edit" name="lego__creator" type="text" value=${singleLego.creation} autofocus />
    </fieldset>
  </form>
  <button class="save-edit-btn" id="save-edit-${singleLego.id}">Save</button>`
```

At this point, our event listener might look like this:
```js
document.querySelector("body").addEventListener("click", () => {
  // Check to see if the user clicked on something with a class of edit-btn
  if(event.target.classList.contains("edit-btn")){
    const legoId = event.target.id.split("-")[1] // "1"
    getSingleItem(legoId)
    .then(singleLegoData => {
      document.querySelector(`#lego-creation-${legoId}`).innerHTML = buildEditForm(singleLegoData);
    })
  }
})
```
When the user clicks the edit button, voila! An edit form pops up where that lego creation used to be. All the fields are auto-populated with the lego creation's information. We can make any changes we want before we click the save button.

## What happens when a user clicks the save button on an edit form?

We need to do three things:
1. Get the values of all the form fields.
1. Build a new object with those values
1. PUT the new lego object to our json-server database.

Our event listener might look something like this:
```js
document.querySelector("body").addEventListener("click", () => {
  // Check to see if the user clicked on something with a class of save-edit-btn
  if(event.target.classList.contains("save-edit-btn")){
    const legoId = event.target.id.split("-")[2] // "1"
    // build a new object with the data in the edit form
    const editedLegoData = {
      id: legoId,
      creator: document.querySelector("#lego__creator--edit").value,
      shape: document.querySelector("#lego__shape--edit").value,
      creation: document.querySelector("#lego__creation--edit").value
    }

  // We'll call our PUT method right here!

  }
})
```

Now we just need to send our newly edited lego data to our json-server database!

Here's what a PUT method looks like:
```js
const editLego= legoObject =>{
    return fetch(`http://localhost:8088/tasks/${legoObject.id}`,{
        method: "PUT",
        headers: {
            "Content-Type": "application/json"
        },
        body: JSON.stringify(legoObject)
    })

}
```
Here's what our final event listner might look like:

```js
document.querySelector("body").addEventListener("click", () => {
  // Check to see if the user clicked on something with a class of save-edit-btn
  if(event.target.classList.contains("save-edit-btn")){
    const legoId = event.target.id.split("-")[2] // "1"
    // build a new object with the data in the edit form
    const editedLegoData = {
      id: legoId,
      creator: document.querySelector("#lego__creator--edit").value,
      shape: document.querySelector("#lego__shape--edit").value,
      creation: document.querySelector("#lego__creation--edit").value
    }

    editLego(editedLegoData)
    .then(() => {
      // Get all legos from the database
      // Print all legos to the DOM to "refresh" the list and display the newly edited information
    })
  }
})
```

Once the PUT request is successfully completed, we need to make another GET request to get all of the legos in the database and print them to the DOM so that our list "refreshes" and our newly edited information shows up.

gha_language: Shell


text:
# Protected Storage Test Suite

## Common tests
Since Protected Storage(PS) and Internal Trusted Storage(ITS) APIs shares the similar API prototypes and return values, some of the ITS tests are reused for PS also. The reused tests are available with ``test_s[x]`` (where, x= test_num) directory name syntax in protected_storage/. The source code of these tests are located in internal_trusted_storage/ dir with same test name.

## License

Arm PSA test suite is distributed under Apache v2.0 License.
--------------

*Copyright (c) 2018-2019, Arm Limited and Contributors. All rights reserved.*


text:
---
layout: page
title: My Talks
permalink: /talks/
---

1. **[TripleO cephadm integration](https://www.youtube.com/watch?v=zJVoleSpSOk)** - [openinfra.live](https://openinfra.dev/live)
2. **[Upgrading Openstack From Kilo to Mitaka](https://www.slideshare.net/f3ancesco/upgrading-openstack-from-kilo-to-mitaka)** - [Openstack Day Italy](https://openstackday.it)
3. **[An Introduction to Ansible](https://www.slideshare.net/f3ancesco/introducing-ansible)** - Turin Meetup
4. **[An Introduction to Docker](https://www.slideshare.net/f3ancesco/docker-intro-59728364)** - Turin Meetup
5. **[SNSP - Sensor Node Plugin System](https://www.slideshare.net/f3ancesco/sensor-node-plugin-system)** - University Thesis


text:
# Description

The `SqlAlwaysOnService` DSC resource enables or disables SQL Server Always
On high availability and disaster recovery (Always On HADR) for a SQL
Server instance.

## Requirements

* Target machine must be running Windows Server 2012 or later.
* Target machine must be running SQL Server Database Engine 2012 or later.
* Target machine must be a member of a Windows Server Failover Cluster.

## Known issues

All issues are not listed here, see [here for all open issues](https://github.com/dsccommunity/SqlServerDsc/issues?q=is%3Aissue+is%3Aopen+in%3Atitle+SqlAlwaysOnService).

repository: dsccommunity/SqlServerDsc

gha_language: PowerShell

repo_name: dsccommunity/SqlServerDsc


text:
##### Development of this repository has been stopped in favour of https://github.com/getavalon/docker

# Goal

To provide simple entry points into Avalon.

# Usage

Download the [zip](https://github.com/tokejepsen/avalon-environment/archive/master.zip), extract and use any of the entry points provided. Initial setup will take a while depending on your internet connection.

# Entry points

All entry points will ensure that all dependencies of Avalon is installed.

## Server

This will launch the MongoDB server.

This takes an optional argument to specify a custom database location. For example ```server C:\data\custom```. If no argument is specified the default location will be used ```C:\data\db```.

## Launcher

This will launch the Avalon launcher. Make sure the server is running before.

## Terminal

This will launch a terminal with all Avalon dependencies available.

# About

When using any of the entry points, the dependencies of Avalon will be installed. The dependencies include:

- mongodb 3.4.10
- python 3.6.5
- git 2.14.1
- pymongo 3.6.1
- pyqt5 5.7.1

The installation is powered by [Miniconda](https://conda.io/miniconda.html), which gets installed to ```[avalon-environment]/bin/miniconda```. The Conda environment is located at ```[avalon-environment]/bin/miniconda/envs/avalon-environment```.

Once all dependencies are downloaded and installed, this repository will get expanded to around 1.6 GB on disk.

## Uninstall

You can find an uninstaller at ```[avalon-environment]/bin/miniconda/Uninstall-Miniconda2.exe```.

Alternatively you can also just delete ```[avalon-environment]/bin/miniconda```, as this directory contains all files from the installation.

repository: tokejepsen/avalon-environment

gha_language: Batchfile

repo_name: tokejepsen/avalon-environment


text:
# struct-lmm

Structured Linear Mixed Model (StructLMM) is a computationally efficient method
to test for and characterize loci that interact with multiple environments.

## Getting Started

StructLMM is Python package implemented in both Python and R programming
languages that depends on some libraries implemented in C.
To make its installation as easy as possible, we make use
[conda](https://conda.io/), a package manager for software implemented in
Python, R, and C/C++ (among others) languages.

Interaction with StructLMM happens in the terminal via the following command
line tools installed with the package, and described at the [Command Line Interface](http://struct-lmm.readthedocs.io/en/latest/commandline.html)
section of the [documentation](http://struct-lmm.readthedocs.io/):

- norm_env
- struct_lmm_analyze
- lmm_int_analyze
- lmm_analyze
- struct_lmm_analyze

### Requisites

The installation script runs in on GNU/Linux and macOS operating systems.
It requires either [wget](https://www.gnu.org/software/wget/) or
[curl](https://curl.haxx.se/) command line tools in case
[conda](https://conda.io/) is not already installed.
In any case, the installation script will inform the user if it cannot proceed.
Otherwise, the StructLMM dependencies is automatically installed and does not
require user intervention.

### Install

For Linux and macOS operating systems, struct-lmm can be install from the
command line by entering

```bash
bash <(curl -fsSL https://raw.githubusercontent.com/limix/struct-lmm/master/install)
```

The user might be prompted to install conda in case he/she does not have
it, and will warn the user if for some reason the installation process cannot
proceed.
The whole installation process should take less than 15 minutes and mainly
consists in downloading essential R and Python packages for a working
environment.

## Usage example

StructLMM can be run from the command line using the following

```bash
wget http://www.ebi.ac.uk/~casale/data_structlmm.zip
unzip data_structlmm.zip

BFILE=data_structlmm/chrom22_subsample20_maf0.10
PFILE=data_structlmm/expr.csv
EFILE0=data_structlmm/env.txt
EFILE=data_structlmm/env_norm.txt

norm_env  --in $EFILE0 --out $EFILE

struct_lmm_analyze --bfile $BFILE --pfile $PFILE --pheno_id gene10 --efile $EFILE --ofile out/results.res --idx_start 0 --idx_end 1000 --batch_size 100 --unique_variants
```
Further examples can be found at [http://struct-lmm.readthedocs.io/](http://struct-lmm.readthedocs.io/).

## Documentation

Documentation is available online at
[http://struct-lmm.readthedocs.io/](http://struct-lmm.readthedocs.io/).

## Problems

If you encounter any problem, please, consider submitting a [new issue](https://github.com/limix/struct-lmm/issues/new).

## Authors

* **Rachel Moore** - [https://github.com/rm18](https://github.com/rm18)
* **Danilo Horta** - [https://github.com/horta](https://github.com/horta)
* **Francesco Paolo Casale** - [https://github.com/fpcasale](https://github.com/fpcasale)

## License

This project is licensed under the Apache License (Version 2.0, January 2004) -
see the [LICENSE](LICENSE) file for details

repository: DPCscience/struct-lmm

repo_name: DPCscience/struct-lmm


text:
# Maven Build Plugins

Recommended Maven build plugins:

* [Ant Run](https://maven.apache.org/plugins/maven-antrun-plugin/), can handle Ant scripts.
* [Assembly](http://maven.apache.org/plugins/maven-assembly-plugin/), uilds a distributable file from all the project components.
* [Clean](https://maven.apache.org/plugins/maven-clean-plugin/), cleans the output folder.
* [Compiler](https://maven.apache.org/plugins/maven-compiler-plugin/), compiles the source code.
* [Dependency](https://maven.apache.org/plugins/maven-dependency-plugin/), copies and manipulates the project dependencies.
* [Deploy](https://maven.apache.org/plugins/maven-deploy-plugin/), takes care of the deployment phase.
* [Enforcer](https://maven.apache.org/enforcer/maven-enforcer-plugin/), stops the project from being built if it does not comply with a set of rules
* [Failsafe](https://maven.apache.org/surefire/maven-failsafe-plugin/), runs integration tests.
* [Install](https://maven.apache.org/plugins/maven-install-plugin/), installs the project into the local Maven repository.
* [JaCoCo](http://eclemma.org/jacoco/trunk/doc/maven.html), generates coverage data from Surefire and Failsafe.
* [Jar](https://maven.apache.org/plugins/maven-jar-plugin/), generates the jar file.
* [Javadoc](https://maven.apache.org/plugins/maven-javadoc-plugin/), handles the Javadocs.
* [Release](https://maven.apache.org/maven-release/maven-release-plugin/), generates releases and updates the project.
* [Resources](https://maven.apache.org/plugins/maven-resources-plugin/), handles the project resources.
* [Site](https://maven.apache.org/plugins/maven-site-plugin/), generates the Maven Site.
* [Source](https://maven.apache.org/plugins/maven-source-plugin/), bundles the source into the packaged project.
* [Surefire](https://maven.apache.org/surefire/maven-surefire-plugin/), runs unit tests.

These will be used by Maven, but some may require additional configuration.

Check the [archetypes](https://github.com/bernardo-mg/development-docs/tree/607d3a34739325f64d3fc216771c0bc79458f781/maven/templates.md) to find out how to set them up.

repository: Bernardo-MG/development-docs-java

repo_name: Bernardo-MG/development-docs-java


text:
# SugerKit

[![CI Status](https://img.shields.io/travis/luckyBoy/SugerKit.svg?style=flat)](https://travis-ci.org/luckyBoy/SugerKit)
[![Version](https://img.shields.io/cocoapods/v/SugerKit.svg?style=flat)](https://cocoapods.org/pods/SugerKit)
[![License](https://img.shields.io/cocoapods/l/SugerKit.svg?style=flat)](https://cocoapods.org/pods/SugerKit)
[![Platform](https://img.shields.io/cocoapods/p/SugerKit.svg?style=flat)](https://cocoapods.org/pods/SugerKit)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

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

```ruby
pod 'SugerKit'
```

## Author

luckyBoy<EMAIL_ADDRESS>
## License

SugerKit is available under the MIT license. See the LICENSE file for more info.


text:
# curly

[![Build Status](https://img.shields.io/travis/r-rojo/curly.svg)](https://travis-ci.org/r-rojo/curly)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/14639/badge.svg)](https://scan.coverity.com/projects/curly)
[![Coverage Status](https://img.shields.io/coveralls/github/r-rojo/curly.svg)](https://coveralls.io/github/r-rojo/curly?branch=master)

`curly` is a C++ implementation of the `curl` command. It currently supports Linux and Darwin for fetching remote resources identified by their URLs.

repository: r-rojo/curly

repo_name: r-rojo/curly


text:
---
title: First Row is Always Selected
page_title: First Row is Always Selected
description: Get staretd with Telerik's {{ site.framework_name }} DataGrid and learn how not to have the first row selected by default.
slug: gridview-troubleshooting-first-row-always-selected
tags: first,row,is,always,selected
published: True
position: 6
---

# First Row is Always Selected

__PROBLEM__

By default, the first row of the RadGridView is selected. This is also causing the [SelectionChanged]({%slug gridview-selection-events%}) event to fire when the control is loaded.

>tipThis behavior does not occur in versions after __Q2 2010__.

__CAUSE__

Let's first start with some definitions:

* __SelectedItem__: Holds the data item (business object) of the __selected row__.

* __CurrentItem__: Corresponds to the **CurrentItem** of the bound **ICollectionView**. It may or may not coincide with the selected row.

With versions prior to Q2 2010, the __current item was synchronized with the selected item__ by default. As a result, the __first row__ of the control was __initially selected__.

__SOLUTION__

Set the __IsSynchronizedWithCurrentItem__ property of RadGridView to __False__.

>Since Q2 2010 version the __IsSynchronizedWithCurrentItem__ is **null** by default - SelectedItem is synchronized with the CurrentItem only if a **CollectionView** is used as **ItemsSource**.

## See Also

* [CurrentItem, SelectedItem & SelectedItems]({%slug gridview-selection-selecteditem-currentitem%})
* [Basic Selection]({%slug gridview-selection-basics%})

repository: telerik/xaml-docs

repo_name: telerik/xaml-docs


text:
# Extended Kalman Filter Project Starter Code
Self-Driving Car Engineer Nanodegree Program [link](https://www.udacity.com/course/self-driving-car-engineer-nanodegree--nd013)

This project creates an extended kalman filter to estimate the state of a moving object, using readings from a noisy lidar and noisy radar to converge on a state and estimated state. The error is measured using RMSE values that were required to be lower than specified tolerances.

![Gif](ekf_gif.gif)

## Running the simulation
This project uses a Udacity simulator which can be downloaded here: [Simulator](https://github.com/udacity/self-driving-car-sim/releases)

To build the project, run:
1. The .sh script for your computer to set up uWebSocketIo (once)
2. mkdir build
3. cd build
4. cmake ..
5. make
6. ./ExtendedKF


text:
    Whatsapp Bot

  For Whatsapp Api

Bot for use with Whatsapp Api providing easy registration of menus and their items.

  Technologies   |
  Prerequisites   |
  How To Use   |
  How To Contribute   |
  License

## :rocket: Technologies

My sincere thanks to [adiwajshing](https://github.com/adiwajshing).

This project was developed with the [adiwajshing/Baileys](https://github.com/adiwajshing/Baileys) with the following technologies:

- [TypeScript](https://www.typescriptlang.org/)
- [Commitizen](https://github.com/commitizen/cz-cli)
- [Commitlint](https://github.com/conventional-changelog/commitlint)
- [JS Standard Style](http://standardjs.com)
- [Tests with Jest](https://jestjs.io/)
- [Align Text Line](https://github.com/mckatoo/align-text-line.git)
- [Axios](https://github.com/axios/axios)

## :warning: Prerequisites

To use and test the application, you must have already set up the development environment for NodeJS applications. You can install and configure NodeJS:

## :information_source: How To Use

To clone and run this application, you'll need [Git](https://git-scm.com), [Node.js v12.18][nodejs] or higher + [Yarn v1.22][yarn] or higher installed on your computer. From your command line:

```bash
# Clone this repository
$ git clone https://github.com/mckatoo/whatsapp-bot.git

# Go into the repository
$ cd whatsapp-bot

# Install dependencies
$ yarn
# or
$ npm install

# Build the app
$ yarn build
# or
$ npm run build

# Start the app
$ yarn start
# or
$ npm run start
```

### This data structure is required for querying the robot:
#### http://localhost:1337/menus
```json
[
  {
    "id": 2,
    "title": "Pizzas",
    "options_menus": [
      {
        "id": 7,
        "option": "Peperoni",
        "menu": 2,
        "price": 26.56,
      }
    ]
  }
]
```
#### http://localhost:1337/options-menus
```json
[
  {
    "id": 5,
    "option": "X Salada",
    "menu": {
      "id": 3,
      "title": "Lanches",
    },
    "price": 15,
  }
]
```

## :information_source: How To Contribute

To clone and run this application, you'll need [Git](https://git-scm.com), [Node.js v12.18][nodejs] or higher + [Yarn v1.22][yarn] or higher installed on your computer. From your command line:

### Fork the repository

```bash
# Clone this forked repository
$ git clone https://github.com/your_repository/whatsapp-bot.git

# Go into the repository
$ cd whatsapp-bot

# Add this remote repository
$ git remote add mckatoo https://github.com/mckatoo/whatsapp-bot.git

# Update your local repository if necessary
$ git fetch mckatoo

# Merge your local repository with recentily pushed
$ git merge mckatoo/master

# Push local repository updated for your remote repository
$ git push

# Never work on the main branch
$ git checkout -b your-branch

# There, you can start the job.

# Install dependencies
$ yarn
# or
$ npm install

# Run the app
$ yarn develop
# or
$ npm run develop

# After the modifications are finished, do it.
$ git add .
$ git commit

# This project uses commitizen and commitlint to standardize and organize commits.
# Follow the steps indicated by commitizen.

# After committing, it's time to send your branch
$ git push origin your-branch

# To open a pull request go to your github repository and click on the green button labeled 'Compare & pull request'
# Check all the data and describe the pull request with clear and direct information.
# Click on the green button labeled 'Create pull request'.
# Okay, now just wait for approval or not.
```

For a better illustration of the process, follow a video by [Diego Fernandes of RocketSeat](https://youtu.be/mcd7lqpUzIA)

## :memo: License

This project is under the MIT license. See the [LICENSE](https://github.com/mckatoo/whatsapp-bot/blob/master/LICENSE) for more information.

---

Made with ♥ by Milton Carlos Katoo :wave: Get in touch!

[nodejs]: https://nodejs.org/
[yarn]: https://yarnpkg.com/

repository: clevertonh/whatsapp-bot

repo_name: clevertonh/whatsapp-bot


text:
---
layout: default
---

# 1998-09-18 - No Subject

## Header Data

From: Anonymous<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash:<PHONE_NUMBER>0e82dd0ce83fc1538328c7c60719f21414ba5dba5d5c1462a5c0f8

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1998-09-18 17:09:26 UTC

Raw Date: Sat, 19 Sep 1998 01:09:26 +0800

## Raw message

```
{% raw  %}From: Anonymous<EMAIL_ADDRESS>Date: Sat, 19 Sep 1998 01:09:26 +0800
To<EMAIL_ADDRESS>Subject: No Subject
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>a security dude grabbed my laptop and said he wanted
>to 'analyze' it.  Yeah sure whatever, I decided not to protest
>I was late for my flight.
>This analysis, it turned out, was wiping a coffee filter over the strap
>of its bag, and sticking the coffee filter into a slot on a machine.
>No solvent even.  The machine had columns labelled TNT RDX NITRO PETN HMX.
.....
>The machine name was ION-something; I wonder whether it sucked vapors
>from the fiber disk or whether it was a neutron-spectrometer (?) device.

Try asking them where they've posted the California Prop 65 warning
indicating which toxic chemicals are used in the system :-)

{% endraw %}
```

## Thread

+ Return to [September 1998](/archive/1998/09)

+ Return to "[Anonymous <nobody@replay.com>](/authors/anonymous_nobody_at_replay_com_)"

+ 1998-09-18 (Sat, 19 Sep 1998 01:09:26 +0800) - No Subject - _Anonymous<EMAIL_ADDRESS>


text:
---
author: lindsay
date: 2013-09-12 19:00:55+00:00
layout: post
slug: nms-primer-5
title: 'NMS Primer 5: Implementation'
categories:
- NMS
series: 'NMS Primer'
tags:
- NMS
- series
---

{% include series.html %}

We've covered [what an NMS does]({% post_url 2013-09-08-nms-primer-1 %}), and provided [some]({% post_url 2013-09-10-nms-primer-3 %}) [tips]({% post_url 2013-09-11-nms-primer-4 %}) on selecting one. Now let's assume you've chosen a system, and you're about to start installing it. The exact steps you go through will vary, based upon your network, your goals, and your chosen product sets. Here’s a few things I’ve learned about implementing network management systems:

1. [Start small](#start-small)
2. [Get team buy-in](#get-team-buy-in)
3. [Be aware of the pitfalls - don’t believe all the marketing](#be-aware-pitfalls)
4. [Expect noise, and be ready to deal with it](#expect-noise)
5. [Allocate sufficient time and resources](#allocate-time-resources)

Let’s go through these.

## 1. Start small.   {#start-small}

Have a few clear, achievable goals in mind. Deliver those first, before getting carried away. Your initial goals might be as simple as:

1. Get all network devices added to the NMS.
2. Get up/down alarming for all devices working, and escalated as required (email, Service Desk, etc)
3. Get regular device backups for all systems

And that’s it. No, it’s not exciting. But make damn sure you’ve got that level working before you move on to things like performance management, and pretty visualisations. It’s probably going to take you a while to get that stuff done anyway - updating SNMP community strings, ACLs and login credentials can take a while if you don’t have all your devices centrally managed (yet).

## 2. Team buy-in   {#get-team-buy-in}

If your network team doesn’t like the tool, and doesn’t know how to use it, the project will be a disaster. Trust me. Make sure that internal people are involved, and ideally there is at least one internal team member responsible for this project. You want at least one permanent staff member to fully take it on board, and own, love and cherish that system. It can’t just be consultant-driven.

## 3. Be Aware of Pitfalls - Don’t Believe the Hype   {#be-aware-pitfalls}

Be very aware of the potential pitfalls of implementing any new NMS. Everyone gets excited about the new system, and all the wonderful things the marketing material said it can do. But there’s some hard work required to realise those benefits, and some things will just prove too hard (you didn’t believe ALL the marketing, did you?). Be realistic with your goals, and don’t lose heart if it’s not “magical” from day one.

## 4. There will be Noise. Be ready to fix things   {#expect-noise}

One of the main challenges is that you’re going to get a lot of noise from your network. There’s going to be a lot of things that you’ll find out about your network. The new system may be a bit too sensitive, or it may actually be your network that needs fixing. Don’t shy away from it because the noise gets overwhelming. Be prepared for it, and allow time to fix your network issues. Approach them in a “noisiest-first” manner. Soon it will quieten down.

## 5. Do the Hard Yards - Allocate Time and Resources   {#allocate-time-resources}

Finally, don’t underestimate the time required. It’s tempting to get external resources in to help with the initial implementation. Great idea! I know some people who can help! :D But if you do this, the consultant should not work by themselves - they should be working with you, preferably with you driving the mouse and keyboard. This is a valuable investment, as you will learn the skills you need to drive the tools. This will pay off in future, when you have the skills to use your new NMS to reduce the time it takes to detect and repair faults. If you don’t have the time to do this, consider using contractors to take on your regular workload, rather than the NMS implementation work.

## Conclusion: It’s not rocket science - just hard work

Don’t shoot for the moon with your NMS. At least not at first. Start small, ensure all key staff are involved, and steadily expand. Do that, and there’s far less chance of it becoming shelfware.


text:
## Execute Playbook by following steps as below

- Follow Chapter 3 Setup CSAH node in [OCP 42 Dell Deployment Guide](https://www.dellemc.com/resources/en-us/asset/technical-guides-support-information/solutions/h18022-ocp4.2-dpg.pdf) to run ansible playbook

- Gather the IP address and NIC mac address of bootstrap, master(s), worker(s) nodes

- Update the hosts file located in repository home directory

- Current hosts file already is filled with sample values and comments are included for each section accordingly.

- Below are the links to the OpenShift software files. Download them and specify the names accordingly for each variable in hosts file. These files are also referenced in Deployment Guide.

  a) [uefi_file](https://mirror.openshift.com/pub/openshift-v4/dependencies/rhcos/4.2/4.2.0/rhcos-4.2.0-x86_64-metal-uefi.raw.gz)

  b) [initramfs](https://mirror.openshift.com/pub/openshift-v4/dependencies/rhcos/4.2/4.2.0/rhcos-4.2.0-x86_64-installer-initramfs.img)

  c) [openshift_client](https://mirror.openshift.com/pub/openshift-v4/clients/ocp/4.2.0/openshift-client-linux-4.2.0.tar.gz)

  d) [openshift_installer](https://mirror.openshift.com/pub/openshift-v4/clients/ocp/4.2.0/openshift-install-linux-4.2.0.tar.gz)

  e) [kernel_file](https://mirror.openshift.com/pub/openshift-v4/dependencies/rhcos/4.2/4.2.0/rhcos-4.2.0-x86_64-installer-kernel)

  f) [pull_secret_file](https://cloud.redhat.com/openshift/install/metal/user-provisioned)

repository: mohammedidriss/openshift-bare-metal

repo_name: mohammedidriss/openshift-bare-metal


text:
---
title: 558. For the Fruits of His Creation - Seventh Day Adventist Hymnal
metadata:
    description: |
      SDAH 558. For the Fruits of His Creation. 1. For the fruits of His creation, thanks be to God; For the gifts to every nation, thanks be to God; For the plowing, sowing, reaping, Silent growth while men are sleeping, Future needs in earth’s safe keeping, thanks be to God!
    keywords:  |
      SDAH, Seventh Day Adventist Hymnal, adventhymnals, advent hymnals, For the Fruits of His Creation, For the fruits of His creation, thanks be to God;
    author: Brian Onang'o
---

#### Advent Hymnals
## 558. FOR THE FRUITS OF HIS CREATION
#### Seventh Day Adventist Hymnal

```txt

1.
For the fruits of His creation, thanks be to God;
For the gifts to every nation, thanks be to God;
For the plowing, sowing, reaping,
Silent growth while men are sleeping,
Future needs in earth’s safe keeping, thanks be to God!

2.
In the just reward of labor, God’s will is done;
In the hop we give our neighbor, God’s will is done;
In our worldwide take of caring
For the hungry and despairing,
In the harvests men are sharing, God’s will is done.

3.
For the harvests of His Spirit, thanks be to God;
For the good all men inherit, thanks be to God;
For the wonders that astound us,
For the truths that still confound us,
Most of all, that love has found us, thanks be to God!

```

- |   -  |
-------------|------------|
Title | For the Fruits of His Creation |
Key |  |
Titles | undefined |
First Line | For the fruits of His creation, thanks be to God; |
Author |
Year |
Composer|  |
Hymnal|  - |
Tune|  |
Metrical pattern | |
# Stanzas |  |
Chorus |  |
Chorus Type |  |
Subjects |  |
Texts |  |
Print Texts |
Scripture Song |  |

repository: GospelSounders/adventhymnals

repo_name: GospelSounders/adventhymnals


text:
## 1.0.7
[AFXAuthClient](https://github.com/romaonthego/AFXAuthClient/compare/1.0.6...1.0.7)

###### Bug fixes

* Validate the input to `RFC3986EscapedStringWithEncoding()`, so that it does not return nil. [#6](https://github.com/romaonthego/AFXAuthClient/issues/6)

## 1.0.6
[AFXAuthClient](https://github.com/romaonthego/AFXAuthClient/compare/1.0.5...1.0.6)

###### Enhancements

* Added NSCoding support to AFXAuthToken.

## 1.0.5
[AFXAuthClient](https://github.com/romaonthego/AFXAuthClient/compare/1.0.4...1.0.5)

###### Bug fixes

* Fixed bug where passwords with certain special characters (eg. asterisks) fail
in certain services such as Instapaper. [#2](https://github.com/romaonthego/AFXAuthClient/issues/2)

## 1.0.4
[AFXAuthClient](https://github.com/romaonthego/AFXAuthClient/compare/1.0.3...1.0.4)

###### Bug fixes

* Strip query after ? in GET requests. [#1](https://github.com/romaonthego/AFXAuthClient/issues/1)

## 1.0.3
[AFXAuthClient](https://github.com/romaonthego/AFXAuthClient/compare/1.0.2...1.0.3)

###### Enhancements

* Changed AFXAuthToken assignment from readonly to readwrite.

## 1.0.2
[AFXAuthClient](https://github.com/romaonthego/AFXAuthClient/compare/1.0.1...1.0.2)

###### Enhancements

* Added support for multi part data requests.

## 1.0.1
[View diff](https://github.com/romaonthego/AFXAuthClient/compare/1.0...1.0.1)

###### Bug fixes

* Fix GET request parameters bug.

## 1.0

Initial release.

repository: ketzusaka/AFXAuthClient

repo_name: ketzusaka/AFXAuthClient


text:
# Tiny Typescript Standard Library (ttsl)

TTSL stands for Tiny Typescript Standard Library. It's originally an attempt to learn Typescript.
It contains in particular a of typed collections (list, map, set, etc.).

# Installation

First thing first: retrieving local node modules listed in package.json. You can simply do it by:
```bash
npm install
```

Then set your favorite IDE (Webstorm, VS Code, etc.) to understand ES6 syntax.

Finally you can compile/transpile all .ts files into ES5 by doing:
```bash
tsc --target es5 --modules commonjs
```


text:
# ActionStatus

`from tdw.replicant.action_status import ActionStatus`

The status of the Replicant after doing an action.

| Value | Description |
| --- | --- |
| `ongoing` | The action is ongoing. |
| `failure` | Generic failure code (useful for custom APIs). |
| `success` | The action was successful. |
| `failed_to_move` | Tried to move to a target position or object but failed. |
| `failed_to_turn` | Tried to turn but failed to align with the target angle, position, or object. |
| `cannot_reach` | Didn't try to reach for the target position because it can't. |
| `failed_to_reach` | Tried to reach for the target but failed; the magnet isn't close to the target. |
| `not_holding` | Didn't try to drop the object(s) because it isn't holding them. |
| `collision` | Tried to move or turn but failed because it collided with something. |
| `detected_obstacle` | Detected an obstacle in its path. |
| `already_holding` | Already holding the object. |
| `still_dropping` | Dropped an object but, after many `communicate()` calls, the object is still moving. |
| `cannot_grasp` | Didn't try to grasp the object because it's of an invalid type (e.g. a kinematic object). |

repository: threedworld-mit/tdw

repo_name: threedworld-mit/tdw