text:
Sometimes it's easier to make quick changes directly from the GitLab interface
than to clone the project and use the Git command line tool. In this feature
highlight we look at how you can create a new file, directory, branch or
tag from the file browser. All of these actions are available from a single
dropdown menu.

## Create a file

From a project's files page, click the '+' button to the right of the branch selector.
Choose **New file** from the dropdown.

![New file dropdown menu](img/web_editor_new_file_dropdown.png)

---

Enter a file name in the **File name** box. Then, add file content in the editor
area. Add a descriptive commit message and choose a branch. The branch field
will default to the branch you were viewing in the file browser. If you enter
a new branch name, a checkbox will appear allowing you to start a new merge
request after you commit the changes.

When you are satisfied with your new file, click **Commit Changes** at the bottom.

![Create file editor](img/web_editor_new_file_editor.png)

## Upload a file

The ability to create a file is great when the content is text. However, this
doesn't work well for binary data such as images, PDFs or other file types. In
this case you need to upload a file.

From a project's files page, click the '+' button to the right of the branch
selector. Choose **Upload file** from the dropdown.

![Upload file dropdown menu](img/web_editor_upload_file_dropdown.png)

---

Once the upload dialog pops up there are two ways to upload your file. Either
drag and drop a file on the pop up or use the **click to upload** link. A file
preview will appear once you have selected a file to upload.

Enter a commit message, choose a branch, and click **Upload file** when you are
ready.

![Upload file dialog](img/web_editor_upload_file_dialog.png)

## Create a directory

To keep files in the repository organized it is often helpful to create a new
directory.

From a project's files page, click the '+' button to the right of the branch selector.
Choose **New directory** from the dropdown.

![New directory dropdown](img/web_editor_new_directory_dropdown.png)

---

In the new directory dialog enter a directory name, a commit message and choose
the target branch. Click **Create directory** to finish.

![New directory dialog](img/web_editor_new_directory_dialog.png)

## Create a new branch

If you want to make changes to several files before creating a new merge
request, you can create a new branch up front. From a project's files page,
choose **New branch** from the dropdown.

![New branch dropdown](img/web_editor_new_branch_dropdown.png)

---

Enter a new **Branch name**. Optionally, change the **Create from** field
to choose which branch, tag or commit SHA this new branch will originate from.
This field will autocomplete if you start typing an existing branch or tag.
Click **Create branch** and you will be returned to the file browser on this new
branch.

![New branch page](img/web_editor_new_branch_page.png)

---

You can now make changes to any files, as needed. When you're ready to merge
the changes back to master you can use the widget at the top of the screen.
This widget only appears for a period of time after you create the branch or
modify files.

![New push widget](img/web_editor_new_push_widget.png)

## Create a new tag

Tags are useful for marking major milestones such as production releases,
release candidates, and more. You can create a tag from a branch or a commit
SHA. From a project's files page, choose **New tag** from the dropdown.

![New tag dropdown](img/web_editor_new_tag_dropdown.png)

---

Give the tag a name such as `v1.0.0`. Choose the branch or SHA from which you
would like to create this new tag. You can optionally add a message and
release notes. The release notes section supports markdown format and you can
also upload an attachment. Click **Create tag** and you will be taken to the tag
list page.

![New tag page](img/web_editor_new_tag_page.png)

## Tips

When creating or uploading a new file, or creating a new directory, you can
trigger a new merge request rather than committing directly to master. Enter
a new branch name in the **Target branch** field. You will notice a checkbox
appear that is labeled **Start a new merge request with these changes**. After
you commit the changes you will be taken to a new merge request form.

![Start a new merge request with these changes](img/web_editor_start_new_merge_request.png)


text:
package org.arrowhead.wp5.aggmanager.impl.resources;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import org.arrowhead.wp5.agg.impl.Aggregator;
import org.arrowhead.wp5.core.entities.FlexOffer;
import org.arrowhead.wp5.core.entities.TimeSeries;
import org.arrowhead.wp5.core.entities.TimeSeriesType;

@Path("/energy")
public class EnergyResource {
	private Aggregator agg;

	public EnergyResource(Aggregator agg) {
		this.agg = agg;
	}

	@GET
	@Path("/scheduled")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public TimeSeries getScheduledEnergy() throws Exception {
		return this.agg.getScheduledEnergy();
	}

	@GET
	@Path("/baseline")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public TimeSeries getBaselineEnergy() throws Exception {
		return this.agg.getBaselineEnergy();
	}

	@GET
	@Path("/minimum")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public TimeSeries getMinimumEnergy() throws Exception {
		TimeSeries ts = new TimeSeries(new double[] {});

		for(FlexOffer f : this.agg.getAllSimpleFlexOffers()) {
			TimeSeries ft = new TimeSeries(f, TimeSeriesType.tstMinEnergy);
			ts._extend(ft)._plus(ft);
		}
		return ts;
	}

	@GET
	@Path("/maximum")
	@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
	public TimeSeries getMaximumEnergy() throws Exception {
		TimeSeries ts = new TimeSeries(new double[] {});

		for(FlexOffer f : this.agg.getAllSimpleFlexOffers()) {
			TimeSeries ft = new TimeSeries(f, TimeSeriesType.tstMaxEnergy);
			ts._extend(ft)._plus(ft);
		}
		return ts;
	}

}

redpajama_set_name: RedPajamaGithub


text:
{% extends "layout.html" %}

{% block head %}
{% endblock %}

{% block body %}

Help

For more info on the project, check the About page.

Send us a message if you're stuck; contact details are here.

FAQ

Is my data private?

Yes.  Your forms and the responses from participants are private by default.

Is this open to people from outside of the US?

Absolutely - this was designed to work with respondents from anywhere.  If you have connection issues please let us know.  If you'd like to read more about coverage, you should know that we use Twilio to control our calls; here is some information on Twilio's international coverage.

How are the question prompts created?

If your questions are in English, Spanish, French or German, you can type them out and we will use a text-to-speech program to read the words.  If you are creating a form in a different language, you can upload audio recordings of the question prompts.

Can I control who is allowed to call in?

Yes, you have the option to "whitelist" certain phone numbers so that only they may respond.  Keeping your form's calling code private also provides some measure of security.

How much does this cost?

The beta will be free.  Once out of beta, costs will largely depend on where you're calling and for how long; see this map to get an idea of the rates.

How does this scale?

IVRHub is great for testing voice responses systems on your project.  For long term work in one locale, we recommend setting up Asterisk or FreeSwitch with a local number to reduce costs.

{% endblock %}


text:
using System;
using System.Linq;
using System.Reflection;
using MooGet;
using Mono.Options;
using NUnit.Framework;

namespace MooGet.Specs.CLI {

	[TestFixture]
	public class CommandsCommandSpec : Spec {

		[Test][Description("moo help commands")]
		public void help() {
			var output = moo("help commands");
			output.ShouldContain("Usage: moo commands");
		}

		[Test][Description("moo commands")]
		public void lists_commands() {
			var output = moo("commands");
			output.ShouldMatch(@"commands\s+List all available Moo commands");
		}
	}
}


text:
A PHP client for the VtcPay SOAP API
==============================================================

Introduction
------------

### Features ###

This library's features include the following.

* Added an EventDispatcher to your Soap client. It will trigger events at all important phases of the SOAP call
* Easily extensible through events: add custom logging, caching, error handling etc
* Completely tested

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

