text:
/* globals OS_ANDROID, OS_IOS */

'use strict';

const ImageFactory = require('ti.imagefactory');

let navigationWindow = null;
const imageMap = {
	'PNG - Opaque': 'assets/images/IconOpaque.png',
	'PNG - Transparent': 'assets/images/IconTransparent.png',
	'JPEG - Upright': 'assets/images/ExifUpright.jpeg',
	'JPEG - EXIF Rotate 90': 'assets/images/ExifRotate90.jpeg',
	'JPEG - EXIF Rotate 180': 'assets/images/ExifRotate180.jpeg',
	'JPEG - EXIF Rotate 270': 'assets/images/ExifRotate270.jpeg',
	'JPEG - EXIF Flip Horizontal': 'assets/images/ExifFlipHorizontal.jpeg',
	'JPEG - EXIF Flip Vertical': 'assets/images/ExifFlipVertical.jpeg',
	'JPEG - EXIF Transpose': 'assets/images/ExifTranspose.jpeg',
	'JPEG - EXIF Transverse': 'assets/images/ExifTransverse.jpeg',
};
const parentWindow = Ti.UI.createWindow({ title: 'Images' });
const tableView = Ti.UI.createTableView({
	data: Object.keys(imageMap).map((title) => {
		return Ti.UI.createTableViewRow({ title: title });
	}),
});
tableView.addEventListener('click', (e) => {
	// Load the selected image as a blob.
	let sourceBlob = null;
	if (OS_IOS) {
		sourceBlob = Ti.Filesystem.getAsset(imageMap[e.row.title]);
	}
	if (!sourceBlob) {
		sourceBlob = Ti.Filesystem.getFile(Ti.Filesystem.resourcesDirectory, imageMap[e.row.title]).read();
	}

	// Displays the given blob's image metadata/exif info in a child window.
	function showMetadataWindowFor(imageBlob) {
		const metadataDictionary = ImageFactory.metadataFrom(imageBlob);
		const windowSettings = { title: 'Metadata' };
		if (OS_IOS) {
			windowSettings.backgroundColor = 'white';
		}
		const metadataWindow = Ti.UI.createWindow(windowSettings);
		const scrollView = Ti.UI.createScrollView({
			layout: 'vertical',
			scrollType: 'vertical',
			showVerticalScrollIndicator: true,
			width: Ti.UI.FILL,
			height: Ti.UI.FILL,
		});
		scrollView.add(Ti.UI.createLabel({
			text: '\n' + JSON.stringify(metadataDictionary, null, 4) + '\n',
			left: 10,
			right: 10,
		}));
		metadataWindow.add(scrollView);
		navigationWindow.openWindow(metadataWindow, { animated: true });
	}

	// Displays the given blob's image in a child window.
	function showImageWindowFor(imageBlob) {
		const windowSettings = { title: 'Resulting Image' };
		if (OS_IOS && imageBlob) {
			const metadataButton = Ti.UI.createButton({
				systemButton: Ti.UI.iOS.SystemButton.INFO_LIGHT,
			});
			metadataButton.addEventListener('click', () => {
				showMetadataWindowFor(imageBlob);
			});
			windowSettings.backgroundColor = 'white';
			windowSettings.rightNavButton = metadataButton;
		}
		const imageWindow = Ti.UI.createWindow(windowSettings);
		if (imageBlob) {
			imageWindow.add(Ti.UI.createImageView({ image: imageBlob, autorotate: false }));
			if (OS_ANDROID) {
				imageWindow.activity.onCreateOptionsMenu = (e) => {
					const menuItem = e.menu.add({
						title: 'View Metadata',
						showAsAction: Ti.Android.SHOW_AS_ACTION_NEVER,
					});
					menuItem.addEventListener('click', () => {
						showMetadataWindowFor(imageBlob);
					});
				};
			}
		} else {
			imageWindow.add(Ti.UI.createLabel({ text: 'Image factory returned null.' }));
		}
		navigationWindow.openWindow(imageWindow, { animated: true });
	}

	// Show a list of ImageFactory transformations to apply to selected image.
	const settingsWindow = Ti.UI.createWindow({ title: 'Transformations' });
	const tableView = Ti.UI.createTableView();
	{
		const row = Ti.UI.createTableViewRow({ title: 'None' });
		row.addEventListener('click', () => {
			showImageWindowFor(sourceBlob);
		});
		tableView.appendRow(row);
	}
	if (OS_ANDROID) {
		const row = Ti.UI.createTableViewRow({ title: 'compress() PNG' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.compress(sourceBlob, 1.0, ImageFactory.PNG));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'compress() JPEG 5% quality' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.compress(sourceBlob, 0.05));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'compress() JPEG 100% quality' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.compress(sourceBlob, 1.0));
		});
		tableView.appendRow(row);
	}
	if (OS_ANDROID) {
		const row = Ti.UI.createTableViewRow({ title: 'compress() WebP 5% quality' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.compress(sourceBlob, 0.05, ImageFactory.WEBP));
		});
		tableView.appendRow(row);
	}
	if (OS_ANDROID) {
		const row = Ti.UI.createTableViewRow({ title: 'compress() WebP 100% quality' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.compress(sourceBlob, 1.0, ImageFactory.WEBP));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'compressToFile() PNG' });
		row.addEventListener('click', () => {
			const file = Ti.Filesystem.getFile(Ti.Filesystem.applicationDataDirectory, 'CompressTest.png');
			ImageFactory.compressToFile(sourceBlob, 1.0, file.nativePath);
			showImageWindowFor(file.read());
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'compressToFile() JPEG 5% quality' });
		row.addEventListener('click', () => {
			const file = Ti.Filesystem.getFile(Ti.Filesystem.applicationDataDirectory, 'CompressTest.jpg');
			ImageFactory.compressToFile(sourceBlob, 0.05, file.nativePath);
			showImageWindowFor(file.read());
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'compressToFile() JPEG 100% quality' });
		row.addEventListener('click', () => {
			const file = Ti.Filesystem.getFile(Ti.Filesystem.applicationDataDirectory, 'CompressTest.jpg');
			ImageFactory.compressToFile(sourceBlob, 1.0, file.nativePath);
			showImageWindowFor(file.read());
		});
		tableView.appendRow(row);
	}
	if (OS_ANDROID) {
		const row = Ti.UI.createTableViewRow({ title: 'compressToFile() WebP 5% quality' });
		row.addEventListener('click', () => {
			const file = Ti.Filesystem.getFile(Ti.Filesystem.applicationDataDirectory, 'CompressTest.webp');
			ImageFactory.compressToFile(sourceBlob, 0.05, file.nativePath);
			showImageWindowFor(file.read());
		});
		tableView.appendRow(row);
	}
	if (OS_ANDROID) {
		const row = Ti.UI.createTableViewRow({ title: 'compressToFile() WebP 100% quality' });
		row.addEventListener('click', () => {
			const file = Ti.Filesystem.getFile(Ti.Filesystem.applicationDataDirectory, 'CompressTest.webp');
			ImageFactory.compressToFile(sourceBlob, 1.0, file.nativePath);
			showImageWindowFor(file.read());
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageAsUpright()' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageAsUpright(sourceBlob));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageAsResized() 320x320' });
		row.addEventListener('click', () => {
			const options = {
				width: 320,
				height: 320,
			};
			showImageWindowFor(ImageFactory.imageAsResized(sourceBlob, options));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageAsCropped() 320x320 center' });
		row.addEventListener('click', () => {
			const options = {
				width: 320,
				height: 320,
			};
			showImageWindowFor(ImageFactory.imageAsCropped(sourceBlob, options));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageAsCropped() bottom-left quadrant' });
		row.addEventListener('click', () => {
			const options = {
				x: 0,
				y: sourceBlob.uprightHeight / 2,
				width: sourceBlob.uprightWidth / 2,
				height: sourceBlob.uprightHeight / 2,
			};
			showImageWindowFor(ImageFactory.imageAsCropped(sourceBlob, options));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageAsCropped() top-right quadrant' });
		row.addEventListener('click', () => {
			const options = {
				x: sourceBlob.uprightWidth / 2,
				y: 0,
				width: sourceBlob.uprightWidth / 2,
				height: sourceBlob.uprightHeight / 2,
			};
			showImageWindowFor(ImageFactory.imageAsCropped(sourceBlob, options));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRoundedCorner()' });
		row.addEventListener('click', () => {
			const options = {
				borderSize: 4,
				cornerRadius: 64,
				format: ImageFactory.PNG,
			};
			showImageWindowFor(ImageFactory.imageWithRoundedCorner(sourceBlob, options));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithTransparentBorder()' });
		row.addEventListener('click', () => {
			const options = {
				borderSize: 50,
				format: ImageFactory.PNG,
			};
			showImageWindowFor(ImageFactory.imageWithTransparentBorder(sourceBlob, options));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageAsThumbnail() 320x320 circle' });
		row.addEventListener('click', () => {
			const options = {
				size: 320,
				cornerRadius: 160,
				format: ImageFactory.PNG,
			};
			showImageWindowFor(ImageFactory.imageAsThumbnail(sourceBlob, options));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageAsThumbnail() 320x320 square' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageAsThumbnail(sourceBlob, { size: 320 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithAlpha()' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithAlpha(sourceBlob, { format: ImageFactory.PNG }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRotation() 0 degrees' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithRotation(sourceBlob, { degrees: 0 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRotation() 45 clockwise' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithRotation(sourceBlob, { degrees: 45 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRotation() 90 clockwise' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithRotation(sourceBlob, { degrees: 90 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRotation() 180 clockwise' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithRotation(sourceBlob, { degrees: 180 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRotation() 270 clockwise' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithRotation(sourceBlob, { degrees: 270 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRotation() 90 counter-clockwise' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithRotation(sourceBlob, { degrees: -90 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRotation() 180 counter-clockwise' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithRotation(sourceBlob, { degrees: -180 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageWithRotation() 270 counter-clockwise' });
		row.addEventListener('click', () => {
			showImageWindowFor(ImageFactory.imageWithRotation(sourceBlob, { degrees: -270 }));
		});
		tableView.appendRow(row);
	}
	{
		const row = Ti.UI.createTableViewRow({ title: 'imageTransform() crop/rounded/rotate-90' });
		row.addEventListener('click', () => {
			const options = [
				{
					type: ImageFactory.TRANSFORM_CROP,
					width: 320,
					height: 320,
				},
				{
					type: ImageFactory.TRANSFORM_ROTATE,
					degrees: 90,
				},
				{
					type: ImageFactory.TRANSFORM_ROUNDEDCORNER,
					borderSize: 4,
					cornerRadius: 64,
				},
			];
			showImageWindowFor(ImageFactory.imageTransform(sourceBlob, ...options));
		});
		tableView.appendRow(row);
	}
	settingsWindow.add(tableView);
	navigationWindow.openWindow(settingsWindow, { animated: true });
});
parentWindow.add(tableView);
navigationWindow = Ti.UI.createNavigationWindow({
	window: parentWindow,
});
navigationWindow.open();


text:
package no.ntnu.httpmock.servlet

import javax.servlet.http.HttpServlet
import javax.servlet.http.HttpServletRequest

object ServletHelper {
  class ParameterNotFoundException(message: String) extends Exception(message)

  /** Get the request path relative to the servlet path.
   *
   * Strips the servlet path from the request URI. Example: If the servlet path
   * is "/MyServlet", and the request path is "/MyServlet/SomePage", returns
   * "/SomePage".
   */
  def getServletRelativePath(request: HttpServletRequest): String =
    request.getRequestURI().replace(request.getServletPath(), "")

  /** Get a request parameter or fail with an exception */
  @throws(classOf[ParameterNotFoundException])
  def getParameter(parameterName: String, request: HttpServletRequest): String = {
    val value = request.getParameter(parameterName)
    if (value == null) {
      throw new ParameterNotFoundException(parameterName)
    }
    value
  }
}

redpajama_set_name: RedPajamaGithub


text:
'use strict';

/**
 * @ngdoc directive
 * @name nboApp.directive:adminMenu
 * @description
 * # adminMenu
 */
angular.module('nboApp')
  .directive('sidebarMenu', function ($routeParams) {
    return {
      templateUrl: 'views/directives/sidebar-menu.html',
      restrict: 'E',
      scope: {
        links: '='
      },
      link: function(scope) {
        scope.section = $routeParams.section;
        scope.client = $routeParams.client;
        scope.currentLink = $routeParams.file;
        scope.lang = $routeParams.lang;
      }
    };
  });


text:
[![Code style: pep8](https://img.shields.io/badge/code%20style-pep8-yellow.svg?style=flat-square)](https://www.python.org/dev/peps/pep-0008/)

**Welcome to KAT!**

kat.py is an incredibly simple Python wrapper over the KAT search functionality. The code was originally taken from [KickassTorrentsAPI](https://github.com/stephan-mclean/KickassTorrentsAPI) however, there hasn't been much activity for almost a year and some features weren't working due to changes to the KAT website.

kat.py uses [BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/) to scrape data made against `https://kat.cr/usearch/<query>/`. Torrent details are then parsed and stored as a list of dictionaries. You can check out the source to see which fields are extracted. See below for usage examples.

## Installation

```
pip install git+https://github.com/davidvuong/kat.git
```

## Usage

```python
import kat
from pprint import pprint

# Retrieves torrents with "the flash" in their title and displays results.
for torrent in kat.search('the flash'):
    pprint(torrent)

# Retrieves first 5 pages, filtering torrents by category.
torrents = kat.search('arrow', pages=5, category=kat.Category.TV)

# Retrieves sorted results by the leech count (ascending order).
torrents = kat.search('game of thrones', sort=kat.SortType.LEECH, desc=False)

# Displays the number of torrents found.
print len(torrents)
```

## License

[MIT](LICENSE.md)


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Nova Acta R. Soc. Scient. upsal. , Ser. 3 1: 101 (1851)

#### Original name
Hexagonia unicolor Fr.

### Remarks
null


text:
<!doctype html>

        <meta http-equiv="refresh"
   content="0; url=https://www.linkedin.com/in/michaeljacobbell/">

        This page has moved to https://www.linkedin.com/in/michaeljacobbell/


text:
package com.aerospike.client.query;

import java.io.IOException;

import com.aerospike.client.AerospikeException;
import com.aerospike.client.Key;
import com.aerospike.client.Record;
import com.aerospike.client.cluster.Node;
import com.aerospike.client.command.MultiCommand;
import com.aerospike.client.policy.Policy;

public final class QueryRecordCommand extends MultiCommand {

	private final Policy policy;
	private final Statement statement;
	private final RecordSet recordSet;

	public QueryRecordCommand(Node node, Policy policy, Statement statement, RecordSet recordSet) {
		super(node, true);
		this.policy = policy;
		this.statement = statement;
		this.recordSet = recordSet;
	}

	@Override
	protected final Policy getPolicy() {
		return policy;
	}

	@Override
	protected final void writeBuffer() throws AerospikeException {
		setQuery(policy, statement, false);
	}

	@Override
	protected void parseRow(Key key) throws IOException {
		Record record = parseRecord();

		if (! valid) {
			throw new AerospikeException.QueryTerminated();
		}

		if (! recordSet.put(new KeyRecord(key, record))) {
			stop();
			throw new AerospikeException.QueryTerminated();
		}
	}
}


text:
<!DOCTYPE html>

  <meta charset="utf-8">

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <meta http-equiv="X-UA-Compatible" content="IE=edge">

  <title>About</title>
  <meta name="description" content="Stuff I do when bored.
" />

  <meta name="HandheldFriendly" content="True" />
  <meta name="MobileOptimized" content="320" />
  <meta name="apple-mobile-web-app-capable" content="yes">
  <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">

  <link rel="canonical" href="http://extigy.github.io/about/">

  <link rel="shortcut icon" href="/assets/images/favicon.ico">

  <link rel="stylesheet" href="http://brick.a.ssl.fastly.net/Linux+Libertine:400,400i,700,700i/Open+Sans:400,400i,700,700i">
  <link href="//maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css" rel="stylesheet">

  <link rel="stylesheet" type="text/css" media="screen" href="/css/main.css" />
  <link rel="stylesheet" type="text/css" media="print" href="/css/print.css" />

About

Blog Logo

A place for me to put my thoughts and projects. Will probably only really be used to write about REMEngine.

        Image

Teggers Blog

Stuff I do when bored.

        Back to Overview


text:
Ext.define('devilry.student.browseperiods.AssignmentGrid', {
    extend: 'Ext.grid.Panel',
    alias: 'widget.student-browseperiods-assignmentgrid',

    constructor: function(config) {
        this.createStore();
        this.callParent([config]);
    },

    assignmentTpl: Ext.create('Ext.XTemplate',
        '
{parentnode__long_name}
'
    ),

    pointsTpl: Ext.create('Ext.XTemplate',
        '',
        '    <tpl if="feedback">',
        '       {feedback__points}',
        '    </tpl>',
        '    <tpl if="!feedback">',
        '       ∅',
        '   </tpl>',
        ''
    ),

    gradeTpl: Ext.create('Ext.XTemplate',
        '
',
        '   <tpl if="feedback">',
        '
',
        '           <tpl if="feedback__is_passing_grade">Passed</tpl>',
        '           <tpl if="!feedback__is_passing_grade">Failed</tpl>',
        '           : {feedback__grade}',
        '
',
        '
',
        '            <tpl if="feedback__delivery__delivery_type == 0">Electronic</tpl>',
        '            <tpl if="feedback__delivery__delivery_type == 1">Non-electronic</tpl>',
        '            <tpl if="feedback__delivery__delivery_type == 2">From previous period (semester)</tpl>',
        '            <tpl if="feedback__delivery__delivery_type > 2">Unknown delivery type</tpl>',
        '
',
        '   </tpl>',
        '    <tpl if="!feedback">',
        '
',
        '           No feedback',
        '
',
        '    </tpl>',
        '
'
    ),

    createStore: function() {
        this.store = Ext.create('Ext.data.Store', {
            model: 'devilry.apps.student.simplified.SimplifiedAssignmentGroup',
            remoteFilter: true,
            remoteSort: false,
            autoSync: true
        });
        this.store.pageSize = 100000;
        //this.store.proxy.setDevilryOrderby(['parentnode__publishing_time', 'parentnode__short_name']);
    },

    loadGroupsInPeriod: function(periodRecord) {
        this.store.proxy.setDevilryFilters([{
            field: 'parentnode__parentnode',
            comp: 'exact',
            value: periodRecord.get('id')
        }])
        this.store.load({
            scope: this,
            callback: function(records, op) {
                this.getEl().unmask();
                if(records.length === 0) {
                    this.getEl().mask('You are not registered on any assignments within this period/semester. This may not be an issue if your subject/course do not have assignments, if no assignments have been published yet, or if the subject/course only use Devilry to register final results.', 'information-mask');
                }
            }
        });
    },

    initComponent: function() {
        Ext.apply(this, {
            cls: 'selectable-grid',
            //hideHeaders: true,
            columns: [{
                header: 'Assignment', dataIndex: 'parentnode__long_name', flex: 4,
                renderer: function(value, m, record) {
                    return this.assignmentTpl.apply(record.data);
                }
            //}, {
                //header: 'Points', dataIndex: 'feedback__points', flex: 1,
                //renderer: function(value, m, record) {
                    //return this.pointsTpl.apply(record.data);
                //}
            }, {
                header: 'Grade', dataIndex: 'feedback__grade', flex: 2,
                renderer: function(value, m, record) {
                    return this.gradeTpl.apply(record.data);
                }
            }],

            listeners: {
                scope: this,
                select: this._onSelect
            }
        });
        this.callParent(arguments);
    },

    _onSelect: function(grid, record) {
        var url = Ext.String.format('{0}/student/assignmentgroup/{1}', DevilrySettings.DEVILRY_URLPATH_PREFIX, record.get('id'));
        window.location.href = url;
    }
});


text:
<?php

/*
 * This file is part of the Lime test framework.
 *
 * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
 * (c) Bernhard Schussek <bernhard.schussek@symfony-project.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

/**
 * Requires a method call to satisfy a constraint for one parameter.
 *
 * The index of the parameter is given to the constructor. The desired
 * constraint can be configured by calling any of the methods of this class.
 *
 * @package    Lime
 * @author     Bernhard Schussek <bernhard.schussek@symfony-project.com>
 * @version    SVN: $Id: LimeMockInvocationMatcherParameter.php 23864 2009-11-13 18:06:20Z bschussek $
 * @see        LimeMockInvocationMatcherInterface
 */
class LimeMockInvocationMatcherParameter implements LimeMockInvocationMatcherInterface
{
  private
    $index      = null,
    $parent     = null,
    $constraint = null;

  /**
   * Constructor.
   *
   * @param integer $index
   * @param LimeMockInvocationExpectation $parent
   */
  public function __construct($index, LimeMockInvocationExpectation $parent)
  {
    $this->index = $index;
    $this->parent = $parent;
  }

  /**
   * Returns the parameter index of this matcher.
   *
   * @return integer
   */
  public function getIndex()
  {
    return $this->index;
  }

  /**
   * (non-PHPdoc)
   * @see mock/matcher/LimeMockInvocationMatcherInterface#invoke($invocation)
   */
  public function invoke(LimeMockInvocation $invocation)
  {
    try
    {
      if (!is_null($this->constraint))
      {
        $this->constraint->evaluate($invocation->getParameter($this->index-1));
      }
    }
    catch (LimeConstraintException $e)
    {
      $message = LimeTools::indent($e->getMessage(), 2);

      throw new LimeMockInvocationMatcherException("was called with wrong parameter $this->index\n".$message);
    }
    catch (OutOfRangeException $e)
    {
      throw new LimeMockInvocationMatcherException("was not called with $this->index or more parameters");
    }
  }

  /**
   * Returns whether this matcher matches the given invocation.
   *
   * @param  LimeMockInvocation $invocation
   * @return boolean
   */
  public function matches(LimeMockInvocation $invocation)
  {
    try
    {
      if (!is_null($this->constraint))
      {
        $this->constraint->evaluate($invocation->getParameter($this->index-1));
      }
    }
    catch (LimeConstraintException $e)
    {
      return false;
    }
    catch (OutOfRangeException $e)
    {
      return false;
    }

    return true;
  }

  /**
   * (non-PHPdoc)
   * @see mock/matcher/LimeMockInvocationMatcherInterface#isInvokable()
   */
  public function isInvokable()
  {
    return true;
  }

  /**
   * (non-PHPdoc)
   * @see mock/matcher/LimeMockInvocationMatcherInterface#isSatisfied()
   */
  public function isSatisfied()
  {
    return true;
  }

  /**
   * (non-PHPdoc)
   * @see mock/matcher/LimeMockInvocationMatcherInterface#getMessage()
   */
  public function getMessage()
  {
    return '';
  }

  /**
   * Sets the constraint and returns the related invocation expectation object.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   */
  private function setConstraint(LimeConstraintInterface $constraint)
  {
    $this->constraint = $constraint;

    return $this->parent;
  }

  /**
   * Requires the parameter to be equal to the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintIs
   */
  public function is($expected)
  {
    return $this->setConstraint(new LimeConstraintIs($expected));
  }

  /**
   * Requires the parameter to be not equal to the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintIsNot
   */
  public function isnt($expected)
  {
    return $this->setConstraint(new LimeConstraintIsNot($expected));
  }

  /**
   * Requires the parameter to be identical to the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintSame
   */
  public function same($expected)
  {
    return $this->setConstraint(new LimeConstraintSame($expected));
  }

  /**
   * Requires the parameter to be not identical to the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintNotSame
   */
  public function isntSame($expected)
  {
    return $this->setConstraint(new LimeConstraintNotSame($expected));
  }

  /**
   * Requires the parameter to be like the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintLike
   */
  public function like($expected)
  {
    return $this->setConstraint(new LimeConstraintLike($expected));
  }

  /**
   * Requires the parameter to be unlike the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintUnlike
   */
  public function unlike($expected)
  {
    return $this->setConstraint(new LimeConstraintUnlike($expected));
  }

  /**
   * Requires the parameter to contain the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintContains
   */
  public function contains($expected)
  {
    return $this->setConstraint(new LimeConstraintContains($expected));
  }

  /**
   * Requires the parameter to not contain the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintContainsNot
   */
  public function containsNot($expected)
  {
    return $this->setConstraint(new LimeConstraintContainsNot($expected));
  }

  /**
   * Requires the parameter to be greater than the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintGreaterThan
   */
  public function greaterThan($expected)
  {
    return $this->setConstraint(new LimeConstraintGreaterThan($expected));
  }

  /**
   * Requires the parameter to be greater than or equal to the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintGreaterThanEqual
   */
  public function greaterThanEqual($expected)
  {
    return $this->setConstraint(new LimeConstraintGreaterThanEqual($expected));
  }

  /**
   * Requires the parameter to be less than the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintLessThan
   */
  public function lessThan($expected)
  {
    return $this->setConstraint(new LimeConstraintLessThan($expected));
  }

  /**
   * Requires the parameter to be less than or equal to the given value.
   *
   * @param  LimeConstraintInterface $constraint
   * @return LimeMockInvocationExpectation
   * @see    LimeConstraintLessThanEqual
   */
  public function lessThanEqual($expected)
  {
    return $this->setConstraint(new LimeConstraintLessThanEqual($expected));
  }
}


text:
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */

/*************************************************************
 *
 *  MathJax/localization/de/TeX.js
 *
 *  Copyright (c) 2009-2013 The MathJax Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

MathJax.Localization.addTranslation("de","TeX",{
        version: "2.3",
        isLoaded: true,
        strings: {
          ExtraOpenMissingClose: "Zus\u00E4tzliche \u00F6ffnende oder fehlende schlie\u00DFende Klammer",
          ExtraCloseMissingOpen: "Zus\u00E4tzliche schlie\u00DFende oder fehlende \u00F6ffnende Klammer",
          MissingLeftExtraRight: "Fehlendes '\\left' oder zus\u00E4tzliches '\\right'",
          MissingScript: "Fehlendes Argument im Sub- oder Superskript",
          ExtraLeftMissingRight: "Zus\u00E4tzliches '\\left' oder fehlendes '\\right'",
          Misplaced: "%1 falsch plaziert",
          MissingOpenForSub: "Fehlende \u00F6ffnende Klammer im Subskript",
          MissingOpenForSup: "Fehlende \u00F6ffnende Klammer im Superskript",
          AmbiguousUseOf: "Mehrdeutige Verwendung von %1",
          EnvBadEnd: "\\begin{%1} endet mit \\end{%2}",
          EnvMissingEnd: "\\end{%1} fehlt",
          MissingBoxFor: "Fehlende Box: %1",
          MissingCloseBrace: "Fehlende schlie\u00DFende Klammer",
          UndefinedControlSequence: "Nicht definierter Befehl: %1",
          DoubleExponent: "Doppeltes Superskript: verwende Klammern zum Gruppieren",
          DoubleSubscripts: "Doppeltes Subskript: verwende Klammern zum Gruppieren",
          DoubleExponentPrime: "Prime f\u00FChrt zu doppeltem Superskript: verwende Klammern zum Gruppieren",
          CantUseHash1: "Das Zeichen '#' ist ein Makroparameter und kann nicht im Mathematikmodus verwendet werden.",
          MisplacedMiddle: "%1 muss zwischen '\\left' und '\\right' stehen",
          MisplacedLimits: "%1 ist nur bei Operatoren erlaubt",
          MisplacedMoveRoot: "%1 muss innerhalb einer Wurzel stehen",
          MultipleCommand: "Zu viele %1",
          IntegerArg: "Das Argument in %1 muss ganzzahlig sein",
          NotMathMLToken: "%1 ist kein Token-Element",
          InvalidMathMLAttr: "Unzul\u00E4ssiges MathML-Attribut: %1",
          UnknownAttrForElement: "%1 ist kein zul\u00E4ssiges Attribut f\u00FCr %2",
          MaxMacroSub1: "Maximale Anzahl an Makros ist erreicht; wird ein rekursiver Makroaufruf verwendet?",
          MaxMacroSub2: "Maximale Anzahl an Substitutionen ist erreicht; wird eine rekursive LaTeX-Umgebung verwendet?",
          MissingArgFor: "Fehlendes Argument in %1",
          ExtraAlignTab: "Zus\u00E4tzliches \u0026 im '\\cases' Text",
          BracketMustBeDimension: "Das geklammerte Argument f\u00FCr %1 muss eine Dimension sein",
          InvalidEnv: "Ung\u00FCltiger Umgebungsname %1",
          UnknownEnv: "Ung\u00FCltige Umgebung %1",
          ExtraCloseLooking: "Zus\u00E4tzliche schlie\u00DFende Klammer w\u00E4hrend der Suche nach %1",
          MissingCloseBracket: "Argument zu %1 wurde nicht mit ']' geschlossen",
          MissingOrUnrecognizedDelim: "Fehlender oder nichterkannter Delimiter bei %1",
          MissingDimOrUnits: "Fehlende Dimension oder Einheiten bei %1",
          TokenNotFoundForCommand: "Konnte %1 nicht f\u00FCr %2 finden",
          MathNotTerminated: "Formel in Textbox nicht abgeschlossen",
          IllegalMacroParam: "Ung\u00FCltiger Makroparameter",
          MaxBufferSize: "Interne Puffergr\u00F6\u00DFe \u00FCberschritten; wird ein rekursiver Makroaufruf verwendet?",
          CommandNotAllowedInEnv: "%1 ist in der Umgebung %2 nicht erlaubt",
          MultipleLabel: "Label '%1' \u00FCberdefiniert",
          CommandAtTheBeginingOfLine: "%1 muss am Zeilenanfang stehen",
          IllegalAlign: "Ung\u00FCltige Ausrichtung in %1",
          BadMathStyleFor: "Schlechtes 'math style' Argument: %1",
          PositiveIntegerArg: "Argument bei %1 muss positiv und ganzzahlig sein",
          ErroneousNestingEq: "Fehlerhafte Verschachtelung von Gleichungen",
          MultlineRowsOneCol: "Zeilen in der %1-Umgebung m\u00FCssen genau eine Spalte haben",
          MultipleBBoxProperty: "%1 wurde zweimal in %2 angegeben",
          InvalidBBoxProperty: "'%1' scheint keine Farbe, Padding-Dimension oder Stil zu sein",
          ExtraEndMissingBegin: "Zus\u00E4tzliches %1 oder fehlendes \\begingroup",
          GlobalNotFollowedBy: "'%1' nicht von '\\let', '\\def' oder '\\newcommand' gefolgt",
          UndefinedColorModel: "Farbmodell '%1' nicht definiert",
          ModelArg1: "Farbwerte f\u00FCr Farbmodell '%1' ben\u00F6tigen 3 Werte",
          InvalidDecimalNumber: "Ung\u00FCltige Dezimalzahl",
          ModelArg2: "Farbwerte f\u00FCr Farbmodell '%1' m\u00FCssen zwischen %2 und %3 liegen",
          InvalidNumber: "Ung\u00FCltige Zahl",
          NewextarrowArg1: "Das erste Argument von %1 muss Name einer Befehlsfolge sein",
          NewextarrowArg2: "Zweites Argument von %1 m\u00FCssen zwei ganze Zahlen sein, durch Komma getrennt",
          NewextarrowArg3: "Drittes argument von %1 m\u00FCssen Unicode-Nummern sein",
          NoClosingChar: "Kann schlie\u00DFende %1 nicht finden",
          IllegalControlSequenceName: "Ung\u00FCltige Befehlsfolge f\u00FCr %1",
          IllegalParamNumber: "Ung\u00FCltige Anzahl von Parametern in %1",
          MissingCS: "%1 muss von Befehlsfolge gefolgt werden",
          CantUseHash2: "Ung\u00FCltige Verwendung von # im Template von %1",
          SequentialParam: "Parameter von %1 m\u00FCssen durch nummeriert sein",
          MissingReplacementString: "Ersetzende Zeichenkette f\u00FCr Definition von %1 fehlt",
          MismatchUseDef: "Verwendung von %1 passt nicht zur Definition",
          RunawayArgument: "Nichtgeschlossenes Argument f\u00FCr %1?",
          NoClosingDelim: "Kein schliessender Delimiter f\u00FCr %1"
        }
});

MathJax.Ajax.loadComplete("[MathJax]/localization/de/TeX.js");


text:
package serene.datatype;

import org.relaxng.datatype.Datatype;
import org.relaxng.datatype.DatatypeBuilder;
import org.relaxng.datatype.DatatypeException;
import org.relaxng.datatype.ValidationContext;

public class DefaultBuilder implements DatatypeBuilder {

	private final Datatype baseType;

	public DefaultBuilder( Datatype baseType ) {
		this.baseType = baseType;
	}

	public void addParameter( String name, String strValue, ValidationContext context )
			throws DatatypeException {
		throw new DatatypeException("Param not allowed.");
	}

	public Datatype createDatatype() throws DatatypeException {
		return baseType;
	}
}


text:
namespace silifuzz::testing {

// ===============================
// ASSERT_OK_AND_ASSIGN(dest, src)
// ===============================
//
// Macro that evaluates src as a StatusOr, asserts that the status is OK, and
// assigns the value to dest.
//
// Example:
//   ...
//   StatusOr<std::string> sor_message("Hello, world");
//   ASSERT_OK_AND_ASSIGN(std::string message, sor_message);
//   EXPECT_EQ(message, "Hello, world");
//
// Note: Uses of ASSERT_OK_AND_ASSIGN in single-statement if blocks without
// curly braces is not valid due to the expansion into a multi-statement macro.
// The macro body is not wrapped in a `do {} while (0)` to allow dest variables
// to be declared within the macro.

// Internal helper for concatenating macro values.
#define STATUS_MACROS_INTERNAL_CONCAT_IMPL_(x, y) x##y
#define STATUS_MACROS_INTERNAL_CONCAT_(x, y) \
  STATUS_MACROS_INTERNAL_CONCAT_IMPL_(x, y)

#undef ASSERT_OK_AND_ASSIGN
#undef ASSERT_OK_AND_ASSIGN_IMPL_
#define ASSERT_OK_AND_ASSIGN(dest, src) \
  ASSERT_OK_AND_ASSIGN_IMPL_(           \
      STATUS_MACROS_INTERNAL_CONCAT_(status_or_, __LINE__), dest, src)
#define ASSERT_OK_AND_ASSIGN_IMPL_(status_or, dest, src) \
  auto status_or = (src);                                \
  ASSERT_THAT(status_or, silifuzz::testing::IsOk());     \
  dest = std::move(status_or).value();

// ===============
// ASSERT_OK(expr)
// ===============
//
// Macro that asserts that expr evaluates to an OK Status or StatusOr.
//
// ===============
// EXPECT_OK(expr)
// ===============
//
// Macro that expects that expr evaluates to an OK Status or StatusOr.

#undef ASSERT_OK
#define ASSERT_OK(expr) ASSERT_THAT(expr, silifuzz::testing::IsOk());

#undef EXPECT_OK
#define EXPECT_OK(expr) EXPECT_THAT(expr, silifuzz::testing::IsOk());

}  // namespace silifuzz::testing

#endif  // THIRD_PARTY_SILIFUZZ_UTIL_TESTING_STATUS_MACROS_H_


text:
<?php

namespace Valit\Validators;

use Traversable;
use Valit\Manager;
use Valit\Util\Val;
use LogicException;
use BadMethodCallException;
use Valit\Util\FlatContainer;
use Valit\Assertion\AssertionBag;
use Valit\Result\AssertionResult;
use Valit\Result\AssertionResultBag;
use Valit\Result\ContainerResultBag;
use Valit\Assertion\AssertionBagFactory;

/**
 * Validate a container (variable with array access).
 *
 * @method $this as(string $name) set the alias of the container
 */
class ContainerValidator extends ContainerResultBag
{
    /**
     * Internal.
     *
     * @var Manager
     */
    public $manager;

    /**
     * Internal.
     *
     * @var array|object
     */
    public $container;

    /**
     * Internal.
     *
     * @var FlatContainer
     */
    public $flatContainer;

    /**
     * Internal.
     *
     * @var bool
     */
    public $throwOnFailure;

    /**
     * Constructor.
     *
     * @param Manager           $manager
     * @param array|Traversable $container
     * @param bool              $throwOnFailure
     */
    public function __construct(Manager $manager, $container, $throwOnFailure)
    {
        $this->manager = $manager;
        $this->container = $container;
        $this->throwOnFailure = (bool) $throwOnFailure;
        $this->flatContainer = new FlatContainer($container);
        parent::__construct([], 'Container');
    }

    /**
     * Check container against a number of assertions.
     *
     * @param array|Traversable $containerAssertionMap
     *
     * @return ContainerResultBag
     */
    public function passes($containerAssertionMap)
    {
        if (!Val::iterable($containerAssertionMap)) {
            throw new LogicException('$containerAssertionMap must be iterable');
        }

        foreach ($containerAssertionMap as $fieldNameGlob => $assertions) {
            $normalizedAssertions = AssertionBagFactory::create($assertions);
            $this->executeAndAdd($fieldNameGlob, $normalizedAssertions);
        }

        return $this->throwOnFailure
            ? $this->orThrowException()
            : $this;
    }

    /**
     * Execute an array of assertions on a number of values.
     *
     * @param string       $fieldNameGlob A field name glob (such as "address" or "order.*.id")
     * @param AssertionBag $assertions    A normalized array of assertions
     */
    protected function executeAndAdd($fieldNameGlob, $assertions)
    {
        $fieldsToValidate = $this->flatContainer->find($fieldNameGlob);

        $optional = $assertions->hasFlag('optional');

        if ($fieldsToValidate === []) {
            $message = $optional ? '{name} is optional' : '{name} must be present';
            $fieldResults = new AssertionResultBag($this->container, $fieldNameGlob);
            $fieldResults->addAssertionResult(new AssertionResult($optional, $message));
            $this->addAssertionResultBag($fieldNameGlob, $fieldResults);
        }

        foreach ($fieldsToValidate as $fieldPath => $value) {
            $fieldResults = new ValueValidator($this->manager, $value, $this->throwOnFailure);
            $fieldResults->alias($fieldPath);

            if (!$optional) {
                $fieldResults->addAssertionResult(new AssertionResult(true, '{name} must be present'));
            }

            $assertions->applyToValidator($fieldResults);

            $this->addAssertionResultBag($fieldPath, $fieldResults);
        }
    }

    /**
     * Magic method for setting the alias of the container.
     *
     * @param string $methodName
     * @param array  $args
     *
     * @return mixed
     *
     * @throws BadMethodCallException if the $methodName is invalid
     */
    public function __call($methodName, $args)
    {
        if ($methodName === 'as') {
            $this->alias($args[0]);

            return $this;
        }

        // Forward call to ValueValidator
        $valueValidator = new ValueValidator($this->manager, $this->container, $this->throwOnFailure);

        return $valueValidator->__call($methodName, $args);
    }
}


text:
Rails.application.config.sorcery.submodules = [:reset_password, :remember_me, :activity_logging]

# Here you can configure each submodule's features.
Rails.application.config.sorcery.configure do |config|
  # -- core --
  # config.not_authenticated_action = :not_authenticated              # what controller action to call for
                                                                      # non-authenticated users.
                                                                      # You can also override 'not_authenticated'
                                                                      # instead.

  # config.save_return_to_url = true                                  # when a non logged in user tries to enter
                                                                      # a page that requires login,
                                                                      # save the URL he wanted to reach,
                                                                      # and send him there after login, using
                                                                      # 'redirect_back_or_to'.

  # config.cookie_domain = nil                                        # set domain option for cookies
                                                                      # Useful for remember_me submodule

  # -- session timeout --
  # config.session_timeout = 3600                                     # how long in seconds to keep the session alive.
  # config.session_timeout_from_last_action = false                   # use the last action as the beginning of
                                                                      # session timeout.

  # -- http_basic_auth --
  # config.controller_to_realm_map = {"application" => "Application"} # What realm to display for which controller name.
                                                                      # For example {"My App" => "Application"}

  # -- activity logging --
  # config.register_login_time = true                                 # will register the time of last user login, every login.
  # config.register_logout_time = true                                # will register the time of last user logout, every logout.
  # config.register_last_activity_time = true                         # will register the time of last user action, every action.

  # -- external --
  # config.external_providers = []                                    # What providers are supported by this app,
                                                                      # i.e. [:twitter, :facebook, :github, :google, :liveid] .
  # config.ca_file = 'path/to/ca_file'                                # Path to ca_file. By default use a internal ca-bundle.crt.
                                                                      # You can change it by your local ca_file.
                                                                      # i.e. '/etc/pki/tls/certs/ca-bundle.crt'

  # Twitter wil not accept any requests nor redirect uri containing localhost,
  # make sure you use 0.0.0.0:3000 to access your app in development
  #
  # config.twitter.key = "eYVNBjBDi33aa9GkA3w"
  # config.twitter.secret = "XpbeSdCoaKSmQGSeokz5qcUATClRW5u08QWNfv71N8"
  # config.twitter.callback_url = "http://0.0.0.0:3000/oauth/callback?provider=twitter"
  # config.twitter.user_info_mapping = {:email => "screen_name"}
  #
  # config.facebook.key = "34cebc81c08a521bc66e212f947d73ec"
  # config.facebook.secret = "5b458d179f61d4f036ee66a497ffbcd0"
  # config.facebook.callback_url = "http://0.0.0.0:3000/oauth/callback?provider=facebook"
  # config.facebook.user_info_mapping = {:email => "name"}
  #
  # config.github.key = ""
  # config.github.secret = ""
  # config.github.callback_url = "http://0.0.0.0:3000/oauth/callback?provider=github"
  # config.github.user_info_mapping = {:email => "name"}
  #
  # config.google.key = "491253340633.apps.googleusercontent.com"
  # config.google.secret = "4oE6kXqbL_LN-VGcGcg7qgdL"
  # config.google.callback_url = "http://0.0.0.0:3000/oauth/callback?provider=google"
  # config.google.user_info_mapping = {:email => "email", :username => "name"}
  #
  # To use liveid in development mode you have to replace mydomain.com with
  # a valid domain even in development. To use a valid domain in development
  # simply add your domain in your /etc/hosts file in front of 127.0.0.1
  #
  # config.liveid.key = ""
  # config.liveid.secret = ""
  # config.liveid.callback_url = "http://mydomain.com:3000/oauth/callback?provider=liveid"
  # config.liveid.user_info_mapping = {:username => "name"}

  # --- user config ---
  config.user_config do |user|
    # -- core --
    user.username_attribute_names = [:email]                                     # specify username
                                                                                # attributes, for example:
                                                                                # [:username, :email].

    # user.password_attribute_name = :password                                        # change *virtual* password
                                                                                # attribute, the one which is used
                                                                                # until an encrypted one is
                                                                                # generated.

    # user.downcase_username_before_authenticating = false                            # downcase the username before
                                                                                # trying to authenticate, default
                                                                                # is false

    # user.email_attribute_name = :email                                              # change default email attribute.

    # user.crypted_password_attribute_name =  :crypted_password                       # change default crypted_password
                                                                                # attribute.

    # user.salt_join_token = ""                                                       # what pattern to use to join the
                                                                                # password with the salt

    # user.salt_attribute_name = :salt                                                # change default salt attribute.

    # user.stretches = nil                                                            # how many times to apply
                                                                                # encryption to the password.

    # user.encryption_key = nil                                                       # encryption key used to encrypt
                                                                                # reversible encryptions such as
                                                                                # AES256.
                                                                                #
                                                                                # WARNING:
                                                                                #
                                                                                # If used for users' passwords, changing this key
                                                                                # will leave passwords undecryptable!

    # user.custom_encryption_provider = nil                                           # use an external encryption
                                                                                # class.

    # user.encryption_algorithm = :bcrypt                                             # encryption algorithm name. See
                                                                                # 'encryption_algorithm=' for
                                                                                # available options.

    # user.subclasses_inherit_config = false                                          # make this configuration
                                                                                # inheritable for subclasses.
                                                                                # Useful for ActiveRecord's STI.

    # -- user_activation --
    # user.activation_state_attribute_name = :activation_state                        # the attribute name to hold
                                                                                # activation state
                                                                                # (active/pending).

    # user.activation_token_attribute_name = :activation_token                        # the attribute name to hold
                                                                                # activation code (sent by email).

    # user.activation_token_expires_at_attribute_name = :activation_token_expires_at  # the attribute name to hold
                                                                                # activation code expiration date.

    # user.activation_token_expiration_period =  nil                                  # how many seconds before the
                                                                                # activation code expires. nil for
                                                                                # never expires.

    # user.user_activation_mailer = nil                                               # your mailer class. Required.

    # user.activation_needed_email_method_name = :activation_needed_email             # activation needed email method
                                                                                # on your mailer class.

    # user.activation_success_email_method_name = :activation_success_email           # activation success email method
                                                                                # on your mailer class.

    # user.prevent_non_active_users_to_login = true                                   # do you want to prevent or allow
                                                                                # users that did not activate by
                                                                                # email to login?

    # -- reset_password --
    # user.reset_password_token_attribute_name = :reset_password_token                          # reset password code
                                                                                # attribute name.

    # user.reset_password_token_expires_at_attribute_name = :reset_password_token_expires_at    # expires at attribute
                                                                                # name.

    # user.reset_password_email_sent_at_attribute_name = :reset_password_email_sent_at          # when was email sent,
                                                                                # used for hammering
                                                                                # protection.

    user.reset_password_mailer = UserMailer                                                          # mailer class. Needed.

    # user.reset_password_email_method_name = :reset_password_email                             # reset password email
                                                                                # method on your mailer
                                                                                # class.

    # user.reset_password_expiration_period = nil                                               # how many seconds
                                                                                # before the reset
                                                                                # request expires. nil
                                                                                # for never expires.

    # user.reset_password_time_between_emails = 5 * 60                                          # hammering protection,
                                                                                # how long to wait
                                                                                # before allowing
                                                                                # another email to be
                                                                                # sent.

    # -- brute_force_protection --
    # user.failed_logins_count_attribute_name = :failed_logins_count                  # failed logins attribute name.

    # user.lock_expires_at_attribute_name = :lock_expires_at                          # this field indicates whether
                                                                                # user is banned and when it will
                                                                                # be active again.

    # user.consecutive_login_retries_amount_limit = 50                                # how many failed logins allowed.

    # user.login_lock_time_period = 60 * 60                                           # how long the user should be
                                                                                # banned. in seconds. 0 for
                                                                                # permanent.

    # -- activity logging --
    # user.last_login_at_attribute_name = :last_login_at                              # last login attribute name.
    # user.last_logout_at_attribute_name = :last_logout_at                            # last logout attribute name.
    # user.last_activity_at_attribute_name = :last_activity_at                        # last activity attribute name.
    # user.activity_timeout = 10 * 60                                                 # how long since last activity is
                                                                                # the user defined logged out?

    # -- external --
    # user.authentications_class = nil                                                # class which holds the various
                                                                                # external provider data for this
                                                                                # user.

    # user.authentications_user_id_attribute_name = :user_id                          # user's identifier in
                                                                                # authentications class.

    # user.provider_attribute_name = :provider                                        # provider's identifier in
                                                                                # authentications class.

    # user.provider_uid_attribute_name = :uid                                         # user's external unique
                                                                                # identifier in authentications
                                                                                # class.
  end

  # This line must come after the 'user config' block.
  config.user_class = "User"                                       # define which model authenticates
                                                                                # with sorcery.
end


text:
<?php

namespace Metrol\DBObject;

use Metrol\DBSql;

/**
 * Define the methods used to support a set of Items
 *
 */
interface ItemSetInterface
{
    /**
     * Provide the SQL SELECT statement
     *
     */
    public function getSqlSelect(): DBSql\SelectInterface;

    /**
     * Sets raw SQL as the query to be run
     *
     */
    public function setRawSQL(string $sql): static;

    /**
     * Sets data bindings for the RawSQL.
     *
     * This is completely ignored by any other SQL engine type.  You need to
     * bind with those specific engines if doing so manually.
     *
     */
    public function setRawSQLBindings(array $bindings): static;

    /**
     * Run the assembled query and apply it to the data set
     *
     */
    public function run(): static;

    /**
     * Run the assembled query, but only fetch the count of the records.
     *
     */
    public function runForCount(): int;

    /**
     * Provide the entire result set
     *
     */
    public function output(): array;

    /**
     * Provide a quick check for the data set being empty or not
     *
     */
    public function isEmpty(): bool;

    /**
     * Provide a quick check for the data set being empty or not
     *
     */
    public function isNotEmpty(): bool;

    /**
     * How many items in the set
     *
     */
    public function count(): int;

    /**
     * Removes all the objects from the set.  Does not remove them from the DB
     *
     */
    public function clear(): static;

    /**
     * Fetch a single item based on the index value of the data set
     *
     */
    public function get(int $index): ?Item;

    /**
     * Remove the specified index from the set.
     *
     */
    public function remove(int $index): static;

    /**
     * Fetching the first item off the top of the list
     *
     */
    public function top(): Item;

    /**
     * Reverse the order of the items in the data set
     *
     */
    public function reverse(): static;

    /**
     * Find the first item with specified field matching the specified value
     *
     */
    public function find(string $fieldName, mixed $findValue): ?Item;

    /**
     * Find all items with the specified field matching the specified value
     *
     */
    public function findAll(string $fieldName, mixed $findValue): array;

    /**
     * Provide the item that has the largest value for the specified field.
     * If all the field values in question are null, the top item in the list
     * is returned.
     *
     */
    public function max(string $fieldName): ?Item;

    /**
     * Provide the item that has the smallest value for the specified field.
     * If all the field values in question are null, the top item in the list
     * is returned.
     *
     * Null values are not used in the comparisons.
     *
     */
    public function min(string $fieldName): ?Item;

    /**
     * Fetch a list of values for a specific field from the dataset as a simple
     * array.
     *
     */
    public function getFieldValues(string $fieldName): array;
}


text:
package org.shaolin.javacc.context;

//imports
import java.io.Serializable;
import java.util.List;

import org.shaolin.javacc.exception.EvaluationException;

/**
 * The evaluation context interface for evaluation
 */
public interface EvaluationContext extends Serializable
{
	/**
	 *  Get the value of a variable with the specified name
	 *
	 *  @param      name    the variable name
	 *  @return     the variable value object
	 *  @throws     EvaluationException     if can't find the variable with this name
	 */
	public Object getVariableValue(String name) throws EvaluationException;

	/**
	 *  Set the value of a variable with the specified name
	 *
	 *  @param      name    the variable name
	 *  @param      value   the variable value object
	 *  @throws     EvaluationException     if can't find the variable with this name
	 */
	public void setVariableValue(String name, Object value) throws EvaluationException;

	/**
	 *  Invoke a method with the the specified name and specified argument type classes and objects
	 *
	 *  @param      name    the method name
	 *  @param      argClasses     list of argument type classes
	 *  @param      argObjects     list of argument objects
	 *  @return     the invocation result object
	 *  @throws     EvaluationException     if can't find the variable with this name
	 */
	public Object invokeMethod(String name, List argClasses, List argObjects) throws EvaluationException;

}


text:
module.exports = Module3;

function Module3() {

}

Module3.prototype.stop = function (callback) {
  // console.log('stop', this.$happn.config);
  callback();
};

Module3.prototype.methodWithHappn = function (req, $happn, res, next) {
  res.end(JSON.stringify($happn.config));
};

Module3.prototype.methodWithoutHappn = function (req, res) {
  res.end('ok');
};

Module3.prototype.methodWithHappnInFront = function ($happn, req, res, next) {
  res.end(JSON.stringify({
    config: $happn.config,
    next: next.toString()
  }));
};

Module3.prototype.methodWithHappnInMiddle = function (req, res, $happn, next) {
  res.end(JSON.stringify({
    config: $happn.config,
    next: next.toString()
  }));
};

Module3.prototype.methodWithHappnInEnd = function (req, res, next, $happn) {
  res.end(JSON.stringify({
    config: $happn.config,
    next: next.toString()
  }));
};


text:
from django.shortcuts import render
from django.views import View

class IndexView(View):
    def get(self, request):
        return render(request, 'personal/index.html')

class NotFoundView(View):
    def get(self, request):
        return render(request, 'personal/notfound.html', status=404)


text:
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="20dp"
    android:height="20dp"
    android:viewportWidth="20"
    android:viewportHeight="20"
    android:tint="?attr/colorControlNormal">
  <path
      android:fillColor="@android:color/white"
      android:pathData="M1.792,18.208V1.792H18.208V18.208Z"/>
</vector>


text:
<?php
require_once 'Config.php';

class DbRooms{
    public function Connect(){
		$conn = mysqli_connect(dbhost, dbuser,dbpass, dbname);
		if(!$conn){
			return false;
		}else{
			return $conn;
		}
    }

    public function viewRooms(){
        $query = "SELECT DESCRIPTION, TYPE, ROOM, CAPACITY FROM rooms";
        $con = $this->Connect();

        $result = mysqli_query($con, $query);

        if(mysqli_num_rows($result) > 0){
            $rows = array();
            while($row = mysqli_fetch_array($result,MYSQLI_ASSOC)){
                $rows[]= $row;
            }

            return $rows;
        }else{
            return false;
        }
    }
}

class DbBookings{
    public function Connect(){
		$conn = mysqli_connect(dbhost, dbuser,dbpass, dbname);
		if(!$conn){
			return false;
		}else{
			return $conn;
		}
    }

    public function viewBookings(){
        $query = "SELECT ROOM, CAPACITY, DATE, TIME FROM bookings";
        $con = $this->Connect();

        $result = mysqli_query($con, $query);

        if(mysqli_num_rows($result) > 0){
            $rows = array();
            while($row = mysqli_fetch_array($result,MYSQLI_ASSOC)){
                $rows[]= $row;
            }

            return $rows;
        }else{
            return false;
        }
    }

    public function viewBookingsAdmin(){
        $query = "SELECT ROOM, CAPACITY, DATE, TIME, USER FROM bookings";
        $con = $this->Connect();

        $result = mysqli_query($con, $query);

        if(mysqli_num_rows($result) > 0){
            $rows = array();
            while($row = mysqli_fetch_array($result,MYSQLI_ASSOC)){
                $rows[]= $row;
            }

            return $rows;
        }else{
            return false;
        }
    }
}

class DbRegistered{
    public function Connect(){
		$conn = mysqli_connect(dbhost, dbuser,dbpass, dbname);
		if(!$conn){
			return false;
		}else{
			return $conn;
		}
    }
    public function viewRegistered(){
        $query = "SELECT firstname, lastname, username, email FROM registered";
        $con = $this->Connect();

        $result = mysqli_query($con, $query);

        if(mysqli_num_rows($result) > 0){
            $rows = array();
            while($row = mysqli_fetch_array($result,MYSQLI_ASSOC)){
                $rows[]= $row;
            }

            return $rows;
        }else{
            return false;
        }
    }
}

?>


text:
package mtconverter

import "strconv"

func Bytes2Float64(b []byte) (float64, error) {
	if len(b) == 0 {
		return 0, nil
	}
	return strconv.ParseFloat(string(b), 64)
}
func Float642String(f float64) string {
	return strconv.FormatFloat(f, 'f', -1, 64)
}
func Int642String(i int64) string {
	return strconv.FormatInt(i, 10)
}
func Bytes2Int(b []byte) (int64, error) {
	return strconv.ParseInt(string(b), 10, 64)
}


text:
var app = new Vue({
    mounted: function (argument) {
        console.log("app is ready");
    },
    created() {
        this.fetchData();
        this.updateTheme();
    },
    el: '#app',
    data: {
        message: 'Hello Vue!',
        activities: [],
        showNewForm: 'm-fadeOut',
        currUser: '',
        searchEmail: '',
        emailSearchStatus: '',
        emailSearchStatusGroup: '',
        actDesc: '',
        showDescForm: 'm-fadeOut',
        errorMessage: '',
        symbolPath: '',
        theme: '',
        options: [
            { text: 'Hamburger', value: '/svg/hamburger.svg' },
            { text: 'Beer', value: '/svg/pint.svg' },
            { text: 'Resturant', value: '/svg/restaurant.svg' },
            { text: 'Taxi', value: '/svg/taxi.svg' },
            { text: 'Movie', value: '/svg/clapperboard.svg' },
            { text: 'Cocktail', value: '/svg/cocktail.svg' },
            { text: 'Coffee', value: '/svg/coffee-cup.svg' },
            { text: 'Steak', value: '/svg/food.svg' },
            { text: 'Drink', value: '/svg/glass.svg' },
            { text: 'Taco', value: '/svg/taco.svg' },
            { text: 'Tickets', value: '/svg/tickets.svg' },
            { text: 'Train', value: '/svg/train.svg' },
            { text: 'Travel', value: '/svg/luggage.svg' }
        ]
    },
    methods: {
        fetchData() {
            this.$http.get('/api/activities/get').then(response => {
                this.$set(this, 'activities', response.body.activities);
                this.$set(this, 'currUser', response.body.currUser);
            });
        },
        updateTheme: function () {
            this.$http.get('/api/user/get').then(response => {
                var theme = response.body.profile.theme;
                switch (theme) {
                    case 1:
                        this.theme = 'theme-light';
                        break;
                    case 2:
                        this.theme = 'theme-dark';
                        break;
                    case 3:
                        this.theme = 'theme-color';
                        break;
                    default:
                        this.theme = 'theme-light';
                        break;
                }
            });
        },
        updatePost: function (data) {
            data._csrf = $('meta[name="csrf-token"]').attr('content');
            this.$http.post('/api/activities/changeturn', data)
                .then(function () {
                    this.fetchData();
                }
                    .bind(this),
                function () { });

        },
        findUser: function () {
            this.errorMessage = '';
            var data = {};
            data._csrf = $('meta[name="csrf-token"]').attr('content');
            data.email = this.searchEmail;
            this.$http.post('/api/user/find', data).then(response => {
                var userSearchStatus = JSON.stringify(response.body);
                if (userSearchStatus == 'true') {
                    this.emailSearchStatus = 'form-control-success';
                    this.emailSearchStatusGroup = 'has-success';
                    this.showDescForm = 'm-fadeIn';
                } else {
                    this.emailSearchStatus = 'form-control-danger';
                    this.emailSearchStatusGroup = 'has-danger';
                    this.showDescForm = 'm-fadeOut';
                    this.errorMessage = "Couldn't find that Moocher, want to send an invite?";
                }
            }, response => {
                this.emailSearchStatus = 'form-control-danger';
                this.showDescForm = 'm-fadeOut';
                this.emailSearchStatusGroup = 'has-danger';
                this.errorMessage = response.body.replace('"', '');
            }).bind(this),
                function () { };
        },
        newActivity: function () {
            this.$http.post('/api/activities/create', {
                email: this.searchEmail,
                desc: this.actDesc,
                symbolPath: this.symbolPath,
                _csrf: $('meta[name="csrf-token"]').attr('content')
            })
                .then(function (response) {
                    this.actDesc = '';
                    this.searchEmail = '';
                    this.showDescForm = 'm-fadeOut';
                    this.showNewForm = 'm-fadeOut';
                    this.fetchData();
                }.bind(this),
                function () { });
        },
        getProfileImage: function (user) {
            if (user.profile !== "undefined")
                return user.profile.picture;
            else
                // Twitter only, if FB then other implementation is needed.
                return "";
        },
        getOtherUsers: function (activity) {
            var currUser = this.currUser;
            var otherUser = activity.users.filter(function (user) {
                return user._id != currUser;
            });
            return otherUser[0].profile.name;
        },
        isItYourTurn: function (activity) {
            // console.log(activity.turn._id);
            // console.log(this.currUser);
            return activity.turn._id === this.currUser ? "It's your turn!" : "It's not your turn.";
        },
        toggleNewForm: function () {
            this.showNewForm = 'm-fadeIn';
        },
        FormatDateTime: function (activity) {
            //// Fix dynamic substring variables. ZZzzzz tired...
            return new Date(activity.lastUpdate).toISOString().replace(/T/, ' ').replace(/\..+/, '').substring(0,16)
        },
        getLogo: function () {
            switch (this.theme) {
                    case 'theme-light':
                        return '/Moocher-logo.png'
                    case 'theme-dark':
                        return '/Moocher-logo-light.png'
                    case 'theme-color':
                        return '/Moocher-logo.png'
                    default:
                        return '/Moocher-logo.png'
                }
        }
    }
})


text:
package org.apache.jmeter.gui.action;

import java.awt.event.ActionEvent;
import java.util.HashSet;
import java.util.Set;

import org.apache.jmeter.util.JMeterUtils;

/**
 * Zoom IN/OUT
 * @since 3.2
 */
public class ZoomInOut extends AbstractAction {
    private static final Set<String> commands = new HashSet<>();

    private static final float ZOOM_SCALE = JMeterUtils.getPropDefault("zoom_scale", 1.1f);

    static {
        commands.add(ActionNames.ZOOM_IN);
        commands.add(ActionNames.ZOOM_OUT);
    }

    /**
     * @see org.apache.jmeter.gui.action.AbstractActionWithNoRunningTest#doActionAfterCheck(ActionEvent)
     */
    @Override
    public void doAction(ActionEvent e) {
        final String actionCommand = e.getActionCommand();
        if (actionCommand.equals(ActionNames.ZOOM_IN)) {
            JMeterUtils.applyScaleOnFonts(ZOOM_SCALE);
        } else if (actionCommand.equals(ActionNames.ZOOM_OUT)) {
            JMeterUtils.applyScaleOnFonts(1/ZOOM_SCALE);
        }
    }

    /**
     * @see org.apache.jmeter.gui.action.Command#getActionNames()
     */
    @Override
    public Set<String> getActionNames() {
        return commands;
    }
}


text:
Function Remove-TfsTeam
{
    [CmdletBinding(SupportsShouldProcess=$true, ConfirmImpact='High')]
    [OutputType([Microsoft.TeamFoundation.Client.TeamFoundationTeam])]
    param
    (
		[Parameter(Position=0, ValueFromPipeline=$true)]
		[Alias("Name")]
		[ValidateScript({($_ -is [string]) -or ($_ -is [Microsoft.TeamFoundation.Client.TeamFoundationTeam])})]
		[SupportsWildcards()]
		[object]
		$Team = '*',

		[Parameter()]
		[object]
		$Project,

		[Parameter()]
		[object]
		$Collection
    )

    Process
    {
        $t = Get-TfsTeam -Team $Team -Project $Project -Collection $Collection

        if ($PSCmdlet.ShouldProcess($t.Name, 'Delete team'))
        {
            $tp = Get-TfsTeamProject -Project $Project -Collection $Collection
            $tpc = $tp.Store.TeamProjectCollection
            $identityService = $tpc.GetService([type]'Microsoft.TeamFoundation.Framework.Client.IIdentityManagementService')

            $identityService.DeleteApplicationGroup($t.Identity.Descriptor)
        }
    }
}


text:
grepopts() {

    # Start with ignoring binary files
    local -a grepopts=(-I)

    # Snarf the output of `grep --help` into a variable
    local grephelp
    grephelp=$(grep --help 2>/dev/null)

    # If the --exclude option is available, exclude some VCS files
    if [[ $grephelp == *--exclude* ]] ; then
        for exclude_file in .gitignore .gitmodules ; do
            grepopts=("${grepopts[@]}" "--exclude=$exclude_file")
        done
    fi

    # If the --exclude-dir option is available, exclude some VCS dirs
    if [[ $grephelp == *--exclude-dir* ]] ; then
        for exclude_dir in .cvs .git .hg .svn ; do
            grepopts=("${grepopts[@]}" "--exclude-dir=$exclude_dir")
        done
    fi

    # If the --color option is available and we have a terminal that supports
    # at least eight colors, add --color=auto to the options
    local colors
    colors=$(tput colors)
    if [[ $grephelp == *--color* ]] && ((colors >= 8)) ; then
        grepopts=("${grepopts[@]}" "--color=auto")
    fi

    # Print the options as a single string, space-delimited
    printf %s "${grepopts[*]}"
}

# Alias grep with those options
alias grep="grep $(grepopts)"
alias fgrep="fgrep $(grepopts)"
alias egrep="egrep $(grepopts)"

# Unset helper function
unset -f grepopts


text:
/**
 * Indonesian
 */

$.FroalaEditor.LANGUAGE['id'] = {
  translation: {
    // Place holder
    "Type something": "Ketik sesuatu",

    // Basic formatting
    "Bold": "Tebal",
    "Italic": "Miring",
    "Underline": "Garis bawah",
    "Strikethrough": "Coret",

    // Main buttons
    "Insert": "Memasukkan",
    "Delete": "Hapus",
    "Cancel": "Batal",
    "OK": "Ok",
    "Back": "Kembali",
    "Remove": "Hapus",
    "More": "Lebih",
    "Update": "Memperbarui",
    "Style": "Gaya",

    // Font
    "Font Family": "Jenis Huruf",
    "Font Size": "Ukuran leter",

    // Colors
    "Colors": "Warna",
    "Background": "Latar belakang",
    "Text": "Teks",

    // Paragraphs
    "Paragraph Format": "Format",
    "Normal": "Normal",
    "Code": "Kode",
    "Heading 1": "Header 1",
    "Heading 2": "Header 2",
    "Heading 3": "Header 3",
    "Heading 4": "Header 4",

    // Style
    "Paragraph Style": "Paragraf gaya",
    "Inline Style": "Di barisan gaya",

    // Alignment
    "Align": "Rate",
    "Align Left": "Rate kiri",
    "Align Center": "Rate tengah",
    "Align Right": "Rata kanan",
    "Align Justify": "Justifi",
    "None": "Tak satupun",

    // Lists
    "Ordered List": "List nomor",
    "Unordered List": "List simbol",

    // Indent
    "Decrease Indent": "Turunkan inden",
    "Increase Indent": "Tambah inden",

    // Links
    "Insert Link": "Memasukkan link",
    "Open in new tab": "Buka di tab baru",
    "Open Link": "Buka tautan",
    "Edit Link": "Mengedit link",
    "Unlink": "Menghapus link",
    "Choose Link": "Memilih link",

    // Images
    "Insert Image": "Memasukkan gambar",
    "Upload Image": "Meng-upload gambar",
    "By URL": "Oleh URL",
    "Browse": "Melihat-lihat",
    "Drop image": "Jatuhkan gambar",
    "or click": "atau klik",
    "Manage Images": "Mengelola gambar",
    "Loading": "Pemuatan",
    "Deleting": "Menghapus",
    "Tags": "Label",
    "Are you sure? Image will be deleted.": "Apakah Anda yakin? Gambar akan dihapus.",
    "Replace": "Mengganti",
    "Uploading": "Gambar upload",
    "Loading image": "Pemuatan gambar",
    "Display": "Pameran",
    "Inline": "Di barisan",
    "Break Text": "Memecah teks",
    "Alternate Text": "Teks alternatif",
    "Change Size": "Ukuran perubahan",
    "Width": "Lebar",
    "Height": "Tinggi",
    "Something went wrong. Please try again.": "Ada yang salah. Silakan coba lagi.",

    // Video
    "Insert Video": "Memasukkan video",
    "Embedded Code": "Kode tertanam",

    // Tables
    "Insert Table": "Sisipkan tabel",
    "Header": "Header",
    "Row": "Baris",
    "Insert row above": "Sisipkan baris di atas",
    "Insert row below": "Sisipkan baris di bawah",
    "Delete row": "Hapus baris",
    "Column": "Kolom",
    "Insert column before": "Sisipkan kolom sebelumSisipkan kolom sebelum",
    "Insert column after": "Sisipkan kolom setelah",
    "Delete column": "Hapus kolom",
    "Cell": "Sel",
    "Merge cells": "Menggabungkan sel",
    "Horizontal split": "Perpecahan horisontal",
    "Vertical split": "Perpecahan vertikal",
    "Cell Background": "Latar belakang sel",
    "Vertical Align": "Menyelaraskan vertikal",
    "Top": "Teratas",
    "Middle": "Tengah",
    "Bottom": "Bagian bawah",
    "Align Top": "Menyelaraskan atas",
    "Align Middle": "Menyelaraskan tengah",
    "Align Bottom": "Menyelaraskan bawah",
    "Cell Style": "Gaya sel",

    // Files
    "Upload File": "Meng-upload berkas",
    "Drop file": "Jatuhkan berkas",

    // Emoticons
    "Emoticons": "Emoticon",
    "Grinning face": "Sambil tersenyum wajah",
    "Grinning face with smiling eyes": "Sambil tersenyum wajah dengan mata tersenyum",
    "Face with tears of joy": "Hadapi dengan air mata sukacita",
    "Smiling face with open mouth": "Tersenyum wajah dengan mulut terbuka",
    "Smiling face with open mouth and smiling eyes": "Tersenyum wajah dengan mulut terbuka dan tersenyum mata",
    "Smiling face with open mouth and cold sweat": "Tersenyum wajah dengan mulut terbuka dan keringat dingin",
    "Smiling face with open mouth and tightly-closed eyes": "Tersenyum wajah dengan mulut terbuka dan mata tertutup rapat",
    "Smiling face with halo": "Tersenyum wajah dengan halo",
    "Smiling face with horns": "Tersenyum wajah dengan tanduk",
    "Winking face": "Mengedip wajah",
    "Smiling face with smiling eyes": "Tersenyum wajah dengan mata tersenyum",
    "Face savoring delicious food": "Wajah menikmati makanan lezat",
    "Relieved face": "Wajah Lega",
    "Smiling face with heart-shaped eyes": "Tersenyum wajah dengan mata berbentuk hati",
    "Smiling face with sunglasses": "Tersenyum wajah dengan kacamata hitam",
    "Smirking face": "Menyeringai wajah",
    "Neutral face": "Wajah Netral",
    "Expressionless face": "Wajah tanpa ekspresi",
    "Unamused face": "Wajah tidak senang",
    "Face with cold sweat": "Muka dengan keringat dingin",
    "Pensive face": "Wajah termenung",
    "Confused face": "Wajah Bingung",
    "Confounded face": "Wajah kesal",
    "Kissing face": "wajah mencium",
    "Face throwing a kiss": "Wajah melempar ciuman",
    "Kissing face with smiling eyes": "Berciuman wajah dengan mata tersenyum",
    "Kissing face with closed eyes": "Berciuman wajah dengan mata tertutup",
    "Face with stuck out tongue": "Muka dengan menjulurkan lidah",
    "Face with stuck out tongue and winking eye": "Muka dengan menjulurkan lidah dan mengedip mata",
    "Face with stuck out tongue and tightly-closed eyes": "Wajah dengan lidah terjebak dan mata erat-tertutup",
    "Disappointed face": "Wajah kecewa",
    "Worried face": "Wajah Khawatir",
    "Angry face": "Wajah Marah",
    "Pouting face": "Cemberut wajah",
    "Crying face": "Menangis wajah",
    "Persevering face": "Tekun wajah",
    "Face with look of triumph": "Hadapi dengan tampilan kemenangan",
    "Disappointed but relieved face": "Kecewa tapi lega wajah",
    "Frowning face with open mouth": "Sambil mengerutkan kening wajah dengan mulut terbuka",
    "Anguished face": "Wajah sedih",
    "Fearful face": "Wajah Takut",
    "Weary face": "Wajah lelah",
    "Sleepy face": "wajah mengantuk",
    "Tired face": "Wajah Lelah",
    "Grimacing face": "Sambil meringis wajah",
    "Loudly crying face": "Keras menangis wajah",
    "Face with open mouth": "Hadapi dengan mulut terbuka",
    "Hushed face": "Wajah dipetieskan",
    "Face with open mouth and cold sweat": "Hadapi dengan mulut terbuka dan keringat dingin",
    "Face screaming in fear": "Hadapi berteriak dalam ketakutan",
    "Astonished face": "Wajah Kaget",
    "Flushed face": "Wajah memerah",
    "Sleeping face": "Tidur face",
    "Dizzy face": "Wajah pusing",
    "Face without mouth": "Wajah tanpa mulut",
    "Face with medical mask": "Hadapi dengan masker medis",

    // Line breaker
    "Break": "Memecah",

    // Math
    "Subscript": "Subskrip",
    "Superscript": "Superskrip",

    // Full screen
    "Fullscreen": "Layar penuh",

    // Horizontal line
    "Insert Horizontal Line": "Sisipkan Garis Horizontal",

    // Clear formatting
    "Clear Formatting": "Menghapus format",

    // Undo, redo
    "Undo": "Batal",
    "Redo": "Ulang",

    // Select all
    "Select All": "Pilih semua",

    // Code view
    "Code View": "Melihat kode",

    // Quote
    "Quote": "Kutipan",
    "Increase": "Meningkat",
    "Decrease": "Penurunan",

    // Quick Insert
    "Quick Insert": "Memasukkan cepat"
  },
  direction: "ltr"
};


text:
package com.postmark

/**
 * User: cvrabie
 * Date: 19/08/2013
 */
abstract class PostmarkException(val msg:String, val cause:Option[Throwable] = None)
extends Exception(msg, cause.getOrElse(null))

object PostmarkException{
  def unapply(e:PostmarkException) = Some((e.msg, e.cause))
}

class InvalidMessage(override val msg:String, override val cause:Option[Throwable] = None)
extends PostmarkException(msg, cause)

object InvalidMessage{
  def unapply(e:InvalidMessage) = Some((e.msg, e.cause))
}

/**
 * You ran out of credits.
 * @param msg
 */
case class NotAllowedToSend(override val msg:String) extends PostmarkException(msg)

/**
 * Validation failed for the email request JSON data that you provided.
 * @param msg
 */
case class InvalidEmailRequest(override val msg:String) extends InvalidMessage(msg)

/**
 * You are trying to send email with a From address that does not have a sender signature.
 * OR
 * You are trying to send email with a From address that does not have a corresponding confirmed sender signature.
 * @param msg
 */
case class SenderSignatureNotFound(override val msg:String) extends InvalidMessage(msg)

/**
 * The JSON input you provided is syntactically incorrect.
 * OR
 * The JSON input you provided is syntactically correct, but still not the one we expect.
 * OR
 * Your HTTP request does not have the Accept and Content-Type headers set to application/json.
 * @param msg
 */
case class InvalidJson(override val msg:String) extends InvalidMessage(msg)

/**
 * You tried to send to a recipient that has been marked as inactive. Inactive recipients are ones that have
 * generated a hard bounce or a spam complaint.
 * @param msg
 */
case class InactiveRecipient(override val msg:String) extends InvalidMessage(msg)

/**
 * Your request did not submit the correct API token in the X-Postmark-Server-Token header.
 * @param msg
 */
case class ApiTokenException(override val msg:String)
extends PostmarkException(msg, None)

/**
 * You requested a bounce by ID, but we could not find an entry in our database.
 * OR
 * You provided bad arguments as a bounces filter.
 * @param msg
 */
case class BounceException(override val msg:String) extends InvalidMessage(msg)

/**
 * Your batched request contains more than 500 messages.
 * @param msg
 */
case class TooManyBatchMessages(override val msg:String) extends InvalidMessage(msg)

case class ErrorResponse(val errorCode:Int, val message:String)

object ErrorResponse{
  import spray.json.DefaultJsonProtocol._
  implicit val errorResponseJsonFormat = jsonFormat2(ErrorResponse.apply)
}


text:
package generate

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io/ioutil"
)

// This file implements necessary functions to generate and save RSA key pair.

// PrivateKeyFile - the private key filename
// PublicKeyFile  - the public key filename
const (
	PrivateKeyFile = "autograph.key"
	PublicKeyFile  = "autograph.pub"
)

func generatePrivateKey(bits int) (*rsa.PrivateKey, error) {
	privateKey, err := rsa.GenerateKey(rand.Reader, bits)

	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	return privateKey, nil
}

func generatePublicKey(privateKey *rsa.PrivateKey) *rsa.PublicKey {
	publicKey := &privateKey.PublicKey
	return publicKey
}

func savePrivateKey(privateKey *rsa.PrivateKey) error {
	PrivASN1 := x509.MarshalPKCS1PrivateKey(privateKey)

	privBytes := pem.EncodeToMemory(&pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: PrivASN1,
	})
	ioutil.WriteFile(PrivateKeyFile, privBytes, 0600)

	return nil
}

func savePublicKey(publicKey *rsa.PublicKey) error {
	PubASN1, err := x509.MarshalPKIXPublicKey(publicKey)
	if err != nil {
		fmt.Println(err)
		return err
	}

	pubBytes := pem.EncodeToMemory(&pem.Block{
		Type:  "RSA PUBLIC KEY",
		Bytes: PubASN1,
	})
	ioutil.WriteFile(PublicKeyFile, pubBytes, 0600)

	return nil
}

// KeyPair generated RSA key pair with 2048 bits length.
// Also writes RSA key pair to the file system
// under names defined in PrivateKeyFile and PublicKeyFile constants.
//
// Function takes *rsa.PrivateKey and *rsa.PublicKey as arguments
// It might be parsed/loaded using following functions:
// - keys.LoadPrivateKey
// - keys.LoadPublicKey
func KeyPair() (*rsa.PrivateKey, *rsa.PublicKey, error) {
	fmt.Println("Generating private and public RSA key pair..")

	privateKey, err := generatePrivateKey(2048)
	if err != nil {
		fmt.Println(err)
		return nil, nil, err
	}

	publicKey := generatePublicKey(privateKey)

	err = savePrivateKey(privateKey)
	if err != nil {
		fmt.Println(err)
		return nil, nil, err
	}

	err = savePublicKey(publicKey)
	if err != nil {
		fmt.Println(err)
		return nil, nil, err
	}

	fmt.Println("Successfully generated private and public RSA key pair")
	return privateKey, publicKey, nil
}


text:
package org.nexbook.concepts.akka

import org.nexbook.app.{DelegatorsProvider, Module}
import org.nexbook.core.Handler
import org.nexbook.neworderhandler.NewOrderHandler
import org.nexbook.neworderhandler.akka.AkkaNewOrderHandler
import org.nexbook.orderbookresponsehandler.akka.AkkaOrderBookResponseHandler
import org.nexbook.orderbookresponsehandler.response.OrderBookResponse
import org.nexbook.orderchange.OrderChangeCommand
import org.nexbook.orderchange.akka.AkkaOrderChangeHandler

/**
  * Created by milczu on 12/21/15.
  */
class AkkaModule extends Module with DelegatorsProvider {

  override def module: Module = this

  override def newOrderHandler: NewOrderHandler = new AkkaNewOrderHandler(orderHandlers)

  override def orderBookResponseHandlers: List[Handler[OrderBookResponse]] = List(new AkkaOrderBookResponseHandler(orderResponseHandlers))

  override def orderChangeHandlers: List[Handler[OrderChangeCommand]] = List(new AkkaOrderChangeHandler(orderChangeCommandHandlers))
}


text:
module PTEstruturado.Data where

{-
  modulo que contem a definicação das estruturas da Linguagem de programação
-}

data Variavel = Variavel {nome::String, tipo::Tipo} deriving (Show)

data Tipo = Inteiro
          | Fracionario
          | Logico
          deriving (Eq)

instance Show Tipo where
  show Inteiro     = "int"
  show Fracionario = "real"
  show Logico      = "logico"

data Expr = Arit ExpArit
          | Logica ExpLogica
          | Nada
          deriving (Show)

data ExpLogica = VarLogica String
               | ConsLogica Bool
               | Negacao ExpLogica
               | LogicoBin OpLogico ExpLogica ExpLogica
               | RelacianalBin OpRelacional ExpArit ExpArit
               deriving (Show)

data OpLogico = E | Ou deriving (Show)

data OpRelacional = Maior
                  | MaiorIgual
                  | Menor
                  | MenorIgual
                  | Igual
                  | Diferente
                  deriving (Show)

data ExpArit = VarArit String
             | ConsArit (Either Integer Double)
             | Neg ExpArit
             | AritBin OpArit ExpArit ExpArit
             deriving (Show)

data OpArit = Soma
            | Subt
            | Divi
            | Mult
            | Rest
            deriving (Show)

data Instr = Seq [Instr]
           | Atrib String Expr
           | Se ExpLogica Instr Instr
           | Enquanto ExpLogica Instr
           | Escreva String Expr
           | Ler String String
           deriving (Show)

data Algoritimo = Algoritimo String [Variavel] Instr
                deriving (Show)


text:
<ParaViewWriters>
  <Writer name="GocadVoxetWriter"
    extensions="vo"
    file_description="Gocad ASCII Files">
  </Writer>
</ParaViewWriters>


text:
CREATE TABLE articles (
    article_id            BIGINT(20)   NOT NULL AUTO_INCREMENT PRIMARY KEY,
    article_pmid          BIGINT(20)   UNIQUE,
    article_title         VARCHAR(255) NOT NULL,
    article_content       TEXT         NOT NULL,
    article_year          INT          NOT NULL,
    article_is_annotated  BOOLEAN      NOT NULL,
    article_is_processing BOOLEAN      NOT NULL
);

# --- !Downs

DROP TABLE articles;


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <title>Charted — Demo of chart state</title>
    <link rel="stylesheet" href="../demo_charts.css">

Simple bar chart

Chart sharing the same state object

Multiple charts can share the same ChartState object. When they do,
        any changes to state on one chart is indicated in the other chart too.
        Try hovering on a bar in one of the charts above!

ChartState supports hovering and
        highlighting a value and
        selecting and
        previewing a series (actually a column)

Try hovering on blue text in above paragraph. ChartState can be
        updated from scripts outside the chart too!


text:
<?php include('static/helmet.php'); ?>

<?php include('static/header.php'); ?>

Add Product

Settings 1

Settings 2

					<form enctype="multipart/form-data" method="post" action="<?php echo base_url() ?>products/save_product" class="form-horizontal form-label-left">

              Nama Product *

                <input type="text" id="nama_product" name="nama_product" required="required" class="form-control col-md-7 col-xs-12">

              Deskripsi *

                <textarea type="text" id="ssadas-names" name="desc_text" required="required" class="form-control col-md-7 col-xs-12"></textarea>

              Harga *

                <input type="text" id="ssadas-name" name="harga" required="required" class="form-control col-md-7 col-xs-12">

              Upload  Photo Banner*

                <input type="file" name="photoProduct" required="required" class="form-control col-md-7 col-xs-12">

              Jumlah Warna *

                <select class="form-control" id="jumlah_warna" onchange="render_color()" required>
                  <option value="" selected disabled>Pilih Jumlah Warna</option>
                  <option value="1">1</option>
                  <option value="2">2</option>
                  <option value="3">3</option>
                  <option value="4">4</option>
                  <option value="5">5</option>
                  <option value="6">6</option>
                  <option value="7">7</option>
                  <option value="8">8</option>
                  <option value="9">9</option>
                  <option value="10">10</option>
                </select>

              Jumlah Size *

                <select class="form-control" id="jumlah_size" onchange="render_size()" required>
                  <option value="" selected disabled>Pilih Jumlah Size</option>
                  <option value="1">1</option>
                  <option value="2">2</option>
                  <option value="3">3</option>
                  <option value="4">4</option>
                  <option value="5">5</option>
                </select>

            	<button type="submit" class="btn btn-info">Simpan Product</button>

					</form>

<?php include('static/footer.php'); ?>


text:
#region MIT
//
// Gorgon.
// Copyright (C) 2018 Michael Winsor
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// Created: September 17, 2018 8:19:33 AM
//
#endregion

using System;
using System.Runtime.Serialization;
using Gorgon.Properties;

namespace Gorgon
{
    ///
    /// Exception to be thrown when an argument is missing.
    ///
    /// <remarks>
    /// <para>
    /// The ideal use case for this exception is when a method expects a structure of data with specific members and a required member is not initialized (e.g. null).
    /// </para>
    /// </remarks>
    [Serializable]
    public class ArgumentMissingException
        : Exception
    {
        ///
        /// Initializes a new instance of the <see cref="ArgumentMissingException"/> class.
        ///
        /// <param name="memberName">The name of the member that is missing.</param>
        /// <param name="parameterName">The name of the parameter that is in error.</param>
        public ArgumentMissingException(string memberName, string parameterName)
            : base(string.Format(Resources.GOR_ERR_ARGUMENT_MISSING, memberName, parameterName))
        {

        }

        ///
        /// Initializes a new instance of the <see cref="ArgumentMissingException"/> class.
        ///
        /// <param name="memberName">The name of the member that is missing.</param>
        /// <param name="parameterName">The name of the parameter that is in error.</param>
        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference if no inner exception is specified. </param>
        public ArgumentMissingException(string memberName, string parameterName, Exception innerException)
            : base(string.Format(Resources.GOR_ERR_ARGUMENT_MISSING, memberName, parameterName), innerException)
        {
        }

        ///
        /// Initializes a new instance of the <see cref="ArgumentMissingException"/> class.
        ///
        /// <param name="info">The object that holds the serialized object data.</param>
        /// <param name="context">The contextual information about the source or destination.</param>
        protected ArgumentMissingException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }
    }
}