text:
# pm2-logrotate-s3

[![NPM](https://nodei.co/npm/pm2-logrotate-s3.png)](https://nodei.co/npm/pm2-logrotate-s3/)

[![npm version](https://badge.fury.io/js/pm2-logrotate-s3.png)](https://badge.fury.io/js/pm2-logrotate-s3)
[![Build Status](https://img.shields.io/travis/sthnaqvi/pm2-logrotate-s3.svg?style=flat-square)](https://travis-ci.org/sthnaqvi/pm2-logrotate-s3)
[![Coverage](https://img.shields.io/codecov/c/github/sthnaqvi/pm2-logrotate-s3.svg?style=flat-square)](https://codecov.io/github/sthnaqvi/pm2-logrotate-s3)
[![Dependency Status](https://img.shields.io/david/sthnaqvi/pm2-logrotate-s3.svg?style=flat-square)](https://david-dm.org/sthnaqvi/pm2-logrotate-s3)
[![Known npm Vulnerabilities](https://img.shields.io/snyk/vulnerabilities/npm/pm2-logrotate-s3.svg?label=npm%20vulnerabilities&style=flat-square)](https://snyk.io/test/npm/pm2-logrotate-s3)
[![Known Vulnerabilities](https://img.shields.io/snyk/vulnerabilities/github/sthnaqvi/pm2-logrotate-s3.svg?label=repo%20vulnerabilities&style=flat-square&targetFile=package.json)](https://snyk.io/test/github/sthnaqvi/pm2-logrotate-s3?targetFile=package.json)

## Description
## [pm2-logrotate-s3](https://github.com/sthnaqvi/pm2-logrotate-s3) is based on [pm2-logrotate](https://github.com/keymetrics/pm2-logrotate)

PM2 module to automatically rotate logs of processes managed by PM2 and upload to s3 before deleting logs.

## Install

`pm2 install pm2-logrotate-s3`

**NOTE:** the command is `pm2 install` NOT `npm install`

## Configure
create pm2-logrotate-s3-config.json file in PM2 home folder which by default is ~/.pm2 .
set config values as given in example below:

```javascript
module.exports = {
                    "max_size": "10M",
                    "retain": "2",
                    "compress": true,
                    "dateFormat": "YYYY-MM-DD_HH-mm-ss",
                    "workerInterval": "30",
                    "rotateInterval": "0 0 * * *",
                    "rotateModule": true,
                    "TZ": null,
                    "aws": {
                      "credentials": {
                        "accessKeyId": "<AWS_ACCESS_KEY_ID>",
                        "secretAccessKey": "<AWS_SECRET_ACCESS_KEY>"
                      }
                    },
                    "logBucketSetting": {
                      "bucket": "<S3_BUCKET>",
                      "s3Path": "website-node-react",
                      "s3FilePathFormat": "__year__/__month__/__day__/__ip__/__filename__"
                    },
                    "getServerPublicIp": true,
                    "serverIp": null
                }

```

### Config Property Description
#### S3 upload properties
All of the following properties needs to defined for s3 upload to work.
- `aws.credentials.accessKeyId` (Defaults to `null`): This is access key id of your aws account.
- `aws.credentials.secretAccessKey` (Defaults to `null`): This is secret key of your aws account.
- `logBucketSetting.s3Path` (Defaults to `null`): This is s3 path in bucket where all your logs would be kept.
- `logBucketSetting.s3FilePathFormat` (Defaults to `__year__/__month__/__day__/__ip__/__filename__`): This is key path where your logs would be uploaded. Here `__year__`, `__month__`, `__day__`, `__ip__`, `__filename__`, and `__epoch__` are place holders for dynamic value to be inserted in key path.
One of two properties should be set for this to work.
- `getServerPublicIp` (Defaults to `false`): This extracts the public ip of server.
- `serverIp` (Defaults to `null`): This is the static value of ip of server that needed to be passed.

#### PM2 log rotate properties
- `max_size` (Defaults to `10M`): When a file size becomes higher than this value it will rotate it (its possible that the worker check the file after it actually pass the limit) . You can specify the unit at then end: `10G`, `10M`, `10K`
- `retain` (Defaults to `all`): This number is the number of rotated logs that are keep at any one time, it means that if you have retain = 7 you will have at most 7 rotated logs and your current one.
- `compress` (Defaults to `false`): Enable compression via gzip for all rotated logs
- `dateFormat` (Defaults to `YYYY-MM-DD_HH-mm-ss`) : Format of the data used the name the file of log
- `rotateModule` (Defaults to `true`) : Rotate the log of pm2's module like other apps
- `workerInterval` (Defaults to `30` in secs) : You can control at which interval the worker is checking the log's size (minimum is `1`)
- `rotateInterval` (Defaults to `0 0 * * *` everyday at midnight): This cron is used to a force rotate when executed.
We are using [node-schedule](https://github.com/node-schedule/node-schedule) to schedule cron, so all valid cron for [node-schedule](https://github.com/node-schedule/node-schedule) is valid cron for this option. Cron style :
- `TZ` (Defaults to system time): This is the standard [tz database timezone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) used to offset the log file saved. For instance, a value of `Etc/GMT+1`, with an hourly log, will save a file at hour `14` GMT with hour `13` (GMT+1) in the log name.

```
*    *    *    *    *    *
┬    ┬    ┬    ┬    ┬    ┬
│    │    │    │    │    |
│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)
│    │    │    │    └───── month (1 - 12)
│    │    │    └────────── day of month (1 - 31)
│    │    └─────────────── hour (0 - 23)
│    └──────────────────── minute (0 - 59)
└───────────────────────── second (0 - 59, OPTIONAL)
```

gha_language: JavaScript


text:
# worp - fixtures factory / generator

This package is useful when you need to quickly create lots of objects (fixtures) based on some instructions. Nice thing about this library is that it's super small (no dependencies) and it works very well with Typescript.

### Installation

To install this package:

```bash
npm install worp
```

If you use Typescript you don't need to download anything else. Typescript will be automatically loaded.

### Example use

**Javascript:**

```typescript
import { fixtureFactory } from "worp";

const factoryInstructions = {
  a: index => `property A, record nr: ${index + 1}`,
  b: index => index + 1,
  c: () =>
    `property C, random integer from 1 to 10: ${Math.ceil(Math.random() * 10)}`
};

const records = fixtureFactory(factoryInstructions, {
  nrOfRecordsToGenerate: 100
});
```

**Typescript:**

```typescript
import { fixtureFactory, FactoryInstructions } from "worp";

type ExampleProps = {
  a: string;
  b: number;
  c: string;
};

const factoryInstructions: FactoryInstructions<ExampleProps> = {
  a: index => `property A, record nr: ${index + 1}`,
  b: index => index + 1,
  c: () =>
    `property C, random integer from 1 to 10: ${Math.ceil(Math.random() * 10)}`
};

const records = fixtureFactory(factoryInstructions, {
  nrOfRecordsToGenerate: 100
});
```

This code will generate 100 objects like this:

```
[
  {
    a: "property A, record nr: 1",
    b: 1,
    c: "property C, random integer from 1 to 10: 3",
  },
  {
    a: "property A, record nr: 2",
    b: 2,
    c: "property C, random integer from 1 to 10: 6",
  },
  ... (98 more like this)
]
```

---

**Tags:**
mongodb, mongoose, typescript, database, db, fixtures, fixture, factory, generator

---

This package was created out of this boilerplate:
https://github.com/michal-wrzosek/react-component-lib

license: MIT

repository: michal-wrzosek/worp

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: michal-wrzosek/worp


text:
# .github
Organization policies

## Community Membership
The hapi community consists (non-exclusively) of participants in GitHub issues and PRs throughout the organization, users of the the hapi [Slack](https://join.slack.com/t/hapihour/shared_invite/zt-g5ortpsk-ErlnRA2rUcPIWES21oXBOg), project contributors, and the Technical Steering Committee (TSC).

### TSC Members
 - Devin Ivy ([@devinivy](https://github.com/devinivy))
 - Jonas Pauthier ([@nargonath](https://github.com/nargonath))
 - Lloyd Benson ([@lloydbenson](https://github.com/lloydbenson))
 - Nathan LaFreniere ([@nlf](https://github.com/nlf))
 - Wyatt Lyon Preul ([@geek](https://github.com/geek))
 - Colin Ihrig ([@cjihrig](https://github.com/cjihrig))

## Code of Conduct
> See [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)

## Security and Disclosure
> See [SECURITY.md](SECURITY.md)

## Maintenance of Issues, PRs, and Releases
> See [MAINTENANCE.md](MAINTENANCE.md)


text:
# Thread Local Storage #

The ELF Thread Local Storage ABI (TLS) is a storage model for variables that
allows each thread to have a unique copy of a global variable. This model
is used to implement C++'s `thread_local` storage model. On thread creation the
variable will be given its initial value from the initial TLS image. TLS
variables are for instance useful as buffers in thread safe code or for per
thread book keeping. C style errors like errno or dlerror can also be handled
this way.

TLS variables are much like any other global/static variable. In implementation
their initial data winds up in the `PT_TLS` segment. The `PT_TLS` segment
is inside of a read only `PT_LOAD` segment despite TLS variables being writable.
This segment is then copied into the process for each thread in a unique
writable location. The location the `PT_TLS` segment is copied to is influenced
by the segment's alignment to ensure that the alignment of TLS variables is
respected.

## ABI ##

The actual interface that the compiler, linker, and dynamic linker must adhere
to is actually quite simple despite the details of the implementation being more
complex. The compiler and the linker must emit code and dynamic relocations that
use one of the 4 access models (described in a following section). The dynamic
linker and thread implementation must then set everything up so that this
actually works. Different architectures have different ABIs but they're similar
enough at broad strokes that we can speak about most of them as if there was
just one ABI. This document will assume that either x86-64 or AArch64 is being
used and will point out differences when they occur.

The TLS ABI makes use of a few terms:

  * Thread Pointer: This is a unique address in each thread, generally stored
    in a register. Thread local variables lie at offsets from the thread pointer.
    Thread Pointer will be abbreviated and used as `$tp` in this document. `$tp`
    is what `__builtin_thread_pointer()` returns on AArch64. On AArch64 `$tp`
    is given by a special register named `TPIDR_EL0` that can be accessed using
    `mrs <reg>, TPIDR_EL0`. On `x86_64` the `fs.base` segment base is used and
    can be accessed with `%fs:` and can be loaded from `%fs:0` or `rdfsbase`
    instruction.
  * TLS Segment: This is the image of data in each module and specified by the
    `PT_TLS` program header in each module. Not every module has a `PT_TLS`
    program header and thus not every module has a TLS segment. Each module
    has at most one TLS segment and correspondingly at most one `PT_TLS`
    program header.
  * Static TLS set: This is the sum total of modules that are known to the
    dynamic linker at program start up time. It consists of the main executable
    and every library transitively mentioned by `DT_NEEDED`. Modules that
    require being in the Static TLS set have `DF_STATIC_TLS` set on their
    `DT_FLAGS` entry in their dynamic table (given by the `PT_DYNAMIC` segment).
  * TLS Region: This is a contiguous region of memory unique to each
    thread. `$tp` will point to some point in this region. It contains the
    TLS segment of every module in Static TLS set as well as some
    implementation-private data, which is sometimes called the TCB (Thread
    Control Block). On AArch64 a 16-byte reserved space starting at `$tp` is
    also sometimes called the TCB. We will refer to this space as the "ABI TCB"
    in this doc.
  * TLS Block: This is an individual thread's copy of a TLS segment. There is
    one TLS block per TLS segment per thread.
  * Module ID: The module ID is not statically known except for the main
    executable's module ID which is always 1. Other module's module IDs are
    chosen by the dynamic linker. It's just a unique non-zero ID for each
    module. In theory it could be any non-zero 64-bit value that is unique to
    the module like a hash or something. In practice it's just a simple counter
    that the dynamic linker maintains.
  * The main executable: This is the module that contains the start address. It,
    is also treated in a special way in one of the access models. It always
    has a Module ID of 1. This is the only module that can use fixed offsets
    from `$tp` via the Local Exec model described below.

To comply with the ABI all access models must be supported.

#### Access Models ####

There are 4 access models specified by the ABI:

  * `global-dynamic`
  * `local-dynamic`
  * `initial-exec`
  * `local-exec`

These are the values that can be used for `-ftls-model=...` and
`__attribute__((tls_model("...")))`

Which model is used relates to:

1. Which module is performing the access:
  1. The main executable
  2. A module in the static TLS set
  3. A module that was loaded after startup, e.g. by `dlopen`
2. Which module the variable being accessed is defined in:
  1. Within the same module (i.e. `local-*`)
  2. In a different module (i.e. `global-*`)

* `global-dynamic` Can be used from anywhere, for any variable.
* `local-dynamic` Can be used by any module, for any variable defined in that
  same module.
* `initial-exec` Can be used by any module for any variable defined in the static
  TLS set.
* `local-exec` Can be used by the main executable for variables defined in the
  main executable.

###### Global Dynamic ######

Global dynamic is the most general access format. It is also the slowest.
Any thread-local global variable should be accessible with this method. This
access model *must* be used if a dynamic library accesses a symbol defined in
another module (see exception in section on Initial Exec). Symbols defined
within the executable need not use this access model. The main executable can
also avoid using this access model. This is the default access model when
compiling with `-fPIC` as is the norm for shared libraries.

This access model works by calling a function defined in the dynamic linker.
There are two ways functions might be called, via TLSDESC, or via
`__tls_get_addr`.

In the case of `__tls_get_addr` it is passed the pair of `GOT` entries
associated with this symbol. Specifically it is passed the pointer to the first
and the second entry comes right after it. For a given symbol `S`, the first
entry, denoted `GOT_S[0]`, must contain the Module ID of the module in which
`S` was defined. The second entry, denoted `GOT_S[1]`, must contain offset into
TLS Block, which is the same as the offset of the symbol in the `PT_TLS` segment
of the associated module. The pointer to `S` is then computed using
`__tls_get_addr(GOT_S)`. The implementation of `__tls_get_addr` will be
discussed later.

TLSDESC is an alternative ABI for `global-dynamic` access (and `local-dynamic`)
where a different pair of `GOT` slots are used where the first `GOT` slot
contains a function pointer. The second contains some dynamic linker defined
auxiliary data. This allows the dynamic linker a choice over which function is
called depending on circumstance.

In both cases the calls to these functions must be implemented by a specific
code sequence and a specific set of relocs. This allows the linker to recognize
these accesses and potentially relax them to the `local-dynamic` access model.

(NOTE: The following paragraph contains details about how the compiler upholds
its end of the ABI. Skip this paragraph if you don't care about that.)

For the compiler to emit code for this access model a call needs to be emitted
against `__tls_get_addr` (defined by the dynamic linker) and a reference to the
symbol name. Specifically the compiler the emits code for (minding the
additional relocation needed for the GOT itself) `__tls_get_addr(GOT_S)`. The
linker then emits two dynamic relocations when generating the GOT. On `x86_64`
these are `R_X86_64_DTPMOD` and `R_X86_64_DTPOFF`. On AArch64 these are
`R_AARCH64_DTPMOD` and `R_AARCH64_DTPOFF`. These relocations reference the symbol
regardless of whether or not the module defines a symbol by that name or not.

###### Local Dynamic ######

Local dynamic the same as Global Dynamic but for local symbols. It can be
thought of as a single `global-dynamic` access to the TLS block of this module.
Then because every variable defined in the module is at fixed offsets from the
TLS block the compiler can optimize multiple `global-dynamic` calls into one.
The compiler will relax a `global-dynamic` access to a `local-dynamic` access
whenever the variables are local/static or have hidden visibility. The linker
may sometimes be able to relax some `global-dynamic` accesses to `local-dynamic`
as well.

The following gives an example of how the compiler might emit code for this
access model:

```
static thread_local char buf[buf_cap];
static thread_local size_t buf_size = 0;
while(*str && buf_size < buf_cap) {
  buf[buf_size++] = *str++;
}
```

might be lowered to

```
// GOT_module[0] is the module ID of this module
// GOT_module[1] is just 0
// <X> denotes the offset of X in this module's TLS block
tls = __tls_get_addr(GOT_module)
while(*str && *(size_t*)(tls+<buf_size>) < buf_cap) {
  (char*)(tls+<buf>)[*(size_t*)(tls+<buf_size>)++] = *str++;
}
```

If this code used global dynamic it would have to make at least 2 calls, one to
get the pointer for buf and the other to get the pointer for `buf_size`.

###### Initial Exec ######

This access model can be used anytime the compiler knows the module that the
symbol being accessed is defined in will be loaded in the initial set of
executables rather than opened using `dlopen`. This access model is generally
only used when the main executable is accessing a global symbol with default
visibility. This is because compiling an executable is the only time the
compiler knows that any code generated will be in the initial executable set. If
a DSO is compiled to make thread local accesses use this model then the DSO
cannot be safely opened with `dlopen`. This is acceptable in performance
critical applications and in cases where you know the binary will never be
dlopen-ed such as in the case of libc. Modules compiled/linked this way have
their `DF_STATIC_TLS` flag set.

Initial Exec is the default when compiling without `-fPIC`.

The compiler emits code without even calling `__tls_get_addr` for this access
model. It does so using a single GOT entry, which we'll denote `GOT_s` for symbol
`s`, for which the compiler emits relocations, to ensure that

```
extern thread_local int a;
extern thread_local int b;
int main() {
  return a + b;
}
```

would be lowered to something like the following

```
int main() {
  return *(int*)($tp + GOT[a]) + *(int*)($tp + GOT[b]);
}
```

Note that on x86 architectures `GOT[s]` will actually resolve to a negative
value.

###### Local Exec ######

This is the fastest access model and can only be used if the symbol is in the
first TLS block, which is the TLS block of the main executable. In practice only
the main executable can use this access mode because any shared library can't
(and normally wouldn't need to) know if it is accessing something from the main
executable. The linker will relax `initial-exec` to `local-exec`. The compiler
can't do this without explicit instructions via `-ftls-model` or
`__attribute__((tls_model("...")))` because the compiler cannot know if the
current translation unit is going to be linked into a main executable or a
shared library.

The precise details of how this offset is computed changes a bit
from architecture to architecture.

example code:

```
static thread_local int a;
static thread_local int b;

int main() {
  return a + b;
}
```

would be lowered to

```
int main() {
  return (int*)($tp+TPOFF_a) + (int*)($tp+TPOFF_b));
}
```

On AArch64 `TPOFF_a == max(16, p_align) + <a>` where `p_align` is exactly the
`p_align` field of the main executable's `PT_TLS` segment and `<a>` is the
offset of `a` from the beginning of the main executable's TLS segment.

On `x86_64` `TPOFF_a == -<a>` where `<a>` is the offset of the `a` from the *end*
of the main executable's TLS segment.

The linker is aware of what `TPOFF_X` is for any given `X` and fills in this
value.

## Implementation ##

This section discusses the implementation as it is implemented on Fuchsia. This
said the broad strokes here are widely similar across different libc
implementations including musl and glibc.

The actual implementation of all of this introduces a few more details. Namely
the so-called "DTV" (Dynamic Thread Vector) (denoted `dtv` in this doc), which
indexes TLS blocks by module ID. The following diagram shows what the initial
executable set looks like. In Fuchsia's implementation we actually store a
bunch of meta information in a thread descriptor struct along with the
ABI TCB (denoted `tcb` below). In our implementation we use the first 8 bytes
of this space to point to the DTV. At first `tcb` points to `dtv` as shown in
the below diagrams but after a dlopen this can change.

arm64:

```
*------------------------------------------------------------------------------*
| thread | tcb | X | tls1 | ... | tlsN | ... | tls_cnt | dtv[1] | ... | dtv[N] |
*------------------------------------------------------------------------------*
^         ^         ^             ^            ^
td        tp      dtv[1]       dtv[n+1]       dtv
```

Here `X` has size `min(16, tls_align) - 16` where `tls_align` is the maximum
alignment of all loaded TLS segments from the static TLS set. This is set by
the static linker since the static linker resolves `TPOFF_*` values. This
padding is set that so that if, as required, `$tp` is aligned to main
executable's `PT_TLS` segment's `p_align` value then `tls1 - $tp` will be
`max(16, p_align)`. This ensures that there is always at least a 16 byte space
for the ABI TCB (denoted `tcb` in the diagram above).

x86:

```
*-----------------------------------------------------------------------------*
| tls_cnt | dtv[1] | ... | dtv[N] | ... | tlsN | ... | tls1 | tcb |  thread   |
*-----------------------------------------------------------------------------*
^                                       ^             ^       ^
dtv                                  dtv[n+1]       dtv[1]  tp/td
```

Here `td` denotes the "thread descriptor pointer". In both implementations this
points to the thread descriptor. A subtle point not made apparent in these
diagrams is that `tcb` is actually a member of the thread descriptor struct in
both cases but on AArch64 it is the last member and on `x86_64` it is the first
member.

#### dlopen ####

This picture explains what happens for the initial executables but it doesn't
explain what happens in the `dlopen` case. When `__tls_get_addr` is called it
first checks to see if `tls_cnt` is such that the module ID (given by `GOT_s[0]`
) is within the `dtv`. If it is then it simply looks up `dtv[GOT_s[0]] + GOT_s[1]`
but if it isn't something more complicated happens. See the implementation of
`__tls_get_new` in [dynlink.c](/zircon/third_party/ulib/musl/ldso/dynlink.c).

In a nutshell a sufficiently large space was already allocated for a larger `dtv`
on a call to `dlopen`. It is an invariant of the system that sufficient space
will always exist somewhere already allocated. The larger space is then setup to
be a proper `dtv`. `tcb` is then set to point to this new larger `dtv`. Future
accesses will then use the simpler code path since `tls_cnt` will be large
enough.

repository: gnoliyil/fuchsia

branch_name: refs/heads/main

repo_name: gnoliyil/fuchsia


text:
# Cryptosquare

#### This app takes a string and returns an encrypted string. Current as of June 9, 2016

#### By Kevin VanEvery and Ben Logue

## Description

|Behavior    |Input   |Output   |
|---|---|---|
|user inputs a string and receives encrypted value |hello world  |holewdlolr  |
|user inputs a string with punctuation and receives encrypted value |"hello world!"  |holewdlolr  |
|user inputs a string with capitals and receives encrypted value |Hello World  |holewdlolr  |
|user inputs a string and and receives encrypted value with spacing every five characters |Hello World  |holew dlolr  |

## Setup/Installation Requirements

To create your own template repository on github

* Clone the github repository using the git clone command from /Desktop
* Open index.html

## Known Bugs

None.

## Support and contact details

Come by during class if you have questions.

## Technologies Used

* Bootstrap
* JQuery

### License

Licensed under the MIT License

Copyright (c) 2016 **Epicodus Pair Projects**

repository: blogue/cryptosquare

repo_name: blogue/cryptosquare


text:
# ngraton.dev

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT) [![Netlify Status](https://api.netlify.com/api/v1/badges/6c29d62a-bbc9-49e2-ad41-fc1953b44f93/deploy-status)](https://app.netlify.com/sites/modest-lichterman-016498/deploys)

My personal dev blog site based on the starter skeleton [`Gatsby Advanced Starter`](https://github.com/Vagr9K/gatsby-advanced-starter) by Ruben Harutyunyan ([@Vagr9K](https://twitter.com/Vagr9K)).

repository: ngraton/ngraton-dot-dev

gha_license_id: MIT

repo_name: ngraton/ngraton-dot-dev


text:
ToroDB Testing utilities
========================

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.torodb.testing/testing-parent/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.torodb.testing/testing-parent)

This repository contains several Maven projects used to test ToroDB projects
that are general enough to be useful on third party software, so they have been
released under Apache 2.0 licese to make it easier to use on any enviroment.

The projects contained on this repository are:
* `testing-core`: which contains some utilities used by other projects.
* `core-junit5`: which contains some utilities to create JUnit 5 tests.
* `docker-core`: which contains some utilities to instanciate Docker containers.
* `sql-docker`: which contains interfaces to generalize Docker containers that
can be used to run SQL databases.
* `postgres-docker`: which contains classes that can be used to run PostgreSQL
on a Docker container.
* `postgres-junit-5`: which contains JUnit5 extensions and annotations to automatically
run a PostgreSQL instance each time a test or test case is executed.
* `mongodb-docker`: which contains classes that can be used to run MongoDB on
Docker containers. Single mongod, replica sets and sharded topologies are
provided out of the box.
* `mongodb-junit-5`: which contains JUnit5 extensions and annotations to automatically
run MongoDB instances, replica sets or shard each time a test or test case is
executed.

How to use it
-------------

This utilities are built with Maven. Released artifacts are hosted on [Maven Central][4]
and snapshot artifacts on [Nexus Repository Management][5].
You may build the source code by running "mvn package" on the root directory.

Currently the project is on beta version, there are no released versions and the
code is on the devel branch. Please use consider it the main branch of this repository
until the first release is done.

## Code QA
 * Master branch:
[![Build Status](https://travis-ci.org/torodb/testing-tools.svg?branch=master)](https://travis-ci.org/torodb/testing-tools)
[![Codacy Badge](https://api.codacy.com/project/badge/grade/445845b64bf54e31be9d4c2d188f803c?branch=master)](https://www.codacy.com/app/torodb/testing-tools?utm_source=github.com&utm_medium=referral&utm_content=torodb/testing-tools&utm_campaign=Badge_Grade)
[![Codacy Coverage](https://api.codacy.com/project/badge/coverage/445845b64bf54e31be9d4c2d188f803c?branch=master)](https://www.codacy.com/app/torodb/testing-tools?utm_source=github.com&utm_medium=referral&utm_content=torodb/testing-tools&utm_campaign=Badge_Grade)
 * Devel branch:
[![Build Status](https://travis-ci.org/torodb/testing-tools.svg?branch=devel)](https://travis-ci.org/torodb/testing-tools)
[![Codacy Badge](https://api.codacy.com/project/badge/grade/445845b64bf54e31be9d4c2d188f803c?branch=devel)](https://www.codacy.com/app/torodb/testing-tools?utm_source=github.com&utm_medium=referral&utm_content=torodb/testing-tools&utm_campaign=Badge_Grade)
[![Codacy Coverage](https://api.codacy.com/project/badge/coverage/445845b64bf54e31be9d4c2d188f803c?branch=devel)](https://www.codacy.com/app/torodb/testing-tools?utm_source=github.com&utm_medium=referral&utm_content=torodb/testing-tools&utm_campaign=Badge_Grade)

[1]: http://docs.mongodb.org/meta-driver/latest/legacy/mongodb-wire-protocol/
[2]: http://netty.io/
[3]: http://www.torodb.com
[4]: http://search.maven.org/
[5]: https://oss.sonatype.org/content/groups/public/com/torodb/testing-tools/

repository: teoincontatto/testing-tools

repo_name: teoincontatto/testing-tools


text:
# GWT Module Migration
To prepare GWT for J2CL the GWT modules need to separated from GWT.
There fore we need to create separate artifacts for each module. These artifacts will be located in separate repos.

## Module Requirements
We made several decisions how to set up and implement the modules:

1. every module will have it's own repository
2. use Maven as build tool
3. structure the Maven project like this:
    * parent module
        * one Maven child module for the module itself (name: **gwt-[module name]**)
        * one Maven child module for GWT2-tests (name: **gwt2-tests**)
        * one Maven child module for j2cl-tests (name: **j2cl-tests**)
        * one Maven child module for junit-tests (name: **junit-tests**), if needed
4. locate the source code inside the jar
5. use the [fmt-maven-plugin](https://github.com/coveooss/fmt-maven-plugin) to format the code
6. use the [license-maven-plugin](https://github.com/mycila/license-maven-plugin) to set up the license header
7. add a `README.md`-file that describes the purpose of the module
8. add a `LICENSE`-file containing the Apache 2 license
9. add a `AUTHORS`-file
10. add a `travis.yaml`-file
11. add a `.gitignore`-file
12. add additional docs

**Important Note**

Even we are using a Maven multi module structure, the Maven child modules do not refer the parent pom!

## Example
[gwt-timer](https://github.com/FrankHossfeld/gwt-timer) is already migrated and uses the example structure. You can copy the files and structure from this Repo and use it as a base to start.

## Branching
During development and before the module is deployed to Maven Central, we will work with one branch (**master**).

Once we have deployed the module to Maven Central, we will use two branches in the module repos:
1. a **master** branch. This branch will contain the last deployed version and will only updated in case of a new deploy.
2. a **development** branch. We will use this branch for active development

## Formatting
We will use the [fmt-maven-plugin](https://github.com/coveooss/fmt-maven-plugin) to format the code.

The plugin uses the [google-java-format](https://github.com/google/google-java-format) which follows [Google's code styleguide](https://google.github.io/styleguide/javaguide.html).

If you want your IDE to stick to the same format, check out the [available configuration files](https://github.com/google/styleguide).

* [Eclipse](https://github.com/google/styleguide/blob/gh-pages/eclipse-java-google-style.xml)
* [IntelliJ IDEA](https://github.com/google/styleguide/blob/gh-pages/intellij-java-google-style.xml)

and import this file to your IDE.

repository: FrankHossfeld/gwt-modules-migration

repo_name: FrankHossfeld/gwt-modules-migration


text:
igo
===

Go (Chinese: 圍棋 wéiqí, Japanese: 囲碁 igo,[nb 2] Korean: 바둑 baduk, Vietnamese: 碁圍 cờ vây, common meaning: "encircling game") is a board game for two players that originated in China more than 2,500 years ago. The game is noted for being rich in strategy despite its relatively simple rules.

TODO

* 优化死活题的缩放功能
* 增加死活题棋书展示及选择
* 增加死活题棋书在线更新
* 优化做题流程判断
* 增加手数显示
* 增加坐标显示
* 优化棋盘显示效果
* 增加棋盘样式选择
* 增加落子声音
* 实现预览图的生成
* 增加预览图的下载

DONE

* 增加手机上的点击落子功能
* 迁移SGF格式解析逻辑
* 增加测试SGF文件到Assets中进行测试
* 基本的棋盘展示
* 基本的落子逻辑

repository: jiahaitao-braintimes/igo

repo_name: jiahaitao-braintimes/igo


text:
# certbot-manual-dns-name

*Pseudo-plugin for cerbot DNS challenges for name.com using manual hooks*

## Summary

This repository provides authorization and cleanup hooks for use with
Let'sEncrypt's `certbot` in manual mode to make DNS-based ACME challenges for
domains registered through name.com.

"But why", I hear you plead, "wouldn't you just use the built-in RFC-2136 DNS
plugin that certbot already provides?"

Well, name.com does not implement RFC-2136. So there really is no other option
but to roll this myself.

### Usage

You must invoke certbot with the appropriate command-line flags to run in manual
mode and invoke these scripts during the challenge procedure.

You will also need to set some environment variables:
* `NAME_DNS_USERNAME`: (required) Name.com username for your account.
* `NAME_DNS_API_TOKEN`: (required) Name.com API token for this application.
* `NAME_DNS_PROPAGATION_TIME`: (optional) Change the maximum timeout of 1 week.
* `NAME_DNS_DEBUG`: (optional) Make requests against name.com's dev site.

```
export NAME_DNS_USERNAME=username
export NAME_DNS_API_TOKEN=api-token
certbot \
  certonly \
  --manual \
  --manual-auth-hook=.../certbot-manual-dns-name/auth-hook.sh \
  --manual-cleanup-hook=.../certbot-manual-dns-name/cleanup-hook.sh
  [...]
```

## License

`certbot-manual-dns-name` is licensed under the terms of the MIT License, as
described in [LICENSE.md](LICENSE.md).

## Contributing

Contributions are welcome in the form of bug reports, feature requests, or pull
requests.

Contribution to `certbot-manual-dns-name` is organized under the terms of the
[Contributor Covenant](CONTRIBUTOR_COVENANT.md).


text:
Bandcamp Dowloader
==
[![GitHub release](https://img.shields.io/github/release/jaymoulin/bandcamp-down-chrome-ext.svg)](https://jaymoulin.github.io/bandcamp-down-chrome-ext/releases)
[![Chrome Web Store](https://img.shields.io/chrome-web-store/v/nmoobgpmablfmgchfjnhkbloaobiogeh.svg)](https://chrome.google.com/webstore/detail/bandcamp-downloader/nmoobgpmablfmgchfjnhkbloaobiogeh)
[![license](https://img.shields.io/github/license/jaymoulin/bandcamp-down-chrome-ext.svg)]()

This Google Chrome extension allows you to easily download albums you can listen on Bandcamp.

Bug report and suggestions are welcome on this URL : [https://jaymoulin.github.io/bandcamp-down-chrome-ext/issues](https://jaymoulin.github.io/bandcamp-down-chrome-ext/issues).

Developpers are also welcome to contribute by forking and PR-ing at this URL : [https://jaymoulin.github.io/bandcamp-down-chrome-ext/pulls](https://jaymoulin.github.io/bandcamp-down-chrome-ext/pulls)

## What it looks like

when you visit a bandcamp page with a listenable album, a notification will appear to download the album :

![A wild notification appeared!](https://jaymoulin.github.io/bandcamp-down-chrome-ext/notif-1.png "A wild notification appeared!")

Just click on it to download the album

![Download in progress](https://jaymoulin.github.io/bandcamp-down-chrome-ext/notif-2.png "Download in progress")

![Zip downloaded](https://jaymoulin.github.io/bandcamp-down-chrome-ext/zip.png "Zip downloaded")

![All files in a great folder hierarchy](https://jaymoulin.github.io/bandcamp-down-chrome-ext/folder.png "All files in a great folder hierarchy")

## Update 0.3.0

You can now configure the extension with the notification you want to see.

Also, a new download page allows you to download multiple albums at the same time and retry tracks that failed to download.
This page offers you really cool options to ease album downloading !

 ![Download page](https://jaymoulin.github.io/bandcamp-down-chrome-ext/downloadPage.png "Download page")

 ![Download page while albums are downloading](https://jaymoulin.github.io/bandcamp-down-chrome-ext/downloadPageProgress.png "Download page while albums are downloading")

 ![Retry all the things!](https://jaymoulin.github.io/bandcamp-down-chrome-ext/retryAll.png "Retry all the things!")

 ![Settings for your notifications](https://jaymoulin.github.io/bandcamp-down-chrome-ext/settings.png "Settings for your notifications")

repository: infeeeee/bandcamp-down-chrome-ext

repo_name: infeeeee/bandcamp-down-chrome-ext


text:
# Box CLI Maker 📦

[![go.dev reference](https://img.shields.io/badge/go.dev-reference-007d9c)](https://pkg.go.dev/github.com/Delta456/box-cli-maker)
[![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2FDelta456%2Fbox-cli-maker%2Fbadge%3Fref%3Dmaster&style=flat)](https://actions-badge.atrox.dev/Delta456/box-cli-maker/goto?ref=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/Delta456/box-cli-maker)](https://goreportcard.com/report/github.com/Delta456/box-cli-maker)

Box CLI Maker is a Highly Customized Terminal Box Creator.

## Features

- Make terminal box in 8⃣ inbuilt different style
- Custom Title Positions
- Make your own Box style 📦
- Align the text according to the need
- Written in  🇬 🇴

## Installation

```terminal
 go get github.com/Delta456/box-cli-maker
```

## Usage

In `main.go`

```go
package main

import (
 "github.com/Delta456/box-cli-maker"
)

func main() {
    Box := box.New(box.Config{Px: 2, Py: 5, Type: "Single" })
    Box.Print("Box CLI Maker", "It is a highly customized terminal Box Maker")
}
```

`box.New(config Config)` accepts a Config struct with following parameters.

- Parameters
  - `Px` : Horizontal Padding
  - `Py` : Vertical Padding
  - `ContentAlign` : Align content in the Box i.e. `Center`, `Left` and `Right`
  - `Type`: Type of Box (listed down below)
  - `TitlePos` : Position of the Title i.e. `Inside`, `Top` and `Bottom`

`box.Print(title, lines string)` prints Box from the specified arguements.

- Parameters
  - `title` : Title of the Box
  - `lines` : Content written inside the Box

`box.Println(title, lines string)` prints Box in a newline from the specified arguements.

- Parameters
  - `title` : Title of the Box
  - `lines` : Content written inside the Box

`box.String(title, lines string) string` return `string` representation of Box.

- Parameters
  - `title` : Title of the Box
  - `lines` : Content written inside the Box

### Box Types

- `Single`

![single](img/single.png)

- `Single Double`

![Single Double](img/single_double.png)

- `Double`

![Double](img/double.png)

- `Double Single`

![Double Single](img/double_single.png)

- `Bold`

![Bold](img/bold.png)

- `Round`

![Round](img/round.png)

- `Hidden`

![Hidden](img/hidden.png)

- `Classic`

![Classic](img/classic.png)

### Title Positions

- `Inside`

![Inside](img/single.png)

- `Top`

![Top](img/top.png)

- `Bottom`

![Bottom](img/bottom.png)

### Making custom Box

You can make your custom Box by using the inbuilt Box struct provided by the module.

```go
type Box struct {
	TopRight    string // TopRight corner used for Symbols
	TopLeft     string // TopLeft corner used for Symbols
	Vertical    string // Symbols used for Vertical Bars
	BottomRight string // BottomRight corner used for Symbols
	BottomLeft  string // BotromLeft corner used for Symbols
	Horizontal  string // Symbols used for Horizontal Bars
	Con      Config // Configuration for the Box to be made
}
```

```go
box := Box{TopRight: "*", TopLeft: "*", BottomRight: "*", BottomLeft: "*", Horizontal: "-", Vertical: "|", Con: Config{Px: 2, Py: 3, Type: "", TitlePos: "Inside"}}
box.Print("Custom Box", "This is a custom Box and it works well")
```

Output:

![Custom](img/custom.png)

### Note

As different terminals have different font by default so the right vertical alignment may not be aligned well. You will have to change your font accordingly to make it work.

### Acknowledgements

I thank the following people and their packages whom I have studied and was able to port to Go accordingly.

- [thecodrr/boxx](https://github.com/thecodrr/boxx)
- [Atrox/box](https://github.com/Atrox/box)
- [sindreorhus-cli-boxs](https://github.com/sindresorhus/cli-boxes)

### License

Licensed under [MIT](LICENSE)

repository: elimisteve/box-cli-maker

repo_name: elimisteve/box-cli-maker


text:
# djangobeat

Periodic Tasks for Django channels

### Installation

    pip install -U DjangoBeat

It's is important that you have to run --noreload option otherwise it will executed twice

### Settings

    INSTALLED_APPS += ['djangobeat']

### How to use

    $ python manage.py shell
    >>> from djangobeat.models import PeriodicTask
    >>> PeriodicTask.objects.create(
        task_name="hello",
        channel_name="print-hello",
        schedule=timedelta(seconds=20)
    )

repository: gitter-badger/djangobeat

repo_name: gitter-badger/djangobeat


text:
ansible-tools
=============

[![PyPI Version](https://img.shields.io/pypi/v/ansible-tools.svg)](https://pypi.python.org/pypi/ansible-tools)
[![PyPI Downloads](https://img.shields.io/pypi/dm/ansible-tools.svg)](https://pypi.python.org/pypi/ansible-tools)
[![MIT License](https://img.shields.io/badge/license-mit-blue.svg)](http://choosealicense.com/licenses/mit/)

This is a set of wrappers around the `ansible`, `ansible-playbook` and
`ansible-vault` commands which integrate with the system keyring to retrieve
the vault password.

It should work on both Linux and OS X.

# Installation

If you are on OS X and have Homebrew's Python:

    pip install ansible-tools

Otherwise:

    pip install --user ansible-tools

Then make sure to add the local pip's `bin` directory to the `$PATH`. Since it
is different on each platform, please refer to its documentation.

Otherwise, if you're feeling a badass and want to `sudo` your way out, then
run:

    sudo pip install ansible-tools

# Overview

* `ansible-vault-helper`: Used by users to setup keyring integration, called by Ansible to obtain a
  Vault unlock password.
* `vaultify`: Wraps Ansible commands such as `ansible`, `ansible-playbook` and `ansible-playbook` so
  that the Vault is automatically unlocked with the password stored in the system's keyring.
* `ansible-local`: Wrapper to run Ansible locally.
* `ansible-mkpasswd`: Generates a crypted password that can be used with the user module (see also
  [here](http://docs.ansible.com/ansible/faq.html#how-do-i-generate-crypted-passwords-for-the-user-module))

# Usage

Go to the same directory that contains your playbooks and then run:

    ansible-vault-helper --update

You will be prompted for a vault name (which can be anything) and the unlock
password. The former is stored in `ansible.cfg` alongside your playbooks, the
latter is securely stored in your keyring.

At this point you can run Ansible as usual but precede the command with
`vaultify`. That is, to start a playbook run:

    vaultify ansible-playbook site.yml

We also ship a tool to easily apply a playbook on the current system called
`ansible-local` which is composable with `vaultify`.

# Aliases

Here's a list of handy shell aliases to make your life easier. They were
tested on fish but should work also on Bash and Zsh:

    alias v="vault"
    alias ansible="vaultify ansible"
    alias ansible-playbook="vaultify ansible-playbook"

repository: anttilaiti/ansible-tools

repo_name: anttilaiti/ansible-tools


text:
---
title: RecurrenceExceptionCreated
page_title: RecurrenceExceptionCreated - RadScheduler
description: Check our Web Forms article about RecurrenceExceptionCreated.
slug: scheduler/server-side-programming/server-events/recurrenceexceptioncreated
tags: recurrenceexceptioncreated
published: True
position: 13
---

# RecurrenceExceptionCreated

The **RecurrenceExceptionCreated** event occurs when the user creates an exception in a recurrent series. **RecurrenceExceptionCreated** has two parameters:

* **sender** is the scheduler control.

* **e** is an object of type **RecurrenceExceptionCreatedEventArgs**. It has four properties:- **Appointment**- the master appointment;- **ExceptionAppointment**- the newly created exception appointment;- **OccurenceAppointment**- the original occurrencebefore the exception was created;- **Cancel** is a boolean value that lets you prevent the creation of the exception;

## Example

````C#

protected void RadScheduler1_RecurrenceExceptionCreated(object sender, Telerik.Web.UI.RecurrenceExceptionCreatedEventArgs e)
{
	Response.Write("An exception with subject: " + e.ExceptionAppointment.Subject + " was created");
}

````
````VB.NET

Protected Sub RadScheduler1_RecurrenceExceptionCreated(ByVal sender As Object, ByVal e As Telerik.Web.UI.RecurrenceExceptionCreatedEventArgs)
	Response.Write("An exception with subject: " + e.ExceptionAppointment.Subject + " was created")
End Sub

````

# See Also

 * [Working with Recurring Appointments]({%slug scheduler/server-side-programming/working-with-recurring-appointments%})

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs


text:
# RedLight
A Cordova App that allows the screen of the phone to show as a block of colour.

* Use the sliders to select the colour.
* Saved automatically
* Tap the bottom half of the screen to hide/show the sliders.
* Requires https://github.com/EddyVerbruggen/Insomnia-PhoneGap-Plugin


text:
---
layout: post
title: "Nº 128: space, grosbeak, crimes, salaries, rolling stone"
date: '2015-06-05 16:30'
---

* [Conference about a Horizon2020 project related with space (Catalan)](http://www.uab.cat/web/investigar/itineraris/la-recerca/horizon-2020/jornada-informativa-9-de-juny-horizon-2020-espai-1345685442377.html)
* [Maps of the annual migration of the Rose breasted grosbeak](http://uxblog.idvsolutions.com/2015/06/migration.html)
* [London iso-lines map of crimes related with drugs](http://r-video-tutorial.blogspot.com.es/2015/05/interactive-maps-of-crime-data-in.html)
* [Table of salaries of digital jobs at Pays de la Loire, France](http://www.lejournaldesentreprises.com/editions/44/actualite/fait-du-mois/pays-de-la-loire-quels-salaires-dans-les-metiers-du-numerique-03-06-2015-258802.php)
* [Interactive on line map for those that can't decide for one style and want them all](http://openwhatevermap.org/)

repository: rroset/rafagas

branch_name: refs/heads/gh-pages

repo_name: rroset/rafagas


text:
### A script to automatically type ~120-140 words per minute for you in TypeRacer.

<br/>

#### **Disclaimer:** Only use this script when you are in a private lobby playing against friends for good fun. Do NOT use this script in public races as this is against TypeRacer's Terms of Service.
I am NOT responsible for what you do with this script.

#### **Usage:**
1. Click the Simple Allow Copy extension icon to enable.
2. Copy the TypeRacer phrase during the preparation phrase.
3. Click the Simple Allow Copy extension icon again to disable.
4. Open the `phrase.txt` file.
5. Paste the copied text.
6. Save and close `phrase.txt`.
7. Run `main.py` as an administrator.
8. Click the text box in TypeRacer and wait 5 seconds.

#### **Programs required** (make sure to run as administrator as it involves interacting with another program):
- Python 3
- Visual Studio Code (Optional)
- A web browser that supports the [Simple Allow Copy](https://chrome.google.com/webstore/detail/simple-allow-copy/aefehdhdciieocakfobpaaolhipkcpgc) browser extension
  **Note:** This is required as TypeRacer blocks the copy & paste functionality on their website. This extension bypasses said restriction.

#### **Python library dependencies:**
- pyautogui 0.9.52

To easily install, use the command `pip3 install -r requirements.txt`.

#### **To-do:**
None currently, but I'm always open to suggestions.


text:
# Storybook Content Guidelines

This document explains how to write Storybook documentation in order to have consistent examples across the components.
Storybook documentation provides information about components for UX designers and FED developers:

- It provides a full overview of the component and its usage (no alternative information sources should be needed to make a decision)
- It shows if a component is developed, in development or deprecated.
- It explains what's still in development or why it's deprecated and what to use instead.

Guidelines Structure

- [Page Structure](#page-structure)
- [Demo Section](#demo-section)
- [Usage Section](#usage-section)
- [Import Section](#import-section)
- [Variations Section](#variations-section)
  - [1. Core Structure](#1-core-structure)
  - [2. Properties](#2-properties)
  - [3. Common Use Cases](#3-common-use-cases)
- [Code Snippets](#code-snippets)
- [API Section](#api-section)
- [Template](#templates)

## Page Structure

Each component story consists of following sections:

![](../assets/PageStructure.png)

## Demo Section

This section should contain a single interactive example that showcase default component usage:

      DO.
      Use content to display common use case, that component is designed for.

      DON'T.
      Don’t display empty version that might raise more questions than answers.

## Usage Section

This section should provide enough information for a user to make a decision if it’s a right component for a case or an alternative solution should be selected instead. Component description should explain:

- The primary purpose of the component
- If it’s a building part for a larger component (i.e. ListItemSelect)
- Do and don't examples — when component should be used or should not (optional link to correct solutions per case)

```
Modal controls the overlay layout that appears on call functions. It’s a container for components
like CustomModalLayout, ModalPreviewLayout and others.

Use it:
- To reveal all types of modal layouts
- To display a full page loading state

Don't use it:
- Example Don't use it
- Example Don't use it
```

## Import Section

This section should provide a line of code which can be copied and pasted to the developer's project, so component can be used right away.

```js
import { AddItem } from 'wix-style-react';
```

## Variations Section

This section should demonstrate how component behaves and when to use it. In order to maintain consistency between stories, examples should go in this order:

1. Core structure
2. Properties
3. Common use cases

### 1. Core Structure

Container box components should give an example how it is constructed. The example should list all available areas. This example should:

- Visually display existing content areas and design possibilities it provides
- Explain each content area purpose and accepted content types in the description (e.g. node, string, image)
- Use default properties or placeholder content without additional styling

#### Visuals

Use schematic drawing to visualise content areas, when containers do not have a default content type and accept any kind of content (node). If there are multiple content areas use text to communicate how each area is called.

    	DO.
    	Use schematic drawings to communicate structural areas that accept node content type.

    	DON'T.
    	Don’t use sample content as it doesn’t visually explain multiple content areas.

Showcase the effect of different values passed to the same prop if it helps to communicate the possibilities component provides. Use text to communicate what values have been passed and the effect it made.

    	DO.
    	Use content to communicate available options and difference it makes.

    	DON'T.
    	Don’t leave blank space and force user to check code to figure out difference in code.

If a component has a predefined value types, stick to these to showcase primary and recommended usage of a component. If content type is text, use it to explain area name and purpose.

If i.e. ‘title’ also accepts node content, it should be mentioned in a description and API.

    	DO.
    	Use default styling for areas with predefined content types to set right patterns.

    	DON'T.
    	Don’t override predefined styling with placeholder content.

Use other components from the library to explain mechanism containers behaviour, such as modal call out, native file upload, etc.

    	DO.
    	Use components from the library to explain behaviour, that is not visual.

    	DON'T.
    	Don’t use native HTML elements if library components are available.

#### Description

Structure example description should state:

- What areas the component consist of (if there are multiple areas only)
- Which areas are mandatory and which are optional
- What type and amount of children elements areas accept
- How to control component behaviour (for mechanism containers only)

	Structure

      	Render modal content by using children prop. Control modal appearance with props:

isOpen - this bool prop shows and hides the modal.

onRequestClose - this prop calls a function you request. It can be used to control isOpen prop.

	Structure

      	A simple example for modal with an alert

    	DO.
    	Give a meaningful description.

    	DON'T.
    	Don’t write a generic message that gives no value.

### 2. Properties

Property examples step by step introduce users to component features. This section should reveal and explain full component capabilities, also how to handle common edge cases (i.e. text wrapping).

Each component has a set of properties and features to explain. List them in order from least to most complex ones:

1. Appearance - list of properties that controls visual look and feel of a component

- Size and Layout _(i.e. width, height, position, direction)_
- Style _(i.e. skin, shape, shadow, border)_

2. States - list of predefined states of a component and when they should be displayed

- Selection _(i.e. selected, checked)_
- Validation _(i.e. error, warning, status)_

3. Content - list of properties that allow to customise content

- Content areas _(i.e. header, footer, suffix)_
- Text _(i.e. title, subtitle, additionalInfo)_
- Visual content _(i.e. thumbnail, avatar, image)_
- Actions _(i.e. actionText, primaryAction, secondaryAction)_

4. Behaviour - list of properties that control component behaviour or enable specific functionality for it

- Data loading _(i.e. lazyLoading, infiniteScroll)_
- Display _(i.e. horizontalScroll, overflow, collapse)_
- Other _(i.e. spellChecking, custom HTML tag)_

> Note: Order in which properties are listed can and should be adjusted depending per component and its most commonly used props

#### Visuals

Be aware that users are visual learners by nature. Examples we provide should be as self explanatory as possible.

In order to decide what content inside of a snippets would be suitable think about the following:

- What am I trying to communicate to the user (list of options to choose from, what behaviour property enables, etc.)?
- What is a property type (is it visual by its own, or does it need guidance)?
- How could we efficiently use initial component features to provide meaningful context?
- Could we help to set correct content patterns via snippets?

In cases where example lists down available value options use predefined component elements (if there are any) to communicate how passed value affects component appearance or behaviour.

    	DO.
    	Utilize component elements to communicate available prop values.

    	DON'T.
    	Don’t use meaningless placeholder titles which force you to look for information somewhere else.

Merge statuses into a single snippet for interactive components. Use labels to communicate how each status is called.

    	DO.
    	Display all different states in a single snippet and use labels to display state name.

    	DON'T.
    	Don’t use placeholder labels when your intention is to communicate different states.

Display single feature at the time. If example purpose is to list down the options, don’t complicate it with content which is not relevant at that specific moment.

    	DO.
    	Display content which is necessary to communicate example purpose only, i.e. existing states.

    	DON'T.
    	Don’t add content which is irrelevant in scenario you're showcasing (i.e. prefix icon in states example).

In cases where property value affects the content which is allowed to be displayed inside of a component use real case examples. This approach provides the user with context what each value is designed for, and also sets right content patterns.

    	DO.
    	Use real case content which both explains when skin could be used and sets correct content patterns

    	DON'T.
    	Don’t communicate value names only when there’s a direct dependency between accepted messaging and selected theme.

Use real content to demonstrate edge cases handling. It showcases the behaviour and sets correct content patterns at the same time. Avoid gibberish text that doesn't bring benefit.

    	DO.
    	Use real content for text overflow demonstration to set right content patterns.

    	DON'T.
    	Don’t use gibberish text which don’t bring benefit for a user.

Merge directly dependent or same purpose properties into a single example (i.e. width and height could be a single example named ‘Dimensions’):

    	DO.
    	Display similar purpose properties in a single example.

    	DON'T.
    	Don’t create separate examples for similar purpose props. It increases story length unnecessarily.

> Note: Examples of properties that could be shown in a single snippet:
>
>

>

> 		width
height
> 		maxWidth
maxHeight
ellipsis
textWrap
overflow
> 		primary
secondary
> 		border
borderRadius
borderWidth
> 		color
backgroundColour
textColor
> 		selected
disabled
 selected disabled
> 		header
footer
footnote
> 		primaryAction
secondaryAction
>

>

Don't merge property values which serve different purposes. Provide each of them with a dedicated example inside of the same snippet. Use real and meaningful copy to communicate purpose better:

> In example, selection items inside of a dropdown layout can be grouped using subheader or divider, but intentions are different. Subheader provides a name for a group. While divider separates list item that provide entirely different results, i.e. will add another field to the form where you can specify a custom length of a plan.

    	DO.
    	Have separate examples for different purpose prop values. Use real content to communicate purpose clearly.

    	DON'T.
    	Don’t merge prop variations with different intentions in a single layout. It doesn't explain clearly how they differ.

Use content to communicate hard to notice functionality for the end user:

    	DO.
    	Use content to visualise behaviour of not so obvious features.

    	DON'T.
    	Don’t use meaningless placeholder copy that leaves user to figure out what needs to be done by himself.

Guide users with content if they are required to make an action to see a feature or functionality:

    	DO.
    	Provide guidance for the hidden features (i.e. error message will be displayed in a tooltip on hover).

    	DON'T.
    	Don’t leave features partially explained. It’s easy to miss functionality which is explained only in API or longer descriptions.

Add external labels to communicate changes that happen in code for non visual features:

    	DO.
    	 Add labels if component change is not visual to help user figure out the difference instantly.

    	DON'T.
    	Don’t leave visual examples unexplained. This will require user to check the code to see a difference.

#### Description

Property example should always be followed by a description explaining how and when to use it. Depending on a property type description could state:

- what purpose property should be used for (mandatory)
- what property values are available and what each option is used for
- what is a default value
- what are accepted child element types

> Tip: always start writing description with a verb

Selection of examples how to write example descriptions:

			Subtitle

      		Explain action in more detail with a subtitle. Keep in
 mind that long subtitles affect visual hierarchy and compete
 with main CTA.

			Subtitle

			A subtitle text can be set.

			DO.
			Define the purpose of a feature.

			DON'T.
			Don't write generic descriptions that don't bring value.

			Skin

      		Highlights the purpose of an action. It supports 3 skin types.

standard (default)- use in common layouts

dark - use in longer list of actions (>5) in order to not overwhelm the user

destructive - use for destructive actions only

			 Skin

      		Supports three different skins: standard, dark & destructive.

			DO.
			Explain when to use each property option.

			DON'T.
			Don’t list options without explaining when to use each one of them.

			Subtoolbar

      		Provides a sticky container for related actions
 or content (i.e. list of applied filters). Area accepts any kind of content.

			Subtoolbar

			A Table can contain a sticky sub-toolbar, an area for a tag list of filtered items.

			DO.
			Define accepted content types.

			DON'T.
			Don’t be too specific about the use case if feature is flexible.

			Letter Counting

      		Indicates the number of letters typed inside of an input area.
 Set both maxLength and hasCounter props to show the counter.

			Letter Counting

			InputArea can indicate how many letters were typed.

			DO.
			Highlight the required conditions for feature to work as expected.

			DON'T.
			Don’t leave mandatory conditions unmentioned.

### 3. Common Use Cases

> Note:These examples are complex and should be made by WSR team only.

Common use cases is a list of examples which showcase recommended layouts and often used complex scenarios:

- Use real layouts and content to communicate cases where different variations of component should be used
- Use meaningful copy and set correct / recommended content patterns
- Showcase complex structures that can be achieved with a component

    	DO.
    	Use real case content to communicate recommended usage better

    	DON'T.
    	 Don’t use placeholder copy just to illustrate areas that was introduced in property examples already

## Code Snippets

Snippets represent component expressions in code and should be easy to follow so that users can relate the visuals and the code. Component examples should have minimal properties to help users quickly understand their usage.

### Principles

| Clear                                                                                | Consistent                                                    | Meaningful                                                                |
| ------------------------------------------------------------------------------------ | ------------------------------------------------------------- | ------------------------------------------------------------------------- |
| Design snippet examples in such a way that the user can immediately understand them. | Make snippet examples meaningful to communicate your message. | Utilize the patterns outlined below to write snippets that are intuitive. |

### Terminology

**Direct snippet** - an example that is directly inserted into the playground.

```jsx
<TextButton weight="thin">Thin</TextButton>
```

**Functional snippet** - an example containing components within a function.

```jsx
() => {
  return <TextButton weight="thin">Thin</TextButton>;
};
```

### General Guidelines

- Only two kind of snippet styling is allowed: direct or functional.
- The content for the snippets should be prepared together with UX writers and UX designers.
- Do not use native HTML tags except when necessary.
- Code duplication is preferable for readability.
- For property and structure examples layouting use StorybookComponents, but for commone use caases don't.
- Do not waste time on caching optimizations, as these examples are not effective code, but rather representation of usage. (useMemo, useCallback)

### StorybookComponents

StorybookComponents are dedicated components developed by Design Systems team
to meet the needs of example demonstration.
#### <StorybookComponents.Stack>

CSS Flex based component meant for stacking multiple components either horizontally or vertically.

| Property       | Tye    | Default    |
| -------------- | ------ | ---------- |
| justifyContent | string | flex-start |
| alignItems     | string | flex-start |
| gap            | string | 30px       |
| width          | string | ---------  |
| height         | string | ---------  |
| padding        | string | ---------  |
| margin         | string | ---------  |

#### <StorybookComponents.Placeholder>

CSS Block based component meant for structure examples.

| Property | Tye             | Default   |
| -------- | --------------- | --------- |
| skin     | 'dark', 'light' | 'dark     |
| width    | string          | --------- |
| height   | string          | --------- |

### Structure Example

Structure snippets are mostly used to represent components that are container based.

```jsx
<PageFooter>
  <PageFooter.Start>
    // Represents empty slot for other components
    <StorybookComponents.Placeholder>start</StorybookComponents.Placeholder>
  </PageFooter.Start>
  <PageFooter.Center>
    // Represents empty slot for other components
    <StorybookComponents.Placeholder>center</StorybookComponents.Placeholder>
  </PageFooter.Center>
  <PageFooter.End>
    // Represents empty slot for other components
    <StorybookComponents.Placeholder>end</StorybookComponents.Placeholder>
  </PageFooter.End>
</PageFooter>
```

Here we see a `<PageFooter/>` component, which main purpose is to give structure to the footer section of `<Page/>` component. `<StorybookComponents.Placeholder/>` should be used to represent available layouting options.

### Property Example

Property examples are meant to illustrate different types of property usage.

#### 1. Examples should not include additional properties unless additional properties are needed to represent the full feature.

```jsx
// do
<StorybookComponents.Stack>
  <TextButton weight="thin">Thin</TextButton>
  <TextButton weight="normal">Normal</TextButton>
<StorybookComponents.Stack>

// don't
<StorybookComponents.Stack>
  <TextButton weight="thin" size="small">Thin</TextButton>
  <TextButton weight="normal" size="small">Normal</TextButton>
<StorybookComponents.Stack>
```

#### 2. Properties that are image based url's should use assets directly from libraries dedicated assets folder.

> Why? External links tend to get taken down and so our story examples gets broken.

```jsx
// do
<CardGalleryItem backgroundImageUrl="table_with_fruits.jpg" />

// don't
<CardGalleryItem backgroundImageUrl="https://random-link.com/table_with_fruits.jpg" />
```

#### 3. In case property requires large data sets for interpretation - functional snippets can be used to move big data sets to meaningful variables.

```jsx
// do
() => {
  const options = [
    { id: 1, value: 'Option 1' },
    { id: 2, value: 'Option 2' },
    { id: 3, value: 'Option 3' },
    { id: 4, value: 'Option 4' },
    { id: 5, value: 'Option 5' },
    { id: 6, value: 'Option 6' },
    { id: 7, value: 'Option 7' },
    { id: 8, value: 'Option 8' },
    { id: 9, value: 'Option 9' },
    { id: 10, value: 'Option 10' },
  ];

  return <Dropdown options={options} />;
};

// don't
<Dropdown
  options={[
    { id: 1, value: 'Option 1' },
    { id: 2, value: 'Option 2' },
    { id: 3, value: 'Option 3' },
    { id: 4, value: 'Option 4' },
    { id: 5, value: 'Option 5' },
    { id: 6, value: 'Option 6' },
    { id: 7, value: 'Option 7' },
    { id: 8, value: 'Option 8' },
    { id: 9, value: 'Option 9' },
    { id: 10, value: 'Option 10' },
  ]}
/>;
```

#### 4. Complex structure components examples can be daunting to comprehend. In such cases, there is value in abstracting code into smaller modules in order to reduce mental effort in understanding the code.

```jsx
//do
() => {
  const renderTableToolbar = () => (
    <TableToolbar>
      <TableToolbar.Title>Published</TableToolbar.Title>
    </TableToolbar>
  );

  const renderEmptyState = () => (
    <Table.EmptyState>
      <TextButton prefixIcon={<Icons.Add />}>Create New Post</TextButton>
    </Table.EmptyState>
  );

  return (
    <Table>
      {renderTableToolbar()}
      {renderEmptyState()}
    </Table>
  );
};

// don't
() => (
  <Table>
    <TableToolbar>
      <TableToolbar.Title>Published</TableToolbar.Title>
    </TableToolbar>
    <Table.EmptyState>
      <TextButton prefixIcon={<Icons.Add />}>Create New Post</TextButton>
    </Table.EmptyState>
  </Table>
);
```

#### 5. Some component properties are controlled externally and hence require local state. React hooks should be used.

```jsx
() => {
  const [checked, setChecked] = React.useState(false);

  return (
    <CheckToggle checked={checked} onChange={() => setChecked(!checked)} />
  );
};
```

#### 6. Properties that are supposed to relate to the behavior of other components should be used meaningfully and provided with near real world examples.

```jsx
() => {
  const [isModalOpened, setModalOpened] = React.useState(false);

  return (
    <StorybookComponents.Stack>
      <StorybookComponents.Action onClick={() => setModalOpened(true)}>
        Open Announcement Modal
      </StorybookComponents.Action>
      <Modal
        isOpen={isModalOpened}
        onRequestClose={() => setModalOpened(false)}
      >
        Real World Example
      </Modal>
    </StorybookComponents.Stack>
  );
};
```

### Common Use Case

Used to illustrate real-world examples, such as interactivity and components with state and content that is used in actual applications. All components presented in the examples should be library components and content that it used inside must resemble real world use case.

#### 1. Simulating data fetching

Components examples that are meant to work with data fetched from server should use StorybookUtils.fetch function that simulates data coming from server.

```jsx
() => {
  const containerRef = React.useRef(null);
  const [data, setData] = React.useState([]);
  const [container, setContainer] = React.useState(null);

  const fetchMoreData = async (loaded) => {
    setData(
      await StorybookUtils.fetch('/api/table', {
        load: loaded + 5,
      }),
    );
  };

  React.useEffect(() => {
    setContainer(containerRef);
    fetchMoreData();
  }, []);

  const columns = [
    { title: 'First', render: (row) => row.firstName },
    { title: 'Last', render: (row) => row.lastName },
  ];

  return (
    <Table
      data={data}
      columns={columns}
      infiniteScroll
      hasMore={true}
      loadMore={fetchMoreData}
      itemsPerPage={20}
      scrollElement={container && container.current}
    >
      <Table.Content />
    </Table>
  );
};
```

## API Section

API table should list ALL available properties and methods of a presented component.
Each property listed in this sections should have:

- Description
- Type
- Default value written (If component has default value. Bool type props should always have it).
- List of possible value options to choose from, i.e. oneOf (‘placement’) should include available placement options such as top, bottom, left, right

#### Description

> Tip: always start writing description with a verb

      		fixed

      		Makes tooltip's position fixed to its original placement even if it's outside the boundary.

      		 fixed

      		whether to enable the fixed behaviour.

      		 maxWidth

      		Defines maximum width of tooltip content container in pixels.

      		 maxWidth

      		tooltip content container width in pixels

      		 secondary

		Sets text style to secondary. It affects font color only.

      		 secondary

      		is the text type is secondary. Affects the font color

      		 tooltipProps

		Allows to pass all available tooltip properties. Check <Tooltip/> API for the full list.

      		 tooltipProps

      		Properties for tooltip

      		 children

		Accepts any component as a child item. Common cases for this component are headings, text strings, badges or icons.

      		 children

      		any nodes to be rendered

## Templates

For all the future story docs, please start with this template:
[https://docs.google.com/document/d/1KmQ56KeyAPqsiQ7vskSMJxK2Lfq9XlO0vzYoM_Nwn3M/edit?usp=sharing]()

repository: alonbt/wix-style-react

repo_name: alonbt/wix-style-react


text:
# ionic-brackets

**ionic-brackets** is a **[Brackets](http://brackets.io/)** extension for developing mobile applications using **[Ionic](http://ionicframework.com/)** framework.

## Table of contents
- [Installation](#installation)
- [How To Use](#how-to-use)
- [Features](#features)
 - [Start an Ionic project](#start-an-ionic-project)
 - [Add Platform](#add-platform)
 - [Add Plugin](#add-plugin)
 - [Build](#build)
 - [Emulate](#emulate)
 - [Run](#run)
 - [Live Development / Serve](#live-development-serve)
 - [Plugins hook](#plugins-hook)
 - [Add ngCordova](#add-ngcordova)
 - [Quick Docs](#quick-docs)
- [Contributing](#contributing)
- [Links](#links)

## Installation

The extension can be installed by following the instructions on the [official extensions guide](https://github.com/adobe/brackets/wiki/Brackets-Extensions).

## How To Use

If you can see the Ionic icon on the right toolbar, the extension is ready to use.
Simply locate the ionic menu on the menus-bar and continue from there.

| Note: The icon's color is turned light blue when running a background job (build, serve, etc.).

## Features

### Start an Ionic project
Creates an Ionic project using the available templates.

| Note: The extension understands if your project is an Ionic project by the existence of the `www` directory.

### Add platform
Adds a platform to the project [Choosing between ios or android].

### Add plugin
Adds a plugin to the project.

### Build
Builds the project.

### Emulate
Creates an emulator for the application using the android/ios tools.

### Run
Runs the application on a real device using the android/ios tools.

### Live Development / Serve
Runs your application inside Brackets.
You can open/close the live development view using the Ionic icon on the right side of Brackets.

| Note that plugins are currently not available. Intend for basic application UI/navigation testing.

### Plugins hook
Creates a Cordova hook for automatic plugins installation. Automatically adds your installed plugins to the hook.

### Add ngCordova
Adds ngCordova to your project:

1. Installs ngCordova using bower.
2. Adds `<script src="lib/ngCordova/dist/ng-cordova.js"></script>` to the main `index.html` file.
3. Adds a dependency to the main `app.js` file - example: `angular.module('myApp', ['ngCordova'])`.

### Quick docs
While developing, you can see the official docs of Ionic components or ngCordova plugins using quick docs key binding (defaulting to `ctrl+k`).

## Contributing

Feel free to contribute to the project by adding features or fixing bugs.

## Links

- Brackets - http://brackets.io/
- Ionic Framework - http://ionicframework.com/
- ngCordova - http://ngcordova.com/

## License

ionic-brackets is licensed under the MIT Open Source license. For more information, see the LICENSE file in this repository.

repository: andynealects/ionic-brackets

repo_name: andynealects/ionic-brackets


text:
# cdk8s+ (cdk8s-plus)

### High level constructs for Kubernetes

![Stability:Beta](https://img.shields.io/badge/stability-beta-orange)
[![build](https://github.com/cdk8s-team/cdk8s-plus-17/workflows/release/badge.svg)](https://github.com/cdk8s-team/cdk8s-plus-17/actions/workflows/release.yml)
[![npm version](https://badge.fury.io/js/cdk8s-plus-17.svg)](https://badge.fury.io/js/cdk8s-plus-17)
[![PyPI version](https://badge.fury.io/py/cdk8s-plus-17.svg)](https://badge.fury.io/py/cdk8s-plus-17)
[![NuGet version](https://badge.fury.io/nu/Org.Cdk8s.Plus17.svg)](https://badge.fury.io/nu/Org.Cdk8s.Plus17)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.cdk8s/cdk8s-plus-17/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.cdk8s/cdk8s-plus-17)

**cdk8s+** is a software development framework that provides high level abstractions for authoring Kubernetes applications.
Built on top of the auto generated building blocks provided by [cdk8s](../cdk8s), this library includes a hand crafted *construct*
for each native kubernetes object, exposing richer API's with reduced complexity.

## Documentation

See [cdk8s.io](https://cdk8s.io/docs/latest/plus).

## License

This project is distributed under the [Apache License, Version 2.0](./LICENSE).

This module is part of the [cdk8s project](https://github.com/awslabs/cdk8s).


text:
# frontend

This is a Flutter desktop app that provides the frontend for the Dart full-stack
demo.

## Requirements

- [Flutter](https://flutter.dev/docs/get-started/install)

## Environment

If you have not enabled desktop support for your Flutter installation,
do so now with one of the following commands, as appropriate for your system:

```shell
flutter config --enable-windows-desktop
flutter config --enable-macos-desktop
flutter config --enable-linux-desktop
```

> In any of the commands below, replace DESKTOP with `windows`, `macos`, or
> `linux`.

### dev and prod environments

Configuration for `dev` and `prod` environments is stored under `assets/config`.

By default running `flutter run` will use `dev`:

```shell
flutter run -d DESKTOP
```

To use `prod` specify your environment when running `flutter run`:

```shell
flutter run -d DESKTOP --dart-define=ENV=prod
```

## Calling the backend API

The `Greeting` class for invoking the backend API is in `lib/services/api.dart`.

This class is instantiated and used by the model in `lib/models/app_model.dart`.

The JSON serializer / deserializer types are in `lib/services/api_types.dart`.
The serializer part (`lib/services/api_types.g.dart`) is built with the
following command:

```shell
flutter pub run build_runner build
```

Output:

```shell
[INFO] Generating build script...
[INFO] Generating build script completed, took 337ms

[INFO] Initializing inputs
[INFO] Reading cached asset graph...
[INFO] Reading cached asset graph completed, took 50ms

[INFO] Checking for updates since last build...
[INFO] Checking for updates since last build completed, took 423ms

[INFO] Running build...
[INFO] 1.0s elapsed, 8/9 actions completed.
[INFO] Running build completed, took 1.1s

[INFO] Caching finalized dependency graph...
[INFO] Caching finalized dependency graph completed, took 27ms

[INFO] Succeeded after 1.1s with 2 outputs (18 actions)
```

> Note: the JSON serializer code is maintained separately from the code in the
> backend. Tightly coupling client and server code through shared libraries
> (packages) is considered an anti-pattern with microservice architecture.

repository: tonyclickspace/functions-framework-dart

repo_name: tonyclickspace/functions-framework-dart


text:
# git-rbr: "recursive rebase"

**NOTE**: This repository is no longer maintained and may not be up-to-date.

## Running tests

[![Build Status](https://travis-ci.org/dropbox/git-rbr.svg?branch=master)](https://travis-ci.org/dropbox/git-rbr)

From the root of the repo, run

    $ py.test

Dependencies for the test suite:

* **pytest**: `pip install pytest`

* **Git v2.7 or later**: if your Git version is too old, install a
  current one from https://git-scm.com/downloads or
  https://launchpad.net/~git-core/+archive/ubuntu/ppa .
  (`git-rbr` itself should work with much older versions of Git...
  though we don't currently test that automatically.)

## License

Copyright 2017 Dropbox, Inc.

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

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

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

repository: tryweirdier/git-recurse-rebase

repo_name: tryweirdier/git-recurse-rebase


text:
# zip_kv_pairs

This is a short Python script demonstrating how to take values from two separate dictionaries and fuse them together as key:value pairs in one single dictionary.

# Script Operation

We start with two separate dictionaries.
```python
  dict1 = {'a':bin(0b0000), 'b':bin(0b0001), 'c':bin(0b0010), 'd':bin(0b0011),
           'e':bin(0b0100), 'f':bin(0b0101), 'g':bin(0b0110), 'h':bin(0b0111)}

  dict2 = {'a':0, 'b':1, 'c':2, 'd':3, 'e':4, 'f':5, 'g':6, 'h':7}
```
Next, we generate a new dictionary whose key:value pairs are formed of the values from the two separate dictionaries.
```python
  zipped_kv_pairs = dict(zip(dict1.values(), dict2.values()))
```
The resulting `zipped_kv_pairs` dictionary is shown below.
```python
  {'0b0': 0, '0b1': 1, '0b10': 2, '0b11': 3, '0b100': 4, '0b101': 5, '0b110': 6, '0b111': 7}
```


text:
SpreeComfy
==========

Add comfortable-mexican-sofa to spree commerce

Installation
------------

Add spree_comfy to your Gemfile:

```ruby
gem 'spree_comfy'
```

In initializers/comfortable-mexican-sofa.rb
```ruby
config.reveal_cms_partials = true
```
... to see additional menu items in cms admin area

config/routes.rb example
```ruby
mount Spree::Core::Engine, :at => '/'
mount SpreeComfy::Engine, :at => '/'

comfy_route :cms_admin, :path => '/cms_admin'
comfy_route :cms, :path => '/', :sitemap => false
```

Bundle your dependencies and run the installation generator:

```shell
bundle
bundle exec rails g spree_comfy:install
```

Testing
-------

Be sure to bundle your dependencies and then create a dummy test app for the specs to run against.

```shell
bundle
bundle exec rake test_app
bundle exec rspec spec
```

When testing your applications integration with this extension you may use it's factories.
Simply add this require statement to your spec_helper:

```ruby
require 'spree_comfy/factories'
```

Copyright (c) 2014 [name of extension creator], released under the New BSD License


text:
# Change Log
All notable changes to this project will be documented in this file.
`KeyboardAvoidingView` adheres to [Semantic Versioning](http://semver.org/).

## [1.0.0](https://github.com/APUtils/KeyboardAvoidingView/releases/tag/1.0.0)
Released on 2017-07-07.

#### Added
- Support for outer constraints
  - Added by [Anton Plebanovich](https://github.com/anton-plebanovich).

## [0.1.0](https://github.com/APUtils/KeyboardAvoidingView/releases/tag/0.1.0)
Released on 2017-07-06.

#### Added
- Initial release of KeyboardAvoidingView.
  - Added by [Anton Plebanovich](https://github.com/anton-plebanovich).

repository: mohsinalimat/KeyboardAvoidingView

repo_name: mohsinalimat/KeyboardAvoidingView


text:
# @cessair/generic
> The interface for generic programming.

- [License](#license)

## License
[MIT License](https://github.com/cessair/cessair/blob/develop/LICENSE).

repository: cessair/cessair

repo_name: cessair/cessair


text:
---
layout: post
title: "Thursday 05.24.18 -  CrossFit"
teaser: "A.  20 minute EMOM of Barbell Bench Presses, Ring Dips, and SkiErg
 B.  4 Rounds For Time of Shoulder to Overheads and GHD Sit-Ups"
date: 2018-05-24 00:00:00
categories: wodup
tags: wods thursday
header: no
---

A.  20 minute EMOM of Barbell Bench Presses, Ring Dips, and SkiErg

Every 4 minute for 20 minutes (5 rounds):
– 5 Barbell Bench Presses
– 15 Ring Dips
– 15/12 Calories of SkiErg

Build round by round to a heavy bench for 5 reps.

For Rx a Muscle Up must be completed first to get on top of the rings.

B.  4 Rounds For Time of Shoulder to Overheads and GHD Sit-Ups

4 Rounds for Time:
– 15 Shoulder to Overheads @ 52.5/35 kg
– 20 GHD Sit-Ups

This workout should be completed under 10 minutes.  Anything over 12 minutes mean the weight was too heavy or the GHD Sit-Ups would have needed to be scaled.
View on WodUp

#### Compare to other Thursdays
{: .t60 }

{% include list-posts tag='thursday' %}


text:
# Helm-Bulk

This is a Helm plugin that loads or saves Helm releases from File to Cluster,
or Cluster to File, respectively.

## Installation

Install the latest version:

```shell
$ helm plugin install https://github.com/ovotech/helm-bulk
```

Install a specific version:

```shell
$ helm plugin install https://github.com/ovotech/helm-bulk --version 0.0.20
```

This will:

1. Find the `plugin.yaml` in the project root
2. Execute the file specified in `hooks: install:` (useful for any pre-install
  operations)
3. Copy the file that's specified in the `command` value into the Helm plugin
directory (defaults to `.helm/plugins/`). This is the file that'll be executed
when you invoke the plugin with Helm, i.e. `helm bulk`.

The final String of the output, on a successful install, will be:
`helm-bulk [version] is correctly installed.`.

You can also verify it's been installed using:

```
$ helm plugin list

NAME	VERSION	DESCRIPTION
bulk	0.0.20  	Load or Save Helm Releases from File to Cluster, or Cluster to
File, respectively
```

Try invoking it:

```
$ helm bulk

Load or Save Releases from File to Cluster, or Cluster to File, respectively
...
...
```

## Getting Started

`helm-bulk` will only ever use your current kubectl context, so make sure
you've switched to whatever Context/Cluster you want to use (e.g. `kubectl
  config use-context <context_name>` or `gcloud container clusters....` to
  re-auth into your target Cluster).

By default, `helm-bulk` uses TLS in its communication with Tiller. It can
be forced to not use TLS, but it's not recommended to do so. You'll need to
generate `*.key.pem`, `*.csr.pem` and `*.cert.pem` files for who/what-ever is
using `helm-bulk`. The `*.cert.pem` will be signed by a CA key you'll have
generated at some point prior when you enabled TLS on Tiller.

 Copy the CA cert, and the user cert
# and key to the `HELM_HOME` directory. This allows you to omit the TLS filepath
# fields when using helm-bulk.
$ cp ca.cert.pem $(helm home)/ca.pem \
    && cp helm.cert.pem $(helm home)/cert.pem \
    && cp helm.key.pem $(helm home)/key.pem

```
Credit to [this repo](https://github.com/helm/helm/blob/master/docs/tiller_ssl.md)
where these commands have been copied from.

If end-to-end testing, try following these commands through in order, otherwise
they can be run individually:

```
# Use Helm to list your Releases (omit --tls if not using TLS, booo...)
$ helm ls --tls

# Save deployed Helm Releases to archive (defaults to "./helm-releases.tar.gz")
$ helm bulk save -s=<csr_server_name>

# Print out a list of Helm Releases currently stored in the archive
# (defaults to "./helm-releases.tar.gz")
$ helm bulk show

###############################################################################
# if e-2-e testing, simulate loss of Helm Releases in Cluster here
# e.g.:
# recreate cluster, delete all current Helm Releases in Cluster, OR switch
# kubectl context to a fresh Cluster
###############################################################################

# Load Helm Releases from File into your Cluster (replace -s flag with
# -t=false if not using TLS)
$ helm bulk load -s=<csr_server_name>

# Use Helm to list the Releases again
$ helm ls --tls
```

## Idempotency

`helm bulk load` will attempt to get the Helm Releases in your Cluster to
reflect what you have in your File, but only for those Releases defined. It
won't touch any Releases you may already have in your Cluster.

If you already have one or more of the Releases in your File installed in your
Cluster, then things get a little more complicated than working with an 'empty'
Cluster. `helm-bulk` needs to work out whether to ignore, delete or upgrade the
existing Releases.

By default, `helm-bulk` will ignore the existing Releases. If you want it to
delete or upgrade, use the `-d` or `-u` flags respectively.

`helm-bulk` is designed to be used shortly after Cluster create (obviously post
  tiller install), in which case there won't be any existing Helm Releases.

## Save order

By default, Releases will be saved to file in the order they are returned by
`helm ls`, which by default in Helm is alphabetically.

It's possible to specify an overriding order by dropping a yaml file such as:

```
order:
  - first-release
  - second-release
```

..into the working directory, or into a custom directory and specifying this
directory in the `-c, --order-pref-config-dir` flag when the plugin is called.
The config file **must** be named `orderPref.yaml`.

Alternatively the order can be specified in an environment variable like so:

```
$ export HELM_BULK_ORDER=first-release,second-release
```

Note: the ordering is applied at time of `helm bulk save`. When `helm bulk load`
is called, the plugin will just blindly follow the order in the file from top
to bottom.

This could be useful in cases where all Releases are dependent on a small number
of other Releases, e.g. installing CRDs or application config.

Helm dependencies could also be used to achieve the same thing, and should in
theory work, although that hasn't been tested to any degree.

## Release Naming

When you install a Helm Chart, if you don't provide a name, Helm will generate
one for you, e.g. "kissing-wildebeest". Subsequent `helm install` commands
(also with no name specified) will create new Releases with different names
(even if for the same Chart). **All** of these Releases will then be returned
when running `helm ls`, and therefore will also make it into your File after a
`helm bulk save`.

This would lead to greater processing times when running a `helm bulk load` or
`helm bulk save`, and a larger persisted File, and could lead to unexpected
`load` results.

To prevent this, it's recommended to **always name your Release when
installing**, so you only have one current Release (and any upgrades to that
will supersede, with version number incrementing).

## Release History

History of Helm Releases is currently not persisted.

repository: ovotech/helm-bulk

gha_language: Go

repo_name: ovotech/helm-bulk


text:
# SA-Inventory

## What is SA-Inventory

  SA-Inventory is the application which generate the product code via Barcode/QR Code and transfer the data to the host server.

### System Requirement

  - Android version 4.4 or above.

repository: lucky-patty/SA-Inventory-App-

repo_name: lucky-patty/SA-Inventory-App-


text:
### Description

This demo uses recursion to represent a Koch snowflake fractal. For more information about this fractal, there are many resources on the web:
http://en.wikipedia.org/wiki/Koch_snowflake, http://mathworld.wolfram.com/KochSnowflake.html.

repository: Kitware/vtk-examples

repo_name: Kitware/vtk-examples


text:
# StormFox
StormFox is a free environment mod that will freshen your GMod experience with weather, light, effects and textures.

## How to install
You can find it on Steam Workshop [here.][1]

You can also install from this repository via this link [here.][2]

## License

This project is licensed under the [Apache License 2.0.][3]

## API

You can find commen and useful functions [here.][5]

## Fresh out of beta
Please report any bugs via the issue tracker.

Changelogs can be found on the Steam Workshop Page [here.][4]

[1]:http://steamcommunity.com/sharedfiles/filedetails/?id=1132466603
[2]:https://github.com/Nak2/StormFox/archive/master.zip
[3]:https://github.com/Nak2/StormFox/blob/master/LICENSE
[4]:http://steamcommunity.com/sharedfiles/filedetails/changelog/1132466603
[5]:https://github.com/Nak2/StormFox/blob/master/stormfox-api.md

repository: realpack/StormFox

repo_name: realpack/StormFox


text:
# Event Registration System

An example project built on my [React/Django boilerplate](example.com).

## 🖼 Screenshots

![Screenshot](https://github.com/Garfield1002/Event-Reservation/blob/master/Screenshot.png?raw=true)

## 📖 Usage

Prerequisites: Docker and Compose

Configure `EMAIL_HOST_USER` and `EMAIL_HOST_USER` in _app\\django_project\\settings.py_.

You can now start the app by running:

```bash
docker-compose up -d --build

```

It should now be up and running at [http://localhost:8002](http://localhost:8002).

To actually create an event,

1. Create a super user using

   ```bash
       docker-compose exec web python manage.py createsuperuser
   ```

2. You can now log in to [http://localhost:8002/protected/](http://localhost:8002/protected/) to view and manage your events

## 🍕 Contribution

Anyone is welcome to contribute to the quality of this content. Please feel free to submit a PR request for typo fixes, speling corrections, explanation improvements, more speling etc.

Feature requests are also welcome (This is however meant as a usable example/tutorial not necessarily a polished app)

## ⚖ License

MIT


text:
# XL Release CloudForms plugin v1.0.0

[![Build Status][xlr-cloudforms-plugin-travis-image]][xlr-cloudforms-plugin-travis-url]
[![License: MIT][xlr-cloudforms-plugin-license-image]][xlr-cloudforms-plugin-license-url]
![Github All Releases][xlr-cloudforms-plugin-downloads-image]

[xlr-cloudforms-plugin-travis-image]: https://travis-ci.org/xebialabs-community/xlr-cloudforms-plugin.svg?branch=master
[xlr-cloudforms-plugin-travis-url]: https://travis-ci.org/xebialabs-community/xlr-cloudforms-plugin
[xlr-cloudforms-plugin-license-image]: https://img.shields.io/badge/License-MIT-yellow.svg
[xlr-cloudforms-plugin-license-url]: https://opensource.org/licenses/MIT
[xlr-cloudforms-plugin-downloads-image]: https://img.shields.io/github/downloads/xebialabs-community/xlr-cloudforms-plugin/total.svg

## Preface

This document describes the functionality provided by the XL Release CloudForm plugin.

See the [XL Release reference manual](https://docs.xebialabs.com/xl-release) for background information on XL Release and release automation concepts.

## Overview

## Requirements

Note:  XLD or XLR version should not be lower than lowest supported version.  See <https://support.xebialabs.com/hc/en-us/articles/115003299946-Supported-XebiaLabs-product-versions>.

## Installation

* Copy the latest JAR file from the [releases page](https://github.com/xebialabs-community/xlr-cloudforms-plugin/releases) into the `XL_RELEASE_SERVER/plugins` directory.
* Restart the XL Release server.

## XLRelease Tasks

* Check CFME Service: check if the CloudForm Service is available
* Start Service: Request a new Service from a service template ID and wait for its end.

## References


text:
# GREASE MONKEYS
### The work presented in this paper is new and was prepared only for the course COMP 2501 Computer Game Design and Development, Winter 2016, School of Computer Science, Carleton University.

### Programmers:
* Christina Abramson
* Wilson Hodgson
* Thuong Mai

![Game Items](https://bitbucket.org/thuongmai92/grease-monkeys/raw/master/Images/image.png)

![Car Types](https://bitbucket.org/thuongmai92/grease-monkeys/raw/master/Images/image1.png)

**1. Content/Background**
Grease Monkeys is an action, arcade, game where the player strategically collects items,
drive vehicles and avoids being hit by enemies. The game has two main characters: the player
(brown monkey) and the AI enemy (gray monkey). The player can then choose to enter and drive
one of the four different vehicles (red, green, blue and black), each with its own controls.
The player can also pick up and use three different power up items. For the UI elements,
we have a player’s health bar at the top right of the screen to indicate how much health a car has left,
and an inventory at the bottom right to indicate what items the player has collected so far.
The arena is a square shape that was drawn by using vertex array to allow the player and AI move freely,
also for the smooth scrolling screen.


text:
The utility is intended to help debug pylint and astroid.

This program will forward the given path to pylint and conditionally monkey patch pylint to give debug information

# Installation

    git clone git@github.com:brycepg/pylintdebug.git
    cd pylintdebug
    pip install pylintdebug

# Usage

    pylintdebug [args] <path_of_file_to_debug>

To find out where messages are being called use:

    pylintdebug --messages file.py

Use `--extend-args` to pass arguments to pylint

Use the `--inference` flag to print information about inference occuring

### reveal\_inference call

``pylintdebug`` patches astroid with an psuedo-function called `reveal_inference`. Calling `reveal_inference(node)` will reveal astroid information about this node. This is useful for understanding the flow of a python program in the wild. Additional informatino can be gleaned from `reveal_inference(node, pdb=True)` which will start pdb in the function and allow you to step into `astroid` inference.

# API

importing pylintdebug will automatically add the reveal\_inference call to astroid's brain.

## print info about inference functions

```python
from pylintdebug import patch
patch.patch_inference_functions()
```

repository: brycepg/pylintdebug

repo_name: brycepg/pylintdebug


text:
## Simple Service Locator (C#)

Simple Service Locator is a very simple ServiceLocator implementation. It serves as an easy alternative to Dependency Injection for small or legacy projects.

---

## Usage

### Basic Setup

```csharp
using GHSoftware;

// Initialize the ServiceLocator
var serviceLocator = ServiceLocator.Default;

// Set a service
serviceLocator.Set<IService>(new ServiceImplementation());
```

### Accessing a Service

After you have set up the services you can access them using the `Get<T>()` method. Here's an example:

```csharp
// Retrieve a service
var service = serviceLocator.Get<IService>();
```

### Using the Lazy Service Instantiation

If you want to delay the instantiation of your service until it's actually needed, you can use the `GetLazy<T>()` method. This method returns a `Lazy<T>` object, which will only create the instance when it's accessed for the first time.

```csharp
// Retrieve a lazily instantiated service
var lazyService = serviceLocator.GetLazy<IService>();

// Use the service
var service = lazyService.Value;
```

---

## Examples

### Using the ServiceLocator with Multiple Services

```csharp
using GHSoftware;

// Initialize the ServiceLocator
var serviceLocator = ServiceLocator.Default;

// Set multiple services
serviceLocator.Set<IService1>(new Service1Implementation());
serviceLocator.Set<IService2>(new Service2Implementation());
serviceLocator.Set<IService3>(new Service3Implementation());

// Retrieve the services
var service1 = serviceLocator.Get<IService1>();
var service2 = serviceLocator.Get<IService2>();
var service3 = serviceLocator.Get<IService3>();
```

### Handling Exceptions

If a service is not available, the `Get<T>()` method throws a `NotImplementedException`. Here's how you can handle it:

```csharp
try
{
    var service = serviceLocator.Get<IService>();
}
catch (NotImplementedException ex)
{
    Console.WriteLine(ex.Message);
}
```

---

## License

This project is licensed under the MIT License.

---

Please, feel free to contribute or report any issues.

repository: GustavoHennig/SimpleServiceLocator

repo_name: GustavoHennig/SimpleServiceLocator