This library is available on [Packagist](http://packagist.org/packages/vtcpay/soap-client).
The recommended way to install this library is through [Composer](http://getcomposer.org):

```bash
$ php composer.phar require vtcpay/soap-client dev-master
```

Usage
-----

### The client ###

First construct a client using the builder:

```php
$builder = new \Vtcpay\SoapClient\ClientBuilder(
  '/path/to/your/vtcpay/wsdl/sandbox.enterprise.wsdl.xml'
);

$client = $builder->build();
```

### Logging ###

To enable logging for the client, call `withLog()` on the builder. For instance when using [Monolog](https://github.com/Seldaek/monolog):

```php
$log = new \Monolog\Logger('vtcpay');
$log->pushHandler(new \Monolog\Handler\StreamHandler('/path/to/your.log'));

$builder = new \Vtcpay\SoapClient\ClientBuilder(
  '/path/to/your/vtcpay/wsdl/sandbox.enterprise.wsdl.xml'
);
$client = $builder->withLog($log)
  ->build();
```

All requests to the VnPay API, as well as the responses and any errors that it returns, will now be logged.

### Completely tested ###

* [tests/index.php](https://github.com/vtcpay/soap-client/blob/master/tests/index.php)


text:
/*global define */
/*jslint sloppy:true */
/*
| Copyright 2014 Esri
|
| 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.
*/
define({
  "map": {
    "error": "Δεν είναι δυνατή η δημιουργία χάρτη"
  },
  "webMapList": {
    "owner": "Κάτοχος",
    "created": "Ημερομηνία δημιουργίας",
    "modified": "Ημερομηνία τροποποίησης",
    "description": "Περιγραφή",
    "snippet": "Σύνοψη",
    "licenseInfo": "Περιορισμοί στην πρόσβαση και τη χρήση",
    "accessInformation": "Συντελεστές",
    "tags": "Ετικέτες",
    "numViews": "Αριθμός προβολών",
    "avgRating": "Αξιολόγηση",
    "noWebMapInGroup": "Η παραμετροποιημένη ομάδα δεν είναι έγκυρη ή δεν έχει γίνει ακόμη κοινοποίηση στοιχείων σε αυτήν την ομάδα",
    "infoBtnToolTip": "Πληροφορίες χάρτη",
    "openWebmapList": "Άνοιγμα πλαισίου",
    "closeWebmapList": "Κλείσιμο πλαισίου"
  },
  "geoform": {
    "enterInformation": "Λεπτομ.",
    "selectAttachments": "Συνημμένα",
    "selectFileText": "Αναζήτηση",
    "enterLocation": "Τοποθεσία",
    "reportItButton": "Υποβολή",
    "cancelButton": "Ακύρωση",
    "requiredField": "(απαιτούμενο)",
    "selectDefaultText": "Επιλέξτε…",
    "invalidInputValue": "Εισαγάγετε μια έγκυρη τιμή.",
    "noFieldsConfiguredMessage": "Τα πεδία του θεματικού επιπέδου δεν έχουν παραμετροποιηθεί για την καταγραφή δεδομένων",
    "invalidSmallNumber": "Εισαγάγετε έναν ακέραιο αριθμό",
    "invalidNumber": "Εισαγάγετε έναν ακέραιο αριθμό",
    "invalidFloat": "Εισαγάγετε έναν αριθμό",
    "invalidDouble": "Εισαγάγετε έναν αριθμό",
    "requiredFields": "Δώστε τιμές για όλα τα απαιτούμενα πεδία.",
    "selectLocation": "Επιλέξτε τη θέση για την αναφορά σας",
    "numericRangeHintMessage": "${openStrong}Υπόδειξη:${closeStrong} Ελάχιστη τιμή ${minValue} και μέγιστη τιμή ${maxValue}",
    "dateRangeHintMessage": "${openStrong}Υπόδειξη:${closeStrong} Ελάχιστη ημερομηνία ${minValue} και μέγιστη ημερομηνία ${maxValue}",
    "errorsInApplyEdits": "Δεν ήταν δυνατή η υποβολή της αναφοράς",
    "attachmentSelectedMsg": "συνημμένα επιλέχθηκαν",
    "attachmentUploadStatus": "Απέτυχε η μεταφόρτωση ${failed} από ${total} συνημμένων",
    "geoLocationError": "Η τρέχουσα τοποθεσία δεν είναι διαθέσιμη",
    "geoLocationOutOfExtent": "Η τρέχουσα τοποθεσία είναι εκτός της έκτασης του υποβάθρου",
    "submitButtonTooltip": "Αποθήκευση",
    "cancelButtonTooltip": "Ακύρωση",
    "geoformBackButtonTooltip": "Επιστροφή στη λίστα αναφορών",
    "updateFeaturesConfirmationMsg": "${count} στοιχεία θα ενημερωθούν",
    "attachmentHeaderText": "Συνημμένα",
    "unknownPopupAttachment": "ΑΡΧΕΙΟ",
    "unableToEditPopupMessage": "Δεν έχετε δικαίωμα να εκτελέσετε αυτή την ενέργεια."
  },
  "mapViewer": {
    "zoomInToolTip": "Εστίαση σε μεγαλύτερη κλίμακα",
    "zoomOutToolTip": "Απομάκρυνση σε μικρότερη κλίμακα"
  },
  "applicationHeader": {
    "signInOption": "Είσοδος",
    "signOutOption": "Έξοδος",
    "pleaseSignInText": "Εισέλθετε"
  },
  "dataviewer": {
    "noIssuesReported": "Δεν υπάρχουν διαθέσιμες αναφορές",
    "noFeatureGeometry": "Δεν είναι δυνατή η εμφάνιση του στοιχείου",
    "ascendingFlagTitle": "Ταξινόμηση με αύξουσα σειρά",
    "descendingFlagTitle": "Ταξινόμηση με φθίνουσα σειρά",
    "filterLabel": "Φίλτρο",
    "valueRadioButtonLabel": "Τιμή",
    "uniqueRadioButtonLabel": "Μοναδικό",
    "selectLayerToBegin": "Επιλέξτε μια κατηγορία για να ξεκινήσετε",
    "layerFeatureCount": "${selectedFeatureCount} επιλεγμένα / ${featureCount} εγγραφές"
  },
  "timeSlider": {
    "timeSliderLabel": "Εύρος χρόνου",
    "timeSliderInEditModeAlert": "Η μπάρα κύλισης χρόνου δεν είναι διαθέσιμη κατά την επεξεργασία"
  },
  "comment": {
    "commentsFormSubmitButton": "Αποθήκευση",
    "commentsFormCancelButton": "Ακύρωση",
    "errorInSubmittingComment": "Δεν ήταν δυνατή η αποθήκευση αλλαγών.",
    "emptyCommentMessage": "Απαιτείται τιμή",
    "placeHolderText": "",
    "noCommentsAvailableText": "Δεν υπάρχουν διαθέσιμες εγγραφές",
    "remainingTextCount": "Απομένουν ${0} χαρακτήρες",
    "showNoText": "Όχι",
    "selectAttachments": "Συνημμένα",
    "selectFileText": "Αναζήτηση",
    "attachmentSelectedMsg": "συνημμένα επιλέχθηκαν",
    "attachmentHeaderText": "Συνημμένα",
    "addRecordText": "Προσθήκη εγγραφής",
    "unknownCommentAttachment": "ΑΡΧΕΙΟ",
    "unableToAddOrEditCommentMessage": "Δεν έχετε δικαίωμα να εκτελέσετε αυτή την ενέργεια."
  },
  "main": {
    "noGroup": "Δεν έχει παραμετροποιηθεί κάποια ομάδα"
  },
  "search": {
    "searchIconTooltip": "Αναζήτηση σε αυτό το θεματικό επίπεδο",
    "noResultFoundText": "Δεν βρέθηκαν αποτελέσματα",
    "searchInEditModeAlert": "Η αναζήτηση δεν είναι διαθέσιμη κατά την επεξεργασία"
  },
  "manualRefresh": {
    "manualRefreshIconTooltip": "Ανανέωση",
    "confirmManualRefreshText": "Όλες οι επιλογές και οι μη αποθηκευμένες αλλαγές θα απορριφθούν"
  },
  "help": {
    "helpIconTooltip": "Βοήθεια"
  },
  "filter": {
    "noFeatureFoundText": "Δεν βρέθηκαν στοιχεία για αυτήν την τιμή.",
    "distinctQueryFailed": "Δεν βρέθηκαν διακριτές τιμές για το πεδίο.",
    "andText": "και",
    "filterInEditModeAlert": "Τα φίλτρα δεν είναι διαθέσιμα κατά την επεξεργασία.",
    "dropdownSelectOption": "Επιλογή",
    "filterInShowSelectedEditModeAlert": "Τα φίλτρα δεν είναι διαθέσιμα στη λειτουργία \"Εμφάνιση επιλεγμένων\"."
  },
  "detailsPanel": {
    "editContentText": "Επεξεργασία εγγραφής"
  },
  "signOutPage": {
    "signOutMessage": "Αποσυνδεθήκατε με επιτυχία",
    "reSignInMessage": "Κάντε κλικ εδώ για να συνδεθείτε"
  },
  "selectionOptions": {
    "selectionOptionsIconTooltip": "Δυνατότητες επιλογής",
    "showAllOptionText": "Εμφάνιση όλων",
    "showSelectedOptionText": "Εμφάνιση επιλεγμένων"
  }
});


text:
using System;

using commercetools.Common.UpdateActions;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace commercetools.Common.Converters
{
    /// <summary>
    /// Custom converter for the GenericAction class.
    /// </summary>
    public class GenericActionConverter : JsonConverter
    {
        /// <summary>
        /// CanRead
        /// </summary>
        public override bool CanRead
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// CanConvert
        /// </summary>
        /// <param name="objectType">Object type</param>
        /// <returns>True if the type is GenericAction, false otherwise</returns>
        public override bool CanConvert(Type objectType)
        {
            return (objectType == typeof(GenericAction));
        }

        /// <summary>
        /// ReadJson (not implemented)
        /// </summary>
        /// <param name="reader">JsonReader</param>
        /// <param name="objectType">Object type</param>
        /// <param name="existingValue">Existing value</param>
        /// <param name="serializer">Serializer</param>
        /// <returns></returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// WriteJson
        /// </summary>
        /// <param name="writer">JsonWriter</param>
        /// <param name="value">Value</param>
        /// <param name="serializer">JsonSerializer</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value is GenericAction)
            {
                GenericAction genericAction = (GenericAction)value;

                JObject jObject = new JObject();
                jObject.Add("action", genericAction.Action);

                foreach (string key in genericAction.Properties.Keys)
                {
                    jObject.Add(key, genericAction.Properties[key]);
                }

                jObject.WriteTo(writer);
            }
        }
    }
}


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using Microsoft.Scripting;
using Microsoft.Scripting.Hosting;
using ZyGames.Framework.Collection.Generic;
using ZyGames.Framework.Common;
using ZyGames.Framework.Common.Log;
using ZyGames.Framework.Common.Security;

namespace ZyGames.Framework.Script
{
    /// <summary>
    ///
    /// </summary>
    [Serializable]
    public class PythonRuntimeScope : LuaRuntimeScope
    {
        private ScriptEngine _scriptEngine;
        private string pythonPath;
        private const string FileFilter = "*.py";
        private DictionaryExtend<string, PythonFileInfo> _pythonCodeCache;

        /// <summary>
        ///
        /// </summary>
        /// <param name="settupInfo"></param>
        public PythonRuntimeScope(ScriptSettupInfo settupInfo)
            : base(settupInfo)
        {
            _pythonCodeCache = new DictionaryExtend<string, PythonFileInfo>();
        }

        /// <summary>
        ///
        /// </summary>
        public override void Init()
        {
            if (!SettupInfo.DisablePython)
            {
                string refPath = Path.GetDirectoryName(SettupInfo.PythonReferenceLibFile);
                if (!string.IsNullOrEmpty(refPath) && !Directory.Exists(refPath))
                {
                    Directory.CreateDirectory(refPath);
                }
                pythonPath = Path.Combine(SettupInfo.RuntimePath, SettupInfo.ScriptRelativePath, SettupInfo.PythonScriptPath);
                AddWatchPath(pythonPath, FileFilter);
                InitPython();
            }
            base.Init();
        }

        /// <summary>
        ///
        /// </summary>
        public void InitPython()
        {
            var pythonOptions = new Dictionary<string, object>();
            pythonOptions["Debug"] = SettupInfo.PythonIsDebug;

            var assm = Assembly.LoadFrom(Path.Combine(SettupInfo.RuntimePrivateBinPath, "IronPython.dll"));
            var type = assm.GetType("IronPython.Hosting.Python", false, true);
            if (type == null)
            {
                throw new Exception("Not found Python class in IronPython.dll");
            }
            _scriptEngine = type.InvokeMember("CreateEngine", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, null, null, new[] { pythonOptions }) as ScriptEngine;

            //_scriptEngine = IronPython.Hosting.Python.CreateEngine(pythonOptions);
            _scriptEngine.Runtime.LoadAssembly(typeof(string).Assembly);
            _scriptEngine.Runtime.LoadAssembly(Assembly.GetExecutingAssembly());

            //load python path
            var searchPaths = new List<string> { "*" };
            string libPath = Environment.GetEnvironmentVariable("IRONPYTHONPATH");
            if (string.IsNullOrEmpty(libPath))
            {
                TraceLog.WriteError("The environment variables:\"IRONPYTHONPATH\" is not be setting.");
                Console.WriteLine("# Error>>The environment variables:\"IRONPYTHONPATH\" is not be setting.");
            }
            if (!string.IsNullOrEmpty(libPath))
            {
                string[] items = libPath.Split(';');
                searchPaths.AddRange(items.Where(p => p.Length > 0));
            }
            if (Directory.Exists(pythonPath))
            {
                searchPaths.Add(pythonPath);
                var dirList = Directory.GetDirectories(pythonPath, "*", SearchOption.AllDirectories);
                searchPaths.AddRange(dirList);
            }
            TraceLog.ReleaseWrite("The py path:{0}", string.Join(@";", searchPaths));
            _scriptEngine.SetSearchPaths(searchPaths.ToArray());

            Load();
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="scriptCode"></param>
        /// <param name="typeName"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public override object Execute(string scriptCode, string typeName, params object[] args)
        {
            string code = FormatScriptCode(SettupInfo.PythonScriptPath, scriptCode, ".py");
            object scriptScope = ExecutePython(code);
            if (scriptScope != null)
            {
                return scriptScope;
            }
            return base.Execute(scriptCode, typeName, args);
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="scriptCode"></param>
        /// <param name="typeName"></param>
        /// <param name="typeArgs"></param>
        /// <param name="method"></param>
        /// <param name="methodArgs"></param>
        /// <returns></returns>
        public override bool InvokeMenthod(string scriptCode, string typeName, object[] typeArgs, string method, params object[] methodArgs)
        {
            string code = FormatScriptCode(SettupInfo.PythonScriptPath, scriptCode, ".py");
            object scriptScope = ExecutePython(code);
            if (scriptScope != null)
            {
                MethodInfo methodInfo = scriptScope.GetType().GetMethod(method);
                if (methodInfo != null)
                {
                    methodInfo.Invoke(scriptScope, methodArgs);
                    return true;
                }
                return false;
            }
            return base.InvokeMenthod(scriptCode, typeName, typeArgs, method, methodArgs);
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="scriptCode"></param>
        /// <returns></returns>
        public object ExecutePython(string scriptCode)
        {
            string code = FormatScriptCode(SettupInfo.PythonScriptPath, scriptCode, ".py");
            var scriptInfo = _pythonCodeCache[code] as PythonFileInfo;
            if (!SettupInfo.DisablePython && scriptInfo != null)
            {
                var scope = _scriptEngine.CreateScope();
                scriptInfo.CompiledCode.Execute(scope);
                return scope;
            }
            return null;
        }

        private void Load()
        {
            if (Directory.Exists(pythonPath))
            {
                var files = Directory.GetFiles(pythonPath, FileFilter, SearchOption.AllDirectories);
                foreach (var fileName in files)
                {
                    LoadScript(fileName);
                }
            }
            Compile();
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="fileNames"></param>
        public void InitPython(params string[] fileNames)
        {
            foreach (var fileName in fileNames)
            {
                var scriptFile = LoadScript(fileName, true);
                CompilePython(scriptFile);
            }
        }

        private void Compile()
        {
            foreach (var pair in _pythonCodeCache)
            {
                CompilePython(pair.Value);
            }

        }

        private void CompilePython(PythonFileInfo scriptFile)
        {
            try
            {
                var scriptSource = _scriptEngine.CreateScriptSourceFromString(scriptFile.Source, Path.GetFullPath(scriptFile.FileName), SourceCodeKind.File);
                scriptFile.CompiledCode = scriptSource.Compile();
                scriptFile.Source = null;
            }
            catch (Exception ex)
            {
                TraceLog.WriteError("CompilePython script:{0} error:{1}", scriptFile.FileName, ex);
            }
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="isReLoad"></param>
        /// <returns></returns>
        private PythonFileInfo LoadScript(string fileName, bool isReLoad = false)
        {
            PythonFileInfo scriptFileInfo = null;
            string scriptCode = GetScriptCode(fileName);
            if (!isReLoad && _pythonCodeCache.ContainsKey(scriptCode))
            {
                var old = _pythonCodeCache[scriptCode];
                if (!File.Exists(fileName) ||
                    old.HashCode == GetFileHashCode(fileName))
                {
                    return old;
                }
            }
            scriptFileInfo = CreateScriptFile(fileName);
            if (scriptFileInfo != null)
            {
                _pythonCodeCache[scriptCode] = scriptFileInfo;
            }
            return scriptFileInfo;
        }

        private PythonFileInfo CreateScriptFile(string fileName)
        {
            FileInfo fi = new FileInfo(fileName);
            if (fi.Extension == ".py")
            {
                string fileCode = GetScriptCode(fileName);
                string source = "";
                using (var sr = fi.OpenText())
                {
                    source = Decode(sr.ReadToEnd(), fi.Extension);
                }
                return new PythonFileInfo(fileCode, fileName)
                {
                    Source = source,
                    HashCode = CryptoHelper.ToMd5Hash(source)
                };
            }
            return null;
        }

    }

}


text:
<?php

namespace PhpGit\Exception;

/**
 * Class GitException
 * @author  Raphaël Pommier (raphael@pommier.me)
 * @since   2014-02-22
 */
class GitException extends \Exception {

}


text:
package de.tobiaserthal.akgbensheim.drawer;

/**
 * An interface to respond to click events in the navigation drawer.
 */
public interface DrawerCallbacks {
    /**
     * Called when a navigation item (not the header and not a section) registered a click event.
     * @param position The absolute adapter position of the item.
     * @param id The item id set while adding to adapter
     * @param reselect Whether this item is reselected
     */
    void onNavigationItemSelected(int position, int id, boolean reselect);
}


text:
/***********************************************
* ZQCustomAction.cpp
*
* @author: zyq
* @date: 16/12/22
* @Description:
*
***********************************************/
#include "ZQCustomAction.h"

using namespace zq;

ZQCustomAction::ZQCustomAction():_listener(0)
{

}

ZQCustomAction::~ZQCustomAction()
{
    if (_listener)
    {
        cocos2d::LuaEngine::getInstance()->removeScriptHandler(_listener);
    }
}

ZQCustomAction* ZQCustomAction::create()
{
    ZQCustomAction* customAction = new (std::nothrow) ZQCustomAction();
    customAction->autorelease();

    return customAction;
}

void ZQCustomAction::registerScriptListener(cocos2d::LUA_FUNCTION listener)
{
    this->_listener = listener;
}

void ZQCustomAction::unregisterScriptListener()
{
    if (_listener)
    {
        cocos2d::LuaEngine::getInstance()->removeScriptHandler(_listener);
        _listener = 0;
    }
}

bool ZQCustomAction::initWithDuration(float duration)
{
    return cocos2d::ActionInterval::initWithDuration(duration);
}

void ZQCustomAction::startWithTarget(cocos2d::Node *target)
{
    cocos2d::ActionInterval::startWithTarget(target);

    if (_listener)
    {
        cocos2d::LuaValueDict dict;

        dict["name"] = cocos2d::LuaValue::stringValue("startWithTarget");
        dict["total"] = cocos2d::LuaValue::intValue((int)5);

        cocos2d::LuaStack *stack = cocos2d::LuaEngine::getInstance()->getLuaStack();
        stack->clean();
        stack->pushLuaValueDict(dict);
        stack->executeFunctionByHandler(_listener, 1);
    }
}

void ZQCustomAction::update(float time)
{
    if (_listener)
    {
        cocos2d::LuaValueDict dict;

        dict["name"] = cocos2d::LuaValue::stringValue("update");
        dict["time"] = cocos2d::LuaValue::floatValue(time);

        cocos2d::LuaStack *stack = cocos2d::LuaEngine::getInstance()->getLuaStack();
        stack->clean();
        stack->pushLuaValueDict(dict);
        stack->executeFunctionByHandler(_listener, 1);
    }

}


text:
#include <itkFiltersDivideProcess.h>

#include <dtkCore/dtkAbstractProcessFactory.h>
#include <medAbstractDataFactory.h>

#include <medMetaDataKeys.h>

#include <itkFiltersDivideProcess_p.h>

//-------------------------------------------------------------------------------------------

itkFiltersDivideProcess::itkFiltersDivideProcess(itkFiltersDivideProcess *parent)
    : itkFiltersProcessBase(*new itkFiltersDivideProcessPrivate(this), parent)
{
    DTK_D(itkFiltersDivideProcess);

    d->filter = this;
    d->output = NULL;

    d->description = tr("ITK divide by constant filter");
}

itkFiltersDivideProcess::itkFiltersDivideProcess(const itkFiltersDivideProcess& other)
    : itkFiltersProcessBase(*new itkFiltersDivideProcessPrivate(*other.d_func()), other)
{
}

//-------------------------------------------------------------------------------------------

itkFiltersDivideProcess::~itkFiltersDivideProcess( void )
{
}

//-------------------------------------------------------------------------------------------

bool itkFiltersDivideProcess::registered( void )
{
    return dtkAbstractProcessFactory::instance()->registerProcessType("itkDivideProcess", createitkFiltersDivideProcess);
}

//-------------------------------------------------------------------------------------------

void itkFiltersDivideProcess::setParameter(double data, int channel)
{
    if (channel != 0)
        return;

    DTK_D(itkFiltersDivideProcess);
    d->divideFactor = data;
}

//-------------------------------------------------------------------------------------------

int itkFiltersDivideProcess::update ( void )
{
    DTK_D(itkFiltersDivideProcess);

    if ( !d->input )
        return -1;

    QString id = d->input->identifier();

    qDebug() << "itkFilters, update : " << id;

    if ( id == "itkDataImageChar3" )
    {
        d->update<char>();
    }
    else if ( id == "itkDataImageUChar3" )
    {
        d->update<unsigned char>();
    }
    else if ( id == "itkDataImageShort3" )
    {
        d->update<short>();
    }
    else if ( id == "itkDataImageUShort3" )
    {
        d->update<unsigned short>();
    }
    else if ( id == "itkDataImageInt3" )
    {
        d->update<int>();
    }
    else if ( id == "itkDataImageUInt3" )
    {
        d->update<unsigned int>();
    }
    else if ( id == "itkDataImageLong3" )
    {
        d->update<long>();
    }
    else if ( id== "itkDataImageULong3" )
    {
        d->update<unsigned long>();
    }
    else if ( id == "itkDataImageFloat3" )
    {
        d->update<float>();
    }
    else if ( id == "itkDataImageDouble3" )
    {
        d->update<double>();
    }
    else
    {
        qDebug() << "Error : pixel type not yet implemented ("
        << id
        << ")";
        return -1;
    }

    return EXIT_SUCCESS;
}

// /////////////////////////////////////////////////////////////////
// Type instanciation
// /////////////////////////////////////////////////////////////////

dtkAbstractProcess * createitkFiltersDivideProcess ( void )
{
    return new itkFiltersDivideProcess;
}


text:
remco --config integration/file/file.toml
cat /tmp/remco-basic-test.conf


text:
import java.util.*;
public class StringProblem{
  public static void main(String[] args){
    System.out.println(catDog("catdogcatcatdogdogcatdog"));
  }

// Method returns the number of spaces in str.
  public static int countSpaces(String str){
    if(str.indexOf(" ")==-1){
      return 0;
    } else {
      return 1 + countSpaces(str.substring(str.indexOf(" ")+1));
    }
  }
//count the number of times b occurs in a.
  public static int countWords(String a, String b){
    if(a.indexOf(b)==-1){
      return 0;
    } else {
      return 1 + countWords(a.substring(a.indexOf(b)+1), b);
    }
  }
//return true if str has the same number of occurences of
// "cat" and "dog".
// Must Use countWords!!
  public static boolean catDog(String str){
    return countWords(str,"cat")==countWords(str,"dog");
  }
}


text:
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<!--
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You 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.
-->

<configuration>

<!-- Hive Configuration can either be stored in this file or in the hadoop configuration files  -->
<!-- that are implied by Hadoop setup variables.                                                -->
<!-- Aside from Hadoop setup variables - this file is provided as a convenience so that Hive    -->
<!-- users do not have to edit hadoop configuration files (that may be managed as a centralized -->
<!-- resource).                                                                                -->

<!-- Hive Execution Parameters -->
<property>
  <name>mapred.reduce.tasks</name>
  <value>-1</value>
    <description>The default number of reduce tasks per job.  Typically set
  to a prime close to the number of available hosts.  Ignored when
  mapred.job.tracker is "local". Hadoop set this to 1 by default, whereas hive uses -1 as its default value.
  By setting this property to -1, Hive will automatically figure out what should be the number of reducers.
  </description>
</property>

<property>
  <name>hive.exec.reducers.bytes.per.reducer</name>
  <value>1000000000</value>
  <description>size per reducer.The default is 1G, i.e if the input size is 10G, it will use 10 reducers.</description>
</property>

<property>
  <name>hive.exec.reducers.max</name>
  <value>999</value>
  <description>max number of reducers will be used. If the one
	specified in the configuration parameter mapred.reduce.tasks is
	negative, hive will use this one as the max number of reducers when
	automatically determine number of reducers.</description>
</property>

<property>
  <name>hive.cli.print.header</name>
  <value>false</value>
  <description>Whether to print the names of the columns in query output.</description>
</property>

<property>
  <name>hive.exec.scratchdir</name>
  <value>/tmp/hive-${user.name}</value>
  <description>Scratch space for Hive jobs</description>
</property>

<property>
  <name>hive.test.mode</name>
  <value>false</value>
  <description>whether hive is running in test mode. If yes, it turns on sampling and prefixes the output tablename</description>
</property>

<property>
  <name>hive.test.mode.prefix</name>
  <value>test_</value>
  <description>if hive is running in test mode, prefixes the output table by this string</description>
</property>

<!-- If the input table is not bucketed, the denominator of the tablesample is determinied by the parameter below   -->
<!-- For example, the following query:                                                                              -->
<!--   INSERT OVERWRITE TABLE dest                                                                                -->
<!--   SELECT col1 from src                                                                                -->
<!-- would be converted to                                                                                -->
<!--   INSERT OVERWRITE TABLE test_dest                                                                             -->
<!--   SELECT col1 from src TABLESAMPLE (BUCKET 1 out of 32 on rand(1))                                             -->
<property>
  <name>hive.test.mode.samplefreq</name>
  <value>32</value>
  <description>if hive is running in test mode and table is not bucketed, sampling frequency</description>
</property>

<property>
  <name>hive.test.mode.nosamplelist</name>
  <value></value>
  <description>if hive is running in test mode, dont sample the above comma seperated list of tables</description>
</property>

<property>
  <name>hive.metastore.local</name>
  <value>true</value>
  <description>controls whether to connect to remove metastore server or open a new metastore server in Hive Client JVM</description>
</property>

<property>
  <name>javax.jdo.option.ConnectionURL</name>
  <value>jdbc:derby:;databaseName=metastore_db;create=true</value>
  <description>JDBC connect string for a JDBC metastore</description>
</property>

<property>
  <name>javax.jdo.option.ConnectionDriverName</name>
  <value>org.apache.derby.jdbc.EmbeddedDriver</value>
  <description>Driver class name for a JDBC metastore</description>
</property>

<property>
  <name>javax.jdo.PersistenceManagerFactoryClass</name>
  <value>org.datanucleus.jdo.JDOPersistenceManagerFactory</value>
  <description>class implementing the jdo persistence</description>
</property>

<property>
  <name>javax.jdo.option.DetachAllOnCommit</name>
  <value>true</value>
  <description>detaches all objects from session so that they can be used after transaction is committed</description>
</property>

<property>
  <name>javax.jdo.option.NonTransactionalRead</name>
  <value>true</value>
  <description>reads outside of transactions</description>
</property>

<property>
  <name>javax.jdo.option.ConnectionUserName</name>
  <value>APP</value>
  <description>username to use against metastore database</description>
</property>

<property>
  <name>javax.jdo.option.ConnectionPassword</name>
  <value>mine</value>
  <description>password to use against metastore database</description>
</property>

<property>
  <name>datanucleus.connectionPoolingType</name>
  <value>DBCP</value>
  <description>Uses a DBCP connection pool for JDBC metastore</description>
</property>

<property>
  <name>datanucleus.validateTables</name>
  <value>false</value>
  <description>validates existing schema against code. turn this on if you want to verify existing schema </description>
</property>

<property>
  <name>datanucleus.validateColumns</name>
  <value>false</value>
  <description>validates existing schema against code. turn this on if you want to verify existing schema </description>
</property>

<property>
  <name>datanucleus.validateConstraints</name>
  <value>false</value>
  <description>validates existing schema against code. turn this on if you want to verify existing schema </description>
</property>

<property>
  <name>datanucleus.storeManagerType</name>
  <value>rdbms</value>
  <description>metadata store type</description>
</property>

<property>
  <name>datanucleus.autoCreateSchema</name>
  <value>true</value>
  <description>creates necessary schema on a startup if one doesn't exist. set this to false, after creating it once</description>
</property>

<property>
  <name>datanucleus.autoStartMechanismMode</name>
  <value>checked</value>
  <description>throw exception if metadata tables are incorrect</description>
</property>

<property>
  <name>datanucleus.transactionIsolation</name>
  <value>read-committed</value>
  <description>Default transaction isolation level for identity generation. </description>
</property>

<property>
  <name>datanucleus.cache.level2</name>
  <value>false</value>
  <description>Use a level 2 cache. Turn this off if metadata is changed independently of hive metastore server</description>
</property>

<property>
  <name>datanucleus.cache.level2.type</name>
  <value>SOFT</value>
  <description>SOFT=soft reference based cache, WEAK=weak reference based cache.</description>
</property>

<property>
  <name>datanucleus.identifierFactory</name>
  <value>datanucleus</value>
  <description>Name of the identifier factory to use when generating table/column names etc. 'datanucleus' is used for backward compatibility</description>
</property>

<property>
  <name>datanucleus.plugin.pluginRegistryBundleCheck</name>
  <value>LOG</value>
  <description>Defines what happens when plugin bundles are found and are duplicated [EXCEPTION|LOG|NONE]</description>
</property>

<property>
  <name>hive.metastore.warehouse.dir</name>
  <value>/user/hive/warehouse</value>
  <description>location of default database for the warehouse</description>
</property>

<property>
  <name>hive.metastore.connect.retries</name>
  <value>5</value>
  <description>Number of retries while opening a connection to metastore</description>
</property>

<property>
  <name>hive.metastore.client.connect.retry.delay</name>
  <value>1</value>
  <description>Number of seconds for the client to wait between consecutive connection attempts</description>
</property>

<property>
  <name>hive.metastore.client.socket.timeout</name>
  <value>20</value>
  <description>MetaStore Client socket timeout in seconds</description>
</property>

<property>
  <name>hive.metastore.rawstore.impl</name>
  <value>org.apache.hadoop.hive.metastore.ObjectStore</value>
  <description>Name of the class that implements org.apache.hadoop.hive.metastore.rawstore interface. This class is used to store and retrieval of raw metadata objects such as table, database</description>
</property>

<property>
  <name>hive.default.fileformat</name>
  <value>TextFile</value>
  <description>Default file format for CREATE TABLE statement. Options are TextFile and SequenceFile. Users can explicitly say CREATE TABLE ... STORED AS <TEXTFILE|SEQUENCEFILE> to override</description>
</property>

<property>
  <name>hive.fileformat.check</name>
  <value>true</value>
  <description>Whether to check file format or not when loading data files</description>
</property>

<property>
  <name>hive.map.aggr</name>
  <value>true</value>
  <description>Whether to use map-side aggregation in Hive Group By queries</description>
</property>

<property>
  <name>hive.groupby.skewindata</name>
  <value>false</value>
  <description>Whether there is skew in data to optimize group by queries</description>
</property>

<property>
  <name>hive.groupby.mapaggr.checkinterval</name>
  <value>100000</value>
  <description>Number of rows after which size of the grouping keys/aggregation classes is performed</description>
</property>

<property>
  <name>hive.mapred.local.mem</name>
  <value>0</value>
  <description>For local mode, memory of the mappers/reducers</description>
</property>

<property>
  <name>hive.mapjoin.followby.map.aggr.hash.percentmemory</name>
  <value>0.3</value>
  <description>Portion of total memory to be used by map-side grup aggregation hash table, when this group by is followed by map join</description>
</property>

<property>
  <name>hive.map.aggr.hash.force.flush.memory.threshold</name>
  <value>0.9</value>
  <description>The max memory to be used by map-side grup aggregation hash table, if the memory usage is higher than this number, force to flush data</description>
</property>

<property>
  <name>hive.map.aggr.hash.percentmemory</name>
  <value>0.5</value>
  <description>Portion of total memory to be used by map-side grup aggregation hash table</description>
</property>

<property>
  <name>hive.map.aggr.hash.min.reduction</name>
  <value>0.5</value>
  <description>Hash aggregation will be turned off if the ratio between hash
  table size and input rows is bigger than this number. Set to 1 to make sure
  hash aggregation is never turned off.</description>
</property>

<property>
  <name>hive.optimize.cp</name>
  <value>true</value>
  <description>Whether to enable column pruner</description>
</property>

<property>
  <name>hive.optimize.ppd</name>
  <value>true</value>
  <description>Whether to enable predicate pushdown</description>
</property>

<property>
  <name>hive.optimize.ppd.storage</name>
  <value>true</value>
  <description>Whether to push predicates down into storage handlers.  Ignored when hive.optimize.ppd is false.</description>
</property>

<property>
  <name>hive.optimize.pruner</name>
  <value>true</value>
  <description>Whether to enable the new partition pruner which depends on predicate pushdown. If this is disabled,
  the old partition pruner which is based on AST will be enabled.</description>
</property>

<property>
  <name>hive.optimize.groupby</name>
  <value>true</value>
  <description>Whether to enable the bucketed group by from bucketed partitions/tables.</description>
</property>

<property>
  <name>hive.join.emit.interval</name>
  <value>1000</value>
  <description>How many rows in the right-most join operand Hive should buffer before emitting the join result. </description>
</property>

<property>
  <name>hive.join.cache.size</name>
  <value>25000</value>
  <description>How many rows in the joining tables (except the streaming table) should be cached in memory. </description>
</property>

<property>
  <name>hive.mapjoin.bucket.cache.size</name>
  <value>100</value>
  <description>How many values in each keys in the map-joined table should be cached in memory. </description>
</property>

<property>
  <name>hive.mapjoin.maxsize</name>
  <value>100000</value>
  <description>Maximum # of rows of the small table that can be handled by map-side join. If the size is reached and hive.task.progress is set, a fatal error counter is set and the job will be killed.</description>
</property>

<property>
  <name>hive.mapjoin.cache.numrows</name>
  <value>25000</value>
  <description>How many rows should be cached by jdbm for map join. </description>
</property>

<property>
  <name>hive.optimize.skewjoin</name>
  <value>false</value>
  <description>Whether to enable skew join optimization. </description>
</property>

<property>
  <name>hive.skewjoin.key</name>
  <value>100000</value>
  <description>Determine if we get a skew key in join. If we see more
	than the specified number of rows with the same key in join operator,
	we think the key as a skew join key. </description>
</property>

<property>
  <name>hive.skewjoin.mapjoin.map.tasks</name>
  <value>10000</value>
  <description> Determine the number of map task used in the follow up map join job
	for a skew join. It should be used together with hive.skewjoin.mapjoin.min.split
	to perform a fine grained control.</description>
</property>

<property>
  <name>hive.skewjoin.mapjoin.min.split</name>
  <value>33554432</value>
  <description> Determine the number of map task at most used in the follow up map join job
	for a skew join by specifying the minimum split size. It should be used together with
	hive.skewjoin.mapjoin.map.tasks to perform a fine grained control.</description>
</property>

<property>
  <name>hive.mapred.mode</name>
  <value>nonstrict</value>
  <description>The mode in which the hive operations are being performed. In strict mode, some risky queries are not allowed to run</description>
</property>

<property>
  <name>hive.exec.script.maxerrsize</name>
  <value>100000</value>
  <description>Maximum number of bytes a script is allowed to emit to standard error (per map-reduce task). This prevents runaway scripts from filling logs partitions to capacity </description>
</property>

<property>
  <name>hive.exec.script.allow.partial.consumption</name>
  <value>false</value>
  <description> When enabled, this option allows a user script to exit successfully without consuming all the data from the standard input.
  </description>
</property>

<property>
  <name>hive.script.operator.id.env.var</name>
  <value>HIVE_SCRIPT_OPERATOR_ID</value>
  <description> Name of the environment variable that holds the unique script operator ID in the user's transform function (the custom mapper/reducer that the user has specified in the query)
  </description>
</property>

<property>
  <name>hive.exec.compress.output</name>
  <value>false</value>
  <description> This controls whether the final outputs of a query (to a local/hdfs file or a hive table) is compressed. The compression codec and other options are determined from hadoop config variables mapred.output.compress* </description>
</property>

<property>
  <name>hive.exec.compress.intermediate</name>
  <value>false</value>
  <description> This controls whether intermediate files produced by hive between multiple map-reduce jobs are compressed. The compression codec and other options are determined from hadoop config variables mapred.output.compress* </description>
</property>

<property>
  <name>hive.exec.parallel</name>
  <value>false</value>
  <description>Whether to execute jobs in parallel</description>
</property>

<property>
  <name>hive.exec.parallel.thread.number</name>
  <value>8</value>
  <description>How many jobs at most can be executed in parallel</description>
</property>

<property>
  <name>hive.task.progress</name>
  <value>false</value>
  <description>Whether Hive should periodically update task progress counters during execution.  Enabling this allows task progress to be monitored more closely in the job tracker, but may impose a performance penalty.  This flag is automatically set to true for jobs with hive.exec.dynamic.partition set to true.</description>
</property>

<property>
  <name>hive.hwi.war.file</name>
  <value>lib/hive-hwi-0.7.0.war</value>
  <description>This sets the path to the HWI war file, relative to ${HIVE_HOME}. </description>
</property>

<property>
  <name>hive.hwi.listen.host</name>
  <value>0.0.0.0</value>
  <description>This is the host address the Hive Web Interface will listen on</description>
</property>

<property>
  <name>hive.hwi.listen.port</name>
  <value>9999</value>
  <description>This is the port the Hive Web Interface will listen on</description>
</property>

<property>
  <name>hive.exec.pre.hooks</name>
  <value></value>
  <description>Comma-separated list of pre-execution hooks to be invoked for each statement.  A pre-execution hook is specified as the name of a Java class which implements the org.apache.hadoop.hive.ql.hooks.ExecuteWithHookContext interface.</description>
</property>

<property>
  <name>hive.exec.post.hooks</name>
  <value></value>
  <description>Comma-separated list of post-execution hooks to be invoked for each statement.  A post-execution hook is specified as the name of a Java class which implements the org.apache.hadoop.hive.ql.hooks.ExecuteWithHookContext interface.</description>
</property>

<property>
  <name>hive.merge.mapfiles</name>
  <value>true</value>
  <description>Merge small files at the end of a map-only job</description>
</property>

<property>
  <name>hive.merge.mapredfiles</name>
  <value>false</value>
  <description>Merge small files at the end of a map-reduce job</description>
</property>

<property>
  <name>hive.mergejob.maponly</name>
  <value>true</value>
  <description>Try to generate a map-only job for merging files if CombineHiveInputFormat is supported.</description>
</property>

<property>
  <name>hive.heartbeat.interval</name>
  <value>1000</value>
  <description>Send a heartbeat after this interval - used by mapjoin and filter operators</description>
</property>

<property>
  <name>hive.merge.size.per.task</name>
  <value>256000000</value>
  <description>Size of merged files at the end of the job</description>
</property>

<property>
  <name>hive.merge.smallfiles.avgsize</name>
  <value>16000000</value>
  <description>When the average output file size of a job is less than this number, Hive will start an additional map-reduce job to merge the output files into bigger files.  This is only done for map-only jobs if hive.merge.mapfiles is true, and for map-reduce jobs if hive.merge.mapredfiles is true.</description>
</property>

<property>
  <name>hive.mapjoin.hashtable.initialCapacity</name>
  <value>100000</value>
  <description>In the process of Mapjoin, the key/value will be hold in the hashtable. This value means the initialCapacity of the in-memory hashtable</description>
</property>

<property>
  <name>hive.mapjoin.hashtable.loadfactor</name>
  <value>0.75</value>
  <description>In the process of Mapjoin, the key/value will be hold in the hashtable. This value means the load factor for the in-memory hashtable</description>
</property>

<property>
  <name>hive.mapjoin.smalltable.filesize</name>
  <value>25000000</value>
  <description>The threshold for the input file size of the small tables; if the file size is smaller than this threshold, it will try to convert the common join into map join</description>
</property>

<property>
  <name>hive.mapjoin.localtask.max.memory.usage</name>
  <value>0.90</value>
  <description>This number means how much memory the local task can take to hold the key/value into in-memory hash table; If the local task's memory usage is more than this number, the local task will be abort by themself. It means the data of small table is too large to be hold in the memory.</description>
</property>

<property>
  <name>hive.mapjoin.followby.gby.localtask.max.memory.usage</name>
  <value>0.55</value>
  <description>This number means how much memory the local task can take to hold the key/value into in-memory hash table when this map join followed by a group by; If the local task's memory usage is more than this number, the local task will be abort by themself. It means the data of small table is too large to be hold in the memory.</description>
</property>

<property>
  <name>hive.mapjoin.check.memory.rows</name>
  <value>100000</value>
  <description>The number means after how many rows processed it needs to check the memory usage</description>
</property>

<property>
  <name>hive.auto.convert.join</name>
  <value>false</value>
  <description>Whether Hive enable the optimization about converting common join into mapjoin based on the input file size</description>
</property>

<property>
  <name>hive.script.auto.progress</name>
  <value>false</value>
  <description>Whether Hive Tranform/Map/Reduce Clause should automatically send progress information to TaskTracker to avoid the task getting killed because of inactivity.  Hive sends progress information when the script is outputting to stderr.  This option removes the need of periodically producing stderr messages, but users should be cautious because this may prevent infinite loops in the scripts to be killed by TaskTracker.  </description>
</property>

<property>
  <name>hive.script.serde</name>
  <value>org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe</value>
  <description>The default serde for trasmitting input data to and reading output data from the user scripts. </description>
</property>

<property>
  <name>hive.script.recordreader</name>
  <value>org.apache.hadoop.hive.ql.exec.TextRecordReader</value>
  <description>The default record reader for reading data from the user scripts. </description>
</property>

<property>
  <name>hive.script.recordwriter</name>
  <value>org.apache.hadoop.hive.ql.exec.TextRecordWriter</value>
  <description>The default record writer for writing data to the user scripts. </description>
</property>

<property>
  <name>hive.input.format</name>
  <value>org.apache.hadoop.hive.ql.io.HiveInputFormat</value>
  <description>The default input format, if it is not specified, the system assigns it. It is set to HiveInputFormat for hadoop versions 17, 18 and 19, whereas it is set to CombineHiveInputFormat for hadoop 20. The user can always overwrite it - if there is a bug in CombineHiveInputFormat, it can always be manually set to HiveInputFormat. </description>
</property>

<property>
  <name>hive.udtf.auto.progress</name>
  <value>false</value>
  <description>Whether Hive should automatically send progress information to TaskTracker when using UDTF's to prevent the task getting killed because of inactivity.  Users should be cautious because this may prevent TaskTracker from killing tasks with infinte loops.  </description>
</property>

<property>
  <name>hive.mapred.reduce.tasks.speculative.execution</name>
  <value>true</value>
  <description>Whether speculative execution for reducers should be turned on. </description>
</property>

<property>
  <name>hive.exec.counters.pull.interval</name>
  <value>1000</value>
  <description>The interval with which to poll the JobTracker for the counters the running job. The smaller it is the more load there will be on the jobtracker, the higher it is the less granular the caught will be.</description>
</property>

<property>
  <name>hive.enforce.bucketing</name>
  <value>false</value>
  <description>Whether bucketing is enforced. If true, while inserting into the table, bucketing is enforced. </description>
</property>

<property>
  <name>hive.enforce.sorting</name>
  <value>false</value>
  <description>Whether sorting is enforced. If true, while inserting into the table, sorting is enforced. </description>
</property>

<property>
  <name>hive.metastore.ds.connection.url.hook</name>
  <value></value>
  <description>Name of the hook to use for retriving the JDO connection URL. If empty, the value in javax.jdo.option.ConnectionURL is used </description>
</property>

<property>
  <name>hive.metastore.ds.retry.attempts</name>
  <value>1</value>
  <description>The number of times to retry a metastore call if there were a connection error</description>
</property>

<property>
   <name>hive.metastore.ds.retry.interval</name>
   <value>1000</value>
   <description>The number of miliseconds between metastore retry attempts</description>
</property>

<property>
  <name>hive.metastore.server.min.threads</name>
  <value>200</value>
  <description>Minimum number of worker threads in the Thrift server's pool.</description>
</property>

<property>
  <name>hive.metastore.server.max.threads</name>
  <value>100000</value>
  <description>Maximum number of worker threads in the Thrift server's pool.</description>
</property>

<property>
  <name>hive.metastore.server.tcp.keepalive</name>
  <value>true</value>
  <description>Whether to enable TCP keepalive for the metastore server. Keepalive will prevent accumulation of half-open connections.</description>
</property>

<property>
  <name>hive.metastore.sasl.enabled</name>
  <value>false</value>
  <description>If true, the metastore thrift interface will be secured with SASL. Clients must authenticate with Kerberos.</description>
</property>

<property>
  <name>hive.metastore.kerberos.keytab.file</name>
  <value></value>
  <description>The path to the Kerberos Keytab file containing the metastore thrift server's service principal.</description>
</property>

<property>
  <name>hive.metastore.kerberos.principal</name>
  <value>hive-metastore/_HOST@EXAMPLE.COM</value>
  <description>The service principal for the metastore thrift server. The special string _HOST will be replaced automatically with the correct host name.</description>
</property>

<property>
  <name>hive.metastore.cache.pinobjtypes</name>
  <value>Table,StorageDescriptor,SerDeInfo,Partition,Database,Type,FieldSchema,Order</value>
  <description>List of comma separated metastore object types that should be pinned in the cache</description>
</property>

<property>
  <name>hive.optimize.reducededuplication</name>
  <value>true</value>
  <description>Remove extra map-reduce jobs if the data is already clustered by the same key which needs to be used again. This should always be set to true. Since it is a new feature, it has been made configurable.</description>
</property>

<property>
  <name>hive.exec.dynamic.partition</name>
  <value>false</value>
  <description>Whether or not to allow dynamic partitions in DML/DDL.</description>
</property>

<property>
  <name>hive.exec.dynamic.partition.mode</name>
  <value>strict</value>
  <description>In strict mode, the user must specify at least one static partition in case the user accidentally overwrites all partitions.</description>
</property>

<property>
  <name>hive.exec.max.dynamic.partitions</name>
  <value>1000</value>
  <description>Maximum number of dynamic partitions allowed to be created in total.</description>
</property>

<property>
  <name>hive.exec.max.dynamic.partitions.pernode</name>
  <value>100</value>
  <description>Maximum number of dynamic partitions allowed to be created in each mapper/reducer node.</description>
</property>

<property>
  <name>hive.exec.max.created.files</name>
  <value>100000</value>
  <description>Maximum number of HDFS files created by all mappers/reducers in a MapReduce job.</description>
</property>

<property>
  <name>hive.exec.default.partition.name</name>
  <value>__HIVE_DEFAULT_PARTITION__</value>
  <description>The default partition name in case the dynamic partition column value is null/empty string or anyother values that cannot be escaped. This value must not contain any special character used in HDFS URI (e.g., ':', '%', '/' etc). The user has to be aware that the dynamic partition value should not contain this value to avoid confusions.</description>
</property>

<property>
  <name>hive.stats.dbclass</name>
  <value>jdbc:derby</value>
  <description>The default database that stores temporary hive statistics.</description>
</property>

<property>
  <name>hive.stats.autogather</name>
  <value>true</value>
  <description>A flag to gather statistics automatically during the INSERT OVERWRITE command.</description>
</property>

<property>
  <name>hive.stats.jdbcdriver</name>
  <value>org.apache.derby.jdbc.EmbeddedDriver</value>
  <description>The JDBC driver for the database that stores temporary hive statistics.</description>
</property>

<property>
  <name>hive.stats.dbconnectionstring</name>
  <value>jdbc:derby:;databaseName=TempStatsStore;create=true</value>
  <description>The default connection string for the database that stores temporary hive statistics.</description>
</property>

<property>
  <name>hive.stats.default.publisher</name>
  <value></value>
  <description>The Java class (implementing the StatsPublisher interface) that is used by default if hive.stats.dbclass is not JDBC or HBase.</description>
</property>

<property>
  <name>hive.stats.default.aggregator</name>
  <value></value>
  <description>The Java class (implementing the StatsAggregator interface) that is used by default if hive.stats.dbclass is not JDBC or HBase.</description>
</property>

<property>
  <name>hive.stats.jdbc.timeout</name>
  <value>30</value>
  <description>Timeout value (number of seconds) used by JDBC connection and statements.</description>
</property>

<property>
  <name>hive.stats.jdbc.atomic</name>
  <value>false</value>
  <description>If this is set to true then the metastore stats will be updated only if all types of stats (# of rows, # of files, # of bytes etc.) are available. Otherwise metastore stats are updated in a best effort fashion with whatever are available.</description>
</property>

<property>
  <name>hive.support.concurrency</name>
  <value>false</value>
  <description>Whether hive supports concurrency or not. A zookeeper instance must be up and running for the default hive lock manager to support read-write locks.</description>
</property>

<property>
  <name>hive.concurrency.manager</name>
  <value>org.apache.hadoop.hive.ql.lockmgr.ZooKeeperLockMgr</value>
  <description>The concurrency manager for hive.</description>
</property>

<property>
  <name>hive.lock.numretries</name>
  <value>100</value>
  <description>The number of times you want to try to get all the locks</description>
</property>

<property>
  <name>hive.lock.sleep.between.retries</name>
  <value>60</value>
  <description>The sleep time (in seconds) between various retries</description>
</property>

<property>
  <name>hive.zookeeper.quorum</name>
  <value></value>
  <description>The list of zookeeper servers to talk to. This is only needed for read/write locks.</description>
</property>

<property>
  <name>hive.zookeeper.client.port</name>
  <value>2181</value>
  <description>The port of zookeeper servers to talk to. This is only needed for read/write locks.</description>
</property>

<property>
  <name>hive.zookeeper.session.timeout</name>
  <value></value>
  <description>Zookeeper client's session timeout. The client is disconnected, and as a result, all locks released, if a heartbeat is not sent in the timeout.</description>
</property>

<property>
  <name>hive.zookeeper.namespace</name>
  <value>hive_zookeeper_namespace</value>
  <description>The parent node under which all zookeeper nodes are created.</description>
</property>

<property>
  <name>hive.zookeeper.clean.extra.nodes</name>
  <value>false</value>
  <description>Clean extra nodes at the end of the session.</description>
</property>

<property>
  <name>fs.har.impl</name>
  <value>org.apache.hadoop.hive.shims.HiveHarFileSystem</value>
  <description>The implementation for accessing Hadoop Archives. Note that this won't be applicable to Hadoop vers less than 0.20</description>
</property>

<property>
  <name>hive.archive.enabled</name>
  <value>false</value>
  <description>Whether archiving operations are permitted</description>
</property>

<property>
  <name>hive.archive.har.parentdir.settable</name>
  <value>false</value>
  <description>In new Hadoop versions, the parent directory must be set while
  creating a HAR. Because this functionality is hard to detect with just version
  numbers, this conf var needs to be set manually.</description>
</property>

<property>
  <name>hive.fetch.output.serde</name>
  <value>org.apache.hadoop.hive.serde2.DelimitedJSONSerDe</value>
  <description>The serde used by FetchTask to serialize the fetch output.</description>
</property>

<property>
  <name>hive.exec.mode.local.auto</name>
  <value>false</value>
  <description> Let hive determine whether to run in local mode automatically </description>
</property>

<property>
  <name>hive.exec.drop.ignorenonexistent</name>
  <value>true</value>
  <description>
    Do not report an error if DROP TABLE/VIEW specifies a non-existent table/view
  </description>
</property>

<property>
  <name>hive.exec.show.job.failure.debug.info</name>
  <value>false</value>
  <description>
  	If a job fails, whether to provide a link in the CLI to the task with the
  	most failures, along with debugging hints if applicable.
  </description>
</property>

<property>
  <name>hive.auto.progress.timeout</name>
  <value>0</value>
  <description>
    How long to run autoprogressor for the script/UDTF operators (in seconds).
    Set to 0 for forever.
  </description>
</property>

<!-- HBase Storage Handler Parameters -->

<property>
  <name>hive.hbase.wal.enabled</name>
  <value>true</value>
  <description>Whether writes to HBase should be forced to the write-ahead log.  Disabling this improves HBase write performance at the risk of lost writes in case of a crash.</description>
</property>

<property>
  <name>hive.table.parameters.default</name>
  <value></value>
  <description>Default property values for newly created tables</description>
</property>

<property>
  <name>hive.variable.substitute</name>
  <value>true</value>
  <description>This enables substitution using syntax like ${var} ${system:var} and ${env:var}.</description>
</property>

<property>
  <name>hive.security.authorization.enabled</name>
  <value>false</value>
  <description>enable or disable the hive client authorization</description>
</property>

<property>
  <name>hive.security.authorization.manager</name>
  <value>org.apache.hadoop.hive.ql.security.authorization.DefaultHiveAuthorizationProvider</value>
  <description>the hive client authorization manager class name.
  The user defined authorization class should implement interface org.apache.hadoop.hive.ql.security.authorization.HiveAuthorizationProvider.
  </description>
</property>

<property>
  <name>hive.security.authenticator.manager</name>
  <value>org.apache.hadoop.hive.ql.security.HadoopDefaultAuthenticator</value>
  <description>hive client authenticator manager class name.
  The user defined authenticator should implement interface org.apache.hadoop.hive.ql.security.HiveAuthenticationProvider.</description>
</property>

<property>
  <name>hive.security.authorization.createtable.user.grants</name>
  <value></value>
  <description>the privileges automatically granted to some users whenever a table gets created.
   An example like "userX,userY:select;userZ:create" will grant select privilege to userX and userY,
   and grant create privilege to userZ whenever a new table created.</description>
</property>

<property>
  <name>hive.security.authorization.createtable.group.grants</name>
  <value></value>
  <description>the privileges automatically granted to some groups whenever a table gets created.
   An example like "groupX,groupY:select;groupZ:create" will grant select privilege to groupX and groupY,
   and grant create privilege to groupZ whenever a new table created.</description>
</property>

<property>
  <name>hive.security.authorization.createtable.role.grants</name>
  <value></value>
  <description>the privileges automatically granted to some roles whenever a table gets created.
   An example like "roleX,roleY:select;roleZ:create" will grant select privilege to roleX and roleY,
   and grant create privilege to roleZ whenever a new table created.</description>
</property>

<property>
  <name>hive.security.authorization.createtable.owner.grants</name>
  <value></value>
  <description>the privileges automatically granted to the owner whenever a table gets created.
   An example like "select,drop" will grant select and drop privilege to the owner of the table</description>
</property>

<property>
  <name>hive.error.on.empty.partition</name>
  <value>false</value>
  <description>Whether to throw an excpetion if dynamic partition insert generates empty results.</description>
</property>

<property>
  <name>hive.index.compact.file.ignore.hdfs</name>
  <value>false</value>
  <description>True the hdfs location stored in the index file will be igbored at runtime.
  If the data got moved or the name of the cluster got changed, the index data should still be usable.</description>
</property>

</configuration>


text:
module MultipleMan::Consumers
  class Seed < General

    private

    def operation(_, _)
      "create"
    end

    def routing_key_for_subscriber(subscriber)
      subscriber.routing_key(:seed)
    end

  end
end


text:
require 'spec_helper'

describe DummyController do
  render_views
  context 'show the pay button' do
    before { get :index }
    it { should respond_with :success }
    it { should render_template :index }
    it 'should contain the form' do
      response.body.should have_xpath './/form[@action="https://secure.payza.com/checkout"]'
    end
    it 'should contain ap_purchasetype' do
      response.body.should have_xpath './/input[@name="ap_purchasetype"]'
    end
    it 'should contain ap_merchant' do
      response.body.should have_xpath './/input[@name="ap_merchant"]'
    end
    it 'should contain ap_itemname' do
      response.body.should have_xpath './/input[@name="ap_itemname"]'
    end
    it 'should contain ap_currency' do
      response.body.should have_xpath './/input[@name="ap_currency"]'
    end
    it 'should contain ap_amount' do
      response.body.should have_xpath './/input[@name="ap_amount"]'
    end
    it 'should contain ap_description' do
      response.body.should have_xpath './/input[@name="ap_description"]'
    end
    it 'should contain ap_returnurl' do
      response.body.should have_xpath './/input[@name="ap_returnurl"]'
    end
    it 'should contain ap_cancelurl' do
      response.body.should have_xpath './/input[@name="ap_cancelurl"]'
    end
    it 'should contain apc_1' do
      response.body.should have_xpath './/input[@name="apc_1"]'
    end
    it 'should contain ap_image' do
      response.body.should have_xpath './/input[@name="ap_image"]'
    end
  end

  context 'post an ipn request' do
    before { post :ipn_notification, { token: 'jkfhaugf9wuflegfbasf=='} }
    it { should respond_with :success }
    it 'should be an invalid token' do
      assigns(:response).should == 'INVALID REQUEST'
    end
  end
end