text:
# CMC Frontend

[![Greenkeeper badge](https://badges.greenkeeper.io/hmcts/cmc-citizen-frontend.svg)](https://greenkeeper.io/)

[![Standard - JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)

[![codecov](https://codecov.io/gh/hmcts/cmc-citizen-frontend/branch/master/graph/badge.svg)](https://codecov.io/gh/hmcts/cmc-citizen-frontend)

This is the frontend application for CMC. Service provides web UI for citizens, presented as sequence of HTML 5 web pages designed to GDS Service Design guidelines, so that they can make money claims and / or perform associated actions e.g submitting defence or requesting default judgement.

Service delegates most of the non UI responsibilities to underlying services e.g. claim-store or pdf-service.

### Getting Started

### Prerequisites

* [Node.js](https://nodejs.org/) >= 18.15.0
* [yarn](https://yarnpkg.com/)
* [Gulp](http://gulpjs.com/)
* [Docker](https://www.docker.com)

#### Running the application

Install dependencies by executing the following command:

 ```bash
$ yarn install
 ```

Run:

```bash
$ gulp
```

It will be available at https://localhost:3000

### Running the application on docker (integrated environment)

See the README.md in hmcts/cmc-integration-tests

## Developing

### Code style

We use [TSLint](https://palantir.github.io/tslint/) with [StandardJS](http://standardjs.com/index.html) rules alongside [sass-lint](https://github.com/sasstools/sass-lint)

Running the linting:
`yarn lint`

### Running the tests

Mocha is used for writing tests.

Run them with:

```bash
$ yarn tests
```

For functional testing:

```bash
$ yarn test:routes
```

For accessibility testing:

```bash
$ yarn tests:a11y
```

For test coverage:

```bash
$ yarn test:coverage
```

For unit test coverage only:

```bash
$ yarn test:coverage-unit
```

### Running end to end tests

Integration tests are written using [CodeceptJS](https://codecept.io/) framework and reside in [`src/integration-test`](src/integration-test) directory. They are executed using Docker.

If you want to run them to see if your changes work, you will need to build a docker image containing your updates:

```bash
$ docker-compose build citizen-integration-tests
```

Then you can go to the [integration-tests](https://github.com/hmcts/cmc-integration-tests) project and run them with:

```bash
$ ./bin/run-local-citizen-tests.sh
```

If you didn't have a dockerized environment running it will be started up for you. If you prefer to start it up yourself beforehand, do:

```bash
$ ./bin/start-local-environment.sh
```

For more details on the dockerized environment please refer to integration-tests repository's[`README`](https://github.com/hmcts/cmc-integration-tests/blob/master/README.md) file.

## Troubleshooting

### Warnings while running ```yarn install``` on yarn version 1.0.1

There is currently an open issue : https://github.com/yarnpkg/yarn/issues/3751

Example:

```
warning The case-insensitive file ..\cmc-citizen-frontend\node_modules\nyc\node_modules shouldn't be copied twice in one bulk copy
warning The case-insensitive file ..\cmc-citizen-frontend\node_modules\nyc\node_modules\ansi-regex shouldn't be copied twice in one bulk copy
```

## Preview Environment ##

We get a fully functional environment in Azure Kubernetes (AKS) per pull request. For more
info see: https://tools.hmcts.net/confluence/display/ROC/AKS+-+Azure+Managed+Kubernetes

## License ##
This project is licensed under the MIT License - see the [LICENSE](LICENSE.txt) file for details.

repository: hmcts/cmc-citizen-frontend

gha_language: TypeScript

repo_name: hmcts/cmc-citizen-frontend


text:
# Below is a list of people and organizations that have contributed
# to the Swish project. Names should be added to the list like so:
#
#   Name/Organization <email address>

Basit Ayantunde <rlamarrr@gmail.com>

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
![](https://github.com/petardfoozer/telemetrymvc/blob/master/public/images/telemetry.PNG)

# telemetrymvc
An open source PHP framework

This is a project mainly focused on helping me learn more about MVC frameworks.

I will be updating when I feel the urge to write more functionality into the framework

Future plans are to add support for:

- File Encryption
- SFTP transfer
- Samba Share connection

To get started
 - edit /public/.htaccess file line 4 to set your rewrite base
 - edit /app/config/config
    - Define your DB_HOST
    - Define your DB_USER
    - Define your DB_PASS
    - Define your DB_NAME
    - Define your URL_ROUTE
    - Define your SITE_NAME

Copyright 2020 PETER CAGEAO

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

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

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

repository: petardfoozer/telemetrymvc

repo_name: petardfoozer/telemetrymvc


text:
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/buschmais/software-analytics-starter/master)

# software-analytics-starter

This is a starter project for Software Analytics with jQAssistant, Neo4j, Jupyter Notebooks, and mybinder.

## Example Project

This starter uses the shopizer e-Commerce Shop System (Version 2.12.0) for analysis. It was only modified in the way that jQAssistant was added. The link to the fork can be found in the "resources" section.

The analytics notebooks are structured based on the Software Analytics Canvas created by Markus Harrer. The link to his blog post can be found in the "resources" section.

## How to Use

To launch the Jupyter Notebook simply click the mybinder badge on top of this readme.
A new tab will then be opened where you can see the environment including Jupyter and Neo4j getting spinned up.

Once ready, you can open the Jupyter Notebooks, execute the given queries, write new ones and get into Software Analytics.

## Resources

* [Software Analytics Canvas](https://www.feststelltaste.de/software-analytics-canvas/)
* [Software-Analyse und -Visualisierung mit Python](https://github.com/softvis-research/BeLL)
* [Binder and Neo4j Integration](https://github.com/psychemedia/binder-neo4j)
* [Shopizer Fork](https://github.com/StephanPirnbaum/shopizer)

repository: mdiedric/software-analytics-starter

repo_name: mdiedric/software-analytics-starter


text:
---
layout: post
title:      "Daydreaming of Rack"
date:       2018-07-30 18:33:28 +0000
permalink:  daydreaming_of_rack
---

      So the otherday after wrapping up my Sinatra project I realized I didn't understand much of the structure for setting up Sinatra. I mean I know how to get everything going by copying previous projects but I really couldn't explain much of why I was doing it. As I laid in bed running the setup in my head all I could think about was config.ru, rack, and app.rb. After half-an-hour of this I got on my computer and tried to execute my thoughts I quickly hit a wall and accepted the fact that I couldn't establish a connection to my browser from my IDE.

      After being humbled, I decided to re-read learn's lesson on rack and check out https://www.rubydoc.info/gems/rack/ to gain a different perspective and clean up holes in my thinking. This is what I got:

* Rack provides a **minimal, modular, and adaptable interface** for **developing web applications in Ruby**. By wrapping HTTP requests and responses in the simplest way possible, it **unifies** and **distills** the **API for web servers, web frameworks, and software** in between (the so-called middleware) **into a single method call**.

* Supported web servers:  The included handlers connect all kinds of web servers to Rack, which includes one that I am familiar. I see WEBrick pop-up when everything in my browser is working fine.

* Supported web frameworks: There are many here just like web servers, the ones I'm most familiar with are Sinatra and Ruby on Rails.

**Why should I use Rack?**

* **Convenience**. If you want to develop outside of existing frameworks, implement your own ones, or develop middleware, Rack provides many helpers to create Rack applications quickly and without doing the same web stuff all over:

* **Rack::Request**, which also provides query string parsing and multipart handling.

* **Rack::Response**, for convenient generation of HTTP replies and cookie handling.

* Rack::MockRequest and Rack::MockResponse for efficient and quick testing of Rack application without real HTTP round-trips.

**What's the deal with Rackup and config.ru?**

* Rackup is a **useful tool for running Rack applications**, which **uses** the **Rack::Builder** DSL **to configure middleware** and build up applications easily.

* Rackup **automatically figures out the environment** it is run in, and **runs your application as** FastCGI, CGI, or **WEBrick**—all from the same configuration.

* From my understanding and experimentation it seems that the file does not need to be named config.ru, but must have an .ru extension.

      With this information I opened my IDE, created a config.ru file and wrote the following.

```
class Application

  def call(env)
    resp = Rack::Response.new
    resp.write "Hello World"
    resp.finish
  end

end

run Application.new
```

then I typed,

```
gem install rack
```

followed by,

```
rackup config.ru
```

which output the following,

```
Your server is running at <IP_ADDRESS>:35598
===================LOGS======================
Thin web server (v1.7.2 codename Bachmanity)
Maximum connections set to 1024
Listening on <IP_ADDRESS>:9292, CTRL+C to stop
<IP_ADDRESS> - - [30/Jul/2018:17:18:03 +0000] "GET / HTTP/1.1" 200 6 0.0036
<IP_ADDRESS> - - [30/Jul/2018:17:18:03 +0000] "GET /favicon.ico HTTP/1.1" 200 6 0.0004
```

Originally the purpose of this thought exercise was to see how complicated I could get my program without using my ability to memorize name or look up, but through intuition to see how well I understand my knowledge. With that in mind I created a class to called Student to see if I could get a new Student to display on the browser.

```
class Student
  attr_accessor :name

  def initialize(name:)
    @name = name
  end
end
```

and changed the call method to:

```
def call(env)
    joseph = Student.new(name: "Joseph")
    resp = Rack::Response.new
    resp.write "#{joseph.name}"
    resp.finish
  end
```

Sure enough it worked. From there I decided to see if I could add ActiveRecord to it, but once again I hit a wall. Do I need a Rakefile? or can I add ActiveRecord in my config.ru file? Again, I wanted to see how simple I could build up an applicaiton even if it's sloppy. I'll leave the answer to that for another post.

extension: markdown


text:
# IHasConstant<TClass, TMember> Interface

Namespace: [CsvHelper.Configuration](/api/CsvHelper.Configuration)

Has constant capabilities.

```cs
public interface IHasConstant<TClass, TMember> : IBuildableClass<TClass>
```

## Methods
  |
- | -
Constant(TMember) | The constant value that will be used for every record when reading and writing. This value will always be used no matter what other mapping configurations are specified.

repository: mattosaurus/CsvHelper

gha_license_id: NOASSERTION

repo_name: mattosaurus/CsvHelper


text:
# is-this-version :question:

[![npm version](https://badge.fury.io/js/is-this-version.svg)](https://badge.fury.io/js/is-this-version)
[![Build Status](https://travis-ci.com/rafalmaciejewski/is-this-version.svg?branch=master)](https://travis-ci.com/rafalmaciejewski/is-this-version)
[![Dependencies](https://img.shields.io/david/rafalmaciejewski/is-this-version.svg?style=flat-square)](https://david-dm.org/rafalmaciejewski/is-this-version)
[![Coverage Status](https://coveralls.io/repos/github/rafalmaciejewski/is-this-version/badge.svg?branch=master)](https://coveralls.io/github/rafalmaciejewski/is-this-version?branch=master)
[![License](http://img.shields.io/:license-mit-blue.svg?style=flat-square)](http://badges.mit-license.org)

---

CLI tool that checks if your package version is set correctly.

This tool was made to be used in some deployment pipelines during verify stages.

---

## Installation

```shell
$ npm install -g is-this-version
```

## Usage

If installed globally, `is-this-version` will be available as a CLI command. This command should be executed from a root directory of a project to be verified.

Only argument that needs to passed is a version number.

```shell
$ is-this-version 1.0.1
```

If there will be a mismatch in either package.json or package-lock.json the above command will return an error exit code.

repository: rafalmaciejewski/is-this-version

gha_language: JavaScript

gha_license_id: MIT

repo_name: rafalmaciejewski/is-this-version


text:
# limited-resource-queued-tests
Running JUnit tests that need exclusive use of a limited resource concurrently using maven-failsafe-plugin

Running tests concurrently can cause test flakiness when some tests change the system state in a way that impacts other tests running in the same time.

For example, if several tests are running on an application tenant and one test changes the application's metadata then it affects other tests running in the same time.

When the shared resource is easy to create then each test creates its own instance of that resource.

When it's a costly resource, such as an application tenant which creates database schemas, then only a few instances are created beforehand.

In this case such tests run serially with an exclusive use of the limited resource so they do not impact each other.

The repository shows a solution that creates instances of the limited resource dynamically and runs tests exclusively and concurrently.

The limited resource here is a file, which logs test execution.

Tests are queued and run concurrently, however each test runs with an exclusive use of the file.

The output files are created in java.io.tmp folder.

Run

		mvn clean install

And check that tests run multi-threaded where each thread is executing tests serially and provides exclusive access to the shared file.

license: Unlicense


text:
# Social Tables Docker-Machine DNS Config Utility

This is a utility for making [Docker Machine](https://docs.docker.com/machine/overview/) VMs accessible via hostname on OSX via [Dnsmasq](http://www.thekelleys.org.uk/dnsmasq/doc.html).

When Docker Machine starts a VM to run containers, it can be hard to anticipate what IP it will mount at, making static configuration of both hosts and application-specific redirects (think Dockerized web services implementing flows like OAuth) challenging to configure and maintain. This utility solves the problem by making it easy to automatically update a dnsmasq configuration to point to this occasionally-moving target.

## Contents

This repo contains two primary scripts:

- *update-docker-machine-dns.sh*: A script for updating the current dnsmasq configuration to assign a domain to an actively-running docker-machine instance's ip. Accepts optional arguments to specify which docker-machine name and host name to use, and can be run continuously via the -d flag.
- *install.sh*: An all-in-one installer which installs and configures dnsmasq and a launch daemon which runs update-docker-machine-dns in the background. Targets the "default" docker machine VM. This VM and hostname can be configured as daemon program arguments in the com.socialtables.docker-hostname-daemon.plist.

## Prerequisites

You should have Docker Toolbox and Homebrew installed.

## Usage

```
docker-machine start
./install.sh [-v]
```

repository: socialtables/docker-machine-dns-daemon

branch_name: refs/heads/main

repo_name: socialtables/docker-machine-dns-daemon


text:
# Security Policy

## Supported Versions

Use this section to tell people about which versions of your project are
currently being supported with security updates.

| Version | Supported          |
| ------- | ------------------ |
| 14.x    | :white_check_mark: |
| 13.x    | :x:                |
| 12.x    | :x:                |
| < 11.x  | :x:                |

## Reporting a Vulnerability

Vulnerabilities can be reported to me via email at<EMAIL_ADDRESS>or directly through the [GitHub Issues Board](https://github.com/RichardTMiles/CarbonPHP/issues).

repository: CarbonORM/CarbonPHP

branch_name: refs/heads/lts

gha_language: PHP

repo_name: CarbonORM/CarbonPHP


text:
# axios-cookiejar-support

![axios-cookiejar-support](./docs/assets/ogp.jpg)

[![github sponsors](https://flat.badgen.net/badge/GitHub%20Sponsors/Support%20me%20%E2%9D%A4/ff69b4?icon=github)](https://github.com/sponsors/3846masa)
[![npm](https://flat.badgen.net/npm/v/axios-cookiejar-support)](https://www.npmjs.com/package/axios-cookiejar-support)
[![license](https://flat.badgen.net/badge/license/MIT/blue)](LICENSE)
[![standard-readme compliant](https://flat.badgen.net/badge/readme%20style/standard/green)](https://github.com/RichardLitt/standard-readme)

Add `tough-cookie` support to axios.

## Table of Contents

- [Install](#install)
- [Usage](#usage)
  - [Extended Request Config](#extended-request-config)
- [Contributing](#contributing)
- [License](#license)

## Install

```
npm install axios tough-cookie axios-cookiejar-support
```

## Usage

```js
import axios from 'axios';
import { wrapper } from 'axios-cookiejar-support';
import { CookieJar } from 'tough-cookie';

const jar = new CookieJar();
const client = wrapper(axios.create({ jar }));

await client.get('https://example.com');
```

See [examples](./examples) for more details.

### Extended Request Config

```ts
import type { CookieJar } from 'tough-cookie';

declare module 'axios' {
  interface AxiosRequestConfig {
    jar?: CookieJar;
  }
}
```

See also https://github.com/axios/axios#request-config .

## FAQ

- Q. Why can't I assign the httpAgent / httpsAgent?
  - A. axios-cookiejar-support uses httpAgent / httpsAgent to read and write cookies. If other Agents are assigned, cookies cannot be read/written.
- Q. I want to use it with another Agent (e.g., http-proxy-agent).
  - A. Consider using http-cookie-agent. axios-cookiejar-support also uses http-cookie-agent. Read http-cookie-agent's README for more details.

## Contributing

PRs accepted.

## License

[MIT (c) 3846masa](./LICENSE)


text:
CZSecurityTouchID_swift
=============

CZSecurityTouchID_swift secures your app by requiring a Touch ID fingerprint or passcode.

Validation                |  Adjustment
:-----------------------:|:-------------------------:
![](doc/validation.gif)  |   ![](doc/settings.gif)

Installation
------------
The easiest way to get started is to use [CocoaPods](http://cocoapods.org/). Just add the following line to your Podfile:

```ruby
pod 'CZSecurityTouchID_swift'
```

Usage
-----

### 1. import the class
```swift
import CZSecurityTouchID_swift
```

### Create a simple validation view

In order to conform to the PinViewControllerValidate protocol you have to adopt it in your UIViewController
```swift
class ViewController: UIViewController,PinViewControllerValidateDelegate
```

To conform to the PinViewControllerValidateDelegate you have to implement the following functions:
```swift
func pinViewControllerDidSetWrongPin(action :pinViewAction){

}

func pinViewControllerDidSetСorrectPin(action: pinViewAction){

}
```

To create a validation view
```swift
let viewController = = FingerPrint.sharedInstance.createPinViewWithScope(scope: .PinViewControllerScopeValidate, validationDelegate: self)
```
* `Scope`:
	* PinViewControllerScopeValidate : the view for request the pin or finger print (Need to have some pin saved)
	* PinViewControllerScopeCreate : the view for create a new pincode
	* PinViewControllerScopeChange : the view for change the pincode
	* PinViewControllerScopeDesactive : the view to delete the pincode

* `validationDelegate`:  PinViewControllerValidateDelegate
This method return to UIViewController and you can add in your navigation flow

### Create an adjustment view that covers all scope
Is a simple view to configure all the options of the pin and touch id

To create a setting view
```swift
let viewController = FingerPrint.sharedInstance.createSettingViewWithAppearance(settingAppearance: nil, pinAppearance: nil)
```
This method return to UIViewController and you can add in your navigation flow

### Other Setting

**Setting up length For Pin code**
By default is 4
```swift
FingerPrint.sharedInstance.lengthCodePin = 4
```

**Setting up the validation view appearance**
```swift
let appearance = PinAppearance.defaultAppearance()
appearance.logo = UIImage(named:"sc_logo")
/*You can configure all the attributes you need */
FingerPrint.sharedInstance.appearance = appearance;
```

**Setting up the adjustment view appearance and PinCode View**
```swift
let settingAppearance = SettingsAppearance.defaultAppearance()
settingAppearance.titleGroupText = "Group title"
/*You can configure all the attributes you need */

let appearance = PinAppearance.defaultAppearance()
appearance.logo = UIImage(named:"sc_logo")
/*You can configure all the attributes you need */
let viewController = FingerPrint.sharedInstance.createSettingViewWithAppearance(settingAppearance: settingAppearance, pinAppearance: appearance)
```


text:
# Minichess AI #
#### CS542 Advanced AI: Combinatorial Games ####

### About ###

This is my project for CS542. This minichess AI will play games on the Portland State University Internet MiniChess Server, and eventually it will play well enough to compete.

### Installation ###

The installation utilizes ZeroMQ: http://zeromq.org/. Please ensure that ZeroMQ is installed and that the C++ binding (https://github.com/zeromq/cppzmq) is also installed by ensuring that the zmq.hpp file is in one of the paths found in the `#include <...> search starts here:` section when you execute:

    cpp -v /dev/null -o /dev/null

The preferred compilation is via the make file. The Makefile is in the project root directory so you can issue one of the following commands:
* `make` <-- The default is the same as `make optimized`
* `make debug`
* `make odebug`
* `make optimized`
* `make standard`

There is a cmake file if you choose to use it.You're on your own with that.

For the Python portion, you'll need Python 2.7.13, Python 3.6.0, or Pypy2 5.7.0. To install issue the following CLI commands from the python environment you have:

    python setup.py build
    python setup.py install

### Connecting to the IMCS ###

In order to connect to the IMCS server, you must have a settings file. The game will attempt to help you make the settings file on the first run if no such file is found, but this might be a bit buggy at the moment. For now, please create a file called `settings.ini` and input information like you see in the `example_settings.ini` file.

    [SERVER]
    host = sweet.chess.host.url
    port = 9999

    [PLAYER]
    username = ur_player
    password = hunter2

### Playing a Game ###

A minichess game is played via a bash script which starts the move generator back end as a background process and starts the front end with the CLI options you provided. To get help with the command line options, use `./play -h`. What you'll see is this:

```
usage: play.py [-h] [--debug] [-v]
               [-p {tester,random,negamax,ab,abid,abidttable}] [-a]
               [-o OPPONENT [OPPONENT ...]] [-ao] [-n NAME] [-pw PASSWORD]

Minichess player:

optional arguments:
  -h, --help            show this help message and exit
  --debug               Turn on debugging mode
  -v, --verbosity       Increase output verbosity, blank shows DEBUG only, -v
                        shows ERROR and CRITICAL. -vv shows WARNING, ERROR,
                        and CRITICAL. -vvv shows INFO, WARNING, ERROR, and
                        CRITICAL. -vvvv shows all levels including DEBUG.
  -p {tester,random,negamax,ab,abid,abidttable}, --player {tester,random,negamax,ab,abid,abidttable}
                        Specify the type of player to use. Does what's on the
                        tin. The tester doesn't connect to IMCS; instead, it
                        causes the move generator to return all possible moves
                        of a given board.
  -a, --automatic       Play auto-accept games. Without this option, you will
                        choose games from a menu.
  -o OPPONENT [OPPONENT ...], --opponent OPPONENT [OPPONENT ...]
                        A (space separated) list of player names to play
                        against when playing as automatic player. Without this
                        set, the player will pick games at random.
  -ao, --auto-offer     This player connects and offers games automatically.
  -n NAME, --name NAME  The username to use for this player. Set this if you
                        want to override the settings.ini
  -pw PASSWORD, --password PASSWORD
                        The password to use with the overridden username.
                        Required if --name option is set.
```

repository: mikelane/minichess

repo_name: mikelane/minichess


text:
# `bindkey`

* `bindkey -l`: list of existing keymap names
* `bindkey -M <keymap>`: list of all bindings for a given keymap
* Can add manual keybindings in `.zshrc`
* `cat` and then typing anything will show keystrokes

repository: jaebradley/notes

repo_name: jaebradley/notes


text:
# Dotfiles

My OSX / Ubuntu dotfiles.

This is a fork of [Ben Alman's dotfiles](https://github.com/cowboy/dotfiles). with modifications for my personal preferences and workflows.

## How the "dotfiles" command works

When [dotfiles](bin/dotfiles) is run for the first time, it does a few things:

1. This repo is cloned into your user directory, under `~/.dotfiles`.
2. Files in `/copy` are copied into `~/`. ([read more](#the-copy-step)\)
3. Files in `/link` are symlinked into `~/`. ([read more](#the-link-step)\)
4. You are prompted to choose scripts in `/init` to be executed. The installer attempts to only select relevant scripts, based on the detected OS and the script filename.
5. Your chosen init scripts are executed (in alphanumeric order, hence the funky names). ([read more](#the-init-step)\)

On subsequent runs, step 1 just updates the already-existing repo, and step 4 remembers what you selected the last time. The other steps are the same.

### Other subdirectories

- The `/backups` directory gets created when necessary. Any files in `~/` that would have been overwritten by files in `/copy` or `/link` get backed up there.
- The `/bin` directory contains executable shell scripts (including the [dotfiles](bin/dotfiles) script) and symlinks to executable shell scripts. This directory is added to the path.
- The `/caches` directory contains cached files, used by some scripts or functions.
- The `/conf` directory just exists. If a config file doesn't **need** to go in `~/`, reference it from the `/conf` directory.
- The `/source` directory contains files that are sourced whenever a new shell is opened (in alphanumeric order, hence the funky names).
- The `/test` directory contains unit tests for especially complicated bash functions.
- The `/vendor` directory contains third-party libraries.

### The "copy" step

Any file in the `/copy` subdirectory will be copied into `~/`. Any file that _needs_ to be modified with personal information should be _copied_ into `~/`. Because the file you'll be editing is no longer in `~/.dotfiles`, it's less likely to be accidentally committed into your public dotfiles repo.

### The "link" step

Any file in the `/link` subdirectory gets symlinked into `~/` with `ln -s`. Edit one or the other, and you change the file in both places. Don't link files containing sensitive data, or you might accidentally commit that data! If you're linking a directory that might contain sensitive data (like `~/.ssh`) add the sensitive files to your [.gitignore](.gitignore) file!

### The "init" step

Scripts in the `/init` subdirectory will be executed. A whole bunch of things will be installed, but _only_ if they aren't already.

- Minor XCode init via the [init/10_osx_xcode.sh](init/10_osx_xcode.sh) script
- Homebrew via the [init/20_osx_homebrew.sh](init/20_osx_homebrew.sh) script
- Homebrew recipes via the [init/30_osx_homebrew_recipes.sh](init/30_osx_homebrew_recipes.sh) script
- Homebrew casks via the [init/30_osx_homebrew_casks.sh](init/30_osx_homebrew_casks.sh) script
- Mac App Store apps via the [init/30_osx_mas.sh](init/30_osx_mas.sh) script
- Python and Node via the [init/40_asdf.sh](init/40_asdf.sh) script

## Hacking my dotfiles

Because the [dotfiles](bin/dotfiles) script is completely self-contained, you should be able to delete everything else from your dotfiles repo fork, and it will still work. The only thing it really cares about are the `/copy`, `/link` and `/init` subdirectories, which will be ignored if they are empty or don't exist.

Also, before installing, be sure to [read my gently-worded note](#heed-this-critically-important-warning-before-you-install).

## Installation

You need to be an administrator (for `sudo`).

You need to have [XCode](https://developer.apple.com/downloads/index.action?=xcode) or, at the very minimum, the [XCode Command Line Tools](https://developer.apple.com/downloads/index.action?=command%20line%20tools), which are available as a much smaller download.

The easiest way to install the XCode Command Line Tools in OSX 10.9+ is to open up a terminal, type `xcode-select --install` and [follow the prompts](http://osxdaily.com/2014/02/12/install-command-line-tools-mac-os-x/).

_Tested in OSX 10.15_

### Ubuntu Notes

You might want to set up your ubuntu server [like I do it](https://github.com/cowboy/dotfiles/wiki/ubuntu-setup), but then again, you might not.

Either way, you should at least update/upgrade APT with `sudo apt-get -qq update && sudo apt-get -qq dist-upgrade` first.

_Tested in Ubuntu 14.04 LTS_

### Heed this critically important warning before you install

**If you're not me, please _do not_ install dotfiles directly from this repo!**

Why? Because I often completely break this repo while updating. Which means that if I do that and you run the `dotfiles` command, your home directory will burst into flames, and you'll have to go buy a new computer. No, not really, but it will be very messy.

### Actual installation (for you)

1. [Read my gently-worded note](#heed-this-critically-important-warning-before-you-install)
2. Fork this repo
3. Open a terminal/shell and do this (change `drzax` and `master` as appropriate):

#### macOS

```sh
export DOTFILES_GH_USER=drzax
export DOTFILES_GH_BRANCH=master
bash -c "$(curl -fsSL https://raw.github.com/$DOTFILES_GH_USER/dotfiles/$DOTFILES_GH_BRANCH/bin/dotfiles)" && source ~/.bashrc
```

Since you'll be using the [dotfiles](bin/dotfiles) command on subsequent runs, you'll only have to set the `DOTFILES_GH_USER` variable for the initial install, but if you have a custom branch, you _will_ need to export `DOTFILES_GH_BRANCH` for subsequent runs.

There's a lot of stuff that requires admin access via `sudo`, so be warned that you might need to enter your password here or there.

## Aliases and Functions

To keep things easy, the `~/.bashrc` and `~/.bash_profile` files are extremely simple, and should never need to be modified. Instead, add your aliases, functions, settings, etc into one of the files in the `source` subdirectory, or add a new file. They're all automatically sourced when a new shell is opened. Take a look, I have [a lot of aliases and functions](source). I even have a [fancy prompt](source/50_prompt.sh) that shows the current directory, time and current git/svn repo status.

## Scripts

In addition to the aforementioned [dotfiles](bin/dotfiles) script, there are a few other [bin scripts](bin).

- [dotfiles](bin/dotfiles) - (re)initialize dotfiles. It might ask for your password (for `sudo`).
- [src](link/.bashrc#L8-18) - (re)source all files in `/source` directory
- Look through the [bin](bin) subdirectory for a few more.

## Prompt

I think [my bash prompt](source/50_prompt.sh) is awesome. It shows git and svn repo status, a timestamp, error exit codes, and even changes color depending on how you've logged in.

Git repos display as **[branch:flags]** where flags are:

**?** untracked files**!** changed (but unstaged) files**\+** staged files

SVN repos display as **[rev1:rev2]** where rev1 and rev2 are:

**rev1** last changed revision**rev2** revision

Check it out:

![My awesome bash prompt](http://farm8.staticflickr.com/7142/6754488927_563dd73553_b.jpg)

## Inspiration

https://github.com/gf3/dotfileshttps://github.com/mathiasbynens/dotfiles (and 15+ years of accumulated crap)

## License

Copyright (c) 2014 "Cowboy" Ben Alman Licensed under the MIT license.http://benalman.com/about/license/

repository: drzax/dotfiles

repo_name: drzax/dotfiles


text:
# Gatsby-Notion-Ghpages Template

Based on [Gatsby London theme](https://www.gatsbyjs.com/starters/ImedAdel/gatsby-london) and the work of [Arnaud Valensi](https://arnaudvalensi.github.io/).

A Python script was developed to pull blog posts from Notion and save them as static page assets in the _'content/blog'_ folder.

## Set up local dev environment

- Gatsby runs on Node.js, so install `node` packages via `yarn`:

```bash
yarn
```

- Launch sample pages

```bash
gatsby develop
```

- Create a dev directory to hold dev scripts (will not be committed):

```bash
cp -r bin bin_dev
```

- `NOTION_TOKEN` and `NOTION_ROOT_PAGE_ID` are required environment variables for Python to connect to Notion (see `.env.example`)

```bash
cp .env.example .env
```

- To run all files through Prettier formatter:

```bash
yarn format
```

---

_**@TODO:**_

- Create a demo directory on Notion
- Build & deploy on Github

repository: huydhoang/gatsby-notion-ghpages

repo_name: huydhoang/gatsby-notion-ghpages


text:
# Hare: Smart Shortcut Engine

## Overview

Hare is a miminal rewrite of the open source "smart bookmark" project by Facebook called bunny1 (http://www.bunny1.org/).
Hare allows for the creation of parameterized bookmarks so that, instead of having to type in https://google.com/?q=monkeys,
you can simply type "g monkeys" in your browser and it'll automagically redirect you to the right URL.
The impetus for the rewrite was that Bunny1 requires you to define your destinations and aliases before deploying the application,
and having multiple aliases for a single destination is cumbersome. Hare's solution is to keep destinations, aliases, and arguments in a database,
allowing for dynamic additions of destinations and aliases.

## Installation

### Git

Clone the repo from GitHub and run the setup in a virtual environment:

```bash
$ git clone git@github.com:conveen/hare.git
$ cd hare-engine
$ python3 -m venv venv
$ . venv/bin/activate
$ pip install .
```

## Dependencies

All dependencies are specified in the [setup.py](hare-engine/setup.py) file.

## Getting Started

### Docker

Docker images are available on [Docker Hub](https://hub.docker.com/r/conveen/hare-engine).
Use the `:latest` tag for the most up-to-date image.

```bash
$ docker pull conveen/hare-engine:latest
$ docker run --rm --name hare-engine -e HARE_SECRET_KEY='secret key here' -p 8080:80 conveen/hare-engine:latest
```

#### Environment Variables

The hare-engine image (entrypoint) has a number of environment variables to help configure the server and database connections.

`HARE_SECRET_KEY`

**Required.** Sets the Flask secret key, which is required for creating sessions. In production, this should be set via something like a secrets manager.
See [Flask documentation](https://flask.palletsprojects.com/en/1.1.x/quickstart/#sessions) for more information.

`HARE_DATABASE_URL`

**Required.** Must be [RFC-1738](http://rfc.net/rfc1738.html)-compliant URL pointing to the database.
See [SQLAlchemy documentation](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) for more information.

`HARE_DOMAIN`

Domain at which the hare-engine is hosted, with the format `http[s]://<domain.tld>[:<port>]`.  This is used for the [OpenSearch config file](#firefox-via-opensearch), which will automatically be populated if this variable is provided. If not, the OpenSearch file is removed from the container.

`DEFAULT_SEARCH_ENGINE`

Alias of the default search engine to use in the OpenSearch config file.  Must correspond to existing alias in the database, such as `google` or `duckduckgo`.

`HARE_DATABASE_DRIVER`

Name of the Python package to install for the database driver. See the section for your database in the [SQLAlchemy documentation](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) for more information.

`HARE_DATABASE_BOOTSTRAP_ON_STARTUP`

If provided, the Hare engine will attempt to create all the necessary tables and indices in the database when it starts.  If the tables and indices already exist, it will not erase data or re-create them, so this option should probably be enabled most of the time.

`PORT`

Port that the container will listen on, defaults to `80`.  In most cases this option shouldn't be changed, unless you're using Docker `host` network mode (or `awsvpc` in AWS) and you need to explicitly set the port.  Instead, prefer publishing the port you need when running the container (`-p $PUBLISH_PORT:80`).

### Docker Compose

A [docker compose](hare-engine/deploy/docker-compose.yml) file is provided that uses [Postgres](https://hub.docker.com/_/postgres) for the database and [PGWeb](https://sosedoff.github.io/pgweb/) for running SQL queries on the database.

#### Environment Variables

The compose file handles the required variables for the Hare engine Docker image, though in production environments you should override the default `HARE_SECRET_KEY` value.  There are a few additional variables to configure the compose stack:

`POSTGRES_PASSWORD`

**Required.** Postgres database password. See the [Postgres image documentation](https://hub.docker.com/_/postgres) for more information.

`NETWORK`

Docker networking mode, default is `bridge`.

`PGWEB_PORT`

Published port for the PGWeb container, default is `8081`.

`TAG`

Hare engine Docker image tag to use, default is `latest`.

`HARE_PORT`

Published port for the Hare engine container, default is `8080`.

#### Creating the database

To run the stack, you must create the Hare database before running PGWeb and Hare.  Run the Postgres container and use `createdb` to create the database, then run the whole stack.  You only have to do this once per stack.

```bash
$ cd hare-engine/deploy
$ POSTGRES_PASSWORD='<pg_password>' docker-compose run -d postgres-01 # prints the container name
$ docker exec -it <pg_container_name> /bin/bash # enter the container
$ createdb -U postgres hare 'Hare datacbase' # runs inside the container
$ exit # exit the container
$ docker kill <pg_container_name>
$ docker up # run the stack
```
After creating the database and running the stack, you can (optionally) [bootstrap the database](#bootstrapping-the-database) with a number of common shortcuts.  Since Docker Compose injects the database URL, you can run the script with the `HARE_DATABASE_URL` env variable.

### Local Development

To run a local development (non-Docker) version of Hare, use the Flask command line:

```bash
$ cd hare-engine
$ . venv/bin/activate
$ FLASK_APP=hare_engine.app:gen_app FLASK_ENV=development flask run -p 8080
```

### Bootstrapping the Database

Hare comes with a [script](hare-engine/hare_engine/scripts/bootstrap.py) to bootstrap the database with a number of common websites,
such as DuckDuckGo, Google, Bing, Wikipedia, Reddit, Twitter, Facebook, Youtube, etc.
To run the script, simply point it at the database using an [RFC-1738](http://rfc.net/rfc1738.html)-compliant URL:

```bash
$ ./hare-engine/hare_engine/scripts/bootstrap.py <database_url>
```

## Installing Hare in the Browser

### Chrome

1. Open Chrome and navigate to chrome://settings/searchEngines
2. To the right of `Other search engines` click the `Add` button
3. Enter the following information:
    * `Search engine`: Hare
    * `Keyword`: hare
    * `URL with %s in place of query`: http(s)://\<hare\_domain\_name\>:\<port\>?query=%s&fallback=g
        * Note that the fallback parameter could be any search engine, like DuckDuckGo, Wikipedia, Bing, etc.

### Firefox (via OpenSearch)

Firefox supports the [OpenSearch description format](https://developer.mozilla.org/en-US/docs/Web/OpenSearch) for specifying
search engines.  The Hare OpenSearch template is in the [deploy/opensearch](hare-engine/deploy/opensearch) directory,
and is automatically included in the Docker container if the `HARE_DOMAIN` env variable is provided.

## Contributing/Suggestions

Contributions and suggestions are welcome! To make a feature request, report a bug, or otherwise comment on existing
functionality, please file an issue. For contributions please submit a PR, but make sure to lint, type-check, and test
your code before doing so. Thanks in advance!

repository: conveen/hare

gha_language: Python

repo_name: conveen/hare


text:
# Halftime - Remove football tweets from your timeline.

An open source browser extension to filter football related tweets.

## Usage

1. Install from the [Chrome Web Store](https://chrome.google.com/webstore/detail/halftime/jadppkpaidfckjkfafggbagpekfepobp)
1. Refresh your *twitter.com* page.

The tweets are not deleted but just hidden, so you can get them back any time by clicking "Show Football" in twitter's settings menu.

## License

Licensed under the [MIT License](http://creativecommons.org/licenses/MIT/)
Copyright 2014 [Parham Saidi](http://twitter.com/par_ham) & [Ali Tehrani](http://twitter.com/tehranix)
Original code from https://github.com/rstuven/OpenTweetFilter by Copyright 2012 [Ricardo<EMAIL_ADDRESS>

repository: dotWasim/halftime

repo_name: dotWasim/halftime


text:
# Okta Angular SDK
The Okta Angular SDK is a wrapper around [Okta Auth JS](https://github.com/okta/okta-auth-js), that builds on top of Okta's [OpenID Connect API](https://developer.okta.com/docs/api/resources/oidc.html).

This library currently supports:
  - [OAuth 2.0 Implicit Flow](https://tools.ietf.org/html/rfc6749#section-1.3.2)

## Getting Started
* If you do not already have a **Developer Edition Account**, you can create one at [https://developer.okta.com/signup/](https://developer.okta.com/signup/).
* If you don't have an Angular app, or are new to Angular, please start with the [Angular Quickstart](https://angular.io/guide/quickstart) guide. It will walk you through the creation of an Angular app, creating routes, and other application development essentials.

### Add an OpenID Connect Client in Okta
In Okta, applications are OpenID Connect clients that can use Okta Authorization servers to authenticate users.  Your Okta Org already has a default authorization server, so you just need to create an OIDC client that will use it.
* Log into the Okta Developer Dashboard, click **Applications** > **Add Application**.
* Choose **Single Page App (SPA)** as the platform, then submit the form the default values, which should look like this:

| Setting             | Value                                          |
| ------------------- | ---------------------------------------------- |
| App Name            | My SPA App                                     |
| Base URIs           | http://localhost:{port}                        |
| Login redirect URIs | http://localhost:{port}/implicit/callback      |
| Grant Types Allowed | Implicit                                       |

After you have created the application there are two more values you will need to gather:

| Setting       | Where to Find                                                                  |
| ------------- | ------------------------------------------------------------------------------ |
| Client ID     | In the applications list, or on the "General" tab of a specific application.   |
| Org URL       | On the home screen of the developer dashboard, in the upper right.             |

These values will be used in your Angular application to setup the OpenID Connect flow with Okta.

## Installation

This library is available through [npm](https://www.npmjs.com/package/@okta/okta-angular). To install it, simply add it to your project:

```bash
npm install --save @okta/okta-angular
```

### Configuration
You will need the values from the OIDC client that you created in the previous step to instantiate the middleware. You will also need to know your Okta Org URL, which you can see on the home page of the Okta Developer console.

In your application's `module.ts` file, create a configuration object:

```typescript
// myApp.module.ts

const oktaConfig = {
  issuer: 'https://{yourOktaDomain}.com/oauth2/default',
  redirectUri: 'http://localhost:{port}/implicit/callback',
  clientId: '{clientId}'
}
```

### Create the Callback Handler
In order to handle the redirect back from Okta, you need to capture the token values from the URL. You'll use `/implicit/callback` as the callback URL, and specify the default `OktaCallbackComponent` and declare it in your `NgModule`.

```typescript
const appRoutes: Routes = [
  {
    path: 'implicit/callback',
    component: OktaCallbackComponent
  },
  ...
]

@NgModule({
  ...
  declarations: [
    ...
    OktaCallbackComponent
  ]
})
```

### Add a Protected Route
Routes are protected by the `OktaAuthGuard`, which verifies there is a valid `accessToken` stored. To ensure the user has been authenticated before accessing your route, add the `canActivate` guard:

```typescript
{
  path: 'protected',
  component: MyProtectedComponent,
  canActivate: [ OktaAuthGuard ]
}
```

If a user does not have a valid session, they will be redirected to the Okta Login Page for authentication. Once authenticated, they will be redirected back to your application's **protected** page.

### Update your `NgModule`
Finally, import the `OktaAuthModule` into your `NgModule`, and instantiate it by passing in your configuration object:

```typescript
@NgModule({
  imports: [
    ...
    RouterModule.forRoot(appRoutes),
    OktaAuthModule.initAuth(oktaConfig)
  ],
})
export class MyAppModule { }
```

### Reference
**Configuration Options**
  - `issuer` **(required)**: The OpenID Connect `issuer`
  - `clientId` **(required)**: The OpenID Connect `client_id`
  - `redirectUri` **(required)**: Where the callback is hosted
  - `scope` *(optional)*: Reserved or custom claims to be returned in the tokens
  - `onAuthRequired` *(optional)*: Accepts a callback to make a decision when authentication is required. If not supplied, `okta-angular` will redirect directly to Okta for authentication.

### Using a custom login-page
The `okta-angular` SDK supports the session token redirect flow for custom login pages. For more information, [see the basic Okta Sign-in Widget functionality](https://github.com/okta/okta-signin-widget#new-oktasigninconfig).

To handle the session-token redirect flow, you can modify the unauthentication callback functionality by adding a `data` attribute directly to your `Route`:

```typescript
export function onAuthRequired({oktaAuth, router}) {
  // Redirect the user to your custom login page
  router.navigate(['/custom-login']);
}

const appRoutes: Routes = [
  ...
  {
    path: 'protected',
    component: MyProtectedComponent,
    canActivate: [ OktaAuthGuard ],
    data: {
      onAuthRequired: onAuthRequired
      }
    }
  }
]
```

Alternatively, set this behavior globally by adding it to your configuration object:

```typescript
const oktaConfig = {
  issuer: environment.ISSUER,
  ...
  onAuthRequired: onAuthRequired
};
```

## Development
1. Clone the repo:
    - `git clone git@github.com:okta/okta-oidc-js.git`
2. Navigate into the `okta-angular` package:
    - `cd packages/okta-angular`
3. Install dependencies:
    - Navigate into the sample and install all `@angular` dependencies
    - `cd test/e2e/harness && npm install`
4. Make your changes to `okta-angular/src/`

## Commands

| Command        | Description                        |
| -------------- | ---------------------------------- |
| `npm start`    | Start the sample app using the SDK |
| `npm test`     | Run integration tests              |
| `npm run lint` | Run eslint linting tests           |
| `npm run docs` | Generate typedocs                  |


text:
 Todoish

Task Management web application that enables users to view, create, edit, and delete Tasks along with search and sort Tasks.

See demo here: https://www.youtube.com/edit?o=U&video_id=n5iswnNfi6Y

 Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

 Prerequisites

 Front-End: https://github.com/mrahman1/Mod-4-Final-Project-Client

 Back-End: https://github.com/mrahman1/Mod-4-Final-Project-Back-End

 Installing

 Clone back end repo

 Clone front end repo

 Deployment

 Launch rails server

 Launch front end on a separate server with Yarn install && start

 Built With

React - The Javascript library used to build the front-end

Rails - The Ruby library used to build the back-end

Semantic UI - The Theming guide used to style the front end

 Authors

Mimi Rahman

 License

This project is licensed under the MIT License - see the LICENSE.md file for details