text:
## liboidcagent-py
A `python` library for `oidc-agent` is available at
https://github.com/indigo-dc/liboidc-agent-py.

To use it in your `python` application install it with
```
pip install liboidcagent
```
and import it with:
```python
import liboidcagent as agent
```

### Error Handling
The library will raise an exception of type `OidcAgentError` if something goes
wrong.

Error Handling can be done the following way:
```python
try:
    print(agent.get_access_token(account_name))
except agent.OidcAgentError as e:
    print("ERROR oidc-agent: {}".format(e))
```
### Requesting an Access Token For an Account Configuration
The following functions can be used to obtain an access token for a specific
account configuration from ```oidc-agent```. If you / your application does not
know which account configuration should be used, but you know for which provider
you need an access token you can also [request an access token for a
provider](#requesting-an-access-token-for-a-provider).

#### get_access_token
```python
def get_access_token(account_name, min_valid_period=0,
                     application_hint=None, scope=None)
```
This function requests an access token from oidc-agent for the ```account_name```
account configuration. The access token should have ```scope``` scopes and be
valid for at least ```minValidPeriod``` seconds.

##### Parameters
- ```account_name``` is the shortname of the account configuration that should be
  used.
- If ```min_valid_period``` is
```0``` (default) no guarantee about the validity of the token can be made; it is possible
that it expires before it can be used. Can be omitted.
- ```application_hint``` should be the name of the application that
requests an access token. This string might be displayed to the user for
authorization purposes. Can be omitted.
- If ```scope``` is None, the
default scopes for that account are used. So usually it is enough to use `None`
or to omitt this parameter.

##### Return Value
The function returns only the access token. To additionally obtain other
information use [```get_token_response```](#get_token_response).

##### Example
A complete example can look the following:
```python
token = agent.get_access_token(account_name, 60, "example-app")
print("Access token is: {}".format(token))
```
#### get_token_response
```python
def get_token_response(account_name, min_valid_period=0,
                       application_hint=None, scope=None)
```
This function requests an access token from oidc-agent for the ```account_name```
account configuration. The access token should have ```scope``` scopes and be
valid for at least ```min_valid_period``` seconds.

##### Parameters
- ```account_name``` is the shortname of the account configuration that should be
  used.
- If ```min_valid_period``` is
```0``` (default) no guarantee about the validity of the token can be made; it is possible
that it expires before it can be used. Can be omitted.
- ```application_hint``` should be the name of the application that
requests an access token. This string might be displayed to the user for
authorization purposes. Can be omitted.
- If ```scope``` is None, the
default scopes for that account are used. So usually it is enough to use `None`
or to omitt this parameter.

##### Return Value
The function returns three values: the requested
access token, the url of the issuer that issued the token and the time when the
token expires.

The values can be accesed the following way:
```python
token, iss, exp = agent.get_token_response(account_name, 60, "example-app")
token                  // access token
iss                    // issuer url
exp                    // expiration time

token_response = agent.get_token_response(account_name, 60, "example-app")
token_response[0]      // access token
token_response[1]      // issuer url
token_response[2]      // expiration time
```

##### Example
A complete example can look the following:
```python
token, iss, exp = agent.get_token_response(account_name, 60, "example-app")
print("Access token is: {}".format(token))
print("Access token issued by: {}".format(iss))
print("Access token expires at: {}".format(exp))
```

### Requesting an Access Token For a Provider
The following functions
can be used to obtain an access token for a specific OpenID Provider (issuer).
This might be useful for applications that only work with a specific provider
and therefore know the issuer for which they need an access token, but do not
require the user to provide an account configuration shortname.

#### get_access_token_by_issuer_url
```python
def get_access_token_by_issuer_url(issuer_url, min_valid_period=0,
                                   application_hint=None, scope=None)
```
This function requests an access token from `oidc-agent` for the provider with
```issuer_url```. The access token should have ```scope``` scopes and be valid for at least ```min_valid_period``` seconds.

##### Parameters
- ```issuer_url``` is the issuer url of the provider for which an access token
  should be obtained.
- If ```min_valid_period``` is
```0``` (default) no guarantee about the validity of the token can be made; it is possible
that it expires before it can be used. Can be omitted.
- ```application_hint``` should be the name of the application that
requests an access token. This string might be displayed to the user for
authorization purposes. Can be omitted.
- If ```scope``` is None, the
default scopes for that account are used. So usually it is enough to use `None`
or to omitt this parameter.

##### Return Value
The function returns only the access token. To additionally obtain other
information use
[```get_token_response_by_issuer_url```](#get_token_response_by_issuer_url).

##### Example
A complete example can look the following:
```python
token = agent.get_access_token_by_issuer_url("https://example.com", 60, "example-app")
print("Access token is: {}".format(token))
```

#### get_token_response_by_issuer_url
```python
def get_token_response_by_issuer_url(issuer_url, min_valid_period=0,
                                     application_hint=None, scope=None)
```
This function requests an access token from oidc-agent for the provider with
```issuer_url```. The access token should have ```scope``` scopes and be
valid for at least ```min_valid_period``` seconds.

##### Parameters
- ```issuer_url``` is the issuer url of the provider for which an access token
  should be obtained.
- If ```min_valid_period``` is
```0``` (default) no guarantee about the validity of the token can be made; it is possible
that it expires before it can be used. Can be omitted.
- ```application_hint``` should be the name of the application that
requests an access token. This string might be displayed to the user for
authorization purposes. Can be omitted.
- If ```scope``` is None, the
default scopes for that account are used. So usually it is enough to use `None`
or to omitt this parameter.

##### Return Value
The function returns three values: the requested
access token, the url of the provider that issued the token and the time when the
token expires.

The values can be accesed the following way:
```python
token, iss, exp = agent.get_token_response_by_issuer_url(issuer_url, 60, "example-app")
token                  // access token
iss                    // issuer url
exp                    // expiration time

token_response = agent.get_token_response_by_issuer_url(issuer_url, 60, "example-app")
token_response[0]      // access token
token_response[1]      // issuer url
token_response[2]      // expiration time
```

##### Example
A complete example can look the following:
```python
token, iss, exp = agent.get_token_response_by_issuer_url("https://example.com", 60, "example-app")
print("Access token is: {}".format(token))
print("Access token issued by: {}".format(iss))
print("Access token expires at: {}".format(exp))
```

`


text:
# parse-server-push-adapter

[![Build
Status](https://travis-ci.org/parse-server-modules/parse-server-push-adapter.svg?branch=master)](https://travis-ci.org/parse-server-modules/parse-server-push-adapter)
[![codecov.io](https://codecov.io/github/parse-server-modules/parse-server-push-adapter/coverage.svg?branch=master)](https://codecov.io/github/parse-server-modules/parse-server-push-adapter?branch=master)
[![NPM Version](https://img.shields.io/npm/v/parse-server-push-adapter.svg?style=flat-square)](https://www.npmjs.com/package/parse-server-push-adapter)

Official Push adapter for parse-server

See [parse-server push configuration](https://github.com/ParsePlatform/parse-server/wiki/Push)

### see more logs

You can enable verbose logging with environment variables:

```
VERBOSE=1

or

VERBOSE_PARSE_SERVER_PUSH_ADAPTER=1
```

This will produce a more verbose output for all the push sending attempts

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Packman
[![Django CI](https://github.com/Pack144/packman/actions/workflows/django.yml/badge.svg)](https://github.com/Pack144/packman/actions/workflows/django.yml)
[![CodeQL](https://github.com/Pack144/packman/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/Pack144/packman/actions/workflows/codeql-analysis.yml)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

A Cub Scout pack management web application, written in Python and Django

## Features
* Membership management - complete with address book for keeping track of things
  such as phone numbers and addresses.
    * Parents
    * Scouts
    * Friends of the Pack
* Den Assignments - so you know what cubs belong to which den.
* Committee assignments - Cubs aren't the only ones who get to have all the fun. A
  well run pack has lots of parent involvement.
* Calendar of Events - Always know when the next Pack Meeting, Community Service event,
  or Den Meeting is scheduled.
* Documents Repository. So you have a secure place to make files available to members
  of the pack.
* Dynamic content, manageable through Django's built-in admin frameworks.

## Why this app?
Packman was written specifically for the purpose of managing Cub Scout Pack 144,
a pack based in Seattle, WA.  We are the oldest and one of the largest Cub Scout
Pack in the state of Washington.  We like to do things our way, but that doesn't mean
that what we do doesn't work for your pack.  We built this for ourselves, but we are
sure that there's use for other packs out there too.

Being a pack headquartered in a tech-heavy community in the Pacific Northwest, naturally
we wanted to have a website that we could adapt for our own specific needs.
At the same time, not all of our pack members are tech savvy and we need to ensure that
the frameworks we put in place with our web app are accessible to everyone in the pack.
We chose the Django framework because it is highly flexible, maintainable, and most
importantly understandable.  That means that even members who do not live web development
day to day should be able to pick it up and continue to maintain the site.

## How do I get started?
As with any Python and Django project, it is highly recommended that you install
Packman in its own virtual environment. You can choose which virtual environment
you want to use. Both pip and pipenv files are provided for installing project
requirements.

To begin using virtual environments, we'll use pipenv. Install using your favorite
package manager or use pip that ships with Python.
```
pip install --user pipenv
```

Once Pipenv is installed, clone this repository and create your virtual environment
```
git clone git@bitbucket.org:pack144/packman.git
cd packman
pipenv install
```

Once you have the project downloaded and a virtual environment running you can set
up Packman for your own needs. Many of the project settings are available in
`config/settings.py`. Adjust them there or, to have your own settings that are
not overridden by source updates, create a separate `.env`
file and put your custom settings there. Anything made in this file will overwrite
the project settings file. Use this to configure your own database, secret key,
email, etc.

After you've updated the settings for your own environment, it's time to populate
the database and run Django.
```
pipenv shell

python manage.py migrate

python manage.py runserver
```

## Requirements
Review the included requirements.txt for detailed package requirements.  Our
application is using:

* [Python 3.6](https://python.org)
* [Django 3.2](https://djangoproject.com)
* [Yarn](https://yarnpkg.com/)

branch_name: refs/heads/main

gha_language: Python

gha_license_id: MIT


text:
# @vime/rollup-example

This example simply demonstrates how to bundle Vime (`@vime/core`) using [Rollup](https://rollupjs.org). The
example is here for you to play with, but all you need to do is `import` whatever components and
there dependencies you need into your project, and define them in the custom elements registry. There
are no additional steps required (see [`src/index.js`](./src/index.js)).

## Usage

```bash
$: git clone https://github.com/vime-js/vime --depth=1

$: cd vime/examples/rollup

$: npm install

$: npm run dev
```

repository: vime-js/vime

gha_language: TypeScript

repo_name: vime-js/vime


text:
---
layout: feature
title: 'Person[obj]'
shortdef: 'person agreement with object'
udver: '2'
---

The Yupik transitive verb inflects for the person (and number) of object. If object is provided as a separate noun, it agrees with the verb ending in person (and number).

### `1`: first person object

#### Examples
* [ess] _Aghnalqwaaghem ungipaataanga an'gighniluten._ "The old woman told me you had played outside." The verb ending _-anga_ `Number[obj]=Sing|Person[obj]=1` in _ungipaataanga_ "she told me" encodes that the object is first person singular ("me").

### `2`: second person object

#### Examples

* [ess] _Esghaghlleqamken._ "I will see you." The verb ending _-mken_ `Number[obj]=Sing|Person[obj]=2` in _Esghaghlleqamken_ encodes that the object is second person singular ("you").

### `3`: third person object

#### Examples

* [ess] _Neghaqa perara ellnginaan._ "I ate the meat aspic only." The verb ending _qa_ `Person[obj]=3` in _neghaqa_ agrees with the object _perara_ "meat aspic" in person.

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

gha_language: HTML

repo_name: UniversalDependencies/docs


text:
# Elastic Beanstalk middleware for Laravel and HTTPS
This middlware will ensure that your Laravel app will correctly recognise **secure** requests when running on Elastic Beanstalk with a Load Balancer.
**NOTE:** make sure your web server is not publicly accessible and that the Load Balancer only have access (you can manage that through AWS security groups).

There is also a [gist](https://gist.github.com/peppeocchi/4f522663d7e88029daeba833c835df3d) that does the exact same thing.

## Installation
You can install this middleware through [Composer](https://getcomposer.org/)
```
composer require peppeocchi/laravel-elb-middleware
```

## Usage
The simplest way to use the middleware is to add it as a global middleware in `app/Http/Kernel.php`
```php
...
class Kernel extends HttpKernel
{
    /**
     * The application's global HTTP middleware stack.
     *
     * These middleware are run during every request to your application.
     *
     * @var array
     */
    protected $middleware = [
        \Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode::class,
        \GO\ElasticBeanstalkHttps::class
    ];
...
```
but you are free to add it to a middleware group or directly into your controllers.

### TL;DR
On Elastic Beanstalk (with a load balancer), all the requests are being "proxied" to port 80. The load balancer will add the `x-forwarded-*` headers to the request.

Laravel `Request` inherits from `Symfony\Component\HttpFoundation\Request`, so it already supports the `x-forwarded-*` headers, but it needs to be configured to look at those headers or you are going to get incorrect informations about the request (eg. `$request->isSecure()` will always return false).

The Amazon ELB don't have a static IP or a range to target, so you'll need to trust all proxies.
Of course you need to make sure your web server will respond only to the [load balancer](http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.managing.elb.html).

#### Read also
[Symfony documentation](https://symfony.com/doc/current/request/load_balancer_reverse_proxy.html)

repository: peppeocchi/laravel-elb-middleware

gha_language: PHP

repo_name: peppeocchi/laravel-elb-middleware


text:
Teca
====

A simple static -and configurable- image gallery generator.

DISCLAIMER
==========
IT'S A F**KIN' ALPHA, SO IT COULD DIVIDE BY ZERO AND DESTROY THE LIFE AS WE KNOW IT.
also, Teca code could be heavily modified very fast.
I told ya man, keep an eye on what you're doing.

Installation and Usage
===
```sh
git clone https://github.com/alfateam123/Teca.git
cd Teca
python teca.py $screenshots_folder
echo "Thank you for using Teca"
```

Remove the gallery
==
```sh
python clean.py $screenshots_folders
echo "Thank you for using Teca"
```

Configuration
===
it's all in the cfg.json file.
See Configuration.md file for every information you may need.

Dependencies
===
* Jinja2 (from the Cheese Shop or github)
* optparse (stdlib)

In order to generate thumbnails, you can choose between
* Pillow (from the Cheese Shop or github)
* PIL (from PythonWare website)
In 29 dec 2013 Teca officially supported Pillow: now both PIL and Pillow can be used.
In the log, you can read why:
```
<Robertof> alfateam123
<Robertof> :: Vuoi sostituire python2-imaging con community/python2-pillow? [S/n] s
<Robertof> io faccio y
<alfateam123> Robertof: massì, prova
<alfateam123> sostituisci
<Robertof> già fatto alfateam123
<alfateam123> lol
```

TODO
===
* refactor Teca
* [STARTED] write configuration documentation
* do a stylesheet. or at least, build a better UI.
* [DONE] Support UTF-8

repository: winterthediplomat/Teca

repo_name: winterthediplomat/Teca


text:
{{{
"title": "Marketplace Updates March 2017",
"date": "03-31-2017",
"author": "Brandy Smith",
"attachments": [],
"contentIsHTML": false
}}}

The [Lumen Marketplace](https://www.ctl.io/marketplace/) provides self-service, on-demand provisioning of provider services on the Lumen Platform. Below are the current products available in the Marketplace. The Marketplace is constantly evolving with more products, providers, and offerings. Check the Marketplace Updates for the latest Marketplace offerings. If you would like to join the Lumen Cloud Marketplace Provider Program, you can learn more [here](https://www.ctl.io/marketplace-program/).

Products added to the Lumen Marketplace March 2017 include:

* [Alert Logic Log Manager with ActiveWatch](https://www.ctl.io/marketplace/partner/PST/product/Alert%20Logic%20Log%20Manager%20with%20ActiveWatch/)

* [Alert Logic Threat Manager with ActiveWatch](https://www.ctl.io/marketplace/partner/PST/product/Alert%20Logic%20Threat%20Manager%20with%20ActiveWatch/)

* [Vormetric Transparent Encryption - DSM 10](https://www.ctl.io/marketplace/partner/VRSJ/product/Vormetric%20Transparent%20Encryption%20-%20DSM%2010/)

* [Vormetric Encryption Agent](https://www.ctl.io/marketplace/partner/VRSJ/product/Vormetric%20Encryption%20Agent/)

repository: AnthonyHakim/PublicKB

path: /Marketplace/Marketplace Updates/Marketplace Updates March 2017.md

filename: Marketplace Updates March 2017.md

gha_license_id: NOASSERTION

repo_name: AnthonyHakim/PublicKB


text:
---
layout: "unit"
title: "Guide Entry 06.04.01"
path: "/curriculum/guides/2006/4/06.04.01.x.html"
unitTitle: "Gingerbread Architecture: An Exploration of Architecture and Engineering"
unitAuthor: "Jennifer Esty"
keywords: ""
recommendedFor: "Recommended for Science, grade 8."
---

Guide Entry to 06.04.01:

In this unit students will combine math, technology and art in the creation of gingerbread houses. Students will use math and basic engineering skills to test various gingerbread house building materials for strength and other important building characteristics. Students will also study various building techniques and the materials to which they have been applied throughout human history. Using information gained from these two exercises, students will design and construct gingerbread houses.

This unit will be very good for a class with many different types of learners. It will have strong visual elements to it, but it will also have a very kinesthetic aspect to it as well as spatial and mathematical elements. Because of the many skills required, this unit will lend itself well to a class that can work in small teams. All of the projects involved in this curriculum unit could be accomplished by individuals, but most of them could also be done in small groups or teams.

(Recommended for Science, grade 8.)


text:
# Request Counter

`Request Counter` application - Go HTTP server that on each request responds with a counter of the total number of requests that it has received during the last time period (could be configurable).
`Request Counter` can store it's data in memory only or persist it to a file.

`Request Counter` stores counts into intervals (buckets). Each of them represent particular time interval.

Intervals are sored in a ring.

First two uint64 values in data are metainfo:
  * Current position in the ring
  * Time of first access of interval on current position

## HTTP interface

To get request count execute next `curl` command:
```
curl http://localhost:8080/requestcount
```

GET `/requestcount` return json:
```
{
    "count":3
}
```

## Installation

To install `Request Counter` application `glide` (https://github.com/Masterminds/glide) package manager must be installed.

To build `Request Counter` you can just execute:
```
make
```

To run tests:
```
make test
```

To run the application:
```
./requestcounter -config config-file.yaml
```

## Configuration

```
# address to listen on
host: <IP_ADDRESS>

# port to listen on
port: 8080

# logging lever, could be: error, warning, info, debug
log-level: error

# count of intervals (buckets)
interval-count: 100

# duration of each interval
interval-duration: 600ms

# persist data to a file or store in memory
persistent: true

# file name where data will be persisted
filename: /tmp/reqcnt.dat

# flush data to a file time interval
persist-duration: 5s
```

See `example-config.yaml`.

## Limitations
 - `Request Counter` would not return correct values if config values `interval-count` or `interval-duration` were changed before restart.

## TODO
 - Add more unit and functional tests


text:
# @aftermark/funcdafy

## What it is
This plugin can be used to apply classes to HTML elements using a "class map".

## Class map
A class map is a JSON or YAML file that

```yml
[Example of a class map]
```

When this map is applied to this HTML:
```html
```

It produces this output:
```html
```

## Why you'd use it

repository: aftermark/aftermark

gha_language: JavaScript

repo_name: aftermark/aftermark


text:
# Setup

Details and notes about the build process and setup

## Stop building on prepublish when running npm install locally

```
"prepublish": "in-publish && npm run build || not-in-publish",
```

See https://www.npmjs.com/package/in-publish and https://medium.com/greenkeeper-blog/what-is-npm-s-prepublish-and-why-is-it-so-confusing-a948373e6be1#.u5ht8hn77

## Vendored axios

`index.js` is the entry point for the node.js package, and it requires a vendored version of Axios from the [contentful-sdk-core](https://github.com/contentful/contentful-sdk-core) package.

`browser.js` is the entry point for the CommonJS package when required from a browser aware environment (webpack or browserify) and for the standalone `browser-dist` build which is generated with webpack. This version requires a different vendored version of Axios which contains no code that isn't necessary for browsers.


text:
{% set title = "Implement a New Feature" %}
{{ title }}

<frontmatter>
  title: "{{ title }}"
  layout: devGuide.md
  pageNav: 3
</frontmatter>

# {{ title }}

Creating a new feature makes MarkBind more useful and powerful. This section will guide you through the process of implementing a new feature.

## TLDR

- [ ] Feature proposal
- [ ] Design & iterate
- [ ] Add tests & update documentation
- [ ] Create PR & Follow up with the reviews

## Feature Proposal
Creating a new feature starts with a feature proposal. This can come from you, or from a user who has requested a new feature in the [issue tracker](https://github.com/MarkBind/markbind/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22c.Feature+%F0%9F%9A%80%22). At this stage, the feature proposal should be discussed extensively to ensure that the feature is well-defined and that it is something that MarkBind should support. There are also enhancements to existing features that can be proposed (see [here](https://github.com/MarkBind/markbind/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Ac.Enhancement)) and worked on.

In this part, we will be mentioning a few completed PRs as examples of how a feature was implemented. You can use them as a reference to get a better idea of how a feature is implemented.

<box type="info" seamless>

[Issue #983](https://github.com/MarkBind/markbind/pull/983) is an example where a proposed feature was worked on in [PR #985](https://github.com/MarkBind/markbind/pull/985) but later closed due to a potential lack of user value.
</box>

## Design & Iterate
When there is consensus on the feature proposal, we can start designing the feature. This involves understanding how MarkBind works and how a feature can be implemented. In the broadest sense:
- Additional Markdown-like syntax can be added by tapping into [markdown-it](https://github.com/markdown-it/markdown-it) which does Markdown parsing and rendering.
  - e.g. [issue #900](https://github.com/MarkBind/markbind/issues/900) and [PR #1657](https://github.com/MarkBind/markbind/pull/1657)
- Dynamic components can be created via [Vue.js](../development/writingComponents.html#writing-components).
  - e.g. [issue #898](https://github.com/MarkBind/markbind/issues/898) and [PR #1858](https://github.com/MarkBind/markbind/pull/1858)
- Creating default or optional plugins can be done with our [plugin system](../development/writingPlugins.html).
  - e.g. [issue #1754](https://github.com/MarkBind/markbind/issues/1754) and [PR #1824](https://github.com/MarkBind/markbind/pull/1824)
- And more!
  - e.g. [issue #1946](https://github.com/MarkBind/markbind/issues/1946) and [PR #1947](https://github.com/MarkBind/markbind/pull/1947)

## Add Tests & Update Documentation

_(Same as what we mentioned in the previous task)_

By this time, you should have a good idea about how tests and documentation are written. Where possible, unit tests should also be added to ensure that the feature works as expected. Utilizing the new feature in our documentation is also encouraged so that we can get a better idea of how the feature can be used.

<box type="important" light>

When adding intra-site links, use tags to differentiate between the deployment environment when appropriate, as mentioned in [Adding Intra-Site Links to Documentation](/devGuide/development/workflow.html#adding-intra-site-links-to-documentation)!

</box>

## Create PR & Follow up with the Reviews

_(Same as what we mentioned in the previous task)_

<include src="contributeToDocs.md#pr-steps" />

For features, it is also crucial to get early feedback on implementation details. This is because some considerations may need to be exercised when introducing new user-facing syntax. Another problem is that the implementation may not be the most appropriate or straightforward one, sometimes due to how existing code is structured.

<box type="info" seamless>

[Issue #1475](https://github.com/MarkBind/markbind/issues/1475) is an example where the work in [PR #1988](https://github.com/MarkBind/markbind/pull/1988) involved changing the implementation midway.
</box>

## Summary
In this part, we have reviewed the steps to implement a new feature. Working on a new feature can be a daunting task, but it is also very rewarding to own a feature from start to finish.

Here are some additional tasks for you to try out:
- [ ] Look through the mentioned PRs and try to understand how the features were implemented.
- [ ] Look through the issue tracker and see if there are any features that you would like to work on.

And...that's it!:rocket::rocket::rocket:

You have completed the bootcamp! Take a well-deserved rest and we look forward to your contributions!

{% from "njk/common.njk" import previous_next %}
{{ previous_next('fixABug', '../development/settingUp') }}

repository: MarkBind/markbind

repo_name: MarkBind/markbind


text:
### Colors
[Generated using coolors.co, a must try tool](https://coolors.co)

### Landing Page

[Man vector created by upklyak - www.freepik.com](https://www.freepik.com/vectors/man)

### 404 Page

[404 - Page Not Found by  Chas Turansky](https://dribbble.com/shots/5905597-404-Page-Not-Found?utm_source=Clipboard_Shot&utm_campaign=chasturansky&utm_content=404%20-%20Page%20Not%20Found&utm_medium=Social_Share)


text:
# MRS6xxx Timing
## Timing between Layers
The layers are taken up by the scanner in packs of 6. The scanner delivers at an output data rate of 10 Hz and 24 layers 24/6*10=40 scan packets of 6 layers per second. The following table shows an example of the timing for a complete 24 layer recording

|Raw Time /µs|Delta Time /µs|Elevation Angle /Deg|
|----------|:-------------:|------:|
|2551706348|0|13.19
|2551706348	|0	|12.565
|2551706348	|0	|11.940
|2551706348	|0	|11.315
|2551706348	|0	|10.690
|2551706348	|0	|10.065
|2551731348	|25000	|9.440
|2551731348	|25000	|8.815
|2551731348	|25000	|8.190
|2551731348	|25000	|7.565
|2551731348	|25000	|6.940
|2551731348	|25000	|6.315
|2551756348	|50000	|5.690
|2551756348	|50000	|5.065
|2551756348	|50000	|4.440
|2551756348	|50000	|3.815
|2551756348	|50000	|3.190
|2551756348	|50000	|2.565
|2551781348	|75000	|1.940
|2551781348	|75000	|1.315
|2551781348	|75000	|0.690
|2551781348	|75000	|0.065
|2551781348	|75000	|-0.560
|2551781348	|75000	|-1.185
|NEW SCAN|
|2551807862|	101514|	13.190
|2551807862|	101514|	12.565
|2551807862|	101514|	11.940
|2551807862|	101514|	11.315
|2551807862|	101514|	10.690
|2551807862|	101514|	10.065
|2551832862|	126514|	9.440

## Jitter
The time stamps between the layers are interpolated by the scanner. The time stamps of the first layer (Ang.=13.19°) are measured and show jitter accordingly.
The jitter of the time stamps of the first layer was measured and is shown in the following fig.

![mrs6xxx_jitter_002](mrs_6xxx_timing.png)

In the spectrogram of the sound generated by the scanner, an amplitude modulation appears (e.g. at 6 kHz Band) that roughly matches the fluctuation of the scanning frequencies, compare the following figure.
![mrs6xxx_audio](mrs6xxx_audio_fft.jpg)


text:
### [Unreleased][unreleased]

### [0.3.6] - 2015/08/06

##### Added

- Better error handling in case of CA certificate error with Luasocket.
- Port number in addition to host in socket errors.

##### Fixed

- Shuffling of contact points array.

### [0.3.5] - 2015/07/15

##### Added

- Expose consistency and batch types constants in `cassandra`.
- Better SSL handshake error handling.

### [0.3.3] - 2015/07/14

##### Fixed

- Binary protocol v3 accidentally used v2 encoding methods.
- Startup message accidentally being sent for already established connections (with reusable sockets).

### [0.3.0] - 2015/07/07

##### Added

- Support for SSL encryption (client/server).

##### Fixed

- IPv6 addresses encoding.

### [0.2.0] - 2015/07/07

##### Added

- Support for authentication (Password Authenticator).

### 0.1.0 - 2015/07/03

Initial release. Forked from jbochi/lua-resty-cassandra v0.5.7 with some additional features and bug fixes.

##### Added

- Support for both binary protocols v2 and v3.

##### Changed

- More friendly support of auto pagination. THe loop doesn't require as many parameters.
- OOP style in order to support both binary protocols. `cassandra.new()` must now be called with `:`.

##### Fixed

- `set_keyspace` erroring on names with capital letters.

[unreleased]: https://github.com/thibaultCha/lua-cassandra/compare/0.3.6...HEAD
[0.3.6]: https://github.com/thibaultCha/lua-cassandra/compare/0.3.5...0.3.6
[0.3.5]: https://github.com/thibaultCha/lua-cassandra/compare/0.3.3...0.3.5
[0.3.3]: https://github.com/thibaultCha/lua-cassandra/compare/0.3.0...0.3.3
[0.3.0]: https://github.com/thibaultCha/lua-cassandra/compare/0.2.0...0.3.0
[0.2.0]: https://github.com/thibaultCha/lua-cassandra/compare/0.1.0...0.2.0

repository: smanolache/lua-cassandra

repo_name: smanolache/lua-cassandra


text:
# kata-java-fizzbuzz
[TDD Kata Fizzbuzz](http://codingdojo.org/kata/FizzBuzz/) implemented in Java. It is one of the easiest TDD katas, which makes it very good for learning.

1. I implemented it following [baby steps](http://codingdojo.org/BabySteps/) which can be seen in the [commit list](https://github.com/matiastripode/kata-java-fizzbuzz/commits/master)
2. Of course using the TDD cycle: Red ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) --> Green ![#c5f015](https://placehold.it/15/c5f015/000000?text=+) --> Refactor

1. **Music** to keep you in the zone [radio de x-team](https://radio.x-team.com/)

## References
### In English
- [Adrian Bolboaca](https://blog.adrianbolboaca.ro/) blog with tons of good quality videos doing TDD.

### In Spanish
- [Diseño ágil con TDD](https://uniwebsidad.com/libros/tdd)
- [10 Pines University](https://university.10pines.com/webinars_and_videos)

## Authors

* **Matias Tripode** - *Initial work* - [My profile in Linkedin](https://www.linkedin.com/in/matiastripode/)

## License

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

## Acknowledgments

* [Hernan Wilkinson](https://www.linkedin.com/in/hernanwilkinson/) and [10pines](https://university.10pines.com/webinars_and_videos) for sharing such amazing knowledge

repository: matiastripode/kata-java-fizzbuzz

gha_language: Java

repo_name: matiastripode/kata-java-fizzbuzz


text:
#Open Registry

##What is OpenRegistry?
OpenRegistry is an OpenSource Identity Management System (IDMS). It's a place for data about people
affiliated with your organization.

##Core Functionality
* Interfaces for web, batch, and real-time data transfer
* Identity data store
* Identity reconciliation from multiple systems of record
* Identifier assignment for new, unique individuals

##Why OpenRegistry?
* "Off the shelf" solutions usually end up requiring significant customizations and integration work and/or solve only a portion of an institution's needs
* Lots of institutions still rolling their own
* Combined institutional efforts better leverage scant resources and allow for learning from others' experience (eg: Sakai, uPortal, CAS, Shibboleth, Kuali)
* OpenRegistry is tailored to the needs of higher education

##Building OpenRegistry using Maven2
Building OpenRegistry via the Maven2 system is simple. From within the PROJECT_HOME directory, execute the following command:

`mvn clean package install`

##Generating the DDL for YOUR database

`mvn hibernate3:hbm2ddl`

##For More Information

[Open Registry Wiki Home](https://wiki.jasig.org/display/ORUM/Home)

repository: nazeersyed/openregistry

repo_name: nazeersyed/openregistry


text:
# Using Imports

If there is a collision of names among your entities, you may use `Import` so you do not need to use their full name on queries.

You can also use imports to query returns to classes.

```csharp
using Castle.Framework;

[ActiveRecord, Import(typeof(OrderSummary), "summary")]
public class Order : ActiveRecordBase
{
    // omitted for clarity
}

public class OrderSummary
{
    private float value;
    private int quantity;

    public float Value
    {
        get { return value; }
        set { this.value = value; }
    }

    public int Quantity
    {
        get { return quantity; }
        set { quantity = value; }
    }
}
```

repository: ArionWM/ActiveRecord

repo_name: ArionWM/ActiveRecord


text:
---
hrs_structure:
  division: '1'
  volume: '4'
  title: '13'
  chapter: 209E
  section: '209E-4'
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0209E-0004
    parent: HRS0209E
    name: 209E-4 Enterprise zone designation
weight: 30020
title: Enterprise zone designation
full_title: 209E-4 Enterprise zone designation
---
**§209E-4 Enterprise zone designation.** (a) The governing body of any county may apply in writing to the department to have an area declared to be an enterprise zone. The application shall include a description of the location of the area or areas in question, and a general statement identifying proposed local incentives to complement the state and any federal incentives.

(b) The governor, upon the recommendation of the director, shall approve the designation of up to six areas in each county as enterprise zones for a period of twenty years. Any such area shall be located in one United States census tract or two or more contiguous United States census tracts in accordance with the most recent decennial United States Census. The census tract or tracts within which each enterprise zone is located also shall meet at least one of the following criteria:

(1) Twenty-five per cent or more of the population have incomes below eighty per cent of the median family income of the county; or

(2) The unemployment rate is 1.5 times the state average. [L 1986, c 78, pt of §1; am L 1989, c 390, §2; am L 1993, c 341, §2; am L 1995, c 91, §3; am L 1997, c 262, §2; am L 2009, c 174, §3]

Attorney General Opinions

Act 262, L 1997, did not require city and county to offer county-level incentives to qualified businesses in new enterprise zone created legislatively by the Act. Att. Gen. Op. 98-1.

If extending survey and reporting requirements to new enterprise zone (EZ) created by the legislature would result in an increase in the level of service under city and county's existing program, then, unless department was willing to share in the cost, city and county was not required to submit initial survey or annual report on new EZ. Att. Gen. Op. 98-1.

Qualified businesses located in new enterprise zone (EZ) would be eligible for state tax incentives for seven-year period set forth in §§209E-10(a) and 209E-11, although a portion of that seven-year period extended beyond new EZ's five-year sunset date. Att. Gen. Op. 98-1.

Where legislature designated agricultural lands in Waialua district as an enterprise zone (EZ) in Act 262, L 1997, existing EZ at Waialua-Haleiwa was not affected because it was established prior to December 31, 1996, the retroactive effective date of the Act. Att. Gen. Op. 98-1.

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
> **WARNING:** This repository is a proof-of-concept implementation of a Windows runtime for NativeScript that we **no longer maintain**.

# NativeScript Runtime for the Universal Windows Platform

The NativeScript Runtime allows [Windows Runtime](https://en.wikipedia.org/wiki/Windows_Runtime) APIs to be called from JavaScript. It is similar to the [JavaScript bridge](https://msdn.microsoft.com/en-us/library/hh710230%28v=vs.94%29.aspx?f=255&MSPPError=-2147217396) that Microsoft provides, but also allows XAML UI controls to be instantiated. This way NativeScript UWP apps are truly native, instead of being HTML based.

At the moment, the runtime is in a **proof of concept** stage - it only allows calling of methods with primitive types. Things like inheritance, generics, exception handling, asynchronous tasks and advanced marshalling/projections are further to be developed.

## Building and Running

Make sure you meet the following requirements:
* [Windows 10](https://www.microsoft.com/windows/)
* [Visual Studio 2015](http://www.visualstudio.com/products/visual-studio-community-vs)
* [CMake 3.4](http://www.cmake.org/download/)
* [Python 2.7](https://www.python.org/downloads/windows/)
* [Ruby 2](http://rubyinstaller.org/downloads/)
* [Perl 5](http://www.activestate.com/activeperl/downloads)
* [Bison 2.4](http://gnuwin32.sourceforge.net/packages/bison.htm#download)
* [Gperf 3](http://gnuwin32.sourceforge.net/packages/gperf.htm#download)

Clone the repo (this could take several hours):
```shell
git clone --recursive git@github.com:NativeScript/windows-runtime.git
```

Generate a Visual Studio solution:
```shell
mkdir Build
cd Build
cmake ../Source -DCMAKE_SYSTEM_NAME="WindowsStore" -DCMAKE_SYSTEM_VERSION="10.0" -G"Visual Studio 14"
```
> Use the `"Visual Studio 14 ARM"` generator to create a project compatible with ARM devices.

**Open the newly created NativeScript solution and run the TestRunner project to see the ["Hello, World!"](Source/TestRunner/app/index.js) app in action.**

## Contributing

Please read through our [contributing guidelines](CONTRIBUTING.md). Included are directions for opening issues, coding standards, and notes on development.

## Related Projects

* [Android Runtime](https://github.com/NativeScript/android-runtime)
* [iOS Runtime](https://github.com/NativeScript/ios-runtime)

## License
[Apache 2.0](LICENSE)

repository: nstudio/windows-runtime

repo_name: nstudio/windows-runtime


text:
---
uid: crmscript_ref_NSQuoteLine_GetStatus
title: Integer GetStatus()
intellisense: NSQuoteLine.GetStatus
keywords: NSQuoteLine, GetStatus
so.topic: reference
---

# Integer GetStatus()

If there was a problem with for instance calculation, this field is set to warning or error. Typically shown as an icon. QuoteStatus is an enum with statuses: OK, OKWithInfo, Warning, Error.

**Returns:** Integer

     - Enum: 0 = Ok
     - Enum: 1 = OkWithInfo
     - Enum: 2 = Warning
     - Enum: 3 = Error

```crmscript
NSQuoteLine thing;
Integer status  = thing.GetStatus();
```

repository: stianol/crmscript

repo_name: stianol/crmscript


text:
# CloverBootloader forked by n-d-k [![Build Status](https://travis-ci.org/n-d-k/CloverBootloader.svg?branch=master)](https://travis-ci.org/n-d-k/CloverBootloader)

Bootloader for macOS, Windows and Linux in UEFI and in legacy mode

This github project is a fork of the Clover bootloader/boot manager from https://github.com/CloverHackyColor/CloverBootloader

repository: n-d-k/CloverBootloader

repo_name: n-d-k/CloverBootloader


text:
---
layout: post
title: Silverlight Animation Part 3: Opacity
tags: csharp silverlight
---

Time to extend our burgeoning framework with the ability to programmatically
animate an items opacity. It's pretty quick and I hope easy to follow
code, we're not using key frames or any splines to animate this, just a
simple linear animation. Here's the code.

``` csharp
public class OpacityAnimation : AnimationBase
{
    public static TimeSpan DefaultDuration = TimeSpan.FromMilliseconds(750);

    public OpacityAnimation(double opacity)
        : this(opacity, DefaultDuration)
    {

    }

    public OpacityAnimation(double opacity, TimeSpan duration)
    {
        Opactity = opacity;
        Duration = duration;
    }

    public double Opactity
    {
        get;
        private set;
    }

    public TimeSpan Duration
    {
        get;
        private set;
    }

    protected override Storyboard CreateStoryboard()
    {
        var storyboard = new Storyboard();

        var opacityAnimation = new DoubleAnimation();

        Storyboard.SetTargetProperty(opacityAnimation, new PropertyPath("(FrameworkElement.Opacity)"));

        storyboard.Children.Add(opacityAnimation);

        return storyboard;
    }

    protected override void ApplyValues(Storyboard storyboard)
    {
        if(storyboard == null)
            throw new ArgumentNullException("storyboard");

        var opacityAnimation = storyboard.Children[0] as DoubleAnimation;

        opacityAnimation.To = Opactity;
        opacityAnimation.Duration = Duration;
    }
}
```

Now that we have that in place we can put together four very useful extension methods.

``` csharp
public static void FadeOut(this FrameworkElement element)
{
    element.Fade(0.0);
}

public static void FadeIn(this FrameworkElement element)
{
    element.Fade(1.0);
}

public static void Fade(this FrameworkElement element, double opacity)
{
    new OpacityAnimation(opacity).Apply(element);
}

public static void CrossFade(this FrameworkElement elementToFadeOut, FrameworkElement elementToFadeIn)
{
    FadeOut(elementToFadeOut);
    FadeIn(elementToFadeIn);
}
```

And here's the code to the example which you can find at "[Silverlight Animation Examples](/examples/animation)".

``` csharp
if(leftFadedOut)
{
    Right.CrossFade(Left);
}
else
{
    Left.CrossFade(Right);
}

leftFadedOut = !leftFadedOut;
```


text:
Nox
===

__This style is compatible Textual 5.0 and above__

Nox (Style for the Textual IRC Client)
Based on [Whisper Dark, by Shamil Nunhuck](https://github.com/shamil-nunhuck/textual-whisper-dark)

__Instructions to install (Textual 5+):__
1.  Download the files via Git or the download button to the right.
2.  Copy the downloaded folder to _~/Library/Group Containers/8482Q6EPL6.com.codeux.irc.textual/Library/Application Support/Textual/Styles/_
3.  Open Preferences in Textual and select __Channel View__ in the list to the left.
4.  Select __"Nox"__ in the style list.

![Image of the style](http://alientube.co/nox.jpg)

repository: SuperManifolds/nox

repo_name: SuperManifolds/nox


text:
---
layout: post
title:  "The Appdome Way of Using Make"
subtitle: "Multi-platform Building with Make"
date:   2018-02-15
author: Lior Halphon
---

Appdome's build system is quite complex – it must build dozens of modules (each with its own quirks and compilation flags) on three platforms (Android and two iOS “flavors”), while avoiding code duplication and keeping development as easy as possible. In this article, we'll recreate a similar (yet simpler) `make`-based build system that can create both 64-bit dynamic libraries that runs on both macOS and iOS using a single codebase, without having to run `./configure`-like scripts or `make clean` to switch targets.

## Build System Requirements

For our build system, we have several requirements:

 * Can compile for several targets
   * Adding new targets should be easy
 * It should be easy to determine which files are compiled for which target simply by looking at the file tree
 * It should be possible to make specific files and modules only compile for specific targets
 * It should be possible to add module-specific flags
 * Auto `.h` dependency generation

## Design

Now that we have our requirements down, we can design our build system. To support several targets without having the intermediates conflict with each other, we'll save them to `build/<target>/path/to/file.c.o`. The flags (and if we ever need to, the toolchain paths) will be specified in an included `.mk` file, which will include both common and platform-specific flags. Adding a new platform target should be as easy as adding it to a platform list and adding the correct platform-specific flags.

To make the source tree obvious, we'll make it so *every* source file in the repository gets compiled, so you never have to manage an ever-growing list of source files. We'll use prefixes to filter target-specific files, so files and folders starting with `ios_` won't compile and link into the macOS version, and vice-versa.

To have module-specific flags, we'll define a module as a folder, and let each folder have an optional `module.mk` file that can define module-specific flags.

And finally, for auto dependencies, we can use the built-in compiler features to generate `.dep` files. We will have to generate a `.dep` file per source file *per target*, because different targets can have different flags and defines that can affect dependencies.

## Implementation

So now we can start actually implementing our build system. In order to avoid a huge single `Makefile`, we'll split it into several smaller files:

 * `Makefile` – Includes everything else and provide some basic `make` setup
 * `utils.mk` – Defines useful `make` macros
 * `conf.mk` – Defines defaults to build configurations, such as the build path or using optimization levels
 * `flags.mk` – Defines both the global and the per-target compilation and linkage flags
 * `rules.mk` – Defines the compilation rules for our source files
 * `targets.mk` – Handles defining the correct dependencies for each platform/target

Let's dive into the contents of these files!

### Makefile

```bash
.PREFIXES:
.SUFIXES:
.SECONDARY:
.DELETE_ON_ERROR:

PLATFORMS := ios mac
all: $(PLATFORMS)
.PHONY: all $(PLATFORMS) clean

include utils.mk
include conf.mk

# Prevent make clean from doing anything else (such as generating .dep files)
ifneq ($(MAKECMDGOALS),clean)
include flags.mk
include rules.mk
include targets.mk
endif

clean:
-@rm -rf $(BUILD_PATH)
```

This file is pretty simple – the first few lines disable several unwanted `make` behaviors such as implicit rules. Then, we define our platforms, define `all` to build all platforms, and define all phony targets as such. Then, we include the rest of the files, and finally, define the `clean` rule.

### utils.mk
```
CURRENT_MODULE = $(firstword $(subst /, ,$<))
AUTO_MKDIR = @mkdir -p $(dir $@)
FILTER_OUT = $(foreach v,$(2),$(if $(strip $(foreach word,$(1),$(findstring $(word),$(v)))),,$(v)))
```

This file is relatively simple as well:

 *  `CURRENT_MODULE` operates by returning the name of the top folder of the first dependency in the current build recipe.
 *  `AUTO_MKDIR` is a simple rule that creates the required folders for the current target.
 *  `FILTER_OUT` is similar to the `make` built-in `filter-out`, but it filters out using substring matching instead of `make` patterns. For example, `$(call FILTER_OUT,a,Quack Duck)` will return `Duck`.

### conf.mk

 ```bash
 BUILD_PATH ?= build
 CONF ?= debug
 USE_AUTO_DEPS ?= true

 ifeq ($(CONF),release)
 DEBUG := false
 else ifeq ($(CONF),debug)
 DEBUG := true
 else
 $(error Unsupported CONF value)
 endif
 ```

 `conf.mk` can contain pretty much anything – debugging configuration, logging level and so on. For our example we'll have a single variable called `CONF` which can be either `release` or `debug`, and it shall enable or disable debug specific flags. Our `conf.mk` file will also set the default built path and the default value for `.dep` file generation.

### flags.mk

```bash
# Set up the toolchain. For out proposes, we'll use clang as CC, CXX and LD for all
# targets, but this can be easily modified.

CC := clang
CXX := $(CC)
LD := $(CC)

# CFLAGS   - Flags common to C and C++
# CCFLAGS  - Extra C exclusive flags
# CXXFLAGS - Extra C++ exclusive flags
# CCFLAGS_ios / CXXFLAGS_ios  - Effective flags used when compiling C/++ for ios
# CCFLAGS_mac / CXXFLAGS_mac  - Effective flags used when compiling C/++ for mac

CFLAGS :=
ifeq ($(DEBUG),true)
CFLAGS += -g
endif
CFLAGS += -Wall -Wextra
CFLAGS += -Werror
...
CFLAGS += -I.

ifeq ($(DEBUG),false)
CFLAGS += -DNDEBUG
CFLAGS += -O3
endif

IOS_SYSROOT ?= $(shell xcodebuild -sdk iphoneos -version Path 2> /dev/null)
CFLAGS_ios := $(CFLAGS)
CFLAGS_ios += -arch arm64
CFLAGS_ios += -DIOS_PLATFORM
CFLAGS_ios += -isysroot $(IOS_SYSROOT)
CFLAGS_ios += -miphoneos-version-min=9

MACOS_SYSROOT ?= $(shell xcodebuild -sdk macosx -version Path 2> /dev/null)
CFLAGS_mac := $(CFLAGS)
CFLAGS_mac += -arch x86_64
CFLAGS_mac += -DMAC_PLATFORM
CFLAGS_mac += -isysroot $(MACOS_SYSROOT)
CFLAGS_mac += -mmacosx-version-min=10.9

CCFLAGS += -std=gnu11

CCFLAGS_ios := $(CFLAGS_ios) $(CCFLAGS)
CCFLAGS_mac := $(CFLAGS_mac) $(CCFLAGS)

CXXFLAGS += -std=gnu++11
CXXFLAGS += -fpermissive
CXXFLAGS += -fno-rtti
CXXFLAGS += -fno-exceptions
CXXFLAGS += -stdlib=libc++

CXXFLAGS_ios := $(CFLAGS_ios) $(CXXFLAGS)
CXXFLAGS_mac := $(CFLAGS_mac) $(CXXFLAGS)

LDFLAGS := -shared
LDFLAGS += -framework Foundation

ifeq ($(DEBUG),true)
LDFLAGS += -g
endif

LDFLAGS_ios := $(LDFLAGS)
LDFLAGS_ios += -arch arm64
LDFLAGS_ios += -isysroot $(IOS_SYSROOT)
LDFLAGS_ios += -miphoneos-version-min=9
LDFLAGS_ios += -framework UIKit

LDFLAGS_mac := $(LDFLAGS)
LDFLAGS_mac += -arch x86_64
LDFLAGS_mac += -isysroot $(MACOS_SYSROOT)
LDFLAGS_mac += -mmacosx-version-min=10.9
LDFLAGS_mac += -framework AppKit

# Source files won't compile these targets if their names contain one or more of these strings
SOURCE_FILTER_ios := /mac
SOURCE_FILTER_mac := /ios

TARGET_ios := $(BUILD_PATH)/bin/ios/libsomething.dylib
TARGET_mac := $(BUILD_PATH)/bin/mac/libsomething.dylib
```

This file is a bit longer, but still quite straightforward. We specify our toolchain and various flags for each platform. Additionally, we define the `SOURCE_FILTER` and `TARGET` vars, which we'll use soon. Note that having `/mac` as the iOS `SOURCE_FILTER` will prevent pathnames containing `/mac` from compiling into iOS. This means if a file's name beings with `mac`, or is contained by a folder starting with `mac` won't compile and link into the iOS target. Same goes for the other way around.

Note the difference between `CFLAGS` and `CCFLAGS` – the first applies to all C-like source files (C, Objective-C and C++) while the latter does not affect C++. (Remember that Objective-C a strict superset of C while C++ is not)

### rules.mk

```bash
define DEFINE_RULES

CC_INVOKE_$(1) = $$(CC) $$(CCFLAGS_$(1)) $$(CFLAGS_$$(CURRENT_MODULE)) $$(CCFLAGS_$$(CURRENT_MODULE)) $$(CFLAGS_$$(CURRENT_MODULE)_$(1)) $$(CCFLAGS_$$(CURRENT_MODULE)_$(1)) -DCURRENT_MODULE=$$(CURRENT_MODULE)
CXX_INVOKE_$(1) = $$(CXX) $$(CXXFLAGS_$(1)) $$(CFLAGS_$$(CURRENT_MODULE)) $$(CXXFLAGS_$$(CURRENT_MODULE)) $$(CFLAGS_$$(CURRENT_MODULE)_$(1)) $$(CXXFLAGS_$$(CURRENT_MODULE)_$(1)) -DCURRENT_MODULE=$$(CURRENT_MODULE)

$$(BUILD_PATH)/obj/$(1)/%.m.o: %.m
    $$(AUTO_MKDIR)
    $$(CC_INVOKE_$(1)) -fobjc-arc -c -o $$@ $$<

$$(BUILD_PATH)/obj/$(1)/%.cpp.o: %.cpp
    $$(AUTO_MKDIR)
    $$(CXX_INVOKE_$(1)) -c -o $$@ $$<

$$(BUILD_PATH)/obj/$(1)/%.c.o: %.c
    $$(AUTO_MKDIR)
    $$(CC_INVOKE_$(1)) -c -o $$@ $$<

$$(BUILD_PATH)/obj/$(1)/%.cpp.dep: %.cpp
    $$(AUTO_MKDIR)
    @$$(CXX_INVOKE_$(1)) -Wno-#warnings -MT $$(@:.dep=.o) -M $$^ -o $$@

$$(BUILD_PATH)/obj/$(1)/%.dep: %
    $$(AUTO_MKDIR)
    @$$(CC_INVOKE_$(1)) -Wno-#warnings -MT $$(@:.dep=.o) -M $$^ -o $$@

$$(TARGET_$(1)):
    $$(AUTO_MKDIR)
    $$(LD) $$(LDFLAGS_$(1)) $$^ -o $$@

endef

$(foreach i,$(PLATFORMS),$(eval $(call DEFINE_RULES,$(i))))
```

Now we have to define rules for our source files. Because compilation and linkage flags vary between targets, we have to define our rules per target, but in order to avoid code duplication, we'll use a macro. Note that we use `$$` instead of `$` inside our macro (except for `$(1)`) to avoid premature variable/macro expansion.

The first thing we do inside the macro is define the target's `CC_INVOKE` and `CXX_INVOKE` macros, as we're going to use those invocations more than once each. Note how we use non-constant variable names to allow per-platform, per-target, and per-target-per-platform flags. For example:

 *  `$$(CCFLAGS_$(1))` will expand to `$(CFLAGS_ios)` during an iOS compilation invocation, which will eventually expand to the (Objective-) C compilation flags for iOS.
 *  `$$(CFLAGS_$$(CURRENT_MODULE))` will expand to `$(CFLAGS_mymodule)` during a compilation invocation for a file under a folder called `mymodule`. This allows `mymodule/module.mk` to define that variable to set module-specific (but not platform-specific) flags for all its source files.
 *  `$$(CXXFLAGS_$$(CURRENT_MODULE)_$(1))` will expand to `$(CXXFLAGS_mymodule_mac)` during a macOS compilation invocation for a file under a folder called `mymodule`. This allows `mymodule/module.mk` to define that variable to set module-specific *and* platform-specific flags for its C++ files.

With these macros done, the rest of the macro is just straightforward pattern rule definitions, including rules for our `.dep` files.

Finally, we use `foreach` to run our macro for each of our targets.

The way this file is written makes it easy to add support for more source file types, such as assembly, Objective-C++ and pre-proccessed source files.

### targets.mk

```bash
define HANDLE_PLATFORM

OBJECTS_$(1) += $$(addsuffix .o,$$(addprefix $(BUILD_PATH)/obj/$(1)/,$$(call FILTER_OUT,$$(SOURCE_FILTER_$(1)), $$(SOURCES))))

$$(TARGET_$(1)): $$(OBJECTS_$(1))

$(1): $$(TARGET_$(1))

ifeq ($(USE_AUTO_DEPS),true)
-include $$(patsubst %.o,%.dep,$$(OBJECTS_$(1)))
endif

endef

SOURCES := $(shell find * -type f -name "*.c" -o -name "*.cpp" -o -name "*.m")

-include $(addsuffix module.mk,$(shell echo */))

$(foreach i,$(PLATFORMS),$(eval $(call HANDLE_PLATFORM,$(i))))
```

The last file is responsible to set the targets actual object dependencies for each platform. We first find all sources in our tree (We use `find *` instead of `find .` to avoid avoid searching folders such as `.git`), and then include all `module.mk` files (We use `-include` to keep those optional). Then, for each platform, we run the `HANDLE_PLATFORM` macro.

The `HANDLE_PLATFORM` macro takes the source list, filters it out using the correct `SOURCE_FILTER` variable defined in `flags.mk`, and adds a suffix and prefix to each file to generate an actual object list. Finally, we set the list as the dependencies for our target.

After we configure the target's dependencies, since we already have a list of the required objects, we use the opportunity include the relevant `.dep` files (which will generate them if they don't exist) if `USE_AUTO_DEPS` is enabled.

## Example Usage

Now our build system is ready to be used! As an example, we'll create a dynamic library for both iOS and macOS whose sole purpose is to show a popup once it's `dlopen`ed. We'll have 2 modules for this library – `popup`, which include platform specifc code for showing the popup, and `init`, which calls the platform-specific code using a common API from an `__attribute__((constructor))` function. The texts used for the popup will be determined by `#define`d strings originating from `init`'s `module.mk` file.

[Download the full code and example](/assets/make_example.zip)

extension: markdown


text:
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

## [4.5.0] - 2023-08-14

### Added
- Added `--decrypt-secrets-in-tmp-dir` to solve concurrency issues or if work disk is read-only

### Changes
- BREAKING: helm-secrets requires vals 0.26.2 or higher

### Fixed
- Avoid quoting issues with literals and `vals` backend
- Remove `helm secrets version` to avoid a conflict with `helm version`

## [4.4.2] - 2023-03-11

### Fixed
- Error on custom protocol value files which are not resolving into yaml files

## [4.4.1] - 2023-03-06

### Fixed
- Exclamation mark in --set argument result into to backend not found error
- `HELM_SECRETS_LOAD_GPG_KEYS` uses home dir instead tmp dir which results into errors on argocd-repo-server

## [4.4.0] - 2023-02-18
### Added
- Migrations for ArgoCD multi source application limitations

### Fixed
- Error `curl: option --netrc-file=/custom-tools/.netrc: is unknown`, if NETRC environment variable is defined

## [4.3.0] - 2023-02-18
### Added
- Support for evaluating secret references (`--evaluate-templates`; `vals` backend) in helm templates (requires helm 3.9.0; vals 0.20+)
- Override secret backend per value file
- Restrict secret backend, using `HELM_SECRETS_ALLOWED_BACKENDS` environment variable

### Fixed
- Performance issues with large value files (`vals` backend)
- Remote value file download fails when URL contains query strings

## [4.2.2] - 2022-11-20
### Fixed
- Performance issues with large value files

## [4.2.1] - 2022-11-14
### Fixed
- fixes detection of SOPS YAML files with Windows line-endings (CR LF)

## [4.2.0] - 2022-11-08
### Added
- `--ignore-missing-values` (`HELM_SECRETS_IGNORE_MISSING_VALUES`). This option allows ignoring errors related to file not found.
- if paths or value files beginning with a `?` in beginning, all file not found errors related to that specific value file are ignored.
- Support for shell installed via scoop

### Fixed
- Multiple values in a single --set option not correctly passed to helm
- `cat: can't open '/dev/stdin': No such file or directory` on Windows

## [4.1.1] - 2022-09-21
### Fixed
- Fix handing of special character `\` from literal `vals` values
- Remove escape character `\` from literal `vals` values, if value contains quotes.

## [4.1.0] - 2022-09-20
### Added
- Support for literal `vals` values like `--set`, `--set-string` and `--set-json`, e.g.
  - `--set auth.rootPassword=ref+vault://secret/mysql#/rootPassword`
- Support for literal `vals` values through downloader syntax `secrets+literal://`, e.g.
  - `--set-file secrets+literal://ref+vault://secret/mysql#/rootPassword`

## [4.0.0] - 2022-09-11
### Added
- Support for decrypting files defined via `--set-file`

### Changed
- **Breaking**: Rename `helm secrets dec` to `helm secrets decrypt`
- **Breaking**: Rename `helm secrets enc` to `helm secrets encrypt`
- **Breaking**: The `decrypt` and `encrypt` command write the results to stdout now. Both commands support `-i` flag to en/decrypt file in-line.
- **Breaking**: Secret drivers are renamed to secret backends
  - This is **breaking** custom integrations. All shell functions contains the name `driver` are renamed to `backend`, e.g.: `driver_encrypt_file` -> `backend_encrypt_file`
  - The CLI Arguments `--driver`, `-d` and `--driver-args` has been renamed to `--backend`, `-b` and `--backend-args`
  - The environment variables `HELM_SECRETS_DRIVER` and `HELM_SECRETS_DRIVER_ARGS` has been renamed to `HELM_SECRETS_BACKEND` and `HELM_SECRETS_BACKEND_ARGS`

### Removed
- `HELM_SECRETS_DRIVER` environment variable. `HELM_SECRETS_BACKEND`is a drop-in replacement.
- `helm secret clean` command.
- `helm secret terraform` command. The `helm secret decrypt --terraform` command is a drop-in replacement.
- `helm secret view` command. The `helm secret decrypt` command is a drop-in replacement.
- `vault` driver. The `vals` driver supports vault as backend, too.
- `envsubst` driver. The `vals` driver supports envsubst as backend, too.
- `droppler` driver.
- `sops://` protocol handler
- `secret://` protocol handler
- Parameter `--output-decrypt-file-path` (`HELM_SECRETS_OUTPUT_DECRYPTED_FILE_PATH`) that outputs the path of decrypted files only.

## [3.15.0] - 2022-08-08
### Changed
- Prefer bash from `Git for Windows` over `WSL` shell to avoid WSL interop incompatibilities
- Deprecate `vault` driver. The `vals` driver supports vault as backend, too.
- Deprecate `envsubst` driver. The `vals` driver supports envsubst as backend, too.
- Deprecate `droppler` driver.

### Fixed
- Error with --set arguments, if WSL backend is used.

## [3.14.1] - 2022-07-27
### Changed
- Handing of /tmp file in Windows environments. Fixes performance issues in native WSL environments

### Fixed
- Win32 Console error, if gpg.exe does not exists
- Debug output, if `helm --debug` is set.

## [3.14.0] - 2022-06-06
### Added
- Added error handling in case `curl` or `wget` is not installed.
- Added vals support on Windows
- Enable protocol handling on Windows. Requires the command `helm secrets patch windows` once.

### Changed
- Check detection of a sops encrypted files
- Prefer gpg4win, if available. Use `SOPS_GPG_EXEC=gpg` as environment variable to restore the old behavior.

### Fixed
- Error, if HELM_SECRETS_WINDOWS_SHELL contains spaces

## [3.13.0] - 2022-04-12
### Added
- Support for WSL on Windows

### Fixed
- Strip newlines on helm secrets terraform command

## [3.12.0] - 2022-02-03
### Added
- [Terraform Integration](https://github.com/jkroepke/helm-secrets/blob/5feb8cd38f6e89e680cab9c428d0a97e0143e703/examples/terraform/helm.tf). Can be used together with [external data source provider](https://registry.terraform.io/providers/hashicorp/external/latest/docs/data-sources/data_source)
- Enable parsing of [.netrc](https://everything.curl.dev/usingcurl/netrc) for http based values. The location of the .netrc can be overridden by `NETRC` environment variable.
- Environment variable `HELM_SECRETS_VALUES_ALLOW_SYMLINKS` to allow or deny follow symlinks.
- Environment variable `HELM_SECRETS_VALUES_ALLOW_ABSOLUTE_PATH` to allow or deny absolute value file paths.
- Environment variable `HELM_SECRETS_VALUES_ALLOW_PATH_TRAVERSAL` to allow or deny `dot-dot-slash` values file paths.

## [3.11.0] - 2021-11-25
### Added
- Add environment variable expansion for value files like<EMAIL_ADDRESS>  This feature is disabled by default and can be enabled by set the env var `HELM_SECRETS_URL_VARIABLE_EXPANSION=true`

### Changed
- Add more strict behavior around the downloader syntax to avoid infinite loops

## [3.10.0] - 2021-11-05
### Added
- Add [age](https://github.com/mozilla/sops#encrypting-using-age) support for downloader plugin syntax.

### Changed
- Improvements to the ArgoCD integration documentation.

## [3.9.1] - 2021-10-09
### Fixed
- Wrong format on CHANGELOG.md

## [3.9.0] - 2021-10-09
### Added
- A better ArgoCD Integration. helm-secrets can load now gpg keys for you by using the uri `secrets+gpg-import://path/key.asc?path/secrets.yaml` as value file.
  As alternative, you can use `secrets+gpg-import-kubernetes://` to import a gpg key from an existing kubernetes secret, but it requires the kubectl command.
  Checkout the [docs/ARGOCD.md](docs/ArgoCD Integration.md) for more information.
- [vals](https://github.com/variantdev/vals) driver. vals supporting Vault, AWS SSM, GCP, sops, terraform states or other files.

## [3.8.3] - 2021-08-06
### Changed
- Allow dot, asterisk and underscore for the vault path

## [3.8.2] - 2021-07-14
### Fixed
- Decrypt partially encrypted sops files correctly

## [3.8.1] - 2021-06-12
### Fixed
- OUTPUT_DECRYPTED_FILE_PATH: parameter not set

## [3.8.0] - 2021-06-12
### Added
- New parameter `--output-decrypt-file-path` (`HELM_SECRETS_OUTPUT_DECRYPTED_FILE_PATH`) that outputs the path of decrypted files only.
- `HELM_SECRETS_DEC_PREFIX` variable in addition to `HELM_SECRETS_DEC_SUFFIX`
- New parameter `--version`
- cygwin compatibility

### Changed
- `HELM_SECRETS_DEC_SUFFIX` has been changed from `.yaml.dec` to `.dec`. Additionally, while append the suffix, the file extension `.yaml` is not stripped anymore.
- The detection of encrypted sops files has been changed. Instead, looking for `sops:` and `version:`, the string `unencrypted_suffix` is used now.

## [3.7.0] - 2021-05-22
### Added
- envsubst driver

### Changed
- Output errors on stderr

## [3.6.1] - 2021-03-30
### Fixed
- `mktemp: too few X's in template` error on macOS if gnu coreutils preferred over builtin bsd tools.

## [3.6.0] - 2021-03-29
### Added
- Detect ArgoCD environment by `ARGOCD_APP_NAME` environment variable and set `HELM_SECRETS_QUIET=true` by default. (https://github.com/jkroepke/helm-secrets/pull/83)

### Removed
- **The default sops installation is removed, since helm-secrets could be used with hashicorp vault which does not require sops.**

### Fixed
- Cleanup all temporary files.

## [3.5.0] - 2021-02-20
### Added
- Added `--driver-args` to pass additional argument to underlying commands (https://github.com/jkroepke/helm-secrets/pull/82)

### Fixed
- "grep: Invalid range end" if locale is not C (https://github.com/jkroepke/helm-secrets/pull/81)

## [3.4.2] - 2021-02-19
### Changed
- Dev: Rename `master` branch to `main`

### Fixed
- "grep: Invalid range end" if locale is not C (https://github.com/jkroepke/helm-secrets/pull/79)

## [3.4.1] - 2021-01-23
### Fixed
- Handling `--` inside command line arguments
- Fix handling errors with remote files
- Strip yaml doc separator if the vault driver is used (https://github.com/jkroepke/helm-secrets/pull/70)
- Incompatibilities if sed links to gnu sed on MacOS (https://github.com/jkroepke/helm-secrets/pull/72)

## [3.4.0] - 2020-12-26
From this version, the installation on Helm 2 requires additional steps.
Check https://github.com/jkroepke/helm-secrets/wiki/Installation#helm-2

### Added
- Implement alternate syntax (https://github.com/jkroepke/helm-secrets/pull/52)
- Remote values support (supporting http:// and helm downloader plugins) (https://github.com/jkroepke/helm-secrets/pull/54)
- Let downloader plugin support remote files and all secrets drivers (https://github.com/jkroepke/helm-secrets/pull/55)
- Externalize custom vault driver logic. (https://github.com/jkroepke/helm-secrets/pull/63)
- Dev: Implement code coverage
- Dev: Test zsh compatibility

### Fixed
- Vault driver: If vault command failed, the script execution was not terminated. (https://github.com/jkroepke/helm-secrets/pull/61)

## [3.3.5] - 2020-10-16
### Added
- Better lookup for unix shells on Windows (https://github.com/jkroepke/helm-secrets/pull/42)

## [3.3.4] - 2020-09-09
### Added
- Allow overriding SOPS version on installation (https://github.com/jkroepke/helm-secrets/pull/40)
- Add separat download artefact on GitHub release

## [3.3.0] - 2020-08-28
### Added
- Don't check if file exists on edit (https://github.com/jkroepke/helm-secrets/pull/31)
- Better Windows support (https://github.com/jkroepke/helm-secrets/pull/28)
- Support parameters like --values=secrets.yaml (https://github.com/jkroepke/helm-secrets/pull/34)
- Added CentOS 7 as supported OS system (https://github.com/jkroepke/helm-secrets/pull/35)

## [3.2.0] - 2020-05-08
### Added
- Add Vault support (https://github.com/jkroepke/helm-secrets/pull/22)
- Secret driver to gain secrets from other sources then sops. (https://github.com/jkroepke/helm-secrets/pull/16)
- Remove name restriction (https://github.com/jkroepke/helm-secrets/pull/23)

### Changed
- Run unit tests on bash, dash and ash (busybox), too.

## [3.1.0] - 2020-04-27
### Added
- completion.yaml for helm shell auto-completion
- Tests for all `helm secrets` commands
- Added quiet flag for helm secrets (https://github.com/jkroepke/helm-secrets/pull/8)

### Changed
- Escape special chars in paths correctly (https://github.com/jkroepke/helm-secrets/pull/9)

## [3.0.0] - 2020-04-26
Started a fork of https://github.com/zendesk/helm-secrets

### Added
- POSIX compatibility (https://github.com/jkroepke/helm-secrets/pull/1)
- Optionally decrypt helm secrets in a temporary directory (https://github.com/jkroepke/helm-secrets/pull/5)
- Added CI tests (https://github.com/jkroepke/helm-secrets/pull/2)

### Changed
- Changed secrets.yaml prefix just to `secrets`. All files like `secrets*` are now decrypted
- Remove dependency against gnu-getops
- Remove run as root dependency on helm plugin install
- Verbose output is now on stderr
- Support all helm sub commands and plugins

[Unreleased]: https://github.com/kroepke/helm-secrets/compare/v4.4.2...HEAD
[4.4.2]: https://github.com/jkroepke/helm-secrets/compare/v4.4.1...v4.4.2
[4.4.1]: https://github.com/jkroepke/helm-secrets/compare/v4.4.0...v4.4.1
[4.4.0]: https://github.com/jkroepke/helm-secrets/compare/v4.3.0...v4.4.0
[4.3.0]: https://github.com/jkroepke/helm-secrets/compare/v4.2.2...v4.3.0
[4.2.2]: https://github.com/jkroepke/helm-secrets/compare/v4.2.1...v4.2.2
[4.2.1]: https://github.com/jkroepke/helm-secrets/compare/v4.2.0...v4.2.1
[4.2.0]: https://github.com/jkroepke/helm-secrets/compare/v4.1.1...v4.2.0
[4.1.1]: https://github.com/jkroepke/helm-secrets/compare/v4.1.0...v4.1.1
[4.1.0]: https://github.com/jkroepke/helm-secrets/compare/v4.0.0...v4.1.0
[4.0.0]: https://github.com/jkroepke/helm-secrets/compare/v3.15.0...v4.0.0
[3.15.0]: https://github.com/jkroepke/helm-secrets/compare/v3.14.1...v3.15.0
[3.14.1]: https://github.com/jkroepke/helm-secrets/compare/v3.14.0...v3.14.1
[3.14.0]: https://github.com/jkroepke/helm-secrets/compare/v3.13.0...v3.14.0
[3.13.0]: https://github.com/jkroepke/helm-secrets/compare/v3.12.0...v3.13.0
[3.12.0]: https://github.com/jkroepke/helm-secrets/compare/v3.11.0...v3.12.0
[3.11.0]: https://github.com/jkroepke/helm-secrets/compare/v3.10.0...v3.11.0
[3.10.0]: https://github.com/jkroepke/helm-secrets/compare/v3.9.1...v3.10.0
[3.9.1]: https://github.com/jkroepke/helm-secrets/compare/v3.9.0...v3.9.1
[3.9.0]: https://github.com/jkroepke/helm-secrets/compare/v3.8.3...v3.9.0
[3.8.3]: https://github.com/jkroepke/helm-secrets/compare/v3.8.2...v3.8.3
[3.8.2]: https://github.com/jkroepke/helm-secrets/compare/v3.8.1...v3.8.2
[3.8.1]: https://github.com/jkroepke/helm-secrets/compare/v3.8.0...v3.8.1
[3.8.0]: https://github.com/jkroepke/helm-secrets/compare/v3.7.0...v3.8.0
[3.7.0]: https://github.com/jkroepke/helm-secrets/compare/v3.6.1...v3.7.0
[3.6.1]: https://github.com/jkroepke/helm-secrets/compare/v3.6.0...v3.6.1
[3.6.0]: https://github.com/jkroepke/helm-secrets/compare/v3.5.0...v3.6.0
[3.5.0]: https://github.com/jkroepke/helm-secrets/compare/v3.4.2...v3.5.0
[3.4.2]: https://github.com/jkroepke/helm-secrets/compare/v3.4.1...v3.4.2
[3.4.1]: https://github.com/jkroepke/helm-secrets/compare/v3.4.0...v3.4.1
[3.4.0]: https://github.com/jkroepke/helm-secrets/compare/v3.3.5...v3.4.0
[3.3.5]: https://github.com/jkroepke/helm-secrets/compare/v3.3.4...v3.3.5
[3.3.4]: https://github.com/jkroepke/helm-secrets/compare/v3.3.0...v3.3.4
[3.3.0]: https://github.com/jkroepke/helm-secrets/compare/v3.2.0...v3.3.0
[3.2.0]: https://github.com/jkroepke/helm-secrets/compare/v3.1.0...v3.2.0
[3.1.0]: https://github.com/jkroepke/helm-secrets/compare/v3.0.0...v3.1.0
[3.0.0]: https://github.com/jkroepke/helm-secrets/releases/tag/v3.0.0

repository: jkroepke/helm-secrets

gha_language: Shell

repo_name: jkroepke/helm-secrets


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

## [0.1.4](https://github.com/yosoft/lerna-release-workflow/compare/@yosoft/package-b@0.1.3<EMAIL_ADDRESS>(2021-11-01)

**Note:** Version bump only for package @yosoft/package-b

## [0.1.3](https://github.com/yosoft/lerna-release-workflow/compare/@yosoft/package-b@0.1.2<EMAIL_ADDRESS>(2021-11-01)

**Note:** Version bump only for package @yosoft/package-b

## 0.1.2 (2021-11-01)

**Note:** Version bump only for package @yosoft/package-b

## [0.1.1](https://github.com/jonwa/lerna-release-workflow/compare/@jonwa/package-b@0.1.0<EMAIL_ADDRESS>(2020-09-10)

**Note:** Version bump only for package @jonwa/package-b

# 0.1.0 (2020-03-29)

### Features

* add package-a & package-b ([ad3ac32](https://github.com/jonwa/lerna-release-workflow/commit/ad3ac32b960f58ca7618a3d08a28295a4fabcccb))

repository: YOSOFT/lerna-prueba

repo_name: YOSOFT/lerna-prueba


text:
---
title: influx task retry-failed
description: The `influx task retry-failed` command retries failed InfluxDB task runs.
menu:
  influxdb_2_2_ref:
    name: influx task retry-failed
    parent: influx task
weight: 201
metadata: [influx CLI 2.0.5+, InfluxDB 2.0.5+]
---

The `influx task retry-failed` command retries failed InfluxDB task runs.
## Usage
```
influx task retry-failed [flags]
```

## Flags
| Flag |                   | Description                                                               | Input type | {{< cli/mapped >}}    |
|:-----|:------------------|:--------------------------------------------------------------------------|:----------:|:----------------------|
|      | `--after`         | Retry task runs that occurred after this time (RFC3339 timestamp)         | string     |                       |
| `-c` | `--active-config` | CLI configuration to use for command                                      | string     |                       |
|      | `--configs-path`  | Path to `influx` CLI configurations (default `~/.influxdbv2/configs`)     | string     | `INFLUX_CONFIGS_PATH` |
|      | `--before`        | Retry task runs that occurred before this time (RFC3339 timestamp)        | string     |                       |
|      | `--dry-run`       | Print information about task runs that would be retried                   |            |                       |
| `-h` | `--help`          | Help for the `list` command                                               |            |                       |
|      | `--hide-headers`  | Hide table headers (default `false`)                                      |            | `INFLUX_HIDE_HEADERS` |
|      | `--host`          | HTTP address of InfluxDB (default `http://localhost:8086`)                | string     | `INFLUX_HOST`         |
|      | `--http-debug`    | Inspect communication with InfluxDB servers.                              | string     |                       |
| `-i` | `--id`            | Task ID                                                                   | string     |                       |
|      | `--json`          | Output data as JSON (default `false`)                                     |            | `INFLUX_OUTPUT_JSON`  |
| `-o` | `--org`           | Task organization name                                                    | string     | `INFLUX_ORG`          |
|      | `--org-id`        | Task organization ID                                                      | string     | `INFLUX_ORG_ID`       |
|      | `--run-limit`     | Maximum number of failed runs to retry per task (`1-500`, default `100`)  | integer    |                       |
|      | `--skip-verify`   | Skip TLS certificate verification                                         |            | `INFLUX_SKIP_VERIFY`  |
|      | `--task-limit`    | Maximum number of tasks to retry failed runs for (`1-500`, default `100`) | integer    |                       |
| `-t` | `--token`         | API token                                                                 | string     | `INFLUX_TOKEN`        |

## Examples

{{< cli/influx-creds-note >}}

{{% note %}}
#### Required permissions
Use an [{{% oss-only %}}**Operator** or{{% /oss-only %}} **All-Access** token](/influxdb/v2.2/security/tokens/) to retry failed tasks.
{{% /note %}}

- [Retry failed task runs for a specific task ID](#retry-failed-task-runs-for-a-specific-task-id)
- [Retry failed task runs that occurred before a specific time](#retry-failed-task-runs-that-occurred-before-a-specific-time)
- [Retry failed task runs that occurred after a specific time](#retry-failed-task-runs-that-occurred-after-a-specific-time)
- [Retry failed task runs that occurred in a specific time range](#retry-failed-task-runs-that-occurred-in-a-specific-time-range)
- [Retry failed runs for a limited number of tasks](#retry-failed-runs-for-a-limited-number-of-tasks)
- [Retry a limited number of failed runs for a task](#retry-a-limited-number-of-failed-runs-for-a-task)
- [Print information about runs that will be retried](#print-information-about-runs-that-will-be-retried)

##### Retry failed task runs for a specific task ID
```sh
influx task retry-failed \
  --id 0Xx0oox00XXoxxoo1
```

##### Retry failed task runs that occurred before a specific time
```sh
influx task retry-failed \
  --before 2021-01-01T00:00:00Z
```

##### Retry failed task runs that occurred after a specific time
```sh
influx task retry-failed \
  --after 2021-01-01T00:00:00Z
```

##### Retry failed task runs that occurred in a specific time range
```sh
influx task retry-failed \
  --after 2021-01-01T00:00:00Z \
  --before 2021-01-01T23:59:59Z
```

##### Retry failed runs for a limited number of tasks
```sh
influx task retry-failed \
  --task-limit 5
```

##### Retry a limited number of failed runs for a task
```sh
influx task retry-failed \
  --id 0Xx0oox00XXoxxoo1 \
  --run-limit 5
```

##### Print information about runs that will be retried
```sh
influx task retry-failed \
  --dry-run
```


text:
# Prose: a concept programming language

```
print "Hello world!"
```

## Goals:

1. Read as close as possible to natural english
2. Use as little non-letter characters as possible
3. Transpile to JavaScript so I can use it

repository: travisk-codes/prose-lang

repo_name: travisk-codes/prose-lang


text:
# web-esm

Run TRUE esm on the web ( Demo )

## Run

* yarn ( Both in ROOT_DIR & ROOT_DIR/test )
* yarn start

## Browser supported

* Currently only Chrome Canary (76) is supported as [Import map](https://github.com/WICG/import-maps) is under origin trial

## License

MIT

repository: CarterLi/web-esm

repo_name: CarterLi/web-esm


text:
# Front Flow

### Author
Guilherme Schwade -<EMAIL_ADDRESS>
### Projects incorporated
* [Harvest - Gulp boilerplate](https://github.com/ryanbenson/Harvest)

### Install
```
npm install
```

### Run
* To run the gulp generator
```
gulp
```
* Open the browser in http://localhost:8080

* To deploy your project
```
gulp deploy
```

repository: guilhermevrs/frontflow

repo_name: guilhermevrs/frontflow


text:
### May 25, 2021, Agenda

- Go over things that people have completed this week **[15 minutes]**
  - Yiki's updates on 3D head map
  - Sasha's updates on connectivity plot for specific node pairs and different calculation types

- Quickly show the current status of the UI **[5 minutes]**

- Let partners know we will send them a list of parameters to select for each functions. We can turn the mne built-in parameters to be optional, but since they are a lot, we would like to keep the ones that partners think most useful for them. **[5 minutes]**

- Questions **[10 minutes]**
  - For the 3D head map, there are two options for the colorbar. One is have the color value normalized, another is to have different color range for each time stamps. Which one to keep?
  - Mo's questions regarding the clustering method.

gha_language: Jupyter Notebook


text:
# Twinkle (Ed6767 fork)

Twinkle is a JavaScript application that gives Wikipedians a quick way of performing common maintenance tasks, such as nominating pages for deletion and cleaning up vandalism.

See [Wikipedia:Twinkle][] on the English Wikipedia for more information.

[AzaToth][] is the original author and maintainer of the tool, as well as the `morebits.js` library gadget, which forms the basis for many Wikipedia scripts and editing tools in addition to Twinkle.

## Goal of this fork

* Make Twinkle easier to develop!
* Finally bring Twinkle into the 2010s by implimenting OOUI features, which can be enabled/disabled in preferences if people don't like them
* Increase Twinkle's user friendliness by implimenting some tweaks

## B-but didn't you already make RedWarn?

Yes, but Twinkle covers a much wider scope than RedWarn does and all tools should be accessable for all Wikimedians, both the computer litterate and illiterate.

[select2][] is added under the [MIT license](https://github.com/select2/select2/blob/develop/LICENSE.md).

[Wikipedia:Twinkle]: https://en.wikipedia.org/wiki/Wikipedia:Twinkle
[AzaToth]: https://en.wikipedia.org/wiki/User:AzaToth
[Wikipedia talk:Twinkle]: https://en.wikipedia.org/wiki/Wikipedia_talk:Twinkle
[Twinkle documentation]: https://en.wikipedia.org/wiki/Wikipedia:Twinkle/doc
[WP:TWPREFS]: https://en.wikipedia.org/wiki/Wikipedia:Twinkle/Preferences
[select2]: https://github.com/select2/select2


text:
# EHR System

Electronic Health Record system of patient records, so that you never have to carry your medical files to a doctor again!

---

## Developers and Maintainers
The project is developed and maintained by
- Akshat Jain ([Akshat-Jain](https://github.com/Akshat-Jain))
- Shubhankar Amitabh ([shubhamitabh](https://github.com/shubhamitabh))
- Ravi Kishan ([ravi-kishan](https://github.com/ravi-kishan))
- Ashwani Yadav ([ashwaniYDV](https://github.com/ashwaniYDV))

Akshat Jain

Shubhankar Amitabh

Ravi Kishan

Ashwani Yadav

## Problem Statement
Over decades, medical facilities have evolved elegantly. Still most of us are the witness of the fact that whenever we see a doctor, we need to put forward our medical file in front of him/her. Our file contains our previous prescriptions, medical reports, X-Rays, MRIs etc. It is a tedious task to keep record of all these.

## Aim of the Project
We aim to provide a digital solution to this problem so that next time when you visit your doctor, you don’t need to carry your medical file. We will be using Blockchain technology to store the patient records. This will ensure that the information remains secure while being decentralised across different peers.

The basic idea is to use Blockchain for storing patient records. The workflow would be as follows:
1. Anyone can register on the Blockchain network as a doctor or a patient.
2. Whenever a patient visits a doctor, the doctor will have the required permissions to store the diagnosis and medical logs in the patient’s record which would be stored in distributed ledgers across the Blockchain network.
3. The doctor would require to sign in the transaction (which would be cryptographically encrypted with his private key) to create and modify the records of a patient (who would be uniquely identified by a patient ID).
4. The medical records of a patient will be accessible from any hospital.

## Why Blockchain?

### Security
Blockchain provides a secure way of managing records.
### Public Health
By using blockchain technology, regulatory bodies can create a shared stream of de-identified patient information.
### Managed Consent
Patients can specifically authorise any individual to access their medical information.
### Simplified Claim Processing
Blockchain technology can simplify the complex medical billing process by eliminating the series of validations and multiple third parties acting on behalf of other entities.
### Patient Generated Data
Patients will be able to easily upload and securely store their updated medical information without messing up any previous records.

## Tech Stack used for the project
* IBM’s Hyperledger Framework for Blockchain
* Hyperledger Composer based on Fabric Architecture
* Hyperledger Playground for Blockchain
* JavaScript for website
* Java for creating Android app

# Instructions to run the API Backend
- Clone the repo `git clone https://github.com/Akshat-Jain/EHR-System.git`
- CD into the cloned directory using `cd EHR-System`.
- First install [Hyperledger composer](https://hyperledger.github.io/composer/latest/installing/installing-prereqs.html). Then install the [development environment](https://hyperledger.github.io/composer/latest/installing/development-tools.html).
- Execute the following commands to setup your Blockchain network and generate Hyperledger Composer Rest Server:
- `composer archive create -t dir -n .`
- `composer network install --card PeerAdmin@hlfv1 --archiveFile<EMAIL_ADDRESS>- `composer network start --networkName ehr --networkVersion 0.0.3 --card PeerAdmin@hlfv1 --networkAdmin admin --networkAdminEnrollSecret adminpw --file networkadmin.card`
- `composer card import --file networkadmin.card`
- `composer-rest-server -c admin@ehr -n always -u true -d y -w true`
- Goto `http://localhost:3000/explorer` to explored the REST API

# Client Repositories for the Project

### Repo Link for Web Client:
https://github.com/ashwaniYDV/WebClient

### Repo Link for Android Client:
https://github.com/ravi-kishan/AndroidClient

## License

This project is available under the MIT license. See the [LICENSE](LICENSE) file for more info.


text:
+++
# Display name
name = "Yachen Tang"

# Is this the primary user of the site?
superuser = true

# Role/position
role = "Research Engineer"

# Organizations/Affiliations
#   Separate multiple entries with a comma, using the form: `[ {name="Org1", url=""}, {name="Org2", url=""} ]`.
organizations = [ { name = "GEIRI North America", url = "" } ]

# Short bio (displayed in user profile at end of posts)
bio = "My research interests include distributed robotics, mobile computing and programmable matter."

# Enter email to display Gravatar (if Gravatar enabled in Config)
email =<EMAIL_ADDRESS>
# List (academic) interests or hobbies
interests = [
  "Artificial Intelligence",
  "Knowledge Graph",
  "Data Modeling",
  "Digital Image Processing"
]

# List qualifications (such as academic degrees)
[[education.courses]]
  course = "PhD in Electrical and Computer Engineering"
  institution = "Michigan Technological University"
  year = 2018

[[education.courses]]
  course = "MEng in Electrical and Computer Engineering"
  institution = "Michigan Technological University"
  year = 2014

[[education.courses]]
  course = "BS in Telecommunications Engineering"
  institution = "Jilin University"
  year = 2011

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/widgets/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "#contact" for contact widget.

[[social]]
  icon = "google-scholar"
  icon_pack = "ai"
  link = "https://scholar.google.com/citations?user=JcHBOFMAAAAJ&hl=en"

[[social]]
  icon = "github"
  icon_pack = "fab"
  link = "https://github.com/yachent"

# Link to a PDF of your resume/CV from the About widget.
# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
# [[social]]
#   icon = "cv"
#   icon_pack = "ai"
#   link = "files/cv.pdf"

+++

Yachen Tang received the Ph.D. degree in Electrical and Computer Engineering at Michigan Technological University in 2018. He is currently a research engineer at Global Energy Interconnection Research Institute (GEIRI) North America. He previously received the BS degree in Telecommunication Engineering from Jilin University, China, in 2011, and MS degree in Computer Engineering from Michigan Technological University, Houghton, in 2014, respectively.

He was originally an intern with Henan Provincial Computer Research Institute for the project of Testing and Processing System for Network Image of Yellow River from July 2011 to January 2012. He held a patent on Chinese characters input program. Since his doctorate program at Tech, he has been active in reviewing manuscripts of IEEE PES and IET Generation, Transmission & Distribution transactions journals.

repository: yachent/academic-kickstart

repo_name: yachent/academic-kickstart


text:
Queue
======================================

[![Total Downloads](https://img.shields.io/packagist/dt/maximerenou/queue.svg)](https://packagist.org/packages/maximerenou/queue)
[![Latest Stable Version](https://img.shields.io/packagist/v/maximerenou/queue.svg)](https://packagist.org/packages/maximerenou/queue)

New features in this fork:

- You can push any job in a queue
- Jobs can ask to run one more time (try again)
- You can specify how many jobs you wish to keep in "successful", "error", "failed" and "retry" dynamic queues. It allows you to monitor last jobs without consuming too much disk space or memory.
- You can use a custom function to instance jobs (useful when working with a Container)

Current implementations:

- Redis (see `example/bin/`)

### TODO

- Update tests
- Implements AWS SQS
- Implements MySQL

---

You may want to check the [original repository](https://github.com/javibravo/simpleue).

repository: maximerenou/queue

repo_name: maximerenou/queue


text:
---
layout: default-md
section: Inhabited Worlds
title: Celestial
subtitle: In vestibulum massa quis arcu lobortis tempus. Nam pretium arcu in odio vulputate luctus.
---

## Celestial or Divine Orbs
These worlds are inhabited by purified spirits, where goodness prevails uncontested. There, spirits revel in an everlasting light, an undying beauty, and a permanent state of inner calmness. They enjoy an uninterrupted happiness.

If the blissful and celestial worlds sound too good to be true, know that they are accessible to all of us. The beings who live in those worlds are not privileged. They too, have undergone the same evolutionary process in which we now find ourselves, and through their own hard work and tears, they overcame all the difficulties to victoriously earn their right to join their brothers and sisters in a rank of such merit. We too, will one day do the same. Whether it is sooner or later depends on us as individuals. Starting at the same point, we're all given the same rights and opportunities.

As spirits progress morally and intellectually, they will reincarnate on planets appropriate to their evolutionary level.  Spirits who chose to persist in disobedience and exert no effort toward self-improvement will not progress to more advanced worlds. In fact, if their behavior is severe enough and consistently causes great distress to the social order of their present planet, they may even be forced to reincarnate among less evolved spirits in a more inferior world, where they must then work to help the latter advance in order to earn the right to return to the higher planetary stage they'd once reached. Conversely, when spirits' advancement surpasses that of the world in which they live, they will be rewarded with the right to pass on to a more evolved one.

## Source
[ExploreSpiritism.com: The Universe Evolves](//www.explorespiritism.com/Philosophy_Reincarnation_Universe%20Evolves_Intro.htm)

## See Also
TODO

## Suggested Reading
TODO

Previous: Blissful Worlds
Inhabited Worlds
Next: Transitional Worlds

license: Unlicense

repository: veevo/drafts

repo_name: veevo/drafts


text:
# D3 Scatterplot Project
This webpage is part of FreeCodeCamp's required Data Visualization projects. Given data from [https://raw.githubusercontent.com/FreeCodeCamp/ProjectReferenceData/master/cyclist-data.json](https://raw.githubusercontent.com/FreeCodeCamp/ProjectReferenceData/master/cyclist-data.json)

1. The performance time is visualized in a scatterplot graph
2. Mouse over a plot to see a tooltip with additional information

## Author
Neptune Michael Cabelin
(with reference to Bo.stock.org's scatterplot code and D3 tutorial)

## License
MIT


text:
---
description: This sample shows how to create a new WPF panel in the
  Smart Client settings dialog. This is similar to the
  OptionsDialogPlugin, which allows addition of a WinForms panel.
keywords:
- Plug-in integration
- Smart Client
lang: en-US
title: Smart Client Settings Panel
---

# Smart Client Settings Panel

This sample shows how to create a new WPF panel in the Smart Client
settings dialog. This is similar to the OptionsDialogPlugin, which
allows addition of a WinForms panel.

![](SCSettingsPanel.png)

## The sample demonstrates

-   Create a settings panel plugin

## Using

-   VideoOS.Platform.Client.SettingsPanelPlugin

## Environment

-   Smart Client MIP Environment

## Visual Studio C\# project

-   [SCSettingsPanel.csproj](javascript:openLink('..\\\\PluginSamples\\\\SCSettingsPanel\\\\SCSettingsPanel.csproj');)

repository: florent-phoenix/mipsdk-samples-plugin

repo_name: florent-phoenix/mipsdk-samples-plugin