text:
# 3D Motion Planning

The goal of this project is to plan and execute a trajectory through a 3D complex urban environment.

## Table of Contents
* [Environment](#environment)
* [Grid Search](#grid-search)
* [Graphs](#graphs)
* [Potential Field](#potential-field)
* [Receding Horizon Planning](#receding-horizon-planning)
* [Implementation](#implementation)
* [Reference](#reference)

## Environment

The drone is situated in the middle of a map which represents downtown San Francisco. The drone should take off, plan a trajectory from its current position to a goal position in the map and execute the trajectory avoiding obstacles. This is known as the motion planning problem.

The environment is a continuous space, so we should discretize it into a grid or a graph representation to be able to search through it and find a path.

The complexity of the grid/graph representation is really important in the motion planning problem. A very complex representation will represent the environment precisely but it will take too much time to search and find a path. However, if the representation is very simple, we could miss or collide with obstacles.

## Grid Search

A [grid-based](https://svn.sable.mcgill.ca/sable/courses/COMP763/oldpapers/yap-02-grid-based.pdf) representation of the environment is widely used and it can be searched using A* or other algorithms.

### 2D Grid

Instead of using the entire 3D environment, we can use a 2D grid for representing a certain altitude where the drone is going to fly.

For doing this, we can create a 2D configuration space of the environment given the obstacle data in `colliders.csv` and a safety distance that we would like to leave around obstacles.

The output should look something like this:

The left image shows the original map while the right image is the 2D representation at 5 meters altitude.

### 3D Grid

We can also represent the environment as a 3D grid or a 2.5D grid (limited altitude).

A 3D representation may be useful for representing a local map or small region instead of representing a global map.

However, we can change the resolution of the map to make it more or less complex depending on the situation.

Here we can see a 3D configuration space of the city with a resolution of 10 m³:

With a 2D or 3D grid of the environment we can now search a path using [A*](https://en.wikipedia.org/wiki/A*_search_algorithm) with an appropriate heuristic.

## Graphs

Graphs can also be used to discretize the world and represent the search space. A graph is a collection of nodes connected with edges so we can also plan a path that starts at a specific node and goes through the edges until a goal node.

For example, the road network is actually a graph where the intersections represent the nodes and the roads represent the edges.

### Voronoi diagram

[Voronoi diagram](https://en.wikipedia.org/wiki/Voronoi_diagram#:~:text=In%20mathematics%2C%20a%20Voronoi%20diagram,%2C%20sites%2C%20or%20generators) is a graph that breaks up the space into regions around a set of points representing obstacles so that all the points in a given region are closest to that obstacle.

We can create a graph given the edges of the Voronoi diagram where all of them represent feasible paths to navigate around obstacles and use A* algorithm to find a path from start to goal:

### Probabilistic roadmap

The [Probabilistic roadmap](https://en.wikipedia.org/wiki/Probabilistic_roadmap) creates a graph representation of the free space in the environment sampling points at random and testing them for collision. These random samples are connected to form the roadmap (graph) that can then be searched to find a path from start to goal.

Here's an example of this graph representation after sampling 500 points:

### Rapidly-exploring random trees (RRT)

[RRT](https://en.wikipedia.org/wiki/Rapidly-exploring_random_tree) is an algorithm that iteratively grows a tree from a starting position using random samples from the search space. Then, these samples are connected to the closest available node and checked for collisions.

A tree is a special case of a graph with directed edges and only with one path to any vertex.

Here's an example of a generated RRT where the starting position is situated in the bottom-left corner:

## Potential Field

The [Potential Field algorithm](https://medium.com/@rymshasiddiqui/path-planning-using-potential-field-algorithm-a30ad12bdb08#:~:text=A%20potential%20field%20is%20any,around%20in%20a%20certain%20space.) can also be used for motion planning.

It assigns an artificial potential field to every point in the world using potential field functions.

The robot will go from the highest potential to the lowest potential so the goal node should have the lowest potential while the starting node will have the maximum potential.

We can create a potential field by combining attractive and repulsive forces.

* **Attractive Force** can be used to move in a direction closer to the goal and can be calculate it as follows:

where the alpha term is a constant that controls how strong the pull of the goal is.

* **Repulsive Force** is used to avoid obstacles and can be calculated using the following formula:

The repulsive potential is only computed when d(x - x_obs) < Qmax. That is, when the robot is near to obstacles at a distance less than *Qmax*.

* *x_goal* is the goal location.
* *x_obs* is the obstacle location.
* *d(...)* is the distance metric.

Here's an example of a potential field generated in a local portion of the map:

In this example, the red dot represents the goal location.

## Receding Horizon Planning

Every presented algorithm has its advantages and disadvantages but usually accuracy and time complexity are the main ones and we should find a trade off between them to be able to perform motion planning in real time and react to uncertainties like new obstacles, wind or other flying objects/vehicles.

Ideally, we would like to have a global path to follow that could be represented as a graph or a low resolution grid, and then maintain a local high resolution map to be able to replan over the global trajectory and avoid obstacles.

This local planner could be a high resolution 3D grid centered on the vehicle where the goal is the cell that is nearest to the next waypoint or a potential field centered on the next waypoint.

In the following picture we can see an example of a high resolution grid discretized in 1m^3 voxels:

Concretely, the obstacles (voxels) in the above map represent trees from this environment:

This way, we can have a really accurate representation of the environment and finetune the original global path as we follow the waypoints.

## Implementation

In my final implementation, I plan a global path from the starting position to a goal location using a low resolution grid discretized in 10m^3 voxels, so this will lead in a fast computation of a global plan due to the small amount of cells that have to be searched.

Then, I continuously replan using a 3D 40x40x10 m volume around the current location and calculate a path inside this high resolution grid setting the goal as a limit node in the direction of the next waypoint.

In real world planning, we plan a local trajectory starting from the last calculated trajectory. This is done because there is a delay between the calculation of a trajectory and the actual execution of the trajectory as well as to be able to obtain a smooth transition between one trajectory and the next one.

In my code, I maintain 5 local waypoints for the drone to follow so the receding horizon trajectory is calculated from the last calculated waypoint. The higher the number of local waypoints that we consider, the less we will react to changes in the environment.

[This video](./misc/vid.mp4) shows how the drone follows an inaccurate global path successfully avoiding obstacles thanks to the continuous replanning from the local high resolution grid.

## Reference

* https://www.udacity.com/course/flying-car-nanodegree--nd787
* https://svn.sable.mcgill.ca/sable/courses/COMP763/oldpapers/yap-02-grid-based.pdf
* https://en.wikipedia.org/wiki/Voronoi_diagram#:~:text=In%20mathematics%2C%20a%20Voronoi%20diagram,%2C%20sites%2C%20or%20generators
* https://www.researchgate.net/publication/221350731_Java_Applets_for_the_Dynamic_Visualization_of_Voronoi_Diagrams
* https://en.wikipedia.org/wiki/Rapidly-exploring_random_tree
* https://medium.com/@rymshasiddiqui/path-planning-using-potential-field-algorithm-a30ad12bdb08#:~:text=A%20potential%20field%20is%20any,around%20in%20a%20certain%20space.


text:
## Send Referral Emails

### swellAPI.identifyReferrer()
```javascript

$(document).on("swell:setup", function() {
  var customersInput = $("#customers-input");
  var sendEmailBtn = $("#customers-send-btn");

  $(sendEmailBtn).click(function() {
    onSuccess = function() {
      $("#success").show();
    }

    onError = function() {
      $("#error").show();
    }

    swellAPI.identifyReferrer(email, onSuccess, onError);
  });
})

```

This method takes an email address as a string to identify the email to attribute referred emails to. This is useful if you are building a custom referral program experience in which logged out customers can still participate.

#### Parameters

Parameter | Type | Description
----------|------|------------
email | string | The email address of the customer who will be referring
onSuccess | function | The function to be called if the email is sent successfully
onError | function | The function to be called if the email is sent unsuccessfully

### swellAPI.sendReferralEmails()
```javascript

  $(document).on("swell:setup", function() {
    var referredCustomersInput = $("#referred-customers-input");
    var sendEmailsBtn = $("#referred-customers-send-btn");

    $(sendEmailsBtn).click(function() {
      // assuming you allowed comma separated email input
      var emails = referredCustomersInput.val().split(",");

      var onSuccess = function() {
        $("#success").show();
      }

      var onError = function(err) {
        $("#error").show();
      }

      swellAPI.sendReferralEmails(emails,onSuccess, onError);

    });
  });

```

This method takes an array of email addresses to send the referral email share email to.  This is useful if you are building a custom referral program experience and want your customer to be able to share his referral link with his or her friends via email.

#### Parameters

Parameter | Type | Description
----------|------|------------
emails | array | An array containing the email addresses of those referred
onSuccess | function | The function to be called if the email is sent successfully
onError | function | The function to be called if the email is sent unsuccessfully

repository: SwellRewards/slate

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: NOASSERTION

license_type: permissive

repo_name: SwellRewards/slate


text:
---
title: flac.exe |
excerpt: What is flac.exe?
---

# flac.exe

* File Path: `C:\Program Files (x86)\MusicBee\Codec\flac.exe`

## Hashes

Type | Hash
-- | --
MD5 | `5E7EB27A3B9857C3BDBE57193D7EEFD4`
SHA1 | `C84472A15355C149320830EEF80D64B86F081BFE`
SHA256 | `BC40922B374126B65F4B82F2FC83685421C7FCF409BD1598892DF26A45E17075`
SHA384 | `516588C87E6C9A30961A6E73B5E49F8272E83DE0E4B70765D6DD799191B8F528F5959F4F0BFDE197169A2707E8A05BF1`
SHA512 | `1748B4ACFF6A2BC72DFA89CBAAE7B1F7AB5C32532D5601D56936C7CBCA1FB87F4B5E4A01D7C240F737105B9E9B6CF18258E4BBD396C4E38928215334E7519B2A`
SSDEEP | `12288:TY6Yi7JdO9+yC7GnFhSkn7nW6D8YMHIdF:iil49+yC7CFUkn7nWa8YyIdF`
IMP | `7EA35F193D3FE2323FA2820F78684F48`
PESHA1 | `60231FF51213A66024EB1C5012A011AD7D220F9E`
PE256 | `0B2EE1390B233D053E095F1ABCFD2DB3344F56D40AFC76EAFD71D4054192F850`

## Runtime Data

### Usage (stdout):
```cmhg
===============================================================================
flac - Command-line FLAC encoder/decoder version 1.3.2
Copyright (C) 2000-2009  Josh Coalson
Copyright (C) 2011-2016  Xiph.Org Foundation

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
===============================================================================
Usage:

 Encoding: flac [<general-options>] [<encoding/format-options>] [INPUTFILE [...]]
 Decoding: flac -d [<general-options>] [<format-options>] [FLACFILE [...]]
  Testing: flac -t [<general-options>] [FLACFILE [...]]
Analyzing: flac -a [<general-options>] [<analysis-options>] [FLACFILE [...]]

Be sure to read the list of known bugs at:
http://xiph.org/flac/documentation_bugs.html

general options:
  -v, --version                Show the flac version number
  -h, --help                   Show this screen
  -H, --explain                Show detailed explanation of usage and options
  -d, --decode                 Decode (the default behavior is to encode)
  -t, --test                   Same as -d except no decoded file is written
  -a, --analyze                Same as -d except an analysis file is written
  -c, --stdout                 Write output to stdout
  -s, --silent                 Do not write runtime encode/decode statistics
      --totally-silent         Do not print anything, including errors
      --no-utf8-convert        Do not convert tags from local charset to UTF-8
  -w, --warnings-as-errors     Treat all warnings as errors
  -f, --force                  Force overwriting of output files
  -o, --output-name=FILENAME   Force the output file name
      --output-prefix=STRING   Prepend STRING to output names
      --delete-input-file      Deletes after a successful encode/decode
      --preserve-modtime       Output files keep timestamp of input (default)
      --keep-foreign-metadata  Save/restore WAVE or AIFF non-audio chunks
      --skip={#|mm:ss.ss}      Skip the given initial samples for each input
      --until={#|[+|-]mm:ss.ss}  Stop at the given sample for each input file
      --ogg                    Use Ogg as transport layer
      --serial-number          Serial number to use for the FLAC stream
analysis options:
      --residual-text          Include residual signal in text output
      --residual-gnuplot       Generate gnuplot files of residual distribution
decoding options:
  -F, --decode-through-errors  Continue decoding through stream errors
      --cue=[#.#][-[#.#]]      Set the beginning and ending cuepoints to decode
encoding options:
  -V, --verify                 Verify a correct encoding
      --lax                    Allow encoder to generate non-Subset files
      --ignore-chunk-sizes     Ignore data chunk sizes in WAVE/AIFF files
      --sector-align (DEPRECATED) Align multiple files on sector boundaries
      --replay-gain            Calculate ReplayGain & store in FLAC tags
      --cuesheet=FILENAME      Import cuesheet and store in CUESHEET block
      --picture=SPECIFICATION  Import picture and store in PICTURE block
  -T, --tag=FIELD=VALUE        Add a FLAC tag; may appear multiple times
      --tag-from-file=FIELD=FILENAME   Like --tag but gets value from file
  -S, --seekpoint={#|X|#x|#s}  Add seek point(s)
  -P, --padding=#              Write a PADDING block of length #
  -0, --compression-level-0, --fast  Synonymous with -l 0 -b 1152 -r 3
  -1, --compression-level-1          Synonymous with -l 0 -b 1152 -M -r 3
  -2, --compression-level-2          Synonymous with -l 0 -b 1152 -m -r 3
  -3, --compression-level-3          Synonymous with -l 6 -b 4096 -r 4
  -4, --compression-level-4          Synonymous with -l 8 -b 4096 -M -r 4
  -5, --compression-level-5          Synonymous with -l 8 -b 4096 -m -r 5
  -6, --compression-level-6          Synonymous with -l 8 -b 4096 -m -r 6
                                        -A tukey(0.5) -A partial_tukey(2)
  -7, --compression-level-7          Synonymous with -l 12 -b 4096 -m -r 6
                                         -A tukey(0.5) -A partial_tukey(2)
  -8, --compression-level-8, --best  Synonymous with -l 12 -b 4096 -m -r 6
                    -A tukey(0.5) -A partial_tukey(2) -A punchout_tukey(3)
  -b, --blocksize=#                  Specify blocksize in samples
  -m, --mid-side                     Try mid-side coding for each frame
  -M, --adaptive-mid-side            Adaptive mid-side coding for all frames
  -e, --exhaustive-model-search      Do exhaustive model search (expensive!)
  -A, --apodization="function"       Window audio data with given the function
  -l, --max-lpc-order=#              Max LPC order; 0 => only fixed predictors
  -p, --qlp-coeff-precision-search   Exhaustively search LP coeff quantization
  -q, --qlp-coeff-precision=#        Specify precision in bits
  -r, --rice-partition-order=[#,]#   Set [min,]max residual partition order
format options:
      --force-raw-format       Treat input or output as raw samples
      --force-aiff-format      Force decoding to AIFF format
      --force-rf64-format      Force decoding to RF64 format
      --force-wave64-format    Force decoding to Wave64 format
raw format options:
      --endian={big|little}    Set byte order for samples
      --channels=#             Number of channels
      --bps=#                  Number of bits per sample
      --sample-rate=#          Sample rate in Hz
      --sign={signed|unsigned} Sign of samples
      --input-size=#           Size of the raw input in bytes
negative options:
      --no-adaptive-mid-side
      --no-cued-seekpoints
      --no-decode-through-errors
      --no-delete-input-file
      --no-error-on-compression-fail
      --no-preserve-modtime
      --no-keep-foreign-metadata
      --no-exhaustive-model-search
      --no-lax
      --no-mid-side
      --no-ogg
      --no-padding
      --no-qlp-coeff-prec-search
      --no-replay-gain
      --no-residual-gnuplot
      --no-residual-text
      --no-ignore-chunk-sizes
      --no-sector-align
      --no-seektable
      --no-silent
      --no-force
      --no-verify
      --no-warnings-as-errors

```

### Usage (stderr):
```cmhg

flac 1.3.2
Copyright (C) 2000-2009  Josh Coalson, 2011-2016  Xiph.Org Foundation
flac comes with ABSOLUTELY NO WARRANTY.  This is free software, and you are
welcome to redistribute it under certain conditions.  Type `flac' for details.

ERROR: can't open input file C:\temp\strontic-xcyclopedia\notepad.exe: Permission denied

```

### Child Processes:
conhost.exe

### Loaded Modules:

Path |
-- |
C:\Program Files (x86)\MusicBee\Codec\flac.exe |
C:\Windows\SYSTEM32\ntdll.dll |
C:\Windows\System32\wow64.dll |
C:\Windows\System32\wow64cpu.dll |
C:\Windows\System32\wow64win.dll |

## Signature

* Status: The file C:\Program Files (x86)\MusicBee\Codec\flac.exe is not digitally signed. You cannot run this script on the current system. For more information about running scripts and setting execution policy, see about_Execution_Policies at https:/go.microsoft.com/fwlink/?LinkID=135170
* Serial: ``
* Thumbprint: ``
* Issuer:
* Subject:

## File Metadata

* Original Filename:
* Product Name:
* Company Name:
* File Version:
* Product Version:
* Language:
* Legal Copyright:
* Machine Type: 32-bit

## File Scan

* VirusTotal Detections: 1/72
* VirusTotal Link: https://www.virustotal.com/gui/file/bc40922b374126b65f4b82f2fc83685421c7fcf409bd1598892df26a45e17075/detection/

MIT License. Copyright (c) 2020-2021 Strontic.

license: MIT


text:
# WhatsApp

TODO: Write a gem description

## Installation

Add this line to your application's Gemfile:

    gem 'whatsapp'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install whatsapp

## Usage

  ### Create a client using the phone number and password

  ```
    require 'whatsapp'
    client = WhatsApp::Client.new(phone_number, nickname)
    client.connect
    client.auth(password)

  ```


text:
### [CVE-2023-23900](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-23900)
![](https://img.shields.io/static/v1?label=Product&message=Easy%20Forms%20for%20Mailchimp&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-79%20Improper%20Neutralization%20of%20Input%20During%20Web%20Page%20Generation%20('Cross-site%20Scripting')&color=brighgreen)

### Description

Unauth. Reflected Cross-Site Scripting (XSS) vulnerability in YIKES, Inc. Easy Forms for Mailchimp plugin <= 6.8.8 versions.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/fkie-cad/nvd-json-data-feeds

repository: trickest/cve

branch_name: refs/heads/main

gha_language: HTML

gha_license_id: MIT

repo_name: trickest/cve


text:
# How to add custom configurations

So let's say, you want to add custom variables to your applications configuration file.
Let's say for this documentation you want add a variable for an e-mail address. Then there are 2 ways you can do this.

**1.** Add this to the `config/app.php`

**2.** Create a separate configuration file.

Let's discuss both ways.

### **Way 1**

You need to add a line of code that will be this:

```php
define('key', 'value');
```

Let's say our e-mail address is<EMAIL_ADDRESS>and our key will be **APP_MAIL** we need to add the code like:

```php
define('APP_MAIL', 'shw@example.com');
```

Now that we have done that we need to go to the file **SimpleHtmlWork/helpers/Config.php**, and we need to add that line of code to the array.
So let's do that now. The array by default is:

```php
$str = array(
    'name' => APP_NAME,
    'lang' => APP_LANG,
    'url' => APP_URL,
    'cdn' => APP_CDN,
);
```

The only thing we need to do is add our custom configuration key to that array. So we will do that like:

```php
$str = array(
    'name' => APP_NAME,
    'lang' => APP_LANG,
    'url' => APP_URL,
    'cdn' => APP_CDN,
    // Below we will add the custom configuration variable.
    'mail' => APP_MAIL
);
```

Now that we have done that we can get the mail value of our application with the **Config helper**. For that please check [this](helpers.md) documentation.

### **Way 2**

If you have a lot of these custom configuration, and you want to keep them all separate you can also create a new file inside the config directory.
Let say we have a lot of variables for our application e-mail we will add a new file inside the **config** directory and name the file **mail.php**

Now that we have created the **mail.php** configuration file you need to add a code with a key and a value. So let's say we have 3 e-mail addresses for our application then we also will have 3 keys and 3 values. For example like:

* Email one
    * **MAIL_INFO**
    *<EMAIL_ADDRESS>* Email two
    * **MAIL_ABUSE**
    *<EMAIL_ADDRESS>* Email three
    * **MAIL_PAYMENTS**
    *<EMAIL_ADDRESS>
We also need to add this inside our **mail.php** file. With the below code:

```php
define('MAIL_INFO', 'info_shw@exmaple.com');
define('MAIL_ABUSE', 'abuse_shw@exmaple.com');
define('MAIL_PAYMENTS', 'pay_shw@exmaple.com');
```

Now that we have done that we need to go to the file **SimpleHtmlWork/helpers/Config.php**, and we need to add that lines of code to the array.
So let's do that now. The array by default is:

```php
$str = array(
    'name' => APP_NAME,
    'lang' => APP_LANG,
    'url' => APP_URL,
    'cdn' => APP_CDN,
);
```

The only thing we need to do is add our custom configuration keys to that array. So we will do that like:

```php
$str = array(
    'name' => APP_NAME,
    'lang' => APP_LANG,
    'url' => APP_URL,
    'cdn' => APP_CDN,
    // Below we will add the custom configuration variables.
    'info_mail' => MAIL_INFO,
    'abuse_mail' => MAIL_ABUSE,
    'pay_mail' => MAIL_PAYMENTS
);
```

Now that we have done that we can get the mail value of our application with the **Config helper**. For that please check [this](helpers.md) documentation.

repository: bttmusercontent/SimpleHtmlWork

repo_name: bttmusercontent/SimpleHtmlWork


text:
Leads Management
=========

The Splynx Leads module was specially designed to ease the consuming tasks and activities related to sales, and prospective customers. Each sub-module in the Leads module, ultimately contributes to the overall goal of achieving a managed, convenient and successful process for dealing with prospective customer relationships.

Below are tutorial pages for each of the aspects available for management in the Splynx Leads module:

* [Dashboard](crm/dashboard/dashboard.md)

* [Documents](crm/documents/documents.md)

* [Leads](crm/leads/leads.md)

* [Quotes](crm/quotes/quotes.md)

repository: splynx/docs

repo_name: splynx/docs


text:
# ddry-mocha-tape

[![Build Status](https://travis-ci.org/ddry/ddry-mocha-tape.svg?branch=master)](https://travis-ci.org/ddry/ddry-mocha-tape) [![Coverage Status](https://coveralls.io/repos/github/ddry/ddry-mocha-tape/badge.svg?branch=master)](https://coveralls.io/github/ddry/ddry-mocha-tape?branch=master) [![dependencies Status](https://david-dm.org/ddry/ddry-mocha-tape/status.svg)](https://david-dm.org/ddry/ddry-mocha-tape) [![devDependencies Status](https://david-dm.org/ddry/ddry-mocha-tape/dev-status.svg)](https://david-dm.org/ddry/ddry-mocha-tape?type=dev)

<img src="https://cloud.githubusercontent.com/assets/5163953/22628172/6b91f120-ebe0-11e6-8456-0f5b2dc3a553.png" alt="ddry logo" width="250">

Mounts three test harnesses and three test utility modules to **ddry**. It's hardly believable that you'll ever need this setup, it is for testing **ddry** itself mostly.

Includes:

- [ddry](https://www.npmjs.com/package/ddry) v0.1.28
- [Mocha](https://www.npmjs.com/package/mocha) v6.1.4
- [TAP](https://www.npmjs.com/package/tap) v13.1.2
- [Tape](https://www.npmjs.com/package/tape) v4.10.1
- [ddry-tap-spec](https://www.npmjs.com/package/ddry-tap-spec) v0.0.3
- [nyc](https://www.npmjs.com/package/nyc) v14.1.0
- [coveralls](https://www.npmjs.com/package/coveralls) v3.0.3
- [mocha-lcov-reporter](https://www.npmjs.com/package/mocha-lcov-reporter) v1.3.0

Anyway, this powerful setup enables this module to be used in **ddry** as only **devDependency**.

Version reflects **ddry** version.

### Few words about ddry

It is made to remove all the error-prone code clutter from testing. No more fiddling with `require` target code modules for testing or assertion libraries. You simply _(convention-over-configuration)_ organize your spec folder similar to your code folder, where module spec folder structure resembles module properties and methods structure, and in `spec/someFolder/someModule/someMethod.js` file you have the context of `someMethod` of `someModule` without any requiring — [ddry](https://www.npmjs.com/package/ddry) does it for you seamlessly and transparently. Then in this way placed file

```coffee
'use strict'

module.exports = (dd) ->
  dd.drive [
    it: 'does everything correctly'
    i: [ 'arguments', 'a', 'method', 'receives' ]
    e: 'value it returns'
  ]
```

And that's it. `i` is for input, `e` is for expected. Let's keep focused on data flow. Pray excuse me who think that `require`, `assert`, `expect` etc. are the essence of testing.

This data-driven code will be adapted and passed by [ddry](https://www.npmjs.com/package/ddry) to any of three JS test harnesses: [Mocha JS](https://www.npmjs.com/package/mocha), [TAP](https://www.npmjs.com/package/tap) or [Tape JS](https://www.npmjs.com/package/tape). [ddry](https://www.npmjs.com/package/ddry) itself is fully covered on all of them with unified harness-agnostic codebase.

Also [ddry](https://www.npmjs.com/package/ddry) has:
- cross-harness features: context, before/after hooks and x-style skipping and mass-skipping;
- powerful default matchers set including `plain`, `contains` and `error` and easy custom matchers adding;
- spec sequence syntax allowing to use one setting through multiple specs;
- convention-over-configuration folder-style module instances support;
- easily configurable instantiable attachable spec helper;
- Selenium Webdriver support (with Mocha only);
- `ddry` shell command to maintain the project spec config file `ddry.json`;
- test harness specific commands `ddry-tap` etc. to comfortly run the specs of your choice against test harness of your choice;
- some cute minor features.

Plainly, a decent set of capabilities to make JS testing easy and even fun.

### ddry command line interface

ddry CLI gives you convenient access to your data-driven specs by
- keeping their config in `ddry.json` file;
- implementing powerful features for maintaining this config file;
- applying **only-except** style suite running scope with one shell command.

_**Only-except** scoping logic is applicable to modules folders, modules and module methods levels._

In your development environment you may want to get easy access to `ddry` shell command by installing [ddry](https://www.npmjs.com/package/ddry) globally:

```sh
$ sudo npm i -g ddry
```

`ddry` shell command is just a spec configuring tool, it does not perform any actual testing which is task of harness-specific commands as well as spec suite execution scoping. This package is one of four test harness specific **ddry** optional dependencies packages solving two main tasks:
- adding viable `devDependencies` set — **ddry** core and all three test harnesses — to `package.json`;
- implementing harness-specific shell commands `ddry-mocha`, `ddry-tap` and `ddry-tape`.

Other three are
- [ddry-mocha](https://www.npmjs.com/package/ddry-mocha) for Mocha JS;
- [ddry-tap](https://www.npmjs.com/package/ddry-tap) for TAP;
- [ddry-tape](https://www.npmjs.com/package/ddry-tape) for Tape JS.

Easy access to `ddry-mocha`, `ddry-tap` and `ddry-tape` commands is obtained by installing this package globally:

```sh
$ sudo npm i -g ddry-mocha-tape
```

### Spec suite configuring tool

Well, we have `devDependencies` installed and set of shell commands. Now you can start your `ddry.json` file with `$ ddry i` (`init`) command. It is very easy and welcoming and has quite comprehensive documentation accessible via `$ ddry ? i` command.

Then you can populate your spec folder with data-driven specs and adjust `ddry.json` file for running specs from within the test harness of your choice. Just pass to it the `./node_modules/ddry/ddry.js` file. Please check [Makefile](https://github.com/ddry/ddry-mocha-tape/blob/master/Makefile) of this project for examples for every supported test harness.

`ddry.json` contains full information on data-driven testing of the project. It may have or may not have advanced configuration options which are subject to [ddry](https://www.npmjs.com/package/ddry) core documentation. Anyway, whatever comfort you may have in addition to editing `ddry.json` manually, `ddry` shell command delivers.

With `config` or `c` command you can plug your own JS module receiving arguments and returning the config object you need. That is how config editing automation is solved here.

With `titles` or `t` command you can parse your code folder for module titles taken from the first block comment. Also this command builds the system file `cli.json` used for spec suite execution scoping. If scoping fails, `ddry t` will fix it likely.

With `addScope` or `as` and `removeScope` or `rs` commands you can set and unset permanent **only-except** scopes that will affect running spec from within test harness.

With `add` or `a` and `remove` or `r` commands you can add and remove values of config object. These two commands are rather for compatibility, scoping commands described above or manual editing of `ddry.json` look much more appropriate.

`usage` or `?` or `h` command outputs usage info — summary or for given command. We don't need to reproduce it here.

### Spec suite execution scoping

`ddry-<mocha|tap|tape>` without parameters will launch the entire suite configured in `ddry.json` against its harness.

Use `-e` and `-o` keys for **except** and **only** scoping strategies applied to `tab`-completed code or spec files or folders. Inside code folder you have access to module folders and module level, inside spec folder you may scope method-wise. Keys you use with `ddry-tap` command will have effect only once, while this shell command runs.

As mentioned above, to manage permanent scopes in `ddry.json` you may use `$ ddry as` and `$ ddry rs` commands — they will translate to config object style (dot-notated, by the way) your `tab`-completed findings.

### Programmatical usage
**(obsolete)**

Feed to the test harness any JS file of your choice and start **ddry** modular usage from

```coffee
spec = require('ddry/modular')()
spec.apply
  title: 'Your awesome module'
  code: 'lib'
  spec: 'spec'
```

or even ultimately superlatively obsolete basic plain usage:
```coffee
DataDriven = require 'ddry'
```

But I think you really want CLI for actual work. Editing the spec config in and out for use-once scopes is as boring to death probably as `grep`-ping around your tests.

repository: ddry/ddry-mocha-tape

gha_language: CoffeeScript

repo_name: ddry/ddry-mocha-tape


text:
# LOAM

Original repository: https://github.com/laboshinl/loam_velodyne

## Build
```bash
cd loam/docker
./build.sh
```

## Run

### On host:
```bash
roscore
```

```bash
rosparam set use_sim_time true
rviz -d loam/rviz_cfg/loam_velodyne.rviz
```

```bash
rosbag play --clock nsh_indoor_outdoor.bag
```
nsh_indoor_outdoor.bag: https://drive.google.com/file/d/1s05tBQOLNEDDurlg48KiUWxCp-YqYyGH/view

### On docker image:
```bash
cd loam/docker
./run.sh

roslaunch loam_velodyne loam_velodyne.launch
```

![loam](https://user-images.githubusercontent.com/31344317/98347880-5da2df80-205b-11eb-8aae-abfd8fc67f70.gif)


text:
# Translucent-windows-2018-code
Code to generate and analyze data for D'Andrea et al. Ecol. Lett. 2018

NoiseModel.r contains functions to create the competition kernel and run the Lotka-Volterra competition models presented in D'Andrea et al. Ecology Letters 2018.

KmeansGap.r contains the fucntion used to measure clustering in the data. It receives a data frame with traits and abundances of each species, and returns the gap index and number of clusters in the species assemblage, along with a z-score (i.e. standardized effect size of the gap index) and p-value.

Any questions about the code can be directed to the author, Rafael D'Andrea (rdandrea@illinois.edu).


text:
# Scalacheck Magnolia

Generation of arbitrary case classes / ADTs instances with [Scalacheck](https://github.com/rickynils/scalacheck) and [Magnolia](https://github.com/propensive/magnolia)!

### Why?

Because [scalacheck-shapeless](https://github.com/alexarchambault/scalacheck-shapeless) is good but too slow.
Also this is much smaller and understandable, thanks to [Magnolia](https://github.com/propensive/magnolia)!

### Install

Just copy the files in src/main/scala to your project.
It's 2 files, less than 60 lines in total!
And you don't have to care about updating Scalacheck or Magnolia

### How to use it?

```scala

import scalacheckmagnolia.MagnoliaArbitrary._
import org.scalacheck._

case class Example(a: String, b: Long)

val arbitraryExample = implicitly[Arbitrary[Example]]

println(arbitraryExample.arbitrary.sample.get)

```

# Links

* https://www.scalacheck.org/
* http://magnolia.work/

repository: etaty/scalacheck-magnolia

gha_language: Scala

repo_name: etaty/scalacheck-magnolia


text:
# Initial setup

## Install redis

- [homebrew example](https://medium.com/@petehouston/install-and-config-redis-on-mac-os-x-via-homebrew-eb8df9a4f298)

## Create a virtualenv

These instructions assume [virtualenvwrapper](http://virtualenvwrapper.readthedocs.io/en/latest/install.html) is installed.

```
# Do this from the top directory, e.g. within `raven-metadata-service`
mkvirtualenv preprocess
pip install -r requirements/30_preprocess_web.txt
```

## Open three Terminals

For each of these windows, 1st `cd` into `raven-metadata-service`

- Terminal 1 - Run Redis

```
cd preprocess_web/code
workon preprocess
fab redis_run
```

- Terminal 2 - Run Celery

```
cd preprocess_web/code
workon preprocess
fab celery_run
```

- Terminal 3 - Run Web Server

```
cd preprocess_web/code
workon preprocess
fab run_web
```

## File upload

- Try this page:
  - http://<IP_ADDRESS>:8080/preprocess/form-basic-upload
  - Refresh the response after the file is uploaded

repository: TwoRavens/raven-metadata-service

branch_name: refs/heads/develop

gha_language: Python

repo_name: TwoRavens/raven-metadata-service


text:
# Programming in Haskell -- Exercises and notes

This repository contains my learnings, practice code snippets and solutions to exercises in the process of my learning of Haskell using "Programming in Haskell".

## Book
The book I used is Graham Hutton's [Programming in Haskell](http://www.cs.nott.ac.uk/~pszgmh/pih.html).

My progress is indicated below [based on the original chapters of the book]

### Part I. Basic Concepts:
- [x] 1. [Introduction](https://github.com/P7h/Programming_in_Haskell/tree/master/Chap%231__Introduction)
- [x] 2. [First Steps](https://github.com/P7h/Programming_in_Haskell/tree/master/Chap%232__First_steps)
- [x] 3. [Types and classes](https://github.com/P7h/Programming_in_Haskell/tree/master/Chap%233__Types_and_classes)
- [x] 4. [Defining Functions](https://github.com/P7h/Programming_in_Haskell/tree/master/Chap%234__Defining_functions)
- [x] 5. [List Comprehensions](https://github.com/P7h/Programming_in_Haskell/tree/master/Chap%235__List_comprehensions)
- [x] 6. [Recursive Functions](https://github.com/P7h/Programming_in_Haskell/tree/master/Chap%236__Recursion)
- [ ] 7. Higher-Order Functions :construction:
- [ ] 8. Declaring types and classes
- [ ] 9. The countdown problem

### Part II. Going Further:
- [ ] 10. Interactive programming
- [ ] 11. Unbeatable tic-tac-toe
- [ ] 12. Monads and more
- [ ] 13. Monadic parsing
- [ ] 14. Foldables and friends
- [ ] 15. Lazy evaluation
- [ ] 16. Reasoning about programs
- [ ] 17. Calculating compilers

## MOOC
I also used edX MOOC [Introduction to Functional Programming](https://www.edx.org/course/introduction-functional-programming-delftx-fp101x-0) which had Erik Meijer as the instructor as the reference while reading the book since this course is loosely based on the chapters and the slides of the book.

MOOC also helped me to validate my solutions for all the exercises of the book and also some new ones in the MOOC.

Just a note, MOOC dint run this year yet. I am using the archived session of the course which ran late 2015.

## License
Copyright © 2016 Prashanth Babu.

Licensed under the [Apache License, Version 2.0](LICENSE).


text:
# Dragon Scourge
- See also: [Dragon Knight](https://github.com/renderse7en/dragon-knight)
- [Live Demo](http://www.dragonscourge.com/play)
- Old README: https://github.com/renderse7en/dragon-scourge

# System Requirements
- PHP (4.1 and higher)
- MySQL
- zlib compression enabled on your server (optional)

# Installation Instructions
1. Clone this repo or download the zip.
2. Create a new database for Dragon Scourge to use, if you don't already have one set up.
3. Edit `config.php` to include the correct values for your database setup.
4. Upload the contents of the Dragon Scourge folder to your site.
5. Using a MySQL client such as HeidiSQL or PHPMyAdmin, run the contents of `install.sql` on the database you created.
7. Enjoy the game.


text:
# Filter
filter is a simple program that applies sobel edge detection filter to **png files**.

Original:
![original](img/map.png)

Filtered:
![filtered](img/filtered-map.png)

## Dependencies
This repository depends on the following shared libraries:
* OpenCL
* png

## Modules Requires?
filter allows a fallback mechanism to not always use the GPU whenever it's not possible.
To enable the GPU and newest c++17, you need to add a module in Palmetto:

```sh
module load cuda-toolkit gcc/8.2.0
```

## Compilation
Make sure that you have the above dependencies installed. Then, go to the source code
directory and issue:

```sh
make
```

This will compile everything and generates a program called `filter`.

## How to test?

filter requires 2 arguments: src and dst. `src` is the original image path.
`dst` is the output path.

In the source code directory, there's a sample image file called `map.png` which you can
use to see if this program works by using:

```sh
./filter img/map.png filtered-map.png
```


text:
---
layout: default
---

# 1996-01-03 - Re: Guerilla Internet Service Providers (fwd)

## Header Data

From: Steve Gibbons<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 6e6373574cb8fc24567d45a403da2cb17a392d404878a55357c5e67e47f14eaf

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-01-03 11:21:11 UTC

Raw Date: Wed, 3 Jan 1996 19:21:11 +0800

## Raw message

```
{% raw  %}From: Steve Gibbons<EMAIL_ADDRESS>Date: Wed, 3 Jan 1996 19:21:11 +0800
To<EMAIL_ADDRESS>Subject: Re: Guerilla Internet Service Providers (fwd)
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

In Article<EMAIL_ADDRESS><EMAIL_ADDRESS>(Lucky Green) wrote:
# At 22:51 1/2/96, Steve Gibbons wrote:

# >I had a similar thought about a month ago.  In particular, I was thinking that
# >skyrise office buildings would be a great market for ISPs to target.  Rent a
# >closet in the basement/top floor close to the telco demarc.  Run lots of
# >UTP to
# >the cients through the existing conduit, ceiling acces, air ducts, or whatever
# >and boom, lots  of clients, low overhead, telco bills cut to 1/2 of the
# >competitions'.  Up-front costs might (or might not be) higher, since the wire
# >installation would now be the burden of the ISP.
# [...]
# >FWIW, (and if anyone winds up doing something like this, I want a "finders
# >fee" ;-) )

# Sorry, I thought of this months ago :-)

But did you post/publish?  :)

# But there is an even better
# business opportunity out there. Wireless T1 service covering a whole
# downtown area. I speced the whole system for the last company I worked for
# before they ran out of money. My calculations show that you can deliver
# close to T1 speed to corporate customers at fraction of the cost using land
# lines. In the best case scenario, you can produce the individual connection
# at below $200. No land line based ISP can ever touch that. The total cost
# for a land line based IPS is at least $395/T1. Set-up fee is lower too.
# Best, the whole thing can be set up self financing. If I wasn't so busy
# with other projects, I'd implement it myself.

I'd be interested in seeing your numbers and cost breakdowns.  I'd really be
interested in the up-front costs that would be associated with the equipment
and set-up time/training that will help "insure" data privacy over wideley
broadcast media.  The up-front costs for ~T1 capable tranceivers isn't
insignificant either.  I figure ~$10K up front (maybe half of that, maybe twice
when you include management overhead)  Amortize  over 3 years, and compare.

All of this is assuming that the bandwidth is available on the airwaves to
handle ~200 ~T1s.  (If we're talking $200.00/mo. for T1, sign me up tomorrow,
and my neighbor, and his, and hers, and...  *poof* no more bandwidth in a
"decently" populated metro area or even a downtown.  (Back of the envelope
calculations show that ~200 T1 ~= 1 TV station [although I might be off by an
order of magnitude.])

I apologize if this is off topic, but the crypto part still applies (moreso,
even!) to broadcast over the airwaves.  (Besides, I'm sure that this list has
enough subscribers that are shelling out $200-$500/mo. for 56K/Frac T1/ISDN
that they'd be interested in a less expensive alternative.)

--
<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [January 1996](/archive/1996/01)

+ Return to "[Steve Gibbons <steve@aztech.net>](/authors/steve_gibbons_steve_at_aztech_net_)"

+ 1996-01-03 (Wed, 3 Jan 1996 19:21:11 +0800) - Re: Guerilla Internet Service Providers (fwd) - _Steve Gibbons<EMAIL_ADDRESS>


text:
# TODO

Short term:
===========

  - [ ] find non-opt + debug-log-level concurrency bug (endless test execution)
  - [ ] refactor replication read and write functions
  - [ ] avoid double-read on store during eval -- integrate store-read with locks?
  - [ ] figure out sensible trigger conditions on lattice agreement rounds
  - [ ] maybe clean up the communication plumbing a bit, it's a mess
  - [ ] address question of straggling in watermarks. do we definitely wait on everyone? I guess so?
  - [ ] figure out where the reconfiguration safe-points are and how to detect /
        what to do about in-progress txns during reconfigurations.
  - [ ] switch everything to sorted_vec_maps

Longer term
===========

  - [ ] evaluate the paper's "GC watermark" concept, see if it fits
  - [ ] implement some nontrivial Lang for testing at least
  - [ ] write preliminary log-structured storage backend with column sketches for Store
  - [ ] figure out if there's a nice way to have epochs in the peer-set lattice (&
        peer ID space -- or just stick with big-and-random IDs?)
  - [ ] add some kind of table / database / application-space identifiers
  - [ ] everything else... many TODOs scattered through code

Done
====

  - [X] clean up and document at least the public parts
  - [X] switch everything to tracing
  - [X] add fully-evaluated watermark to collect dead eval locks
  - [X] track successful write-set, and only finalize each after it's actually been written
  - [X] switch edelcrantz to postcard
  - [X] implement put() at end of evaluation
  - [X] implement read-from-local when under fully-replicated watermark
  - [X] fix locking / implement proper lock manager / deal with deadlock
  - [X] figure out correct arrangement of test/bin
  - [X] WONTFIX: fix lattice agreement / sending gets before vwatermark advances
  - [X] decide on a representation for GlobalTime. Maybe avoid being clever with
        bit-packing and let the storage layer do that per-segment via range and dictionary coding.


text:
maybe_tls
=========

An implementation of golang's
[`net.Listener` interface](https://golang.org/pkg/net/#Listener) that accepts both
TCP and TLS-over-TCP connections on the same port.

Example
-------

To use, create a `net.Listener` and a `tls.Config` object first, then wrap them
in a `maybe_tls.Listener`:

```
config := tls.Config{Certificates: []tls.Certificate{keypair}}
ln, err := net.Listen("tcp", ":1234")
if err != nil {
  // Handle error
}
mln := maybe_tls.Listener{ln, &config}
```
Then use the `maybe_tls.Listener` just as you would a `net.Listener`. You can
detect whether the accepted connection is encrypted or not by testing whether
it's a `tls.Conn`:

```
conn, err := mln.Accept()
switch conn.(type) {
default:
    // It's a plain TCP connection
case *tls.Conn:
    // It's a TLS connection
}
```

Restrictions
------------

`maybe_tls.Listener` works by trying to figure out whether the first few bytes
that a client sends look like a TLS ClientHello message. If so, the data from
the connection is "rewound" and wrapped in a
[`tls.Conn`](https://golang.org/pkg/crypto/tls/#Conn). If not, the data from the
connection is rewound and replayed as is. Because of this detection mechanism,
the `maybe_tls.Listener` can only be used with application protocols where the
client is expected to send the first message after a connection is made.

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

    go get github.com/aaw/maybe_tls

license: MIT,Unlicense

repository: Eun/go-hit

detected_licenses: MIT Unlicense

gha_language: Go

repo_name: Eun/go-hit


text:
---
layout: post
title: FTL got a new victim
category: Gaming
tags: [Gaming, FTL, Veronica]
---

{% excerpt %}

[Faster than Light][FTL] the great game [I lost a ton of time on][FTL_post], has found a new victim. It's not someone you'd expect, it's even someone who said: "What a bad game" when she saw me playing it. But nevertheless this Saturday she played it more than 2.5 hours!

I told Veronica I wanted her try out FTL and minecraft, but we never got time for minecraft... It was so funny seeing her, on the edge of the seat, mumbling "die, die, die" to herself when she's in battle and jumping up "hooray!" when she destroyed the enemy. Sadly she didn't beat the boss, but boy did she come close! FTL must be a hidden skill for her.

I'm looking forward to introduce her to minecraft. I just hope she won't get too addicted and turn into a clone of myself.

[FTL]: http://www.ftlgame.com/
[FTL_post]: /blog/2013/02/12/faster_than_light/

{% endexcerpt %}

repository: treeman/madeoftree

extension: markdown

repo_name: treeman/madeoftree


text:
# Import Paths on Server

## `/usr/local/www/nginx`
This directory contains all files that will be served by nginx when requested.
It's the "production" directory for all intents and purposes.

## `/usr/local/etc/nginx`
Contains all nginx configurations

## `/usr/local/etc/nginx/nginx.conf`
contains the particular nginx configuration for the website.

license: ISC

gha_language: CSS


text:
# DROP Spaces Tensor Package

DROP Spaces Tensor Package contains the Rx Continuous/Combinatorial Tensor Spaces.

## Class Components

 * [***BinaryBooleanVector***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/BinaryBooleanVector.java)
 BinaryBooleanVector implements the normed/non-normed Binary/Boolean Combinatorial Vector Spaces.

 * [***Cardinality***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/Cardinality.java)
 Cardinality contains the Type and the Measure of the Cardinality of the given Vector Space.

 * [***GeneralizedVector***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/GeneralizedVector.java)
 GeneralizedVector exposes the basic Properties of the General Vector Space.

 * [***R1CombinatorialVector***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/R1CombinatorialVector.java)
 R1CombinatorialVector exposes the normed/non normed Discrete Spaces with R1 Combinatorial
 Vector Elements.

 * [***R1ContinuousVector***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/R1ContinuousVector.java)
 R1ContinuousVector exposes the Normed/non-normed, Bounded/Unbounded Continuous R1 Vector
 Spaces with Real valued Elements.

 * [***R1GeneralizedVector***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/R1GeneralizedVector.java)
 R1GeneralizedVector exposes the basic Properties of the General R1 Vector Space.

 * [***RdAggregate***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/RdAggregate.java)
 RdAggregate exposes the basic Properties of the Rd as a Sectional Super-position of
 R1 Vector Spaces.

 * [***RdCombinatorialVector***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/RdCombinatorialVector.java)
 RdCombinatorialVector exposes the Normed/Non-normed Discrete Spaces with Rd Combinatorial
 Vector Elements.

 * [***RdContinuousVector***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/RdContinuousVector.java)
 RdContinuousVector implements the Normed/non-normed, Bounded/Unbounded Continuous Rd
 Vector Spaces.

 * [***RdGeneralizedVector***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/tensor/RdGeneralizedVector.java)
 RdGeneralizedVector exposes the basic Properties of the Generalized Rd Vector Spaces.

## References

 * Carl, B., and I. Stephani (1990): Entropy, Compactness, and the Approximation of Operators
 	Cambridge University Press Cambridge UK

## DROP Specifications

 * Main                     => https://lakshmidrip.github.io/DROP/
 * Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
 * GitHub                   => https://github.com/lakshmiDRIP/DROP
 * Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
 * Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
 * Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
 * Release Versions         => https://lakshmidrip.github.io/DROP/version.html
 * Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
 * Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues

repository: fairhopeweb/DROP

repo_name: fairhopeweb/DROP


text:
# Floton, a simple C++ Ray-Tracer

### Introduction

Floton (pronounced flow-ton, rhymes with photon) is a simple, lightweight, CPU ray tracer written in C++. In the project's current state, it is best used as educational tool for those looking to learn more about how a ray tracer works by exploring the source code, but more fancy features will hopefully be added soon.

### How it works
Floton uses a technique called ray tracing to render realistic graphical images. Taken from [Wikipedia](https://en.wikipedia.org/wiki/Ray_tracing_(graphics)),"ray tracing is a rendering technique for generating an image by tracing the path of light as pixels in an image plane and simulating the effects of its encounters with virtual objects. The technique is capable of producing a very high degree of visual realism, usually higher than that of typical scanline rendering methods, but at a greater computational cost. This makes ray tracing best suited for applications where the image can be rendered slowly ahead of time, such as in still images and film and television visual effects, and more poorly suited for real-time applications like video games where speed is critical."

Currently, images can only be outputted in [ppm format](https://en.wikipedia.org/wiki/Netpbm_format), an ascii based image encoding that is very simple but produces very large file sizes. Additional image formats may be supported in the future.

### Getting Started (Linux)
To use, first download the source code from GitHub to your local machine:
```
git clone https://github.com/mjdunn7/Floton.git
cd Floton
```

Then, compile the source (you must have cmake installed):
```
cmake -B./build -H. -DCMAKE_BUILD_TYPE=Release
cmake --build ./build -- install
```

An executable binary file should then appear in the top directory. To render an example image, you can run the following command (the first argument indicates the render driver file, the second indicates the name of the output file):
```
./Floton ./ExampleRenderFiles/CircularReality.txt testRender.ppm
```

### Current Capabilities
  * Rendering of spheres and [wavefront obj](https://en.wikipedia.org/wiki/Wavefront_.obj_file) files with triangular faces
  * Multithreading support
  * Ambient, specular, and diffuse illumination
  * Reflection
  * Shadows
  * Depth of field (image is in focus at a certain distance)
  * Refraction of light through spheres
  * Image output in .ppm format

### Development Guide
Floton was originally made using the C-Lion IDE, but the use of cmake allows for versitile development styles. To get started with C-Lion, simply click file->open in the IDE and navigate to the cloned Floton Github repository. Otherwise, the source code and be found in the SRC folder and edited with your text editor of choice. To compile, run the following commands from the top directory, the first command is only necessary the first time you run:
```
cmake -B./debug-build -H. -DCMAKE_BUILD_TYPE=Debug
cmake --build ./debug-build -- install
```


text:
---
versionFrom: 8.0.0
versionTo: 9.0.0
---

# Add a Blog Post Publication Date

In this lesson, you will learn how to add a new date property to blog posts.

## Outcome

Content editors can specify the publication date for a blog post. Blog posts are displayed with the most recent publication date appearing first.

## Takeaway

Learn how to:

* Add a new property to a Document Type
* Edit a Template to display the new property
* Sort a list of items by a new property

## Steps - Part One

1. In the **Settings** section, expand **Document Types**.
2. Click on *Blogpost*: this is the Document Type that defines the fields for this type of page.

    ![Blogpost Document Type](images/Blogpost-Document-Type.png)

3. The Document Type contains 2 groups: *Content* and *Navigation & SEO*.
    * At the bottom of the *Content* group select **Add property**.
    * This opens the **Property Editor** dialog window.

4. Give the property a name: *Publication Date*.
5. Give the property a description: *The date of the blog post. This is the date used to display the most recent posts first.*.

    * Always try to add a meaningful description to help your editors.

6. Select **Add editor** to specify what type of data is being stored.
    * We need a standard date, so select the **Use existing** tab, then click on the **Date Picker** icon.

7. In the validation section tick to say that the field is mandatory.
8. Submit to close the dialog and save the property.

    ![Property settings](images/property-settings.png)

9. Select the **Reorder** option near the top-right of the pane, then drag the new property to be after *Page Title*.
    * A logical order to your properties will make things easier for your editors.
10. *Save* the Document Type - a confirmation message should appear confirming that the Document Type was saved.

[Proceed to Part Two](part-2.md)

repository: jakob-bagterp/UmbracoDocs

repo_name: jakob-bagterp/UmbracoDocs


text:
# API Certification Service

This service is part of light-portal and it is used to check if the production deployment
meet the security requirements.

The following things will be checked with server/info endpoint:

- If TLS https is enable and key pair are replaced
- If http port is disabled
- If JWT token verification and scope verification are enabled
- If metrics is enabled
- If the right version of JDK/JRE is used to start the server
- If the default JWT key is replaced

repository: liangbaolin/light-portal

repo_name: liangbaolin/light-portal


text:
# Laravel 5 Model Transformers

[![Latest Version on Packagist](https://img.shields.io/packagist/v/themsaid/laravel-model-transformers.svg?style=flat-square)](https://packagist.org/packages/themsaid/laravel-model-transformers)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)
[![Total Downloads](https://img.shields.io/packagist/dt/themsaid/laravel-model-transformers.svg?style=flat-square)](https://packagist.org/packages/themsaid/laravel-model-transformers)

This package helps API developers to easily transform Eloquent models into arrays that are convertible to JSON.

Here's how you use it, let's say you have a model with the following data:

```json
{
	"name": "iPhone",
	"type": 1
}
```
Here you use a numerical value to represent the different types, you also have a mutator in the model that maps the numerical value to a string.

Inside the controller we can transform the model to be represented into more API friendly structure.

```php
<?php
class SomeController{
	function getIndex(){
		$product = Product::find(1);

		return response([
			"product" => ProductTransformer::transform($product)
		]);
	}
}
```

The above code will result a JSON string that may look like this:

```json
{
	"product": {
		"name": "iPhone",
		"type": {
			"key": 1,
			"name": "Mobile Phone"
		}
	}
}
```

---

## Installation
Begin by installing the package through Composer. Run the following command in your terminal:

```
composer require themsaid/laravel-model-transformers:1.*
```

Once composer is done, add the package service provider in the providers array in `config/app.php`

```
Themsaid\Transformers\TransformersServiceProvider::class
```

Finally publish the config file:

```
php artisan vendor:publish
```

That's all what we need.

## Usage
Create a model transformer class by extending the AbstractTransformer class:

```php
<?php
class CategoryTransformer extends Themsaid\Transformers\AbstractTransformer
{
    public function transformModel(Model $item)
    {
        $output = [
            'name'		=> $item->name,
            'type'		=> [
            		'key'	=> $item->type,
            		'name'	=> $item->typeName
            ],
        ];

        return $output;
    }

}
```

Now you can call the transformer from any controller:

```php
<?php
return response(
	CategoryTransformer::transform( Category::find(1) )
);
```

You can also pass a collection and the result will be an array of transformed models:

```php
<?php
return response(
	CategoryTransformer::transform( Category::all() )
);
```

## Dealing with relationships
The package contains two helpful methods for dealing with relationships, the first one helps you know if a specific relation is eager-loaded:

### isRelationshipLoaded()

```php
<?php
class ProductTransformer extends AbstractTransformer
{
    public function transformModel(Model $item)
    {
        $output = array_only($item->toArray(), ['name', 'id']);

        if ($this->isRelationshipLoaded($item, 'tags')) {
            $output['tags'] = TagTransformer::transform($item->tags);
        }

        return $output;
    }
}
```

Now only if the tags are eager-loaded they will be presented in the $output array, this helps reminding you to eager-load when querying models with relationships.

### isLoadedFromPivotTable()
This method helps you know if the model is loaded from a ManyToMany relationship, it's helpful when there are pivot data in the table and you would like to present them, example for that:

```php
<?php
class TagTransformer extends AbstractTransformer
{
    public function transformModel(Model $item)
    {
        $output = array_only($item->toArray(), ['name', 'id']);

        if ($this->isLoadedFromPivotTable($item, 'products_tags')) {
            $output['relationship_data'] = [
                'is_active' => $item->pivot->is_active,
            ];
        }

        return $output;
    }
}
```

---

## Passing options to the transformer
You may need to pass some options from the controller to the transformer, you can do that by providing an array of options to the `transform()` method as a second parameter:

```php
<?php

CategoryTransformer::transform($category, ['hide_admin_id' => true])
```

Now from inside the CategoryTransformer you can check the options parameter:

```php
<?php
class CategoryTransformer extends AbstractTransformer
{
    public function transformModel(Model $item)
    {
    	$output = [];

		if (@$this->options['hide_admin_id']) {
			unset($output['admin_id']);
		}

		return $output;
	}
}
```

## Using the shorthand method
This package is shipped with a shorthand method for applying transformation for a Model or a Collection:

```php
<?php
class SomeController{
	function getIndex(){
		$product = Product::find(1);

		return response([
			"product" => transform($product)
		]);
	}
}
```

Using the `transform()` method, the package locates the suitable transformer based on the Model or the Collection passed as the first argument.

By default it assumes that all transformers are located under the `App\Transformers` namespace, you can change this behaviour in the config file.

You may also pass options to the transformer as a second argument:

```php
<?php

transform(Model::find(1), ['use_nl2br' => true])
```


text:
# Multiple VM Availability Set

Deploys a set of VMs (default 3) as part of the same availability set. This template template also deploys an availability set, a virtual Network (with DNS), a load balancer with a front end Public IP address, and a Network Security Group.


text:
---
type: docs
title: "Config service"
linkTitle: "Config service"
weight: 44
description: >
  Help your classes obtain your app's per-environment configuration.
---

{{% alert title="Credit where credit is due" color="info" %}}
This approach came from
Frederik Prijck's
[Runtime environment configuration with Angular](https://www.thisdot.co/blog/runtime-environment-configuration-with-angular).
{{% /alert %}}

## Overview

We're going to create a service, `ConfigService`, which:
- Uses an `HttpClient`.
- Reads, at runtime, configuration values in this order:
    1. From the Angular environment file.
    2. (If present, overriding the above:) From the config.json file.

The file `assets/config.json` will be kept under source control
and will initially contain no properties, which means that
when debugging all properties will be read from `src/environments/environment.ts`.

The pipeline will entirely replace the default `config.json` file when the app is staged or deployed.

## Create feature branch

feature/obtain-backend-url

## Install Spectator

Why **Spectator**? From their
[README.md](https://github.com/ngneat/spectator):

> Spectator helps you get rid of all the boilerplate grunt work, leaving you with readable, sleek and streamlined unit tests.

Install **Spectator**:
~~~
npm install @ngneat/spectator --save-dev
~~~

Commit with comment "npm install @ngneat/spectator --save-dev"

## assets/config.json

Create `assets/config.json`.
~~~
{
}
~~~

Commit with comment "assets/config.json"

## ConfigService and Config class

Generate some code. Note that our `Config` class is a just a DTO and doesn't need
automated tests, so we use the `--skip-tests=true` option.

~~~
npx ng generate class core/singleton-services/config/config --skip-tests=true
npx ng generate service core/singleton-services/config/config
~~~

Inspect the changes made to:

~~~
src\app\core\singleton-services\config\config.service.ts
src\app\core\singleton-services\config\config.ts
src\app\core\singleton-services\config\config.service.spec.ts
~~~

Commit with comment "ng g class & service config config"

## Write tests first

TODO: Add the test stuff.

## Implement

Edit `config.ts`:
~~~
export class Config {
  apiBaseUrl: string | undefined;
}
~~~

Edit `config.service.ts`:

~~~
/*
  Accessor for configuration properties.

  Loads properties in this order:
    1. From the Angular environment file ().
    2. (If present, overriding the above:) From the config.json file.

  The AppModule (see src\app\app.module.ts) loads this service as part
  of APPINITIALIZER, ensuring the application isn't started before the
  config settings are loaded.

 */

import { HttpClient } from "@angular/common/http";
import { Injectable } from "@angular/core";

import { environment } from './../../../../environments/environment';
import { Config } from "./config";

@Injectable({
  providedIn: 'root'
})
export class ConfigService {
  envName: string;
  apiBaseUrl: string;
  production: boolean;

  constructor(private httpClient: HttpClient) {
    // 1. From the Angular environment file.
    const environmentAny: any = environment;
    this.envName = environmentAny.envName;
    this.production = environmentAny.production;
    this.apiBaseUrl = environmentAny.apiBaseUrl;
  }

  loadConfig() {
    return this.httpClient
      .get<Config>('./assets/config.json')
      .toPromise()
      .then(config => {
        // 2. (If present, overriding the above:) From the config.json file.
        const configAny: any = config;

        if (configAny.envName != undefined) {
          this.production = configAny.production;
        }
        if (configAny.envName != undefined) {
          this.envName = `${configAny.envName}`;
        }
        if (config.apiBaseUrl != undefined) {
          this.apiBaseUrl = `${config.apiBaseUrl}`;
        }
      });
  }
}
~~~

Notice that you now have a failing test. That's because `config.service.spec.ts`
doesn't know yet how to provide the `HttpClient`.

Add an `HttpClientTestingModule` to the `imports` in `config.service.spec.ts` like this:
~~~
  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [HttpClientTestingModule]
    });
    service = TestBed.inject(ConfigService);
  });
~~~

Now your tests should be happy again.

Update `src/app/app.module.ts`:

~~~
...
import { ConfigService } from './core/singleton-services/config/config.service';
import { APP_INITIALIZER } from '@angular/core';

export const configFactory = (configService: ConfigService) => {
  return () => configService.loadConfig();
};
...
providers: [
    {
      // Loading ConfigService as part of APPINITIALIZER
      // ensures the application isn't started before the
      // config settings are loaded.
      provide: APP_INITIALIZER,
      useFactory: configFactory,
      deps: [ConfigService],
      multi: true
    },
...
~~~

## Deploy

Commit with comment "ConfigService"

Push, create a pull request, complete the pull request and delete the branches.

url: https://raw.githubusercontent.com/jrjenks-onbe/bcamp-materials/d879892438fc56d1d0af0906b6f0b27372aea610/content/en/docs/WIP/2021-08 Bootcamp archive/010. Angular SPA/044. Config service.md

repository: jrjenks-onbe/bcamp-materials

filename: 044. Config service.md

repo_name: jrjenks-onbe/bcamp-materials


text:
# Common v0.13.5 [![Build Status](https://travis-ci.org/titon/common.png)](https://travis-ci.org/titon/common) #

Provides common functionality for external packages, such as dependency management through registries and containers,
global configuration with a static configuration management layer, and a base class for all modular abstract classes to inherit.

On top of those features, the common package provides multiple traits that allow horizontal inheritance of powerful
patterns that solve basic use cases, like caching within class instances, class configurations, class dependencies, and more.
Classes can be further enhanced through augmentations, which are self contained inner classes.

For example, we can inherit common class functionality like serialization, configuration, and more.

```php
class Object extends Titon\Common\Base {
    use Titon\Common\Attachable,    \\ Provides lazy-loaded inner class dependencies
        Titon\Common\Cacheable,     \\ Provides memoization (method caching)
        Titon\Common\Instanceable;  \\ Provides multiton instance support
}
```

We can also lazy-load dependencies through the registry.

```php
use Titon\Common\Registry;

Registry::register('foo.bar', function() {
    return new Foo\Bar();
});

$foobar = Registry::get('foo.bar');
$foobar = Registry::factory('Foo\Bar'); // by namespace
```

And finally, configuration management has never been easier.

```php
use Titon\Common\Config;

Config::set('foo.bar', 'baz');
$baz = Config::get('foo.bar');
```

### Features ###

* `Base` - Primary base class
* `Traits` - Horizontal inheritance
* `Augments` - Class functionality encapsulation
* `Registry` - Static dependency container
* `Container` - Dependency container
* `Config` - Configuration management

### Dependencies ###

* `Utility`
* `Io` (optional for Config)

### Requirements ###

* PHP 5.4.0


text:
---
layout: side-code.html.hbs
language-tab:
  js: Javascript
  java: Android
  php: PHP
algolia: true
title: fetchNext
---

# fetchNext

```js
// Using callbacks (NodeJS or Web Browser)
searchResult.fetchNext(function (error, nextSearchResult) {
  // called once the fetchNext action has been completed
  // nextSearchResult is an instantiated SearchResult object
});

// Using promises (NodeJS)
searchResult.fetchNextPromise()
  .then(nextSearchResult => {
    // called once the fetchNext action has been completed
    // nextSearchResult is an instantiated SearchResult object
  });
```

```java
searchResult.fetchNext(new ResponseListener<SearchResult>() {
  @Override
  public void onSuccess(SearchResult nextSearchResult) {
    // called once the fetchNext action has been completed
    // nextSearchResult is an instantiated SearchResult object
  }

  @Override
  public void onError(JSONObject error) {
    // Handle error
  }
});
```

```php
<?php

use \Kuzzle\SearchResult;

// ...

/**
 * @var $searchResult SearchResult
 */

try {
  $nextSearchResult = $searchResult->fetchNext();
} catch (ErrorException $e) {
    // Handle error
}
```

Fetches the next SearchResult, by triggering a new search/scroll request depending on the options and filters of the SearchResult.

If the previous request was a search or a scroll action which provided a `scroll` argument,
`fetchNext` will use the `scrollId` retrieved from the current result to make a new scroll request.

If the previous request was a search action which provided `size` argument and `sort` filtering,
`fetchNext` will use Elasticsearch's [`search_after`](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-request-search-after.html) mechanism, which can efficiently search through a large volume of documents, bypassing internal hard limits\[1\],
but at the cost of reflecting the latest changes of the index, as opposed to using scroll.

If the previous request was a search action which provided `from` and `size` arguments,
`fetchNext` will add `size` to `from` and make a new search request.

---

## How to process every document of a collection

```js
var processDocument = function (document) {
  // do something with the document
};

kuzzle
  .collection('collection', 'index')
  .search({
    from: 0,
    size: 1000,
    scroll: '30s',
    query: {}
  }, function getMoreUntilDone (error, searchResult) {
    if (searchResult === null) {
      return;
    }

    searchResult.documents.forEach(function (document) {
      processDocument(document);
    });

    searchResult.fetchNext(getMoreUntilDone);
  });
```

```java
import io.kuzzle.sdk.core.Kuzzle;
import io.kuzzle.sdk.core.Options;

Kuzzle kuzzle = new Kuzzle("localhost");

JSONObject filter = new JSONObject();

Options options = new Options();
options.setFrom((long) 0);
options.setSize((long) 1000);
options.setScroll("30s");

ResponseListener<SearchResult> listener = new ResponseListener<SearchResult>() {
  @Override
  public void onSuccess(SearchResult searchResult) {
    if (searchResult == null) {
      return;
    }

    for (Document doc : searchResult.getDocuments()) {
      // do something with the document
      // this.processDocument(doc);
    }

    searchResult.fetchNext(this);
  }

  @Override
  public void onError(JSONObject error) {
    // handle errors here
  }
};

kuzzle
  .collection("collection", "index")
  .search(filter, options, listener);
```

```php
<?php

use \Kuzzle\Kuzzle;
use \Kuzzle\Document;
use \Kuzzle\Util\SearchResult;

function processDocument ($doc) {
  // do something with the document
}

$kuzzle = new Kuzzle('localhost');
$collection = $kuzzle->collection('collection', 'index');

try {
  $searchResult = $collection->search([
    'from' => 0,
    'size' => 1000,
    'scroll' => '30s',
    'filter' => []
  ]);

  while ($searchResult !== null) {
    foreach ($searchResult->getDocuments() as $doc) {
      procesDocument($doc);
    }

    $searchResult = $searchResult->fetchNext();
  }
}
catch (ErrorException $e) {
  // Handle errors here
}
```

The safest way to process all documents in a collection is to fetch them as a batch in order to avoid memory exhaustion and possibly hitting some hard limits\[1\] on the database layer.

Make sure your first search request includes size and scroll parameters

\[1\] Elasticsearch limits the number of documents inside a single page to [10,000 by default](https://www.elastic.co/guide/en/elasticsearch/reference/5.4/index-modules.html#dynamic-index-settings).

repository: kuzzleio/documentation-old

repo_name: kuzzleio/documentation-old


text:
---
title:  Beyond the Lesson
date:   01/03/2019
---

Just as God manifests Himself in a triune way the entities of the enemy do the same to try and become the antithesis of God and His work.

* God’s seal (Rev. 7:1-4, 14:1-3) is counterfeited by the mark of the beast (Rev. 13:16-17).

* The three angel’s messages (Rev. 14:6-12) are counterfeited by the three unclean spirits (Rev. 16:13-14).

* The bride of Christ or the New Jerusalem (Rev. 21) is counterfeited by the unclean woman or city of Babylon (Rev. 17-18).

They also become an antithesis for His personal manifestation

* The dragon is a counterfeit of God the Father.

  * Used to live in heaven (Rev. 12:7-9) - God lives in heaven (Ps. 11:4).

  * Has a throne (Rev. 13:2) - God has a throne (Rev 4-5).

  * Gives power, throne, and authority to the sea beast (Rev 13:2,4) - God gives all those to Jesus (Rev. 2:27, 3:21).

* The sea beast is a counterfeit of Jesus the Son. See Sunday’s lesson for details

  * The land beast is a counterfeit of the Holy Spirit.

  * Land beast is lamb-like (Rev. 13:11) - Holy Spirit is a comforter like Jesus (Jn. 14:26, 16:14).

  * Land beast tells people to worship sea beast (Rev. 13:12,15) - Holy Spirit tells people to worship Jesus (Jn. 16:13-14).

  * Land beast works miracles (Rev. 13:13, 19:20) - Holy Spirit works miracles (Acts 4:30-31).

  * Land beast brings fire from heaven (Rev. 13:13) - Holy Spirit brings fire from heaven (Acts 2:1-4).

  * Land beast gives life to the beast’s image (Rev. 13:15) - Holy Spirit gives life (Gen. 2:7, Jn. 3:8, Rom 8:11).

  * Land beast gives a mark to its followers (Rev. 13:16) - Holy Spirit gives a mark to His followers (Eph. 1:13, 4:30, Rev. 7:3)

repository: Adventech/sabbath-school-lessons

branch_name: refs/heads/stage

repo_name: Adventech/sabbath-school-lessons


text:
---
layout: creature
name: "Carrion Crawler"
tags: [large, monstrosity, cr2, monster-manual]
cha: 5 (-3)
wis: 12 (+1)
int: 1 (-5)
con: 16 (+3)
dex: 13 (+1)
str: 14 (+2)
size: Large monstrosity
alignment: unaligned
challenge: "2 (450 XP)"
senses: "darkvision 60 ft."
skills: "Perception +3"
speed: "30 ft., climb 30 ft."
hit_points: "51 (6d10+18)"
armor_class: "13 (natural armor)"
---

***Keen Smell.*** The carrion crawler has advantage on Wisdom (Perception) checks that rely on smell.

***Spider Climb.*** The carrion crawler can climb difficult surfaces, including upside down on ceilings, without needing to make an ability check.

### Actions

***Multiattack.*** The carrion crawler makes two attacks: one with its tentacles and one with its bite.

***Tentacles.*** Melee Weapon Attack: +8 to hit, reach 10 ft., one creature. Hit: 4 (1d4 + 2) poison damage, and the target must succeed on a DC 13 Constitution saving throw or be poisoned for 1 minute. Until this poison ends, the target is paralyzed. The target can repeat the saving throw at the end of each of its turns, ending the poison on itself on a success.

***Bite.*** Melee Weapon Attack: +4 to hit, reach 5 ft., one target. Hit: 7 (2d4 + 2) piercing damage.


text:
# Crux

Crux is a CLI & Node package that generates atomic css from a set of variables.

## Installation

npm install --save-dev crux

## Usage

You can use this in node or from the CLI:

### Node

```javascript
generate({
  colors: {
    primary: 'red',
    secondary: 'blue'
  }
}).then(css => console.log(css))
```

### CLI

```bash
crux -v ./vars.json -o ./styles.css -m ./styles.min.css
```

### Example variables

```javascript
{
  borderWidths: {
    small: '1px',
    medium: '2px',
    large: '3px',
  },
  colors: {
    primary: 'red',
    secondary: 'blue',
  },
  dimensions: {
    1: '1rem',
    2: '2rem',
    3: '4rem',
    4: '8rem',
    5: '16rem',
    6: '32rem',
    7: '64rem',
    8: '128rem',
  },
  fontSizes: {
    small: '0.8rem',
    medium: '1rem',
    large: '1.5rem',
  },
  fontWeights: {
    100: '100',
    200: '200',
    300: '300',
    400: '400',
    500: '500',
  },
  letterSpacings: {
    1: '1px',
    2: '2px',
    3: '3px',
    4: '4px',
  },
  lineHeights: {
    1: '0.8em',
    2: '1em',
    3: '1.2em',
    4: '1.5em',
    5: '2em',
  },
  opacity: {
    10: '0.1',
    20: '0.2',
    30: '0.3',
    40: '0.4',
    50: '0.5',
    60: '0.6',
    70: '0.7',
    80: '0.8',
    90: '0.9',
    100: '1',
  },
  radii: {
    small: '1px',
    medium: '2px',
    large: '3px',
  },
  spacing: {
    1: '1rem',
    2: '2rem',
    3: '3rem',
    4: '4rem',
    5: '5rem',
    6: '6rem',
    7: '7rem',
    8: '8rem',
  },
  media: {
    ns: {
      min: '30em',
    },
    m: {
      min: '30em',
      max: '60em',
    },
    l: {
      min: '60em',
    },
  },
}
```

## Why

Crux will suit you of you have any of the following problems:

- None of the existing CSS libraries suit the style of your app
- You've tried writing your own homebrew css framework, but it's difficult to maintain, document and lacks structure
- You've heard of OOCSS and/of atomic CSS and like the idea
- You've tried out an atomic css library but you have ended up writing / modifying the library to suit your needs

## Prior Art

[Tachyons](http://tachyons.io)
[Basscss](http://basscss.com)

## Credits

Major shout out to [PostCSS](http://postcss.org/) & [Tachyons](http://tachyons.io) for doing all the hard work.

## Contributing

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3.  Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## License

MIT

repository: josephluck/crux

repo_name: josephluck/crux


text:
---
title: "Pixboost - Terms of Service"
description: "Terms of Service"
date: 2021-04-01T00:00:00Z
draft: false
---

**Last revised: August 20, 2017.**

Pixboost (or the “Service”, “Pixboost Service”, “Pixboost”) is a
cloud-based lightweight solution that helps its users optimize their
content (images) and make transformational changes to their content (to
the images).

Please read this Terms of Service carefully before using the Pixboost
Service.

Your access to and use of the Service is conditioned on your acceptance
of, and compliance with, these Terms of Service (or the “Terms”). These
Terms apply to all visitors, users, and others who access or use the
Service.

By accessing or using the Service you agree to be bound by these Terms.
If you disagree with any part of the Terms you may not access the
Service.

## Information about the Service

1. Main purpose of the Service is to deliver a 24/7 robust and reliable
image processing tool that transforms images and delivers them through a
CDN to the Users’ Websites.

2. Pixboost is located at
[pixboost.com](https://www.google.com/url?q=https://pixboost.com/&sa=D&ust=1504409178476000&usg=AFQjCNFeaVEtdo7iDC2sKusY_njPQip3jw).

3. Pixboost is operated by Pixboost, ABN: 566 305 839 58.

4. From time to time Pixboost may modify, enhance, upgrade its
functionality. We may notify you about changes by email. Also we may add
and offer additional features both free-of-charge or subject to
additional fees, which may be governed by this document or different
Terms of Service.

## Changes in the Terms of Service

1. From time to time, Pixboost may change the Terms of Service to meet
technical, legal or operational changes.

2. All information about changes to the Terms of Service will be posted
on the Pixboost Website no less than 30 days before the changes take
effect.

3. You may choose to deny the changes of the Terms of Service. To do so
you have to discontinue the use of the Service. If you continue using
the Service after the new changes have taken effect, you indicate your
agreement to the amended terms.

## Acceptable use of the Service

1. When using Pixboost Service you have to abide by applicable laws,
rules and regulations, and usage guidelines.

2. You may not access or use the Service for any illegal purposes.

## Services

1. Pixboost offers web API (“API Services”) for you to access its
functionality of images transformation and optimization. To use the
Service you have to connect your image hosting to the API Services.

2. You are responsible for keeping the code that connects to the API
Services up-to-date to ensure that it continues working accordingly.

3. Pixboost provides caching of your images for performance reasons,
which is a part of the Service’s functionality. You must be aware that
if you remove an image from its original location it may stay cached on
the CDN for a limited time.

4. Pixboost may change, improve, update or discontinue the Services, or
any features, information, materials, or content of the Services. You
may be notified about changes at least 30 days in advance.

5. You may choose to discontinue the use of Services or terminate the
User Account completely any time. To discontinue the use of the Service
please contact us on
[customer.support@pixboost.com](mailto:customer.support@pixboost.com).
You will be charged only for what you have used by the time of
suspension.

6. Pixboost may choose to terminate your licence upon your breach of
these Terms or for convenience with 30 days' advance notice.

## Compliance with acceptable use policies of Content Delivery Networks

1. To deliver data from numerous locations quickly and reliably we use
Google Cloud CDN. You have to comply with the Google Cloud Platform
Terms of Service located at:
[https://cloud.google.com/terms/](https://www.google.com/url?q=https://cloud.google.com/terms/&sa=D&ust=1504409178482000&usg=AFQjCNG9lUJ8AFX40yBRoauZhRJUe8hpSg).

## Privacy

1. At Pixboost we do our best to provide the safe and reliable solution
for our users. Please see Pixboost’s Privacy Policy for the information
on how we manage your data and personal information.

## Service Fees

1. Pixboost provides several Plans: “Free”, “S”, “M”, “L” and
“Enterprise” Plans (or “Plans”). Users of the Service can choose a Plan
from the Pixboost Website within the section entitled “Plans”.

2. From time to time, Pixboost may change its Plans and will provide
reasonable notice (at least 30 days) to existing customers prior to the
change.

3. All payments will include applicable taxes.

4. To keep using the Service you have to make payments on time and at
the amount corresponding to the Plan you have chosen.

5. You will have to pay the fees using the payment methods available
through the Pixboost Website. Other methods of payment can be requested
by the user.

6. You can start using the Service immediately without payment if you
chose the “Free” Plan.

7. For the Plans “S”, “M”, and “L”, you have to provide credit card
details on submission. Payment for a Plan is deducted at the beginning
of the next month after each Billing Period.

8. One Pixboost User Account (or “Account”) can be used on several
Users’ Websites. By Pixboost User Account, we mean a Registered User of
the Pixboost Website. Traffic from all Websites will be billed to this
Account.

9. Pixboost will not be liable for mistakes, errors, malfunctions and
miscalculations made by the Payment Service Providers.

10. Fees are not refundable.

11.  Pixboost will only charge Users for the Services they use each
Billing Period, which are specified in your User Account on the Pixboost
Website.

12. “Free” Plan includes: 2 GB of data processing per month, unlimited
image processing, unlimited time, unlimited transactions, and use of the
CDN. This Plan does not require credit card or any other financial
information from the user. No payment is required.

13. “S” Plan includes: 10 GB of data processing per month, unlimited
image processing, unlimited time, unlimited transformations, and use of
the CDN. This Plan requires credit card information from the user.
Payment of \$5 a month with \$0.5 per additional GB is required.

14. “M” Plan includes:  50 Gb of data processing  per month, unlimited
image processing, unlimited time, unlimited transactions, and use of the
CDN. This Plan requires credit card information from the user. Payment
of \$25 a month with \$0.45 per additional GB is required.

15. “L” Plan includes: 200 Gb of data processing per month, unlimited
image processing, unlimited time, unlimited transactions, and use of the
CDN. This Plan requires credit card information from the user. Payment
of \$80 a month with \$0.40 per additional GB is required.

16. “Enterprise” Plan: this is a custom plan offered by Pixboost to
meet special customer needs. For further information on this Plan please
contact our friendly staff:
[customer.support<EMAIL_ADDRESS>
17. You might be eligible for a Free trial if you are considering the
Enterprise Plan. For more details please contact our friendly staff:
[customer.support<EMAIL_ADDRESS>
18. If you fail to make payment we will send you a notification with a
one week waiting notice. If payment is not made by the due date from
notice, Pixboost reserves the right to terminate your account without
further notice.

19. If you wish to change your Plan you can do so at any time. The
payment invoice will include only the last chosen Plan. For instance, if
you have chosen the “L” Plan, but then decide to switch to the “S” Plan,
at the end of the month you will be billed only the fee of the “S” Plan.

## Service Level Agreement

1. "Monthly Uptime Percentage" means total number of minutes in a
month, minus the number of minutes of Downtime suffered from all
Downtime Periods in a month, divided by the total number of minutes in a
month.

2. "Downtime" means loss of external connectivity (via the external IP
addresses associated with load balancing forwarding rules) due to the
failure of Google's systems.

3. "Downtime Period" means a period of five consecutive minutes of
Downtime. Intermittent Downtime for a period of less than five minutes
will not be counted towards any Downtime Periods.

4. Pixboost will provide a Monthly Uptime Percentage of at least
99.95%, which includes access to all of Pixboost’s API Services.

5. If Pixboost does not meet the Monthly Uptime Percentage stated
above, and if you meet the obligations under this SLA,  you will be
eligible to receive the Financial Credits described below:

-   99.0%-99.95% - you will receive 10% of your current bill as credit,
    which will be deducted from your next monthly bill for Pixboost
    Service,
-   95.0%-99.0% - you will receive 25% of your current bill as credit,
    which will be deducted from your next monthly bill for Pixboost
    Service,
-   \<95% - you will receive at least 50% of your current bill as
    credit, which will be deducted from your next monthly bill for
    Pixboost Service.

6. You must request Financial Credit in case of a Downtime. In order to
receive financial credit you have to notify Pixboost technical support
staff about your problem in no less than two weeks. You have to provide
server log files showing loss of external connectivity, errors, and the
date and time those errors occurred.

7. Pixboost will not provide the Financial Credit in the following
cases:

-   circumstances beyond Pixboost’s reasonable control, including (but
    not limited to) war, terrorism, labor disturbance, interruption of
    telecommunications, failure of third party software or services,
    acts of God.
-   network issues outside of Pixboost’s control, including DNS and
    connectivity problems.
-   acts or omissions by Authorized Users.
-   downtime resulting from individual periods of non-availability
    lasting less than five (5) minutes.
-   suspension or termination of your right to use the Service in
    accordance with these Terms.
-   if you are using the “Free” Plan.

8. This SLA is your sole and exclusive remedy for any failure by
Pixboost to provide the Service.

## License

1. On the condition that you comply with this Terms of Service,
Pixboost grants you a non-exclusive, non-transferable, revocable licence
to access the Services of Pixboost solely for the purpose of enabling
you to use the Service in the manner permitted by these Terms of
Service.

2. You are not allowed to:

-   copy, adapt or hack the Service;
-   rent, lease, resell, lend, sublicense the Service;
-   remove, alter, obscure any copyright, trademark, or other
    proprietary rights notice or labels on or in the Service;
-   disrupt in any way the work of other users with the Service;
-   use the Service for any illegal or unauthorized purpose;
-   spread the misleading or offensive information about the Service;
-   infringe or violate rights of the Service.

3. If you violate any of the restrictions stated above your license
will be terminated immediately and legal actions could be initiated.

4. To terminate the Service please stop using the Service and delete
any referral links to the Pixboost Website. If you wish to delete your
User Account from the Service please contact our friendly staff:
[customer.support@pixboost.com](mailto:customer.support@pixboost.com).

## Intellectual Property

1. Pixboost reserves all rights, titles, and interest to, and in, all
information, materials, and content including text, graphics, Pixboost
Website data, formatting, designs, HTML, scripts, photographic content,
images, source code, algorithms, and other content, excluding the User
Content or unless you have the written permission from Pixboost. Except
for the licence stated in these Terms you are not granted any rights in
or to the Service including patents, copyrights, trademarks (both
registered and unregistered), trade names, trade secrets, domain names,
or any other rights, functions or licenses with respect to the Service.

2. You are allowed to use logo and name of the Pixboost Service with
the referral link to the Pixboost Website (“pixboost.com”). All Pixboost
Website content is the property of Pixboost and can be used only with
the written permission of Pixboost with the referral link to the source.

3. Pixboost does not claim ownership over User Content. However, you
grant your permission to use your content, for the purposes of
providing, supporting and/or developing the Service. You grant Pixboost
the right to use your official company logo and name on Pixboost’s
Website and/or publications. If you wish to decline the use of your logo
and name please contact our friendly staff:
[customer.support@pixboost.com](mailto:customer.support@pixboost.com).

## User content

1. You retain all rights to images and other content that you upload to
the Service.

2. You do not own any rights to the feedback you are giving to us,
which may include any notes, ideas, images, suggestions in writing or
orally.

3. You hereby grant Pixboost a non-exclusive, revocable licence to use,
store, display, reproduce, re-post, modify, create derivative works of,
use the User Content solely in the course of providing the Services and
for its internal business purposes.

4. You will not use any unlawful content or perform any unlawful
actions through or in association with Pixboost. Pixboost reserves the
right, but does not have the obligation to monitor User Content and to
block any User whos content or actions violate those Terms of Service.

5. If you decide to remove your User Account from our Service, some
information may remain in the System for a certain period of time. We
may keep it for backup, archival, or auditing purposes.

## Confidentiality

1. Pixboost will maintain strict confidentiality of the Confidential
Information you provide to us. Confidential Information is the
identifiable information Users provide to the Service for certain
purposes and which have to be kept secret.  We will not use any of the
Confidential Information except as specifically required to provide you
the Service, subject to your prior permission, or legal request.

2. Upon termination of this agreement, Pixboost will delete all
Confidential Information Stored on its servers or as a hard copy except
as required by law (tax-related requirements, financial documents, and
legal issues).

## Questions

If you have any questions concerning these Terms of Service please
contact us:
[customer.support<EMAIL_ADDRESS>

repository: tcwillis/website-hugo-theme

repo_name: tcwillis/website-hugo-theme


text:
---
plugin: add-to-gallery
---

# Import taxonomy terms and labels into a term set

## Summary

The script is to import terms and labels into a term set. The sample is a small set of terms to showcase the use case but the requirement was to import 100s of terms with labels into SharePoint Online.

The sample using PnP PowerShell to import a csv file (same format you would use for import via UI for a term set but with an additional column for labels delimited by |)

# [PnP PowerShell](#tab/pnpps)
```powershell
Connect-PnPOnline -Url https://contoso-admin.sharepoint.com/ -UseWebLogin
$envTermGroup = "Test"
$termSId = "{38e2bfe9-37a7-4f8c-856f-f65a1b6050a8}"
$csvPath = "C:\script\Status.csv"
Function Add-Synonyms($ImportCsv, $termsetId, $termGroup)
{
   #get term to add label
   #Import CSV and create columns
   Import-Csv $ImportCsv | ForEach-Object {
    #Name and Type are the column names in the CSV
    $labels = $($_.Labels)
    if($labels)
    {
    #determine the term level - up to 7 levels
    $i= 7
    $termName = ""
    while($termName -eq "" -and $i -ge 1)
    {
      $termName = $($_.$("Level " + $i.ToString() + " Term"))
      $i--;
    }

    if($termName)
    {
      if($i -eq 0)
      {
       $term = Get-PnPTerm -Identity $termName -TermSet $termsetId -TermGroup $termGroup
      }
      else
      {
       $term= Get-PnPTerm -Identity $termName -TermSet $termsetId -TermGroup $termGroup -Recursive
      }

     if(!$term)
     {
     write-host $termName not found
     }
    if($term)
    {
     #split label by delimiter :
       foreach($l in $labels.split('|'))
       {

        $otherLabels = Get-PnPTermLabel  -Lcid 1033 -Term $term

        $otherLabel="";
        foreach($label in $otherLabels)
        {
          if($label.Value -eq $l)
            {
              $otherLabel = $label.Value;
            }
        }

        if(!$otherLabel)
         {
         $term.CreateLabel($l,1033,$false)
           sleep -Seconds 5;#added wait to avoid save conflict
         }
       }
     }
    }
   }
 }
}

#Create Term Group
try
{
 $termGroup = Get-PnPTermGroup -Identity $envTermGroup -ErrorAction SilentlyContinue
 if(!$termGroup)
 {
  New-PnPTermGroup -GroupName $envTermGroup
 }
}
Catch
{
 Write-Host "Term Group already exists"
}

Import-PnPTermSet -GroupName $envTermGroup -TermSetId $termSId -Path $csvPath -SynchronizeDeletions
sleep -Seconds 5;#added wait to make sure the terms are accessible to add labels
Add-Synonyms $csvPath $termSId $envTermGroup

```
[!INCLUDE [More about PnP PowerShell](../../docfx/includes/MORE-PNPPS.md)]
***

## Contributors

| Author(s) |
|-----------|
| Reshmee Auckloo |

[!INCLUDE [DISCLAIMER](../../docfx/includes/DISCLAIMER.md)]
<img src="https://telemetry.sharepointpnp.com/script-samples/scripts/spo-import-taxonomy-terms-labels" aria-hidden="true" />


text:
# SkyDrive Puppet Module for Boxen

Install [SkyDrive](http://skydrive.live.com), an easy way to share files the MS way
on Mac OS X.

## Usage

```puppet
include skydrive
```

## Required Puppet Modules

* `boxen`

## Development

Write code. Run `script/cibuild` to test it. Check the `script`
directory for other useful tools.

repository: cdenneen/puppet-skydrive

repo_name: cdenneen/puppet-skydrive