text:
# pptx-automizer
This is a pptx generator for Node.js based on templates. It can read pptx files and insert selected slides or single slide elements into another presentation. *pptx-automizer* will not write files from scratch, but edit and merge existing pptx files. Template slides are styled within PowerPoint and will be merged into the output presentation. Most of the content can be modified by using callbacks with [xmldom](https://github.com/xmldom/xmldom).

*pptx-automizer* will fit best to users who try to maintain their own library of pptx template files. This is perfect to anyone who uses complex and well-styled customized layouts. Any existing slide and even a single element can be a data driven template for output pptx files.

## Requirements
This generator can only be used on the server-side and requires a [Node.js](https://nodejs.org/en/download/package-manager/) environment.

## Limitations
Please note that this project is *work in progress*. At the moment, you might encounter difficulties for special shape types that require further relations (e.g. links will not work properly). Although, most shape types are already supported, such as connection shapes, tables or charts. You are welcome to [report any issue](https://github.com/singerla/pptx-automizer/issues/new).

All testing focuses on PowerPoint 2019 pptx file format.

## Install
There are basically two ways to use *pptx-automizer*.

### As a cloned repository
If you want to see how it works and you like to run own tests, you should clone this repository and install the dependencies:
```
$ git clone git@github.com:singerla/pptx-automizer.git
$ cd pptx-automizer
$ yarn install
```
You can now run
```
$ yarn dev
```
and see the most recent feature from `src/dev.ts`. Every time you change & save this file, you will see new console output and a pptx file in the destination folder. Take a look into `__tests__`-directory to see a lot of examples for several use cases!

### As a package
If you are working on an existing project, you can add *pptx-automizer* to it using npm or yarn. Run
```
$ yarn add pptx-automizer
```
or
```
$ npm install pptx-automizer
```
in the root folder of your project. This will download and install the most recent version into your existing project.

## Example
```js
import Automizer, { modify } from "pptx-automizer"

// First, let's set some preferences
const automizer = new Automizer({
  templateDir: `my/pptx/templates`,
  outputDir: `my/pptx/output`
})

// Now we can start and load a pptx template.
// Each addSlide will append to any existing slide in RootTemplate.pptx.
let pres = automizer.loadRoot(`RootTemplate.pptx`)
  // We want to make some more files available and give them a handy label.
  .load(`SlideWithShapes.pptx`, 'shapes')
  .load(`SlideWithGraph.pptx`, 'graph')
  // Skipping the second argument will not set a label.
  .load(`SlideWithImages.pptx`)

// addSlide takes two arguments: The first will specify the source
// presentation's label to get the template from, the second will set the
// slide number to require.
pres.addSlide('graph', 1)
  .addSlide('shapes', 1)
  .addSlide(`SlideWithImages.pptx`, 2)

// You can also select and import a single element from a template slide.
// The desired shape will be identified by its name from slide-xml's
// 'p:cNvPr'-element.
pres.addSlide('SlideWithImages.pptx', 1, (slide) => {
  // Pass the template name, the slide number, the element's name and
  // (optionally) a callback function to directly modify the child nodes
  // of <p:sp>
  slide.addElement('shapes', 2, 'Arrow', (element) => {
    element.getElementsByTagName('a:t')[0]
      .firstChild
      .data = 'Custom content'
  })
})

// It is possible to modify an existing element on a newly added slide.
pres.addSlide('shapes', 2, (slide) => {
  slide.modifyElement('Drum', [
    // You can use some of the builtin modifiers to edit a shape's xml:
    modify.setPosition({x: 1000000, h:5000000, w:5000000}),
    // Log your target xml into the console:
    modify.dump
  ])
})

// Modify an existing chart on an added slide.
pres.addSlide('charts', 2, (slide) => {
  slide.modifyElement('ColumnChart', [
    // Use an object like this to inject the new chart data.
    // Additional series and categories will be copied from
    // previous sibling.
    modify.setChartData({
      series: [
        { label: 'series 1' },
        { label: 'series 2' },
        { label: 'series 3' },
      ],
      categories: [
        { label: 'cat 2-1', values: [ 50, 50, 20 ] },
        { label: 'cat 2-2', values: [ 14, 50, 20 ] },
        { label: 'cat 2-3', values: [ 15, 50, 20 ] },
        { label: 'cat 2-4', values: [ 26, 50, 20 ] }
      ]
    })
    // Please notice: If your template has more data than your data
    // object, automizer will remove these nodes.
  ])
})

// Finally, we want to write the output file.
pres.write(`myPresentation.pptx`).then(summary => {
  console.log(summary)
})
```

### Testing
You can run all unit tests using these commands:
```
yarn test
yarn test-coverage
```

### Special Thanks
This project is deeply inspired by:

* [PptxGenJS](https://github.com/gitbrent/PptxGenJS)
* [officegen](https://github.com/Ziv-Barber/officegen)
* [node-pptx](https://github.com/heavysixer/node-pptx)
* [docxtemplater](https://github.com/open-xml-templating/docxtemplater)

repository: LBrenac/pptx-automizer

repo_name: LBrenac/pptx-automizer


text:
# Log Collectors

[![Build Status](https://travis-ci.org/haasted/TestLogCollectors.svg?branch=master)](https://travis-ci.org/haasted/TestLogCollectors)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/dk.bitcraft/LogCollector/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dk.bitcraft/LogCollector)
[![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/haasted/TestLogCollectors/blob/master/LICENSE)
[![Javadoc](https://img.shields.io/badge/javadoc-OK-blue.svg)](https://javadoc.io/doc/dk.bitcraft/LogCollector/)

Application logging is important and occasionally important enough to make it worth creating automated tests to verify it. Enter Log Collectors, which captures log records for inspection or verification during testing.

The framework is a [JUnit Rule](https://github.com/junit-team/junit4/wiki/Rules), which hooks into any logger it is provided, and intercepts its messages.

It is applicable in situations where you want to
 - ensure that THE warning is emitted during an error
 - verify that the audit logs gets populated correctly

Log Collectors currently has support for the following libraries
 - [Log4j2](https://logging.apache.org/log4j/2.x/)
 - [Logback](https://logback.qos.ch/)
 - [java.util.logging](https://docs.oracle.com/javase/8/docs/technotes/guides/logging/overview.html)
 - [slf4j](https://www.slf4j.org/) (slf4j-simple, logback, log4j, java.util.logging)

The goals of the framework are
 - Only mandatory dependency is JUnit.
 - Support for the most widespread logging frameworks

Feedback is appreciated. If you find the framework useful, or have suggestions for improving it, get in touch!

# Usage

The following example shows how to include the JUnit rule in a test, provide it with the logger and inspect the log entries generated by testing a component.

```java
@Rule
public LogCollector collector = new LogCollector(LogManager.getLogger("acme.Gizmo"));

@Test
public void testGizmo() {
    Gizmo gizmo = new Gizmo();
    gizmo.run();

    List<LogEvent> rawLogs = (List<LogEvent>) collector.getRawLogs();
    assertTrue(rawLogs.stream().noneMatch(l -> l.getLevel() == Level.ERROR));
}
```

# Installation

Log Collectors is available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22LogCollector%22).

Maven installation
```xml
<dependency>
    <groupId>dk.bitcraft</groupId>
    <artifactId>LogCollector</artifactId>
    <version>0.7.0</version>
    <scope>test</scope>
</dependency>
```

Gradle installation
```
testCompile 'dk.bitcraft:LogCollector:0.7.0'
```

# Future work

  - Come up with a better name for the framework.
  - Improve Javadoc and documentation.
  - Discover the intricacies of the various logging frameworks in real-world settings and adapt to them.
  - Avoid the ugly cast in `getRawLogs`.
  - Detect SLF4j's `NOPLogger` and replace it with `SimpleLogger`
  - Any ideas? Get in touch!

license: MIT

repository: cybernetics/TestLogCollectors

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: cybernetics/TestLogCollectors


text:
# Mouse Squad Python Repository

Congratulations! You've found the Mouse Squad python respository. If you're working on Module 2, you'll find the relevant portions of the assignment in the "module 2" folder.

The module 2 folder includes the MouseIntro.py file, which exposes a class that has three methods:

* printHelloWorld(), which prints a simple "Hello World" statement.
* printSum(value1, value2), which prints the addition of the two supplied numbers.
* multiplyValues(value1, value2), which returns the product of the two values.

## Steps to Leverage Github Code

To leverage this, you'll need to copy the python file to your local machine.
1. In Github, open the "module 2" folder
2. Download the "MouseIntro.py" file to your local machine.
3. Upload the file to your pythonanywhere.com account.
4. Import the file into your console or python file using the import command ("import MouseIntro")

## Sample Consumption Code

Were you successful in getting the imported code to run in your environment? Sample code below.

import mouseintro

test = mouseintro.MouseIntro()

test.printHelloWorld()

test.printSum(10, 20)

x = test.multiplyValues(5, 4)

print x

### Additional Thoughts

What license is this repository covered by?

### Future Assignments

Feel free to browse! Materials for all modules are included in this respository for future consumption.

repository: scotasaurus/MouseSquad

repo_name: scotasaurus/MouseSquad


text:
**[home](index.md) > [other work](otherwork.md) > art 1988**

JHT art 1988
[1981](art1981.md) [1982](art1982.md) [1983](art1983.md) [1985](art1985.md) 1988 [1989](art1989.md)

**Garden of Interactive Delights**

![](images/art88t2.jpg)Artifacts from the "**Garden of Interactive Delights**", an interactive art installation, created in collaboration with Benjamin Bergery. Included "**Picture Piano**", "**Movie Machine**", "**Shadow Canvas**", "**Interactive Bed**". Displayed at the Hague Summer Festival June 11 to 19, 1988.

Stills from the video "Long Night" used in the "Interactive Bed" installation.

**
........................................**

Click [**HERE**](long_night_intro.html',320,270) to watch the intro of the "Long Night" video.
(616KB, [Shockwave plug-in](http://sdc.shockwave.com/shockwave/download/frameset.fhtml?) required)

**........................................**

[![](images/garden_cover_mini.jpg)](images/garden_cover)
Cover for the catalog for the "Garden of Interactive Delights."

[![](images/garden_notes_mini.jpg)](images/garden_notes.)
Notes on the "Garden of Interactive Delights."

[![](images/interactive_bed_notes_mini.jpg)](images/interactive_bed_notes.)
Notes on the "Interactive Bed."

[![](images/jt_bb_on_ibed_mini.jpg)](images/jt_bb_on_ibed)
Newspaper coverage of the "Garden of Interactive Delights."

[![](images/videobed_at_the_film_mini.jpg)](images/videobed_at_the_film)
More newspaper coverage of the "Garden of Interactive Delights."

[![](images/afi_1989_mini.jpg)](images/afi_1989)
Catalog from the exhibition and presentation of "Interactive Bed" at the American Film Institute (AFI) 1988.

[![](images/afi_page_1_mini.jpg)](images/afi_page_1big)
Discussion of "Interactive Bed" at AFI 1988 page 1.

[![](images/afi_page_2_mini.jpg)](images/afi_page_2big)
Discussion of "Interactive Bed" at AFI 1988 page 2.

[![](images/making_ibed_la_mini.jpg)](images/making_ibed_la.)
Collage on the making of the "Interactive Bed."

[top](#topofpage)

**.........................................**

(c) 2001 John Henry Thompson - site by [Pixelyze](http://www.pixelyze.com/) & [CAGE](http://www.cage.nl/)

![](images/spacer.gif)

gha_language: HTML

gha_license_id: MIT


text:
## Cohort Resource Templates
Profiles containing Resource Templates for Sinopia's Cohorts are stored in this
directory's sub-directories.

### Cohort Institution Codes Used in Templates
* Cornell--Cornell University
* Harvard--Harvard University
* HRC--Harry Ransom Center, University of Texas at Austin
* NLM--National Library of Medicine
* Penn--University of Pennsylvania
* Stanford--Stanford University
* UCSD--University of California, San Diego
* UMN--University of Minnesota
* WAU--University of Washington
* CUB--University of Colorado Boulder
* UChicago--University of Chicago

### Codes for Ontologies Used in Templates
* ARM--Art and Rare Materials Ontology
* BF2--BIBFRAME 2.0
* PMO--Performed Music Ontology


text:
# vue-atinternet-smarttag

"vue-atinternet-smarttag" is a VueJS Plugin implementation of [At Internet Smartag solution](https://www.atinternet.com/produits/smarttag/)

__This plugin will add to your VueJs project:__

* a ```v-smarttag-click``` directive to easily track clicks on dom objects
* an access to your tracking tag in every component via ```this.$smartTag```
* an access to your tracking tag via ```Vue.smartTag``` (to be used in your routing scripts or vuex actions)

You'll be able to track page and clicks (only clicks with the directive).

__At Internet SmartTag docs:__

* [Pages tracking](https://developers.atinternet-solutions.com/javascript-en/content-javascript-en/pages-javascript-en/)
* [Clicks tracking](https://developers.atinternet-solutions.com/javascript-en/content-javascript-en/clicks-javascript-en/)

## Todo

* [x] Add Bundler (rollup)
* [x] Add Tests framework (Jest & Vue-test-utils)
* [ ] Add a test case for vue-router auto page view
* [x] Doc website (vuepress)

repository: Seb-L/vue-atinternet-smarttag

gha_language: JavaScript

repo_name: Seb-L/vue-atinternet-smarttag


text:
My Personal Website

## What is?

This is my personal site, it also has a blog area! ✍

Go a head and visit it  👀

I made it with a lot of love ♥

## Installation

```bash
git clone https://github.com/Batusai1291/personal-website.git
```

## Usage

1- Install dependencies:

```bash
yarn
# or
npm install
```

2- Run the development server:

```bash
yarn dev
# or
npm run dev
```

3- Open: [http://localhost:3000](http://localhost:3000) with your browser to see the result.

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)

branch_name: refs/heads/main


text:
The easiest way is to deploy the application to your webserver and execute the following commands from the root directory. Make sure to adjust the config.php to your requirments

## Requirements
The app requires a couple of packages you need to install on your system. Those are:
- Apache with PHP >= 5.6
- MySQL
- MySQL-PDO

## Create Database
<pre>
$ php bin/composer install
$ cp src/sample-config.php src/config.php
$ vendor/bin/doctrine orm:schema-tool:create
$ vendor/bin/doctrine orm:generate-proxies
</pre>
The web root should point to the src directory.

repository: ItonBV/scrumonline

repo_name: ItonBV/scrumonline


text:
---
path:	"/blog/evangelist-consultant-myopia"
date:	"2016-12-14"
title:	"Evangelist/Consultant Myopia"
image:	"../images/1*SZw2Z7tnK2Q5qKxlbOS6Mg.png"
---

How can change agents and change participants make each other awesome ([see the Modern Agile first principle: Make People Awesome](https://www.infoq.com/articles/modern-agile-intro))?

![](../images/1*SZw2Z7tnK2Q5qKxlbOS6Mg.png)

Come Into The Woods: Melonie KingToday’s Thought: **Change agent myopia does not make people awesome**. It’s easy to ignore how silly a lot of what we’re spewing actually sounds, unless you’ve seen it work:

* Why *wouldn’t* we try to build more?
* Why *would* we let our engineers sit around and mob program all day?
* Why *wouldn’t* we try to speed up?
* Why *wouldn’t* we just design everything upfront?
* Why *wouldn’t* we try to keep our developers busy?
* Why *wouldn’t* we try to establish clear roles and responsibilities, clear lines of accountability, and efficient processes?
* Why *wouldn’t* we run a feature factory?
Context and work history dictates our perspective. I spoke recently with someone who had focused on “the enterprise” for their career. They simply couldn’t believe that other organizations targeted similar customers (size, savviness, product complexity) but worked in entirely different ways. “You’re ***ing kidding me!

There are two ways to respond here:

1. a dash of smugness, point to some books, insinuate their org is behind the curve, hype a buzzword methodology, reference a keynote talk on YouTube, or
2. curiosity, empathy, and accepting the burden of proof.
The former fails to accept that what you’re pitching is likely highly counterintuitive. It might have no connection to what this person has seen, experienced, has been subjected to, and has tried in their career. The latter invites an experimentation mindset.

I’ve attended — and sadly given — many talks where the upshot is “you’re wrong, you are behind the curve, and there is a better way!” Peppered through the talk are a list of symptoms everyone can relate to. The audience nods. People laugh. People cry. They want to up their game!

But the reality is that only 5% of the people in the room have actually *experienced *(and that is the critical word) or even observed the better way of working. 15% have experienced some sort of watered down pragmatic variation (see [Larman’s Laws of Organizational Behavior](http://www.craiglarman.com/wiki/index.php?title=Larman%27s_Laws_of_Organizational_Behavior)). 95% of the audience relates to the pain, but cannot relate to the path forward on any visceral, non-theoretical level. And therein is the challenge. We are complex animals, and we like quacking ducks and good stories.

Lasting change often follows a cataclysmic event. In a fit of existential struggle, the organization flips the lever and launches into the new. You could argue that change agents would, in many cases, be better served by triggering an oh-shit threat, and just sitting back.

The other approach is to focus on running safe-to-fail experiments that let people experience the new, and judge for themselves. Have empathy. Start with where you are. Respect prior experience. And focus on experiencing the new in with safety and trust.

repository: johnpcutler/cutlefishblog

repo_name: johnpcutler/cutlefishblog


text:
# Date library for Futhark [![CI](https://github.com/diku-dk/date/workflows/CI/badge.svg)](https://github.com/diku-dk/date/actions) [![Documentation](https://futhark-lang.org/pkgs/github.com/diku-dk/date/status.svg)](https://futhark-lang.org/pkgs/github.com/diku-dk/date/latest/)

A simple date library.  Inspired by code from LexiFi.  This library
does not handle any ancient calendars or anything like that.  It's
designed for simplicity (and thereby speed).

## Installation

```
futhark pkg add github.com/diku-dk/date
futhark pkg sync
```

## Usage

```
> import "lib/github.com/diku-dk/date/date"
> check_date (1900, 2, 29)
false
> check_date (2000, 2, 29)
true
```

license: ISC

repository: diku-dk/date

repo_name: diku-dk/date


text:
rdiff
=====
[![CC0](http://i.creativecommons.org/p/zero/1.0/88x31.png)](http://creativecommons.org/publicdomain/zero/1.0/)
[![Build Status](https://travis-ci.org/dyule/rdiff.svg?branch=master)](https://travis-ci.org/dyule/rdiff)
[![Crates.io](https://img.shields.io/crates/v/rdiff.svg?maxAge=2592000)](https://crates.io/crates/rdiff)

rdiff is a package for comparing versions of a file over time.  It is written is Rust, and expects version > 1.17.

To the extent possible under law, rdiff contributors have waived all copyright and related or neighboring rights to rdiff.

[Documentation](https://dyule.github.io/rdiff/rdiff/)

# Usage

in `Cargo.toml`:

``` toml
[dependencies]
rdiff = "0.1"
```

In your rust file (taken from [examples/predefined.rs](examples/predefined.rs)):

``` rust
extern crate rdiff;

use rdiff::BlockHashes;
use std::fs::File;

pub fn example() {
    let file = File::open("examples/filev1.txt").unwrap();
    let mut hashes = BlockHashes::new(file, 8).unwrap();
    let file = File::open("examples/filev2.txt").unwrap();
    let difference = hashes.diff_and_update(file).unwrap();
    println!("Inserts: {:?}", difference.inserts().collect::<Vec<_>>());
    println!("Deletes: {:?}", difference.deletes().collect::<Vec<_>>());
}
```

This will output
```
Inserts: [Insert(8, 'widely understood '), Insert(90, ' absolutely'), Insert(381, 'hters, or sons if the family was progressive.\n'), Insert(572, 'not, even though he had been following the news quite closely.\n\n'), Insert(734, '\nMr. Ben')]
Deletes: [Delete(34, 24), Delete(428, 8), Delete(638, 8), Delete(742, 8)]
```

repository: dyule/rdiff

gha_language: Rust

repo_name: dyule/rdiff


text:
# example-flask-rest
A minimal flask rest API with a Make file. It returns data in JSON format.

## Development
### Python virtual environment
Used [pyenv](https://github.com/pyenv/pyenv) with [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv) plugin.
```shell
pyenv virtualenv 3.8.5 example-flask    # create a virtual environment with python 3.8.5
pyenv activate example-flask            # activate given virtual environment
pyenv deactivate example-flask          # deactivate given virtual environment
```
### Environment
- Dockerfile: Define the image on Alpine Linux.
- docker-compose.yml: Define the services

## Make targets
- Run application with logs:
```shell
make run
```
Application will be available on http://<IP_ADDRESS>:5000
- Stop application:
```shell
make stop
```
- Remove containers:
```shell
make clean
```
- For other make targets:
```shell
make help
```

### Endpoints:
Server: http://<IP_ADDRESS>:5000
- `/`:
    - `GET`: Returns a static message.
    - `POST`: Returns the request body in the response.
- `GET /square/<number>`: Returns the square of a given number.
- `GET /greeting/<name>`: Returns a greeting message for the given name.

repository: BilyanaDemirok/example-flask-rest

repo_name: BilyanaDemirok/example-flask-rest