text:
## WebRTC, React and Node Js
This is a demo depicting the use of the best peer-to-peer communication technology, WebRTC. Whether you want to implement some video calls capabilities or even peer-to-peer data transfer, WebRTC is the best option.

As far for my understanding, the technology **`WebRTC`** consists of Three main modules:

<strong> 1- RTCMediaStream </strong>

Responsible for acquiring Audio and Video from the client browser, and preprare them to be streamed either locally or to a remote peer

<strong> 2- RTCPeerConnection </strong>

Responsible for establishing the peer-to-peer connection, by mainly creating and sending a connection offer from a side, and accepting and creating a response from the other side.
This process can hide some complications for cases where peers doesn't have static public IPs used for communication. Ex. 4G Nating (sitting behind a firewall), in such case, their IP won't be reachable as the singnaling process will fail. The solution for this is by using a STUN( `Session Traversal Utilities for NAT` ) server, where they can tell what is your public IP to be used for passing data through.  The list can be found here: [**STUN servers List**](https://gist.github.com/zziuni/3741933). This demo uses google stun server.
For availablity, you can also configure some relay server-side channels, in order to give you high availability in cases the peer-to-peer connection is lost. Such support can be satisfied by counting on some TURN (`Traversal Using Relays around NAT`) servers.

<strong> 3- RTCDataChannel </strong>

Responsible mainly for data sharing. It works exactly like socket data transmission, with two options (reliable using TCP) and  (unreliable using UDP). The Api is very flexible and looks similar to what you used to code in web sockets.

## DEMO
**What is it about**
## React-VideoCall
Demo app: [webrtc-jafaralbadarneh ](https://webrtc-jafaralbadarneh.herokuapp.com/)

A video call peer-to-peer application over web. Built with `react-js` and `node`. It enables you to establish a video call with anyone with his ID. the application will generate a new unique ID every time you open a new tab.
The application uses `socket.io` to manage handling call notifications, call pickups and hangups.

**Development**

```
# Running the server [port 5000]
yarn watch:server

# Running the client [port 9000]
yarn watch:client
```

**Deployment**

You can deploy a verision of the app on heroku using the following click-to-deploy button:

[![Deploy](https://www.herokucdn.com/deploy/button.svg)](https://heroku.com/deploy?template=https://github.com/jafar-albadarneh/react-videocall/tree/master)

repository: jafar-albadarneh/react-videocall

repo_name: jafar-albadarneh/react-videocall


text:
General utilities ansible role
=========
Used to bootstrap config of every new host. It performs the following tasks:

* Creates an admin user and makes it sudoer
* Sets motd
* Sets custom zsh prompt
* Enables ssh password authentication

It also install following packages:

* git
* tig
* htop
* wget
* tmux
* vim
* unzip
* lnav
* pydf
* lfm
* httpie
* bat
* micro
* exa
* shellcheck
* yadm
* jq
* python3-pip
* direnv
* pass

Automatic Release process
--------------------------
There is a github action to perform a fully automated release process. Just make sure to provide correct conventional commits message:

```bash
git commit [--allow-empty] -am "[fix|feat|BREAKING]: Your message here"
git push
```
The process uses conventional commits to increase version numbers according to the following commit prefixes:
* fix: Increase patch
* feat: Increase minor
* BREAKING: Increase mayor

Manual Release process
----------------------
To perform a manual release, make sure yoy have exportd the two following environment variables:
* GITHUB_TOKEN (Personal github access token)
* ANSIBLE_GALAXY_API_KEY (Personal Galaxy web repo API Key, you can get one here: https://galaxy.ansible.com/me/preferences)

after commiting all changes just run:
```bash
gradle release
```

Make sure to have ANSIBLE_GALAXY_API_KEY exported environment variable with your personal API Key (https://galaxy.ansible.com/me/preferences), then import the new version into Ansible Galaxy repo:
```bash
ansible-galaxy role import -v --token $ANSIBLE_GALAXY_API_KEY --role-name capitanh.common_ansible_role capitanh common-ansible-role
```

Role Variables
--------------
This role requires the following variables to be defined elsewhere in the playbook that uses it:
```yaml
admin_user:           admin                     # Administration user for all hosts
admin_password:       admin                     # Admin user password
```
All of them are already defined in /defaults/main.yml, feel free to overwrite them

Dependencies
------------
None

Example Playbook
----------------
Register the role in requirements.yml:
```yaml
- src: capitanh.common_ansible_role
  name: common
```
Include it in your playbooks:
```yaml
- hosts: servers
  roles:
  - common
```
License
-------
Apache License, Version 2.0

repository: capitanh/common-ansible-role

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: capitanh/common-ansible-role


text:
# Slack User Sensor

[![HACS][hacs-shield]][hacs-link]
[![GitHub Release][releases-shield]][releases-link]
[![Project Maintenance][maintenance-shield]][maintenance-link]
[![License][license-shield]][license-link]

## Description

This is a custom integration for [Home Assistant](https://www.home-assistant.io/). It provides a sensor for a slack user
by a given token.

## Installation

`ha-slack-user` is available through [HACS](https://hacs.xyz/). Open HACS -> Integrations -> Exlpore & Add repositories and search for "Slack User".

Or, install manually by downloading the `custom_components/slack_user` folder from this repo and placing it in your `config/custom_components/` folder.

## Setup

`ha-slack-user` is set up with Config Flow. After installing the integration, go to Configuration -> Integrations, click
the + button at the bottom right, and search for "Slack User".

The component requires a Slack Member ID (User ID), and API Token.

### Tokens

If you are using the deprecated [Legacy Tokens](https://api.slack.com/legacy/custom-integrations/legacy-tokens), this should work out of the box.

If you are using a token from a Slack App, it'll need to have access to the following scopes:

- `users.profile:read` - to get general profile information - title, profile, status, etc
- `users.profile:write` - to set user status
- `users:read` - to get presence information
- `dnd:read` - to get DND information

## Sensor data

After setting up a Slack User sensor, you'll have a `sensor.name` (with the name you specified during config) with the following attributes:

```
title: string
real_name: string
display_name: string
status_text: string
status_emoji: string
entity_picture: string

# Presence Info
presence: "online" or "away"
online: boolean
auto_away: boolean
manual_away: boolean
connection_count: number
last_activity: timestamp

# DND Info
dnd_enabled: boolean
next_dnd_start_ts: timestamp
next_dnd_end_ts: timestamp
snooze_enabled: boolean
```

Here's an example:

![Example sensor](https://raw.githubusercontent.com/GeorgeSG/ha-slack-user/master/examples/sensor.png)

## Services

### `slack_user.set_status`

Sets the user's slack status.

| Field        | Value                  | Necessity  | Description                                                                                |
| ------------ | ---------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| entity_id    | `sensor.slack_user`    | _Required_ | Name(s) of the sensor entities                                                                                |
| status_text  | `Commuting`            | _Optional_ | New status. Pass empty string (`""`) to clear. Don't pass anything to keep current status.                                                  |
| status_emoji | `:car:`                | _Optional_ | New status emoji. Pass empty string (`""`) to clear. Don't pass anything to keep current emoji. Will throw an error if emoji doesn't exist. |
| expiration   | `2021-06-12 15:00:001` | _Optional_ | Expiration date. Must be in format `yyyy-mm-dd hh:mm:ss`                                                                                |

### `slack_user.clear_status`

Clears the user's slack status.

| Field     | Value               | Necessity  | Description                    |
| --------- | ------------------- | ---------- | ------------------------------ |
| entity_id | `sensor.slack_user` | _Required_ | Name(s) of the sensor entities |

## Meta

**Georgi Gardev**

- [gar.dev](https://gar.dev)
- [![GitHub][github-icon]][github-link] [GeorgeSG][github-link]
- [![Twitter][twitter-icon]][twitter-link] [@georgesg92][twitter-link]

[hacs-shield]: https://img.shields.io/badge/HACS-Default-green.svg
[hacs-link]: https://github.com/custom-components/hacs
[releases-shield]: https://img.shields.io/github/release/GeorgeSG/ha-slack-user.svg
[releases-link]: https://github.com/GeorgeSG/ha-slack-user/releases
[maintenance-shield]: https://img.shields.io/maintenance/yes/2021.svg
[maintenance-link]: https://github.com/GeorgeSG/ha-slack-user
[license-shield]: https://img.shields.io/github/license/GeorgeSG/ha-slack-user?color=brightgreen
[license-link]: https://github.com/GeorgeSG/ha-slack-user/blob/master/LICENSE
[github-icon]: http://i.imgur.com/9I6NRUm.png
[github-link]: https://github.com/GeorgeSG/
[twitter-icon]: http://i.imgur.com/wWzX9uB.png
[twitter-link]: https://twitter.com/georgesg92

license: MIT

repository: orinocoz/ha-slack-user

repo_name: orinocoz/ha-slack-user


text:
# Down, Down, Down
Ludum Dare 48 Game Jam! Theme: Deeper and deeper.

Based on the book ["Alice's Adventures Under Ground" by Lewis Carroll](http://www.gutenberg.org/files/19002/19002-h/19002-h.htm), "Down, Down, Down" is a Narrative/2D Top Down/Platform game, by which I mean it has a little bit of everything, in which you play as a young girl who fell down a rabbit hole while chasing a white rabbit.

Made with [GBStudio](https://twitter.com/GBStudioDev).

### How to play:
- WASD/Arrow Keys: Move
- Z/J/Alt: A
- X/K/Ctrl: B
- Enter: Start
- Shift: Select

branch_name: refs/heads/main


text:
Containers are a new feature of Windows Server 2016. They can be installed on both physical server and virtual machine.

To install Containers we just need to install Windows Feature.

```
PS C:\Users\Administrator> Install-WindowsFeature Containers

Success Restart Needed Exit Code      Feature Result
------- -------------- ---------      --------------
True    Yes            SuccessRest... {Containers}
WARNING: You must restart this server to finish the installation process.

PS C:\Users\Administrator> Restart-Computer
```

On Nano server the installation is performed by Package Provider.

```

Install-PackageProvider NanoServerPackage
Install-NanoServerPackage -Name Microsoft-NanoServer-Containers-Package

```

To manage containers on Windows Server 2016 or Nano Server we have to install Docker service.

First we install the Docker-Microsoft PackageManagement Provider.

```

PS C:\Users\Administrator> Install-Module -Name DockerMsftProvider -Repository PSGallery -Force

NuGet provider is required to continue
PowerShellGet requires NuGet provider version '<IP_ADDRESS>' or newer to interact with NuGet-based repositories. The NuGet
 provider must be available in 'C:\Program Files\PackageManagement\ProviderAssemblies' or
'C:\Users\Administrator\AppData\Local\PackageManagement\ProviderAssemblies'. You can also install the NuGet provider by
 running 'Install-PackageProvider -Name NuGet -MinimumVersion <IP_ADDRESS> -Force'. Do you want PowerShellGet to install
and import the NuGet provider now?
[Y] Yes  [N] No  [S] Suspend  [?] Help (default is "Y"): y

```

Next we install docker package.

```

PS C:\Users\Administrator> Install-Package -Name docker -ProviderName DockerMsftProvider

The package(s) come(s) from a package source that is not marked as trusted.
Are you sure you want to install software from 'DockerDefault'?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "N"): A

Name                           Version          Source           Summary
----                           -------          ------           -------
Docker                         17.03.0-ee       DockerDefault    Contains Docker EE for use with Windows Server 2016...

```

The last step of the installation is a reboot.

```
Restart-Computer
```

After computer boots up, we need to verify the status of Docker service.

```

PS C:\Users\Administrator> get-service -name Docker

Status   Name               DisplayName
------   ----               -----------
Running  Docker             Docker

```

To display basic information about we use ```docker info``` command as shown below.

```
PS C:\Users\Administrator>  docker info
Containers: 0
 Running: 0
 Paused: 0
 Stopped: 0
Images: 0
Server Version: 17.03.0-ee-1
Storage Driver: windowsfilter
 Windows:
Logging Driver: json-file
Plugins:
 Volume: local
 Network: l2bridge l2tunnel nat null overlay transparent
Swarm: inactive
Default Isolation: process
Kernel Version: 10.0 14393 (14393.693.amd64fre.rs1_release.161220-1747)
Operating System: Windows Server 2016 Datacenter Evaluation
OSType: windows
Architecture: x86_64
CPUs: 1
Total Memory: 2 GiB
Name: WIN-5HL01DCA13D
ID: 6R27:5WXC:X6P3:3QX4:AL65:BL3G:QXC2:XMN6:5VW5:CTH4:JVKI:XCNI
Docker Root Dir: C:\ProgramData\docker
Debug Mode (client): false
Debug Mode (server): false
Registry: https://index.docker.io/v1/
Experimental: false
Insecure Registries:
 <IP_ADDRESS>/8
Live Restore Enabled: false
```

The best way to configure docker service is by editing ```daemon.json``` file located in ```C:\ProgramData\docker\network```. If the file does not exist we can create it. In the configuration file we need only to set values that are different from default values.

**CAUTION!!! Not all docker configuration options are available in Windows 2016.**


text:
# IAN

A Tensorflow implementation for ["Interactive Attention Networks for Aspect-Level Sentiment Classification"](https://arxiv.org/pdf/1709.00893.pdf) (Dehong Ma, IJCAI 2017)

## Quick Start

- use `pip install -r requirements.txt` to install required packages
- Create three empty folders: 'analysis' for saving analyzing results, 'logs' for saving experiment logs and 'models' for saving experiment models
- Download the 300-dimensional pre-trained word vectors from [Glove](https://nlp.stanford.edu/projects/glove/) and save it in the 'data' folder as 'data/glove.840B.300d.txt'

## Source Code Tree

```
|--- data

|	|--- laptop

|	|--- restaurant

|	|--- data_info.txt - the preprocessing data information file

|	|--- test_data.txt - the preprocessing testing data file

|	|--- train_data.txt - the preprocessing training data file

|--- main.py

|--- model.py

|--- transfer.py - transfering the origin xml files to text files

|--- utils.py

|--- README.md
```

## Results

| Dataset    | Accuracy |
| ---------- | -------- |
| Laptop     | 70.846   |
| Restaurant | 79.107   |

Note: In the newest version, the results are worse than the results given above, since the code of the model is revised.
I will optimize the model sooner and report the results.

## Todo List

- Implementing by other deep learning frameworks
- Softmax mask
- Optimization to get better performance

gha_language: Python

gha_license_id: MIT


text:
# JS-Signals #

Custom event/messaging system for JavaScript based on [JS-Signals Project Page](http://millermedeiros.github.com/js-signals/). Unprioritized-signals is API compatible with js-signals, but ignores priorities for increased performance with large numbers of listeners.

Custom event/messaging system for JavaScript inspired by [AS3-Signals](https://github.com/robertpenner/as3-signals).

For a more in-depth introduction read the [JS-Signals Project Page](http://millermedeiros.github.com/js-signals/) and visit the links below.

## Links ##

 * [Project Page](https://github.com/martinmcclure/js-unprioritized-signals)
 * [Wiki](https://github.com/martinmcclure/js-unprioritized-signals/wiki/)
 * [Changelog](https://github.com/martinmcclure/js-unprioritized-signals/blob/master/CHANGELOG.md)

## License ##

 * [MIT License](http://www.opensource.org/licenses/mit-license.php)

## Distribution Files ##

You can use the same distribution file for all the evironments, browser script
tag, AMD, CommonJS (since v0.7.0).

Files inside `dist` folder:

 * docs/index.html : Documentation.
 * signals.js : Uncompressed source code with comments.
 * signals.min.js : Compressed code.

You can install JS-Unprioritized-Signals on Node.js using [NPM](http://npmjs.org/)

    npm install unprioritized-signals

## Repository Structure ##

### Folder Structure ###

    |-build       ->  files used on the build process
    |-src         ->  source files
    |-tests       ->  unit tests
    `-dist        ->  distribution files
      `-docs        ->  documentation

### Branches ###

    master      ->  always contain code from the latest stable version
    release-**  ->  code canditate for the next stable version (alpha/beta)
    develop     ->  main development branch (nightly)
    **other**   ->  features/hotfixes/experimental, probably non-stable code

## Building your own ##

This project uses [Apache Ant](http://ant.apache.org/) for the build process. If for some reason you need to build a custom version of JS-Signals install Ant and run:

    ant build

This will delete all JS files inside the `dist` folder, merge/update/compress source files, validate generated code using [JSLint](http://www.jslint.com/) and copy the output to the `dist` folder.

There is also another ant task that runs the build task and generate
documentation (used before each deploy):

    ant deploy

**IMPORTANT:** `dist` folder always contain the latest version, regular users should **not** need to run build task.

## Running Tests ##

The specs work on the browser and on node.js, during development you can use
the `spec/runner_dev.html` file to avoid doing a build every time you make
changes to the source files. On node.js you need to run `ant compile` after
each source file change otherwise `npm test` will execute the files from last
build - not adding it as a `pretest` script since the build adds information
about the build date and build number and that would pollute the commit
history.

repository: martinmcclure/js-unprioritized-signals

repo_name: martinmcclure/js-unprioritized-signals


text:
---
layout: default
---

# 1996-12-27 - Re: Vulis strikes again?

## Header Data

From<EMAIL_ADDRESS>(J Durbin)

To<EMAIL_ADDRESS>Message Hash: 762b9b2f89e7bcb57bd3df603eee27f504d86cd8ab9c79b9cb74e8a258c56942

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-12-27 21:05:42 UTC

Raw Date: Fri, 27 Dec 1996 13:05:42 -0800 (PST)

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(J Durbin)
Date: Fri, 27 Dec 1996 13:05:42 -0800 (PST)
To<EMAIL_ADDRESS>Subject: Re: Vulis strikes again?

There sure are a lot of innocent "coincidences" following Vulis
around.

Poor fellow, to have a reputation of years and years of "coincidental"
vandalism besmirching his name.

jd
--
Fight spam: http://www.vix.com/spam

jason durbin
<EMAIL_ADDRESS>Stop Reading Here <---

{% endraw %}
```

## Thread

+ Return to [December 1996](/archive/1996/12)

+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to<EMAIL_ADDRESS>(Mike Duvos)](/authors/mpd_at_netcom_com_mike_duvos_)"
+ Return to "[Ray Arachelian <sunder@brainlink.com>](/authors/ray_arachelian_sunder_at_brainlink_com_)"
+ Return to<EMAIL_ADDRESS>(J Durbin)](/authors/slothrop_at_poisson_com_j_durbin_)"
+ Return to "["Z.B." <zachb@netcom.com>](/authors/z_b__zachb_at_netcom_com_)"

+ 1996-12-27 (Thu, 26 Dec 1996 16:50:06 -0800 (PST)) - [Vulis strikes again?](/archive/1996/12/ef1747e17067ab1a12ccd44e095f00f8f8c5a80dfb5df9689770d09c6a7928a1) - _Ray Arachelian<EMAIL_ADDRESS>  + 1996-12-27 (Thu, 26 Dec 1996 22:00:40 -0800 (PST)) - [Re: Vulis strikes again?](/archive/1996/12/52f7435f7a0f677c7f03d55d67234256f6bb38d2b6f0640b5470aab608c22720) - _"Z.B."<EMAIL_ADDRESS>    + 1996-12-27 (Fri, 27 Dec 1996 07:21:22 -0800 (PST)) - [Re: Vulis strikes again?](/archive/1996/12/30a1b323247c35af586807fb8a6bed91632f9319b02f37bc2bcc963ebdb5c792) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
      + 1996-12-27 (Fri, 27 Dec 1996 13:05:42 -0800 (PST)) - Re: Vulis strikes again? -<EMAIL_ADDRESS>(J Durbin)_
      + 1996-12-27 (Fri, 27 Dec 1996 14:34:34 -0800 (PST)) - [Re: Vulis strikes again?](/archive/1996/12/4a4d495a6a71a068fa7a0c133732d0da3c38eca96491c64603aeed16732f1ebc) - _Ray Arachelian<EMAIL_ADDRESS>        + 1996-12-28 (Fri, 27 Dec 1996 16:23:02 -0800 (PST)) - [Re: Vulis strikes again?](/archive/1996/12/5c3313e550453ba4db796d87034036b4e6d78e828d2de6dc0f50da345d190253) -<EMAIL_ADDRESS>(Mike Duvos)_
          + 1996-12-28 (Fri, 27 Dec 1996 21:50:26 -0800 (PST)) - [Re: Vulis strikes again?](/archive/1996/12/c25235062178fbed3ee56e7e704dfe04bd8430f8507ffad8a86d85eeb848492e) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
        + 1996-12-28 (Fri, 27 Dec 1996 16:50:26 -0800 (PST)) - [Counting the lies in Ray Arachelian's spam](/archive/1996/12/18fb7983f54b9de43dcd336399e47b2acf50fc73819c112e20666afb96eb8e26) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
          + 1996-12-30 (Mon, 30 Dec 1996 08:56:32 -0800 (PST)) - [Re: Counting the lies in Vulis' spam](/archive/1996/12/dd084bb0c6bfd86f198e97ffb543a75b1a6a872a87a139e9331ad4dc2548a543) - _Ray Arachelian<EMAIL_ADDRESS>


text:
# Airfoil

> All airfoil download form https://m-selig.ae.illinois.edu/ads/coord_database.html

> ## This repositories includes 5 folders.
### 1. **HQ** and **LOW RE** may use in some **Unmanned Aerial Vehicle** airfoil.
### 2. **Wind Turbines** use into wind turbines.
### 3. **NACA** is some NACA airfoil.
### 4. **ANSYS SCDM Scripts** may upload some scripts for airfoil model building, now just have a violence script for NACA 0012.

<p align="right"><I>--Veen 2020/03/15

repository: Veenxz/My-Airfoil-Database

repo_name: Veenxz/My-Airfoil-Database


text:
1282\. Group the People Given the Group Size They Belong To

Medium

There are `n` people that are split into some unknown number of groups. Each person is labeled with a **unique ID** from `0` to `n - 1`.

You are given an integer array `groupSizes`, where `groupSizes[i]` is the size of the group that person `i` is in. For example, if `groupSizes[1] = 3`, then person `1` must be in a group of size `3`.

Return _a list of groups such that each person `i` is in a group of size `groupSizes[i]`_.

Each person should appear in **exactly one group**, and every person must be in a group. If there are multiple answers, **return any of them**. It is **guaranteed** that there will be **at least one** valid solution for the given input.

**Example 1:**

**Input:** groupSizes = [3,3,3,3,3,1,3]

**Output:** [[5],[0,1,2],[3,4,6]]

**Explanation:**

The first group is [5]. The size is 1, and groupSizes[5] = 1.

The second group is [0,1,2]. The size is 3, and groupSizes[0] = groupSizes[1] = groupSizes[2] = 3.

The third group is [3,4,6]. The size is 3, and groupSizes[3] = groupSizes[4] = groupSizes[6] = 3.

Other possible solutions are [[2,1,6],[5],[0,4,3]] and [[5],[0,6,2],[4,3,1]].

**Example 2:**

**Input:** groupSizes = [2,1,3,3,3,2]

**Output:** [[1],[0,5],[2,3,4]]

**Constraints:**

*   `groupSizes.length == n`
*   `1 <= n <= 500`
*   `1 <= groupSizes[i] <= n`

repository: javadev/LeetCode-in-Java

gha_language: Java

repo_name: javadev/LeetCode-in-Java


text:
[![Maven Central](https://img.shields.io/maven-central/v/nl.praegus/fitnesse-bootstrap-plus-theme.svg?maxAge=21600)](https://mvnrepository.com/artifact/com.github.tcnh/fitnesse-bootstrap-plus-theme)

You can go to the [DEVELOPMENT_GUIDE.MD](./DEVELOPMENT_GUIDE.MD), for information about how to get started with the Bootstrap-plus FitNesse Theme.

### [Bootstrap-plus @ Github.io Website](https://praegus.github.io/fitnesse-bootstrap-plus-theme/)

# Bootstrap-plus FitNesse Theme
This is a FitNesse Theme that extends the default bootstrap theme for better usability.
Uses Bootstrap 4.4, JQuery 3.4 and CodeMirror 5.52

## Features:
* Improved styling for better readability and information density
* Light and dark version of the theme for the wiki and CodeMirror editor
* Different favicons for Tests, Suites, Static pages and Edit mode
* Show the page name first in the page title (So different tabs have recognizable titles)
* Optional sidebar to ease navigation
* Visual identification of slim tables using icons
* Failure navigator highlights current failure, eliminates scrolling - jumps to next
* Adds a 'Recent pages' overview to the end of the frontpage
* Optional maven version checker that shows current dependency versions and compares them to the latest version in maven central
* Icons in Table of contents to distinguish between Tests, Suites and Static pages
* Suites now have a 'run tags' input field in the navigation bar, so all tests containing any of the specified tags in this input field can be run immediately
* If Autocomplete responder is also installed, ctrl-space suggestions are context-aware:
  * All fixture methods available in the current test
  * All scenario's from include ScenarioLibraries
  * All slim symbols set by `$varName=` that are available
  * NOTE: If you want context-aware autosuggest in ScenarioLibraries, make sure to edit them from an edit link on a *test-page*. The hint-script will then use the referring page as context
* Context-help pane containing all fixtures, methods, scenario's, slim symbols in current test scope
* Jump to definition for fixture methods and scenario's by pressing ctrl-comma in the editor, revealing candidates in the context-help pane
* validation of wiki tables against current context and basic syntax (aimed at slim usage). Use validate button,auto validate on save option or ctrl-dot.
* Insert scenario's and fixture methods in the editor by clicking the plus-icon in the context pane
* Experimental: Autosave and validate test pages on enter

## Usage:
Use Praegus' toolchain-plugin to use bootstrap-plus and enable all of it's features.
See: https://github.com/praegus/toolchain-fitnesse-plugin

## Screenshots:

#### Fonts, margins and colors
![alt text](https://github.com/tcnh/binstore/raw/master/styling.png "Overall styling")

#### Browser Tabs
![alt text](https://github.com/tcnh/binstore/raw/master/tabs.png "Tab bar")

#### Table of contents with tag management
![image](https://user-images.githubusercontent.com/2232710/78379015-0ecb2e00-75d2-11ea-8e1e-c46c1b3a6683.png)

#### Sidebar Navigation
![alt text](https://github.com/tcnh/binstore/raw/master/sidebar_nav.png "Sidebar")

#### Sidebar Context Menu
![image](https://user-images.githubusercontent.com/2232710/78378675-9bc1b780-75d1-11ea-91ac-22f7929a643a.png)

#### Editor Linting
![alt text](https://github.com/tcnh/binstore/raw/master/linting.png "Editor linting")

#### Navigation Bar
![alt text](https://github.com/tcnh/binstore/raw/master/navbar.png "Navigation bar for suites")

#### Scenario's, Slim Symbols and available Fixture methods in auto-suggest
![alt text](https://github.com/tcnh/binstore/raw/master/suggest.png "Auto suggest contains scenario's")

#### Context help
![alt text](https://github.com/tcnh/binstore/raw/master/context-help.png "Context help panel")

#### Visual Slim table types
![alt text](https://github.com/tcnh/binstore/raw/master/table_identification.png "Table icons")

#### Style switch to toggle light/dark modes
![alt text](https://github.com/tcnh/binstore/raw/master/style-switch.png "Light/dark mode toggle")

#### Dark mode
![alt text](https://github.com/tcnh/binstore/raw/master/darkmode_1.png "Dark theme")
![alt text](https://github.com/tcnh/binstore/raw/master/dark_editor.PNG "Dark editor")
![alt text](https://github.com/tcnh/binstore/raw/master/darkmode_result.PNG "Test results in dark mode")

#### Recent Tests
![alt text](https://github.com/tcnh/binstore/raw/master/recent_pages.png "Recent test pages")

#### Maven version checker
Use "!VersionChecker" in the editor to enable the Maven version checker.

![alt text](https://github.com/tcnh/binstore/raw/master/macen_versioncheck.png "Maven dependency versions")

#### ToolTips
Tooltips are now displayed on every page.

You can add your own tooltips with the following steps:
1. You go to fitnesse/resources/bootstrap-plus/txt/toolTipData.txt for editing.
2. Put the text at the end of the file and separate the tooltips by enters
3. The format of a tooltip is[this is a tooltip] (without the brackets).

Tooltips can now contain links
* You can add a link to your tooltip by adding a simple html link tag to your tooltip.

Tooltips will now also load in from fixtures:

* You can add tooltips to your fixture by adding a Tooltips.txt on [FixtureRoot]/[FixtureName]_tooltips/Tooltips.txt
* You also need to add two executions to your maven dependency plugin to be able to load fixture tooltips:

        <execution>
            <id>unpack-dependencies</id>
            <phase>compile</phase>
            <goals>
                <goal>unpack-dependencies</goal>
            </goals>
            <configuration>
                <includes>**/Tooltips.txt</includes>
                <outputDirectory>${project.basedir}/wiki/TooltipData</outputDirectory>
            </configuration>
        </execution>

repository: praegus/fitnesse-bootstrap-plus-theme

gha_language: JavaScript

repo_name: praegus/fitnesse-bootstrap-plus-theme


text:
## @jscad/3mf-serializer

> Serializer of JSCAD geometries to 3MF shapes

[![npm version](https://badge.fury.io/js/%40jscad%2F3mf-serializer.svg)](https://badge.fury.io/js/%40jscad%2F3mf-serializer)
[![Build Status](https://travis-ci.org/jscad/io.svg)](https://travis-ci.org/jscad/3mf-serializer)

## Overview

This serializer outputs a 'blobable' array of data from one or more JSCAD geometries. Only XML output is supported.
The array of data can either be used to create a Blob (`new Blob(blobable)`), or converted to a Node.js buffer.

The serialization of the following geometries are possible.
- serialization of 3D geometry (geom3) to 3MF mesh(s)

In addition, both color and name attributes are converted to 3MF attributes if found on the JSCAD geometry.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Contribute](#contribute)
- [License](#license)

## Installation

```
npm install @jscad/3mf-serializer
```

## Usage

```javascript
const { serialize } = require('@jscad/3mf-serializer')

const rawData = serialize({unit: inch}, geometry)

//in browser (with browserify etc)
const blob = new Blob(rawData)

```

## Contribute

For questions about the API, please contact the [User Group](https://openjscad.xyz/forum.html)

Please see the README information of the OpenJSCAD.org project for how to submit bug reports or changes.

Small Note: If editing this README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.

## License

[The MIT License (MIT)](./LICENSE)
(unless specified otherwise)

gha_license_id: NOASSERTION


text:
---
title: 'Construct a screen'
tocTitle: 'Screens'
description: 'Construct a screen out of components'
commit: '79829b2'
---

We've concentrated on building UIs from the bottom up, starting small and adding complexity. Doing so has allowed us to develop each component in isolation, figure out its data needs, and play with it in Storybook. All without needing to stand up a server or build out screens!

In this chapter, we continue to increase the sophistication by combining components in a screen and developing that screen in Storybook.

## Connected screens

As our app is straightforward, the screen we'll build is pretty trivial, simply fetching data from a remote API, wrapping the `TaskList` component (which supplies its own data from Redux), and pulling a top-level `error` field out of Redux.

We'll start by updating our Redux store (in `src/lib/store.js`) to connect to a remote API and handle the various states for our application (i.e., `error`, `succeeded`):

```diff:title=src/lib/store.js
/* A simple redux store/actions/reducer implementation.
 * A true app would be more complex and separated into different files.
 */
import {
  configureStore,
  createSlice,
+ createAsyncThunk,
} from '@reduxjs/toolkit';

/*
 * The initial state of our store when the app loads.
 * Usually, you would fetch this from a server. Let's not worry about that now
 */

const TaskBoxData = {
  tasks: [],
  status: "idle",
  error: null,
};

/*
 * Creates an asyncThunk to fetch tasks from a remote endpoint.
 * You can read more about Redux Toolkit's thunks in the docs:
 * https://redux-toolkit.js.org/api/createAsyncThunk
 */
+ export const fetchTasks = createAsyncThunk('todos/fetchTodos', async () => {
+   const response = await fetch(
+     'https://jsonplaceholder.typicode.com/todos?userId=1'
+   );
+   const data = await response.json();
+   const result = data.map((task) => ({
+     id: `${task.id}`,
+     title: task.title,
+     state: task.completed ? 'TASK_ARCHIVED' : 'TASK_INBOX',
+   }));
+   return result;
+ });

/*
 * The store is created here.
 * You can read more about Redux Toolkit's slices in the docs:
 * https://redux-toolkit.js.org/api/createSlice
 */
const TasksSlice = createSlice({
  name: 'taskbox',
  initialState: TaskBoxData,
  reducers: {
    updateTaskState: (state, action) => {
      const { id, newTaskState } = action.payload;
      const task = state.tasks.findIndex((task) => task.id === id);
      if (task >= 0) {
        state.tasks[task].state = newTaskState;
      }
    },
  },
  /*
   * Extends the reducer for the async actions
   * You can read more about it at https://redux-toolkit.js.org/api/createAsyncThunk
   */
+  extraReducers(builder) {
+    builder
+    .addCase(fetchTasks.pending, (state) => {
+      state.status = 'loading';
+      state.error = null;
+      state.tasks = [];
+    })
+    .addCase(fetchTasks.fulfilled, (state, action) => {
+      state.status = 'succeeded';
+      state.error = null;
+      // Add any fetched tasks to the array
+      state.tasks = action.payload;
+     })
+    .addCase(fetchTasks.rejected, (state) => {
+      state.status = 'failed';
+      state.error = "Something went wrong";
+      state.tasks = [];
+    });
+ },
});

// The actions contained in the slice are exported for usage in our components
export const { updateTaskState } = TasksSlice.actions;

/*
 * Our app's store configuration goes here.
 * Read more about Redux's configureStore in the docs:
 * https://redux-toolkit.js.org/api/configureStore
 */
const store = configureStore({
  reducer: {
    taskbox: TasksSlice.reducer,
  },
});

export default store;
```

Now that we've updated our store to retrieve the data from a remote API endpoint and prepared it to handle the various states of our app, let's create our `InboxScreen.js` in the `src/components` directory:

```js:title=src/components/InboxScreen.js
import React, { useEffect } from 'react';
import { useDispatch, useSelector } from 'react-redux';
import { fetchTasks } from '../lib/store';
import TaskList from './TaskList';

export default function InboxScreen() {
  const dispatch = useDispatch();
  // We're retrieving the error field from our updated store
  const { error } = useSelector((state) => state.taskbox);
  // The useEffect triggers the data fetching when the component is mounted
  useEffect(() => {
    dispatch(fetchTasks());
  }, []);

  if (error) {
    return (
      <div className="page lists-show">
        <div className="wrapper-message">
          <span className="icon-face-sad" />
          <div className="title-message">Oh no!</div>
          <div className="subtitle-message">Something went wrong</div>
        </div>
      </div>
    );
  }
  return (
    <div className="page lists-show">
      <nav>
        <h1 className="title-page">
          <span className="title-wrapper">Taskbox</span>
        </h1>
      </nav>
      <TaskList />
    </div>
  );
}
```

We also need to change our `App` component to render the `InboxScreen` (eventually, we would use a router to choose the correct screen, but let's not worry about that here):

```diff:title=src/App.js
- import logo from './logo.svg';
- import './App.css';
+ import './index.css';
+ import store from './lib/store';

+ import { Provider } from 'react-redux';
+ import InboxScreen from './components/InboxScreen';

function App() {
  return (
-   <div className="App">
-     <header className="App-header">
-       <img src={logo} className="App-logo" alt="logo" />
-       <p>
-         Edit <code>src/App.js</code> and save to reload.
-       </p>
-       <a
-         className="App-link"
-         href="https://reactjs.org"
-         target="_blank"
-         rel="noopener noreferrer"
-       >
-         Learn React
-       </a>
-     </header>
-   </div>
+   <Provider store={store}>
+     <InboxScreen />
+   </Provider>
  );
}
export default App;
```

  💡 Don't forget to update the test file src/App.test.js. Or the next time you run your tests they will fail.

However, where things get interesting is in rendering the story in Storybook.

As we saw previously, the `TaskList` component is now a **connected** component and relies on a Redux store to render the tasks. As our `InboxScreen` is also a connected component, we'll do something similar and provide a store to the story. So when we set our stories in `InboxScreen.stories.js`:

```js:title=src/components/InboxScreen.stories.js
import React from 'react';

import InboxScreen from './InboxScreen';
import store from '../lib/store';

import { Provider } from 'react-redux';

export default {
  component: InboxScreen,
  title: 'InboxScreen',
  decorators: [(story) => <Provider store={store}>{story()}</Provider>],
};

const Template = () => <InboxScreen />;

export const Default = Template.bind({});
export const Error = Template.bind({});
```

We can quickly spot an issue with the `error` story. Instead of displaying the right state, it shows a list of tasks. One way to sidestep this issue would be to provide a mocked version for each state, similar to what we did in the last chapter. Instead, we'll use a well-known API mocking library alongside a Storybook addon to help us solve this issue.

![Broken inbox screen state](/intro-to-storybook/broken-inbox-error-state-optimized.png)

## Mocking API Services

As our application is pretty straightforward and doesn't depend too much on remote API calls, we're going to use [Mock Service Worker](https://mswjs.io/) and [Storybook's MSW addon](https://storybook.js.org/addons/msw-storybook-addon). Mock Service Worker is an API mocking library. It relies on service workers to capture network requests and provides mocked data in responses.

When we set up our app in the [Get started section](/intro-to-storybook/react/en/get-started) both packages were also installed. All that remains is to configure them and update our stories to use them.

In your terminal, run the following command to generate a generic service worker inside your `public` folder:

```shell
yarn init-msw
```

Then, we'll need to update our `.storybook/preview.js` and initialize them:

```diff:title=.storybook/preview.js
import '../src/index.css';

+ // Registers the msw addon
+ import { initialize, mswDecorator } from 'msw-storybook-addon';

+ // Initialize MSW
+ initialize();

+ // Provide the MSW addon decorator globally
+ export const decorators = [mswDecorator];

//👇 Configures Storybook to log the actions( onArchiveTask and onPinTask ) in the UI.
export const parameters = {
  actions: { argTypesRegex: '^on[A-Z].*' },
  controls: {
    matchers: {
      color: /(background|color)$/i,
      date: /Date$/,
    },
  },
};
```

Finally, update the `InboxScreen` stories and include a [parameter](https://storybook.js.org/docs/react/writing-stories/parameters) that mocks the remote API calls:

```diff:title=src/components/InboxScreen.stories.js
import React from 'react';

import InboxScreen from './InboxScreen';
import store from '../lib/store';
+ import { rest } from 'msw';
+ import { MockedState } from './TaskList.stories';
import { Provider } from 'react-redux';

export default {
  component: InboxScreen,
  title: 'InboxScreen',
  decorators: [(story) => <Provider store={store}>{story()}</Provider>],
};

const Template = () => <InboxScreen />;

export const Default = Template.bind({});
+ Default.parameters = {
+   msw: {
+     handlers: [
+       rest.get(
+         'https://jsonplaceholder.typicode.com/todos?userId=1',
+         (req, res, ctx) => {
+           return res(ctx.json(MockedState.tasks));
+         }
+       ),
+     ],
+   },
+ };

export const Error = Template.bind({});
+ Error.parameters = {
+   msw: {
+     handlers: [
+       rest.get(
+         'https://jsonplaceholder.typicode.com/todos?userId=1',
+         (req, res, ctx) => {
+           return res(ctx.status(403));
+         }
+       ),
+     ],
+   },
+ };
```

💡 As an aside, yet another viable approach would be to pass data down the hierarchy, especially when using GraphQL. It’s how we have built Chromatic alongside 800+ stories.

Check your Storybook, and you'll be able to see that the `error` story is now working as intended. MSW intercepted our remote API call and provided the appropriate response.

<video autoPlay muted playsInline loop>
  <source
    src="/intro-to-storybook/inbox-screen-with-working-msw-addon-optimized.mp4"
    type="video/mp4"
  />
</video>

## Interactive stories

So far, we've been able to build a fully functional application from the ground up, starting from a simple component up to a screen and continuously testing each change using our stories. But each new story also requires a manual check on all the other stories to ensure the UI doesn't break. That's a lot of extra work.

Can't we automate this workflow and interact with our components automatically?

Storybook's [`play`](https://storybook.js.org/docs/react/writing-stories/play-function) function allows us to do just that. A play function includes small snippets of code that are run after the story renders.

The play function helps us verify what happens to the UI when tasks are updated. It uses framework-agnostic DOM APIs, that means we can write stories with the play function to interact with the UI and simulate human behavior no matter the frontend framework.

Let's see it in action! Update your newly created `InboxScreen` story, and set up component interactions by adding the following:

```diff:title=src/components/InboxScreen.stories.js
import React from 'react';

import InboxScreen from './InboxScreen';

import store from '../lib/store';
import { rest } from 'msw';
import { MockedState } from './TaskList.stories';
import { Provider } from 'react-redux';

+ import {
+  fireEvent,
+  within,
+  waitFor,
+  waitForElementToBeRemoved
+ } from '@storybook/testing-library';

export default {
  component: InboxScreen,
  title: 'InboxScreen',
  decorators: [(story) => <Provider store={store}>{story()}</Provider>],
};

const Template = () => <InboxScreen />;

export const Default = Template.bind({});
Default.parameters = {
  msw: {
    handlers: [
      rest.get(
        'https://jsonplaceholder.typicode.com/todos?userId=1',
        (req, res, ctx) => {
          return res(ctx.json(MockedState.tasks));
        }
      ),
    ],
  },
};

+ Default.play = async ({ canvasElement }) => {
+   const canvas = within(canvasElement);
+   // Waits for the component to transition from the loading state
+   await waitForElementToBeRemoved(await canvas.findByTestId('loading'));
+   // Waits for the component to be updated based on the store
+   await waitFor(async () => {
+     // Simulates pinning the first task
+     await fireEvent.click(canvas.getByLabelText('pinTask-1'));
+     // Simulates pinning the third task
+     await fireEvent.click(canvas.getByLabelText('pinTask-3'));
+   });
+ };
```

Check your newly created story. Click the `Interactions` panel to see the list of interactions inside the story's play function.

<video autoPlay muted playsInline loop>
  <source
    src="/intro-to-storybook/storybook-interactive-stories-play-function-6-4.mp4"
    type="video/mp4"
  />
</video>

The play function allows us to interact with our UI and quickly check how it responds if we update our tasks. That keeps the UI consistent at no extra manual effort. All without needing to spin up a testing environment or add additional packages.

## Component-Driven Development

We started from the bottom with `Task`, then progressed to `TaskList`, now we’re here with a whole screen UI. Our `InboxScreen`
accommodates connected components and includes accompanying stories.

<video autoPlay muted playsInline loop style="width:480px; height:auto; margin: 0 auto;">
  <source
    src="/intro-to-storybook/component-driven-development-optimized.mp4"
    type="video/mp4"
  />
</video>

[**Component-Driven Development**](https://www.componentdriven.org/) allows you to gradually expand complexity as you move up the component hierarchy. Among the benefits are a more focused development process and increased coverage of all possible UI permutations. In short, CDD helps you build higher-quality and more complex user interfaces.

We’re not done yet - the job doesn't end when the UI is built. We also need to ensure that it remains durable over time.

💡 Don't forget to commit your changes with git!


text:
# seb-curr-calc

This is "combined style" web application ASP.NET Core Web API backend with Angular based frontend

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 11.2.9.\
Web API generated with [.NET CLI](https://docs.microsoft.com/en-us/dotnet/core/tools/) version 3.1.402 (.net core 3.1)

## First run

Requires .NET core SDK (dotnet cli)\
Open terminal at /seb-curr-calc folder,\
install node modules (npm install),\
start the app (npm run start) - this compiles web client (to wwwroot), builds and runs backend, opens localhost:5000,\
(wait for backend build to complete, then refresh localhost:5000)

## App description

This is simple currency converter. You can change sums (other will change accordingly), pick from a list of currencies.\
Upon first run frontend connects to backend (/api/Calc/Latest) to retrieve currency rates.\
Currency rates have expiration time. Frontend checks once a minute, if retrieved currencies are not yet expired, if they are - it requests new ones;\
Backend retrieves currencies from https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml, which contain their activation date.\
Currencies expire next day at a set hour (configured in appsettings.json "RefreshHour" setting)\
For the sake of simplicity - currencies on backend are stored simply in memory (no database, sorry db lovers).

## Tests

Run "npm test" to run frontend tests.\
There are some xunit backend tests are in "seb-curr-calc.test" project (in it's own dir).\
To run them you can use "dotnet test" command.

If You prefer Visual studio you can use provided .sln file to load both projects.

## Code description
### Backend
Everything is very simple - classic ASP.NET core web service with only one controller (Controllers/CalcController.cs) and only one endpoint (GET /api/Calc/Current).\
Controller depends on 3 services (in /Services), which are injected with built-in DI.\
Services/MemoryStore/ - trivial storage service. As long, as server runs it stores currencies value. For the needs of this app - no more complexity required\
Services/Indeterminates/ - classic indeterminates, wrapped for testability purposes. Wraps DateTime.Now .\
Services/CurrencyRetrieval/ - really simple implementation of retrieving xml with currencies from given url, and parsing it\
Models - contains 2 trivial DTO objects. CurrencyDTO - simple currency name and rate pair, CurrencyListDTO - wraps list of currencies, expiration date and optional error message - this model is returned from backend

### Frontend
Everything is under /src, inluding pregenerated code.\
Here's structure of component tree in generated page\
|html>body>\
|-app-component     - main application component\
|--/calc            - calc contains main calculator logic\
|----/num-input     - numeric input wraps input functionality\
|-------/mousewheel - simple mousewheel directive, used by numeric input (use mousewheel, ctrl+mousewheel, shift+mousewheel)\
|----/curr-select   - trivial currencies dropdown with a flag

/code contains some utils and types used by above components


text:
## Exercise 4 - Caching

This part of the PCF 201 Workshop focuses on the topic of caching. In this part of the workshop you will learn to:

- Provision a Pivotal Cloud Cache (PCC) service instance
- Deploy multiple instances of your application
- Use Spring to easily configure the the cache for usage in each of your instances
- Know the difference between an inline and a distributed cache, and when/why to use each one
-


text:
---
title: "Guide to adding an image gallery (or other actionscript 2 component) to the mbudm#001 template"
date: "2009-06-15"
categories: ["Development"]
tags: []
---

A few buyers and potential buyers have been asking me about adding an external SWF to my "[Minimalist, versatile, corporate site template](http://flashden.net/item/minimalist-versatile-corporate-site-template/42027?ref=mbudm "My mbudm#001 template on Flash Den")" on FlashDen.net. This is something I expected as the template is purposefully a 'lite' version - it has an inbuilt text module and support for external SWFs only. Other site templates on FlashDen often have other 'modules' like video player, image gallery, php form or news reader . I kept mine minimal for two reasons:

*   I don't yet have these modules coded. I'm getting there but I want my versions to be as stand-out as possible - which means quite a bit of work.
*   I saw a gap in the current site template market at Flash Den for a simplified entry level template

Therefore this blog post is a bit of a guide to existing and potential customers on how to add an external SWF to my template.

### Add an external item to the site index

An entry for an external page in the index XML file for the template looks like this:

```
<page type="external" url="swfs/externalDemo.swf" onresize="onResize" onload="init"
onloadparams="data/externalDemo.xml" title="An external SWF"  />
```

The attributes that are unique to the external type are these (this is copied from my documentation that comes with the template):

*   onresize: The name of the function within your external swf that you want to be called when the size of the space allocated to the page changes. This function should be set up to receive width and height paremeter and it should be located at the root of your swf.
*   onload: The name of the function within your external swf that you want to be called when it first loads. The parameter below is passed. This function should be located at the root of your swf.
*   onloadparams:The parameter you want to pass to the function specified in the onload attribute

So the example XML node above tells the template that when it loads the external SWF it needs to:

*   Call a function in the \_root (\_level0) of the loaded SWF called "init", and pass the contents of the onloadparams attribute, "data/externalDemo.xml".
*   Whenever the width or height of the page area changes (eg. if the template is set to a fluid layout and the browser is resized) then the template should call a function called "onResize", which is also located at \_level0 of the external SWF. This function must be set up to receive two parameters, width and height.

### Setting the size of the loaded movie and calling the onload function

If the external SWF you are using is another purchased item, you may need to consult it's documentation or contact the author to find out what function you need to call to resize the SWF or to initialise it. Once you know this, you simply need to add the code to the external SWF. So for example, if you have a gallery and the gallery.FLA is set up like so;

*   all the gallery code in one movieclip called "gallery\_mc"
*   the gallery\_mc contains a function to initialise called "init" and this needs to receive the path of an XML file as a parameter
*   the gallery\_mc contains a function for setting the width and height called "setSize" and expects to receive two parameters, width and height.

Then the code you need to add to the \_root of the FLA is:

```
function onResize(w:Number,h:Number){
    gallery_mc.setSize(w,h);
}
```
```
function init(xmlFileName:String){
    gallery_mc.init(xmlFileName:String);
}
```

Too easy right?

gha_language: HTML


text:
# Quotes about mathematics

http://scihi.org/category/mathematics/page/3/

https://web.archive.org/web/20120720231539/http://math.sfsu.edu/beck/quotes.html

https://www.prodigygame.com/main-en/blog/math-quotes/

>In mathematics you don't understand things - you just get used to them.
-- Attributed to John von Neumann

>If a religion is defined to be a system of ideas that contains unprovable statements, then Gödel taught us that mathematics is not only a religion, it is the only religion that can prove itself to be one.
-- John Barrow

>Quapropter bono christiano, sive mathematici, sive quilibet impie divinantium, maxime dicentes vera, cavendi sunt, ne consortio daemoniorum animam deceptam, pacto quodam societatis irretiant.
-- Augustinus in "De genesis ad literam"

>We all agree that your theory is crazy, but is it crazy enough?
-- Niels Bohr (1885-1962)

>Questions that pertain to the foundations of mathematics, although treated by many in recent times, still lack a satisfactory solution. Ambiguity of language is philosophy's main source of problems. That is why it is of the utmost importance to examine attentively the very words we use.
-- Giuseppe Peano in "The Principles of Mathematics"

>To many, mathematics is a collection of a collection of theorems. For me, mathematics is a collection of examples; a theorem is a statement about a collection of examples and the purpose of proving theorems is to classify and explain the examples.
-- John H. Conway

>Serious mathematics (contrary to a popular misconception) is not 'about' proofs and logic any more than serious literature is 'about' grammar, or music is 'about' notes."
-- Ethan D. Bloch

>Pure mathematics is, in its way, the poetry of logical ideas.
-- Albert Einstein

>There's more to mathematics than rigour and proofs.
-- Terence Tao
https://terrytao.wordpress.com/career-advice/theres-more-to-mathematics-than-rigour-and-proofs/

license: Unlicense


text:
MetamodelX::Red::Model
----------------------

### method column-names

```raku
method column-names(
    |
) returns Mu
```

Returns a list of columns names.of the model.

### method constraints

```raku
method constraints(
    |
) returns Mu
```

Returns a hash of model constraints classified by type.

### method references

```raku
method references(
    |
) returns Mu
```

Returns a hash of foreign keys of the model.

### method table

```raku
method table(
    Mu \type
) returns Mu
```

Returns the table name for the model.

### method as

```raku
method as(
    Mu \type
) returns Mu
```

Returns the table alias

### method orig

```raku
method orig(
    Mu \type
) returns Mu
```

Returns the original model

### method rs-class-name

```raku
method rs-class-name(
    Mu \type
) returns Mu
```

Returns the name of the ResultSeq class

### method columns

```raku
method columns(
    |
) returns Mu
```

Returns a list of columns

### method migration-hash

```raku
method migration-hash(
    \model
) returns Hash(Any)
```

Returns a hash with the migration hash

### method id-values

```raku
method id-values(
    Red::Model:D $model
) returns Mu
```

Returns a liast of id values

### method default-nullable

```raku
method default-nullable(
    |
) returns Mu
```

Check if the model is nullable by default.

### method unique-constraints

```raku
method unique-constraints(
    \model
) returns Mu
```

Returns all columns with the unique counstraint

### method attr-to-column

```raku
method attr-to-column(
    |
) returns Mu
```

A map from attr to column

### method compose

```raku
method compose(
    Mu \type
) returns Mu
```

Compose

### method add-reference

```raku
method add-reference(
    $name,
    Red::Column $col
) returns Mu
```

Creates a new reference (foreign key).

### method add-unique-constraint

```raku
method add-unique-constraint(
    Mu:U \type,
    &columns
) returns Mu
```

Creates a new unique constraint.

### multi method add-pk-constraint

```raku
multi method add-pk-constraint(
    Mu:U \type,
    &columns
) returns Mu
```

Creates a new primary key constraint.

### multi method add-pk-constraint

```raku
multi method add-pk-constraint(
    Mu:U \type,
    @columns
) returns Mu
```

Creates the primary key constraint.

### method add-column

```raku
method add-column(
    ::T Red::Model:U \type,
    Red::Attr::Column $attr
) returns Mu
```

Creates a new column and adds it to the model.

### multi method rs

```raku
multi method rs(
    Mu:U $
) returns Red::ResultSeq
```

Returns the ResultSeq

### multi method all

```raku
multi method all(
    $obj
) returns Red::ResultSeq
```

Alias for C<.rs()>

### method temp

```raku
method temp(
    |
) returns Mu
```

Sets model as a temporary table

### multi method create-table

```raku
multi method create-table(
    \model where { ... },
    Bool :unless-exists(:$if-not-exists) where { ... },
    *%pars
) returns Mu
```

Creates table unless table already exists

### multi method create-table

```raku
multi method create-table(
    \model where { ... },
    :$with where { ... },
    :if-not-exists($unless-exists) where { ... }
) returns Mu
```

Creates table

### method apply-row-phasers

```raku
method apply-row-phasers(
    $obj,
    Mu:U $phase
) returns Mu
```

Applies phasers

### multi method save

```raku
multi method save(
    $obj,
    Bool :$insert! where { ... },
    Bool :$from-create,
    :$with where { ... }
) returns Mu
```

Saves that object on database (create a new row)

### multi method save

```raku
multi method save(
    $obj,
    Bool :$update! where { ... },
    :$with where { ... }
) returns Mu
```

Saves that object on database (update the row)

### multi method save

```raku
multi method save(
    $obj,
    :$with where { ... }
) returns Mu
```

Generic save, calls C<.^save: :insert> if C<.^is-on-db> or C<.^save: :update> otherwise

### multi method delete

```raku
multi method delete(
    \model,
    :$with where { ... }
) returns Mu
```

Deletes row from database

### multi method load

```raku
multi method load(
    Red::Model:U \model,
    |ids
) returns Mu
```

Loads object from the DB

### multi method new-with-id

```raku
multi method new-with-id(
    Red::Model:U \model,
    %ids,
    :$with where { ... }
) returns Mu
```

Creates a new object setting ids with this values

### multi method new-with-id

```raku
multi method new-with-id(
    Red::Model:U \model,
    |ids
) returns Mu
```

Creates a new object setting the id

### multi method search

```raku
multi method search(
    Red::Model:U \model,
    &filter,
    :$with where { ... }
) returns Mu
```

Receives a `Block` of code and returns a `ResultSeq` using the `Block`'s return as filter

### multi method search

```raku
multi method search(
    Red::Model:U \model,
    Red::AST $filter,
    :$with where { ... }
) returns Mu
```

Receives a `AST` of code and returns a `ResultSeq` using that `AST` as filter

### multi method search

```raku
multi method search(
    Red::Model:U \model,
    *%filter,
    :$with where { ... }
) returns Mu
```

Receives a hash of `AST`s of code and returns a `ResultSeq` using that `AST`s as filter Usualy passed unique values as IDs or columns with unique counstraint

### multi method find

```raku
multi method find(
    |c
) returns Mu
```

Finds a specific row using the same data as search()

repository: FCO/Red

gha_language: Raku

repo_name: FCO/Red


text:
# News Highlight App.

## Description.

News Highlight application is a flask application that lists and previews news articles from various sources.

#### By **Ivy Nzioka**

## Behaviour Driven Development.

| Behaviour                  | Input                       | Output               |
| -------------------------- | -------------------------   | -------------------- |
| View Business sources      | Click on business section   | Page scrolls to business section |
| View Technology sources    | Click on technology section | Page scrolls to technology section
| View Sports sources        | Click on sports section     | Page scrolls to sports section |
| View General sources       | Click on general section    | Page scrolls to general section    |

## Live Demo

Here is a link to a live demo:[id]</>

## Setup/Installation Requirements
* Python 3.6
* Install news highlight by cloning this repository:   <https://github.com/nziokaivy//Newshighlights>
* Edit the start.sh file with your api key from the news.org website
* Install python 3.6
* Run chmod a+x start.py
* Run ./start.py

## Bugs

Incase of any bugs:-

-   Fork a repo
-   Create a new branch (git checkout -b improve-feature)
-   Make the appropriate changes in the files
-   Add changes to reflect the changes made
-   Commit your changes (git commit -m "Improve feature"
-   Push to the branch (git push origin improve-feature)
-   Create a Pull Request

## Technologies Used

-   HTML
-   Bootstrap
-   Python 3.6

## Support and contact details

If you have any issues feel free to contact me at<EMAIL_ADDRESS>
## License

MIT License. Copywright (c) 2018 _Ivy Nzioka._

repository: nziokaivy/Newshighlights

repo_name: nziokaivy/Newshighlights


text:
# Examples

Ok... I might have overstated when I said "a bunch" of examples. There are not many yet, but I will be expanding as I improve testing and add more features

## Compiling

To compile any example, just go to its respective directory and run

```shell
make
./test_[example_name]
```

for example, to run the *primitive_types* type:

```shell
make
./test_primitive_types
```

## Available tests

- [**Primitive types convertion:**](primitive_types) demonstrate all the Java-To-C++ and C++-To-Java primitive type convertions.

repository: brunolapastina/jonc

repo_name: brunolapastina/jonc


text:
Utilities for working with signed requests in Scala. Diamondhead provides low-level generating and parsing functions for signed requests, and makes it easy to handle your own payload JSON format. Diamondhead ships with support for Facebook's signed request format built on these low-level functions.

### sbt

Diamondhead releases are in the central Maven repositories.

```
"com.pongr" %% "diamondhead" % "0.9.0"
```

### Signed Requests

Web services need to communicate with one another. When one web service receives an HTTP request from another which includes important data, that web service often needs to verify that the HTTP request did in fact originate from the expected client (and not some bad actor trying to trick the service). If some other web site is asking your service for HTML to display in an iframe, or notifying you that some event occurred, you need to verify that the requestor is who you expect.

Signed requests provide a simple way for a web service to verify that the information it received in an HTTP request actually came from the expected client. The two services share some secret key (that no one else should know). When one service makes a request to the other, it signs the data it's sending with this secret key (using somethign like [HMAC-SHA256][12]), and includes the signature along with this data. When the other service receives the data it verifies the signature.

Note that signed requests do not encrypt the payload data; the data is sent as-is over whatever communication channel is being used. Signed requests simply provide a way for a web service to verify that the data in the request came from the expected client. You should always send HTTP requests via SSL/HTTPS if you want their contents encrypted.

Signed requests are defined in a (somewhat obscure) [OAuth2-related spec][6] and used increasingly by Facebook, especially when requesting the iframe content for a Facebook app's canvas page or a Facebook page tab. The base64url encoding and decoding, along with HMAC-SHA256 signing to verify signatures, is tedious code to write that can easily be performed by a library. Diamondhead provides all of this for you.

### Facebook Signed Requsts

Diamondhead ships with support for [Facebook signed requests][5], which comes in very handy when your Scala web app needs to verify the signed_request parameter and extract out the Facebook userId and OAuth2 access token. The [SignedRequest][7] case class includes common fields that Facebook uses in their [signed requests][4]. For examples of how Facebook uses signed requests, see the [canvas tutorial][8] and [page tab tutorial][9].

Just call the `parse` function with your Facebook app secret and the signed request String, and you'll either get back an error or the parsed `SignedRequest` object:

``` scala

import com.pongr.diamondhead.facebook._

val signedRequest: String = ??? //probably extracted from a POST request from Facebook
val appSecret: String = ???     //probably from your app config or database
parse(appSecret, signedRequest) match {
  case Right(SignedRequest(_,_,_, Some(userId), Some(token), _,_)) => //authed user
  case Right(sr) => //un-authed user
  case Left(t) => //unable to parse the signed request
}
```

This SignedRequest case class is built on Diamondhead's generic signed request functions. You can define your own case class to work with your own payload data format.

### Custom JSON Protocols

Signed requests aren't just for Facebook. You can define your own payload JSON formats and use them when providing your own services. Typically you want to use a case class to work with payload data, instead of raw json. Simply define a [spray-json protocol][10] for your case class:

``` scala
import spray.json._

object ThingProtocol extends DefaultJsonProtocol {
  case class Thing(a: String, b: Int, c: Boolean)
  implicit val thingFormat = jsonFormat3(Thing)
}
```

The `generate` function will convert your case class to json, base64url encode it, sign it and produce the final signed request string:

``` scala
import com.pongr.diamondhead._

val key = "SomeSecretValue"
val thing = Thing("a", 1, true)
val signedRequest = generate(key, thing)
//signedRequest: String = _W12Hk6kco_wIvlxJcU_u72-nrer2mC1yGi9Fq42dfQ.eyJhIjoiYSIsImIiOjEsImMiOnRydWV9
//now send signedRequest to some web service, they'll know it came from you
```

The `parseAs` function will verify the signature in a signed request string, then decode and parse it into an instance of your case class (or return any error that occurred during this process):

``` scala
import com.pongr.diamondhead._
import ThingProtocol._

val e: Either[Throwable, Thing] = parseAs(key, signedRequest) //use values from above
//e: Either[Throwable,Thing] = Right(Thing(a,1,true))
//handle the parse error or use the thing
```

### Low-Level Functions

The custom JSON protocol functions descried above are built on top of low-level String functions. If by chance you have your own base64url encoded payload String (instead of a case class instance) you can generate the signed request String:

``` scala
import com.pongr.diamondhead._

val payload: String = ??? //already base64url encoded
val signedRequest: String = generate(key, payload)
//now send signedRequest to some web service, they'll know it came from you
```

Similarly, if you just need to verify and extract the encoded payload String from a signed request, you can do that too:

``` scala
import com.pongr.diamondhead._

val e: Either[Throwable, String] = parse(key, signedRequest)
//handle the parse error or use the payload string
```

### License

Diamondhead is released under the [Apache 2 License][11].

### Credits

* [commons-codec][1] for Base64url encoding and decoding
* [spray-json][2] for JSON parsing and generating

### Authors

* [Zach Cox][3]

[1]: http://commons.apache.org/proper/commons-codec/
[2]: https://github.com/spray/spray-json
[3]: https://github.com/zcox
[4]: https://developers.facebook.com/docs/reference/login/signed-request/
[5]: https://developers.facebook.com/docs/facebook-login/using-login-with-games/
[6]: https://docs.google.com/document/d/1kv6Oz_HRnWa0DaJx_SQ5Qlk_yqs_7zNAm75-FmKwNo4/pub
[7]: https://github.com/pongr/diamondhead/blob/master/src/main/scala/facebook/package.scala
[8]: https://developers.facebook.com/docs/appsonfacebook/tutorial/
[9]: https://developers.facebook.com/docs/appsonfacebook/pagetabs/
[10]: https://github.com/spray/spray-json#providing-jsonformats-for-case-classes
[11]: http://www.apache.org/licenses/LICENSE-2.0.txt
[12]: http://en.wikipedia.org/wiki/Hash-based_message_authentication_code

repository: afournier-spotuse/diamondhead

repo_name: afournier-spotuse/diamondhead


text:
# Examples for ADC
The IO-Warrior56, IO-Warrior28 and IO-Warrior100 supports ADC inputs.
For further informations about the ADC functions and differences please take a look into the datasheets.

# Links
[Datasheet IO-Warrior56](https://www.codemercs.com/downloads/iowarrior/IOW56_Datasheet.pdf)
[Datasheet IO-Warrior28](https://www.codemercs.com/downloads/iowarrior/IOW28_Datasheet.pdf)
[Datasheet IO-Warrior100](https://www.codemercs.com/downloads/iowarrior/IOW100_Datasheet.pdf)

## Contact
If you have any questions about the IO-Warrior please contact<EMAIL_ADDRESS>or using the [issues](https://github.com/codemercs-com/io-warrior-win/issues)
section in this repository. There is also a company [forum](https://forum.codemercs.com/) with many solved questions.

repository: codemercs-com/io-warrior-win

repo_name: codemercs-com/io-warrior-win


text:
# Introduction

### Welcome!

First off, thank you for considering contributing to Homer!

### Project philosophy

Homer is meant to be a light and very simple dashboard that keeps all your useful utilities at hands. The few features implemented in Homer focus on
UX and usability. If you are looking for a full featured dashboard, there is tons of great stuff out there like https://heimdall.site/, https://github.com/rmountjoy92/DashMachine or https://organizr.app/.

- Configuration is stored in a simple config file, avoiding the need for a backend/database while making possible to use versioning or [config template](https://docs.ansible.com/ansible/latest/user_guide/playbooks_templating.html).
- Only modern browsers are supported, feel free to use any JS features without any polyfill as soon as the latest version of the major browsers supports them.

# Ground Rules

### Code of conduct and guidelines

First of all, we expect everyone (contributors and maintainers alike) to respect the [Code of conduct](https://github.com/bastienwirtz/homer/blob/main/CODE_OF_CONDUCT.md). It is not a recommendation, it is mandatory.

For all contributions, please respect the following guidelines:

* Each pull request should implement ONE feature or bugfix. If you want to add or fix more than one thing, submit more than one pull request.
* Do not commit changes to files that are irrelevant to your feature or bugfix (e.g. `.gitignore`).
* Do not add unnecessary dependencies.
* Be aware that the pull request review process is not immediate, and is generally proportional to the size of the pull request.

# Getting started

### Discuss about ideas

If you want to add a feature, it's often best to talk about it before starting to work on it and submitting a pull request. It's not mandatory at all, but
feel free to open an issue to present your idea.

### How to submit a contribution

The general process to submit a contribution is as follow:
1. Take a look to the [development guideline](https://github.com/bastienwirtz/homer/blob/main/docs/development.md).
2. Create your own fork of the code
3. Do the changes in your fork
4. Make sure to fill the [pull request description](https://github.com/bastienwirtz/homer/blob/main/.github/PULL_REQUEST_TEMPLATE.md) properly.

### Happy coding :metal:

repository: bastienwirtz/homer

gha_language: Vue

repo_name: bastienwirtz/homer


text:
# dummy-debian-packages
A small tool which massively creates different, dummy .deb files.

This script was originally created to stress test mass deployment of Debian packages to JFrog Artifactory. It utilizes the `equivs-build` binary which is built-in in any Debian based OS.

repository: joeynaor/dummy-debian-packages

repo_name: joeynaor/dummy-debian-packages


text:
Robert C Martin - Clean Architecture

Understanding and Applying Operational Transformation

Welcome to Apache Wave

First winter storm of season to bring ice, snow to northeastern US in final days of 2015

The Micro VCs Are Coming

What I learned from a Sex Addict: 5 Ways to be More Intimate.

11 Brutally Honest Reasons Why Millennials Don't Want Kids

Something Extraordinary Is Happening in the World, And Most People Haven't Noticed

Can We F*ck the Person we Love? {Adult}

Is ecstasy really that dangerous? All your questions answered

#FieldWorkFail Lets Scientists Share Their Hilariously Less-Impressive Moments

buycott

ipiit

House Cat Origin Traced to Middle Eastern Wildcat Ancestor

Republicans Just Destroyed Thousands of Solar Jobs in One of the Sunniest States

When Is an Orgasm More than Just an Orgasm? {Adult} ~ Walker Thornton

repository: btakita/philosophy

repo_name: btakita/philosophy


text:
---
title: Servers
author: v-thopra
description: Overview of PlayFab's multiplayer server hosting service.
ms.author: v-thopra
ms.date: 07/12/2018
ms.topic: article
ms.prod: playfab
keywords: playfab. multiplayer, servers
ms.localizationpriority: medium
---

# Multiplayer Servers

PlayFab's multiplayer server hosting service allows you to operate a dynamically scaling pool of custom game servers in Azure.

All PlayFab indie, pro, and enterprise tier customers can access the service and use a limited, free quota of multiplayer servers for product evaluation and testing.

There are three key concepts to PlayFab multiplayer servers:

1. **Game server executable**. This is the application that you are running in Azure. This server may be a simple network repeater, a fully authoritative game server running physics and AI, or anything in between.
2. **Build**. This is the game server executable, packaged with assets and certificates needed to run the game. This content can be uploaded as individual certificates, zip files, and/or a container image. If you do not need a custom container image, you can use PlayFab managed Windows containers.
3. **Game server**. A container running your game server executable. There may be multiple servers running on a single virtual machine.

These are the typical steps for using the service:

1. **Author game server**. Scaling your server requires integration with the PlayFab game server SDK (GSDK) and testing the server executable in a container. You can download a mock agent and the Windows container image PlayFab uses for local development.
2. **Upload game server executable and assets**. Upload the server and manage builds through Game Manager or PlayFab APIs and SDKs.
3. **Scale game server build**. Once you've uploaded server assets you can create *builds*. PlayFab dynamically creates and recycles virtual machines to fulfill player demand and maintain standing-by levels you specify.
4. **Measure player latency**. When players initiate a multiplayer experience, send UDP messages to PlayFab quality-of-service (QoS) beacons to measure network latency to Azure.
5. **Request multiplayer server**. When players need a multiplayer server, request one to be allocated from a build's standing-by pool. This request can come from a lobby or matchmaking service you operate, or directly from a client calling PlayFab.
6. **Connect and play**. PlayFab will fulfill a server request within 1 second if standing-by servers are available. Once a server has been put into the active state, clients connect to the server and play.

![PlayFab Multiplayer Server Hosting Service diagram](media/tutorials/multiplayer-server-hosting-service-diagram.png)

## Reference Documentation, Samples, and Tools

- [Multiplayer Server API Reference](xref:titleid.playfabapi.com.multiplayer.multiplayerserver)
- [PowerShell Module](https://www.powershellgallery.com/packages/PlayFabMultiplayer)

## Game Server SDK & Samples

- [Game Server SDK (GSDK) Sample - Basic Windows Runner](https://github.com/PlayFab/gsdkSamples)
- [Game Server SDK (GSDK) for C++ Windows servers via nuget](https://www.nuget.org/packages/com.playfab.cppgsdk.v140)
- [Game Server SDK (GSDK) for C# Windows servers via nuget](https://www.nuget.org/packages/com.playfab.csharpgsdk)
- [Game Server SDK (GSDK) for Java Windows & Linux servers via Maven](https://mvnrepository.com/artifact/com.playfab/gameserverSDK)

## Frequently asked questions

### Q: I am using Unity. Do you have a sample of a Unity-based game interfacing with the game server SDK?

At this time, we do not have a Unity sample demonstrating PlayFab Multiplayer Servers. A small group of preview customers have gotten the C# GSDK to work with their Unity-based game server, but it is not a straightforward experience.

### Q: Only 14 Azure regions and 4 VM series appear currently supported. Can I get access to additional series or regions?

Please contact the team through [PlayFab<EMAIL_ADDRESS>as we are adding additional series and regions in response to customer requests. The current selection are the most popular options used by several games in production.


text:
# Event chart (experimental)

Note: This component is still experimental, use with caution! Help us get this
component out of the experimental state by providing feedback.

<ba-ux-snippet name="event-chart-intro"></ba-ux-snippet>

<ba-live-example name="DtExampleEventChartDefault" fullwidth></ba-live-example>

## Imports

You have to import the `DtEventChartModule` when you want to use the
`<dt-event-chart>`:

```typescript
@NgModule({
  imports: [DtEventChartModule],
})
class MyModule {}
```

## Example setup

<ba-live-example name="DtExampleEventChartSessionReplay" fullwidth></ba-live-example>

## Initialization

To create a `dtEventChart` in a minimal configuration, only
`dt-event-chart-events` and `dt-event-chart-lane` elements are required to
create a valid output.

<ba-live-example name="DtExampleEventChartDefault" fullwidth></ba-live-example>

## Options & Properties

### DtEventChart

### Methods

| Name                    | Description                                                                                | Return value |
| ----------------------- | ----------------------------------------------------------------------------------------------------------- | ------------ |
| `select(index: number)` | Selects the event by index. If the event is merged, the merged event will be displayed as the selected one. | `void`       |
| `deselect()`            | Deselects all events.                                                                                | `void`       |
| `closeOverlay()`        | Closes the overlay if one is present.                                                                       | `void`       |

### DtEventChartEvent<T>

The `dtEventChartEvent` component is used to provide event data to the parent
event chart. It will also accept an arbitrary `data` input, which can hold
metadata for this event.

#### Inputs

| Name       | Type                 | Default   | Description                                                                         |
| ---------- | -------------------- | --------- | ----------------------------------------------------------------------------------- |
| `value`    | `number`             | -         | Value of the event (most probably a timestamp).                                     |
| `lane`     | `string`             | -         | Lane that this event is associated with.                                            |
| `duration` | `number`             | 0         | Duration of the event (most probably milliseconds).                                 |
| `color`    | `DtEventChartColors` | `default` | Color of the event. This color property will override the one provided by the lane. |
| `data`     | `T`                  | -         | Any data for this event. This data will be emitted when an event is selected.       |

#### Outputs

| Name       | Type                                        | Description                                        |
| ---------- | ------------------------------------------- | -------------------------------------------------- |
| `selected` | `EventEmitter<DtEventChartSelectedEvent<T>` | Event that fires when a an eventBubble is clicked. |

### DtEventChartHeatfield<T>

The `DtEventChartHeatfield` component is used to provide heatfield data to the
parent event chart. It will also accept an arbitrary `data` input, which can
hold metadata for this field.

#### Inputs

| Name    | Type                 | Default   | Description                                                                       |
| ------- | -------------------- | --------- | --------------------------------------------------------------------------------- |
| `start` | `number`             |           | The start numerical/date value on the x-axis of the chart.                        |
| `end`   | `number`             |           | LThe end numerical/date value on the x-axis of the chart.                         |
| `color` | `DtEventChartColors` | `default` | Color of the heatfield.                                                           |
| `data`  | `T`                  | -         | Any data for this heatfield. This data will be emitted when an event is selected. |

#### Outputs

| Name       | Type                                        | Description                                      |
| ---------- | ------------------------------------------- | ------------------------------------------------ |
| `selected` | `EventEmitter<DtEventChartSelectedEvent<T>` | Event that fires when a an heatfield is clicked. |

### DtEventChartLane

The `dtEventChartLane` defines a lane, on which an event will be rendered. The
events are associated with the lanes via their names. This association is
case-sensitive.

#### Inputs

| Name      | Type                 | Default   | Description                                                                    |
| --------- | -------------------- | --------- | ------------------------------------------------------------------------------ |
| `name`    | `string`             | -         | Name identifier of the lane.                                                   |
| `label`   | `string`             | -         | Label for the lane (will be rendered on the left hand side of the eventChart). |
| `pattern` | `boolean`            | false     | Defines if the events get a pattern within the given lane.                     |
| `color`   | `DtEventChartColors` | `default` | Defines the color for the given lane.                                          |

### DtEventChartLegendItem

The `dtEventChartLegendItem` lets you provide possible legend items for all
varieties of events, that could be rendered within the EventChart. Depending on
which events are being rendered (default, error, conversion, duration events),
the correct legend items will be picked form the given items, and displayed
below the EventChart.

#### Inputs

| Name      | Type                 | Default   | Description                                                        |
| --------- | -------------------- | --------- | ------------------------------------------------------------------ |
| `lanes`   | `string \| string[]` | -         | Defines for which lanes this legend item can be used for.          |
| `pattern` | `boolean`            | false     | Defines that this legend item is used for pattern events.          |
| `color`   | `DtEventChartColors` | `default` | Defines that this legend item is only usable for the passed color. |

### DtEventChartOverlay

The `dtEventChartOverlay` directive applies to an `ng-template` element lets you
provide a template for the rendered overlay. The overlay will be shown when a
user hovers the event bubble. The EventChart will expose the hovered events
(this is always an array, as the events could be clustered) as `$implicit`
context to the overlay template, which can be used as following:

```html
<ng-template dtEventChartOverlay let-tooltip>
  <div *ngFor="let t of tooltip">
    <!-- Insert your template for one event here. -->
  </div>
</ng-template>
```

### DtEventChartHeatfieldOverlay

The `dtEventChartHeatfieldOverlay` directive applies to an `ng-template` element
lets you provide a template for the rendered overlay. The overlay will be shown
when a user hovers the heatfield. The EventChart will expose the hovered events
(this is always an array, as the events could be clustered) as `$implicit`
context to the overlay template, which can be used as following:

```html
<ng-template dtEventChartHeatfieldOverlay let-tooltip>
  <div *ngFor="let t of tooltip">
    <!-- Insert your template for one event here. -->
  </div>
</ng-template>
```

## DtEventChartColors

Currently, there are only four different colors which are applicable to a
`dtEventChartEvent`, `dtEventChartLane` or `dtEventChartLegendItem`.

- default
- error
- conversion
- filtered

## Examples

### Default

<ba-live-example name="DtExampleEventChartDefault" fullwidth></ba-live-example>

### Setting custom colors on events

<ba-live-example name="DtExampleEventChartCustomColor" fullwidth></ba-live-example>

### Providing legend items for events

<ba-live-example name="DtExampleEventChartLegend" fullwidth></ba-live-example>

### Defining the overlay template

<ba-live-example name="DtExampleEventChartOverlay" fullwidth></ba-live-example>

### Setting heatfields and heatfield overlay template

<ba-live-example name="DtExampleEventChartHeatfield" fullwidth></ba-live-example>

### Handling event selection via click

<ba-live-example name="DtExampleEventChartSelection" fullwidth></ba-live-example>

### Session replay example (simplified)

<ba-live-example name="DtExampleEventChartSessionReplay" fullwidth></ba-live-example>

repository: dynatrace-oss/barista

gha_language: TypeScript

repo_name: dynatrace-oss/barista


text:
---
layout: post
title: "Atom Remote Edit UI & speed of opening remote files"
modified:
categories:
excerpt: A very small observation about interface.
tags: [atom, emacs]
date: 2015-04-24T21:28:08+12:00
comments: true
---

I quite like Atom as an editor - it ticks most of the boxes for an editor I'll enjoy using. I've been using Emacs for a Very Long Time and it's one of the harder habits to kick in this world.

Atom has a dialog UI which it seems to encourage - most Atom plugins follow suit and use the same interface to present a list of options. It's very reminiscent of the sheet that Sublime Text presented for option lists, and maybe in turn that interface came from another editor I don't recognise.

I use Tramp in Emacs to open files on remote servers. Sometimes you want to edit a file on a remote server from the editor instance you're already using. I noticed how much slower this experience seemed to be when using Atom than when using Emacs, so I made a quick screencapture of it and was surprised to see how much longer it really was.

Note the benefit of tab completion here too - in opening the same file path using Tramp, I made two typos which were corrected so fast I didn't recall making them until watching the animation play back.

**Emacs + Tramp**

![Opening the same file with Tramp](/images/file-open-tramp.gif)

**Atom + Remote Edit**

![Opening a file with Atom + Remote Edit](/images/file-open-remote-edit.gif)

The time to set up the SSH connection is similar both times, but the delay IMO is introduced where Atom's sheet interface doesn't have as quick a tab-selection (even though it presents a visual list of options to choose from, a feature Tramp lacks).

Another interesting observation watching those animations is the time Atom's Remote Edit spends saying "no matches found". While the plugin isn't "selling" anything, the psychology of showing a "no matches found" message while waiting for files to show might be looked into - I expect just changing the message would improve perceived performance. (Brings [this recent article about website experience and perception management](http://www.smashingmagazine.com/2015/11/why-performance-matters-part-2-perception-management/) to mind for me.)

This has also shown me how much I tend to keep a memory of file paths on remote systems; to me the visual interface just slows things down, but I also tend to perceive unexpected layouts as a bit of a bug (mostly this comes up when a predictable structure isn't kept to consistently). If I didn't have that internal reference, I'd probably not mind picking from a list each time. As it is, I haven't the patience!

Both Atom & its Remote Edit plugin are great tools - thanks @sveale and the Atom team for your work. I'm still flapping between Atom and Emacs on the desktop, but I'll be sticking with Tramp for this task. Implementing a Tramp style UX on Atom would be a fun project.


text:
# hass-haier-ac

Home Assistant Haier AC Custom integration

This repository is a heavy work in progress and is not in a working state yet.

The code is based on this Homebridge plugin: https://github.com/bstuff/haier-ac-remote

# 🔴 DISCLAIMER 🔴

🔴 IT DOES **NOT** WORK YET! Project is in WIP state. 🔴

# Goals

First step is to convert haier-ac-remote code to Python to a state where we can succesfully send proper commands to Haier AC and it will properly respond to them and perform proper actions.

Second step is converting the response parsing part so we can get AC state.

And the final step will be to write it into a proper Home Assistant integration. After that it can be added to HACS.

# Current state

Currently most of the bytecode functions and commands have been translated to the best of my and my friend's knowledge. Code sends commands to AC and it seems to do **something**, because after running this code AC will no longer reply to other commands from original HomeBridge plugin until it's turned OFF and then back ON from it's original IR remote.

I suspect there may be some mistake in bytecode conversion or maybe some important step is missing.

repository: Nixellion/hass-haier-ac

repo_name: Nixellion/hass-haier-ac


text:
# README Starter

**Table Of Contents**
- [Project description](#project-description)
- [Installation](#installation)
- [Example Usage](#example-usage)
- [Contributing](#contributing)
- [Support](#support)
- [Change log](#change-log)
- [Roadmap](#roadmap)
- [License](#license)

#### Project description:
This project is a node.js command line utility that generates a template readme file for use in open-source software products. The readme used in this project is a variation of the [template](./README-template.md) generated by this product. This project was created to reduce the amount of time for creating unique readme files in every software project.

*languages and frameworks:*
- [node.js](https://nodejs.org/en/)
- [npm](https://www.npmjs.com/)

## Installation

**Requirements/Dependencies:**
- node must be installed on your local machine
- this package only has the capability of being run locally within a node.js project (global installation is coming soon)
- this package must be installed in the root of your project where the node_modules/ directory is located, or the creating of the readme will fail
- this project has not been tested within a Windows environment, so this module may not perform as expected on Windows machines

**Mac OSX and Unix/Linux:**
```bash
$ npm install readme-starter
```

## Example Usage

Below provides the two equivalent commands that perform the same execution for this module:

```
npx readme new
```
```
./node_modules/.bin/readme new
```

These is the only accepted command within the CLI (for local execution).

## Contributing
There are no strict contributing guidelines at this time. All issues and pull requests are welcome. Author information is provided below for questions and concerns.

## Support
If you have any questions you can contact the author. Contact Information is provided at the end of this document. If you find any issues or bugs, create a new issue and make a pull request to fix it!

## Change Log
[CHANGELOG.md](./CHANGELOG.md)

## Roadmap

- Converting local executable to global
- Refactoring implementation to use modern code style (ES6 Promises, Async-Await)

## License

[MIT License](./LICENSE)

*Author Info:*
- Skye Brown
  - Twitter: @skyebrownh
  - Email<EMAIL_ADDRESS>

repository: skyebrownh/readme-starter

repo_name: skyebrownh/readme-starter


text:
# Hello, welcome to my 102 notes!

## I am going to keep myself in a Growth Mindset by;
1. Instead of saying "I won't ever be good at this" I'll say "I will be able to do this, it's just going to take a bit of work before I can get there"
2. If I see someone who is better than me at something I won't say "I'll never be able to get to the point they are at" we all start somewhere and it's ok to be a bit slower than others. Everyone has their own pace they go at.
3. Not everyone understands something right away. It just takes practice. Everyone has their own ways that they learn.

### Table of Contents
- [Class 01: Markdown](01-Markdown.md)
- [Class 01b: Growth Mindset](01b-GrowthMindset.md)
- [Class 02: Terminals and Text Editing](02-TextEditorsandTerminal.md)
- [Class 03: Git](03-Git.md)
- [Class 04: Structure web pages with HTML](04-StructureWebPagesWithHTML.md)
- [Class 05: CSS](05-CSS.md)
- [Class 06a: JavaScript](06a-JavaScript.md)
- [Class 06b: Computer Architechture and Logic](06b-AboutComputers.md)
- [Class 07: Programming with JS](07-ProgrammingWithJS.md)
- [Class 08: Operators and Loops](08-OperatorsAndLoops.md)


text:
# The Minimal Demo for Plotters + WASM

Run the demo locally with the following command under this directory.

```
./start-server.sh
```

For Windows user doesn't have Bash, `start-server.bat` can be used to launch the server.

```
start-server.bat
```


text:
Quick links:

* [CONFIG.md](https://github.com/codetaylor/artisan-worktables/blob/master/CONFIG.md)
* [ZENSCRIPT.md](https://github.com/codetaylor/artisan-worktables/blob/master/ZENSCRIPT.md)
* [CHANGELOG.md](https://github.com/codetaylor/artisan-worktables/blob/master/CHANGELOG.md)
* [LICENSE](https://github.com/codetaylor/artisan-worktables/blob/master/LICENSE)

### Artisan Worktables

Themed worktables with a tool slot.

This mod is designed for modpack makers. It is intended to be used with CraftTweaker. JEI integration is supported.

Depends on the library mod Athenaeum.

#### Tables

![Tables](https://raw.githubusercontent.com/codetaylor/artisan-worktables/master/assets/tables.png)

![TableGuis](https://raw.githubusercontent.com/codetaylor/artisan-worktables/master/assets/table_gui.gif)

Recipes for the worktables are like the vanilla crafting recipes (shaped, shapeless) except they require a tool and tool durability cost to be specified. Tools go into the extra slot in the table and remain in the table between crafts. The tables will also retain their contents when closed, but not when broken.

Shift-clicking items will swap tools and place items in the crafting matrix.

Recipes to craft the tables are not provided. It is intended that you use CraftTweaker to supply your own recipes for making and using the worktables.

Vanilla crafting table recipes are not supported in any table and there are currently no plans to do so.

#### Tools

Two tools for each table, made from vanilla and Thermal Foundation materials, are provided if you want to use them.

The tools and their recipes can easily be disabled in the config file.

![TableTools](https://raw.githubusercontent.com/codetaylor/artisan-worktables/master/assets/items.png)

repository: titantwoshot/artisan-worktables

repo_name: titantwoshot/artisan-worktables


text:
# Hacktoberfest 2021 with IEEE-VIT :orange_heart:
This is a expense tracker iOS application built using swift. Users can track their expense and visualise it.

Support open source software by participating in [Hacktoberfest](https://hacktoberfest.digitalocean.com) and get goodies and a free t-shirt! :orange_heart:

> Please check all issues labelled as `hacktoberfest` to start contributing!

Kindly consider leaving a :star: if you like the repository and our organisation.

## Getting Started
* Fork it.

* Clone your forked repo and move inside it:

`git clone https://github.com/IEEE-VIT/Xpendi.git && cd Xpendi`

* Checkout to a new branch to work on an issue:

`git checkout -b my-amazing-feature`

* Running the project

`open the project in Xcode and run!`

`Shortcut: (⌘ + R)`

* Once you're all done coding, it's time to open a PR :)
Run the following commands from the root of the project directory:

`git add .`

`git commit -m "A short description about the feature."`

`git push origin <my-amazing-feature>`

Open your forked repo in your browser and then raise a PR to the `master` branch of this repository!

## Contributing
To start contributing, check out [CONTRIBUTING.md](https://github.com/IEEE-VIT/ToDo-iOS/blob/master/contributing.md). New contributors are always welcome to support this project. If you want something gentle to start with, check out issues labelled as `easy` or `good-first-issue`. Check out issues labelled as `hacktoberfest` if you are up for some grabs! :)

## License
[MIT License](LICENSE)

repository: IEEE-VIT/Xpendi

gha_language: Swift

repo_name: IEEE-VIT/Xpendi


text:
website_multi_image
===================
This module adds multiple product images into a tab in product.template in a tab called Product Images. It is definitely a work in progress, however it does allow for storage of multiple images per product and can be used to display multiple images on your website template's product page.
Website Multi-Image

TODO: master
===================
Add multiple image slideshow to over-ride current single image display on product view and category view pages.

    + Options:

      - WowSlider: https://github.com/WOWSlider/WOWSlider

      - OwlCarousel: https://github.com/OwlFonk/OwlCarousel2

Image magnification

    + Options

      - Magnifier.js: https://github.com/mark-rolich/Magnifier.js

      - Zoom (jQuery): https://github.com/jackmoore/zoom/tree/master

      - BootstrapMagnify: https://github.com/marcaube/bootstrap-magnify

Secondary Image (on Mouseover) (Category list view and grid view)

Image thumbnail preview widget in list view (to replace current download link)