text:
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using OpenRiaServices.DomainServices;

namespace OpenRiaServices.DomainServices.Tools.SharedTypes
{
    /// <summary>
    /// Internal class to maintain a set of known assemblies
    /// and allow clients to ask whether types or methods are
    /// in that set.
    /// </summary>
    internal class SharedAssemblies
    {
        private readonly List<string> _assemblyFileNames;
        private List<Assembly> _assemblies;
        private readonly IEnumerable<string> _assemblySearchPaths;
        private readonly ConcurrentDictionary<string, Type> _sharedTypeByName = new ConcurrentDictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
        private readonly ILogger _logger;

        /// <summary>
        /// Creates a new instance of this type.
        /// </summary>
        /// <param name="assemblyFileNames">The set of assemblies to use</param>
        /// <param name="assemblySearchPaths">Optional set of paths to search for referenced assemblies.</param>
        /// <param name="logger">Optional logger to use to report errors or warnings</param>
        internal SharedAssemblies(IEnumerable<string> assemblyFileNames, IEnumerable<string> assemblySearchPaths, ILogger logger)
        {
            if (assemblyFileNames == null)
            {
                throw new ArgumentNullException("assemblyFileNames");
            }
            this._logger = logger;
            this._assemblyFileNames = new List<string>(assemblyFileNames);
            this._assemblySearchPaths = assemblySearchPaths ?? new string[0];
        }

        /// <summary>
        /// Gets the set of loaded assemblies
        /// </summary>
        private IEnumerable<Assembly> Assemblies
        {
            get
            {
                if (this._assemblies == null)
                {
                    this.LoadAssemblies();
                }
                return this._assemblies;
            }
        }

        /// <summary>
        /// Returns the location of the shared assembly containing the
        /// code member described by <paramref name="key"/>.
        /// </summary>
        /// <param name="key">The description of the code element.</param>
        /// <returns>The location of the assembly that contains it or <c>null</c> if it is not in a shared assembly.</returns>
        internal string GetSharedAssemblyPath(CodeMemberKey key)
        {
            Debug.Assert(key != null, "key cannot be null");
            string location = null;

            Type type = this.GetSharedType(key.TypeName);
            if (type != null)
            {
                switch (key.KeyKind)
                {
                    case CodeMemberKey.CodeMemberKeyKind.TypeKey:
                        location = type.Assembly.Location;
                        break;

                    case CodeMemberKey.CodeMemberKeyKind.PropertyKey:
                        PropertyInfo propertyInfo = type.GetProperty(key.MemberName);
                        if (propertyInfo != null)
                        {
                            location = propertyInfo.DeclaringType.Assembly.Location;
                        }
                        break;

                    case CodeMemberKey.CodeMemberKeyKind.MethodKey:
                        Type[] parameterTypes = this.GetSharedTypes(key.ParameterTypeNames);
                        if (parameterTypes != null)
                        {
                            MethodBase methodBase = this.FindSharedMethodOrConstructor(type, key);
                            if (methodBase != null)
                            {
                                location = methodBase.DeclaringType.Assembly.Location;
                            }
                        }
                        break;

                    default:
                        Debug.Fail("unsupported key kind");
                        break;
                }
            }
            return location;
        }

        /// <summary>
        /// Locates the <see cref="MethodBase"/> in the set of shared assemblies that
        /// corresponds to the method described by <paramref name="key"/>.
        /// </summary>
        /// <param name="sharedType">The <see cref="Type"/> we have already located in our set of shared assemblies.</param>
        /// <param name="key">The key describing the method to find.</param>
        /// <returns>The matching <see cref="MethodBase"/> or <c>null</c> if no match is found.</returns>
        private MethodBase FindSharedMethodOrConstructor(Type sharedType, CodeMemberKey key)
        {
            Type[] parameterTypes = this.GetSharedTypes(key.ParameterTypeNames);
            if (parameterTypes == null)
            {
                return null;
            }
            bool isConstructor = key.IsConstructor;
            IEnumerable<MethodBase> methods = isConstructor ? sharedType.GetConstructors().Cast<MethodBase>() : sharedType.GetMethods().Cast<MethodBase>();
            foreach (MethodBase method in methods)
            {
                if (!isConstructor && !string.Equals(method.Name, key.MemberName, StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }
                ParameterInfo[] parameterInfos = method.GetParameters();
                if (parameterInfos.Length != parameterTypes.Length)
                {
                    continue;
                }
                int matchedParameters = 0;
                for (int i = 0; i < parameterInfos.Length; ++i)
                {
                    if (string.Equals(parameterInfos[i].ParameterType.FullName, parameterTypes[i].FullName, StringComparison.OrdinalIgnoreCase))
                    {
                        ++matchedParameters;
                    }
                    else
                    {
                        break;
                    }
                }

                if (matchedParameters == parameterInfos.Length)
                {
                    return method;
                }
            }
            return null;
        }

        /// <summary>
        /// Given a collection of <see cref="Type"/> names, this method returns
        /// an array of all those types from the set of shared assemblies.
        /// </summary>
        /// <param name="typeNames">The collection of type names.  It can be null.</param>
        /// <returns>The collection of types in the shared assemblies.
        /// A <c>null</c> means one or more types in the list were not shared.</returns>
        private Type[] GetSharedTypes(IEnumerable<string> typeNames)
        {
            List<Type> types = new List<Type>();
            if (typeNames != null)
            {
                foreach (string typeName in typeNames)
                {
                    Type type = this.GetSharedType(typeName);
                    if (type == null)
                    {
                        return null;
                    }
                    types.Add(type);
                }
            }
            return types.ToArray();
        }

        /// <summary>
        /// Returns the <see cref="MethodBase"/> of the method or constructor from the
        /// set of shared assemblies, if it exists.
        /// </summary>
        /// <param name="typeName">The fully qualified type name declaring the method.</param>
        /// <param name="methodName">The name of the method</param>
        /// <param name="parameterTypeNames">The fully qualified type names of the method parameters.</param>
        /// <returns>The <see cref="MethodBase"/> if it exists in the shared assemblies, otherwise <c>null</c></returns>
        internal MethodBase GetSharedMethod(string typeName, string methodName, IEnumerable<string> parameterTypeNames)
        {
            Debug.Assert(!string.IsNullOrEmpty(typeName), "typeName cannot be null");
            Debug.Assert(!string.IsNullOrEmpty(methodName), "methodName cannot be null");

            MethodBase sharedMethod = null;
            Type sharedType = this.GetSharedType(typeName);
            if (sharedType != null)
            {
                CodeMemberKey key = CodeMemberKey.CreateMethodKey(typeName, methodName, parameterTypeNames == null ? new string[0] : parameterTypeNames.ToArray());
                sharedMethod = this.FindSharedMethodOrConstructor(sharedType, key);
            }

            return sharedMethod;
        }

        /// <summary>
        /// Returns the <see cref="Type"/> from the set of shared assemblies of the given name.
        /// </summary>
        /// <param name="typeName">The fully qualified type name.</param>
        /// <returns>The <see cref="Type"/> from the shared assemblies if it exists, otherwise <c>null</c>.</returns>
        internal Type GetSharedType(string typeName)
        {
            Type sharedType = this._sharedTypeByName.GetOrAdd(typeName, n =>
            {
                return this.FindSharedType(n);
            });
            return sharedType;
        }

        /// <summary>
        /// If the given type is defined in a system assembly, returns the type directly, otherwise <c>null</c>.
        /// </summary>
        /// <param name="type">The type whose equivalent we need.</param>
        /// <returns>If the type lives in a system assembly, the input type, else <c>null</c>.</returns>
        private static Type EquivalentMsCorlibType(Type type)
        {
            if (AssemblyUtilities.IsAssemblyMsCorlib(type.Assembly.GetName()))
            {
                // For now, only a core set of predefined system types are assumed to be supported
                return TypeUtility.IsPredefinedType(type) ? type : null;
            }

            return null;
        }

        /// <summary>
        /// Searches the shared assemblies for a type of the given name.
        /// </summary>
        /// <param name="typeName">The fully-qualified type name.</param>
        /// <returns>The <see cref="Type"/> or <c>null</c> if it is not in one of the shared assemblies.</returns>
        private Type FindSharedType(string typeName)
        {
            Type type = Type.GetType(typeName, /*throwOnError*/ false);
            if (type != null)
            {
                Type result = FindSharedTypeInAssemblies(type.FullName);
                if (result != null)
                    return result;

                // TODO: review
                // If we could not find the type, but it lives in mscorlib,
                // we treat it specially because we cannot load mscorlib to tell.
                return EquivalentMsCorlibType(type);
            }

            return FindSharedTypeInAssemblies(typeName);
        }

        /// <summary>
        /// Locates and returns the type in the set of known assemblies
        /// that is equivalent to the given type.
        /// </summary>
        /// <param name="typeFullName">FullName of the type to search for</param>
        private Type FindSharedTypeInAssemblies(string typeFullName)
        {
            foreach (Assembly assembly in this.Assemblies)
            {
                // Utility autorecovers and logs known common exceptions
                IEnumerable<Type> types = AssemblyUtilities.GetExportedTypes(assembly, this._logger);

                foreach (Type searchType in types)
                {
                    if (string.Equals(typeFullName, searchType.FullName, StringComparison.Ordinal))
                    {
                        return searchType;
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Loads all the named assemblies into a cache of known assemblies
        /// </summary>
        private void LoadAssemblies()
        {
            this._assemblies = new List<Assembly>();
            Dictionary<string, Assembly> loadedAssemblies = new Dictionary<string, Assembly>();
            foreach (string file in this._assemblyFileNames)
            {
                // Pass 1 -- load all the assemblies we have been given.  No referenced assemblies yet.
                Assembly assembly = AssemblyUtilities.ReflectionOnlyLoadFrom(file, this._logger);
                if (assembly != null)
                {
                    this._assemblies.Add(assembly);

                    // Keep track of loaded assemblies for next step
                    loadedAssemblies[assembly.FullName] = assembly;
                }
            }

            // Pass 2 -- recursively load all reference assemblies from the assemblies we loaded.
            foreach (Assembly assembly in this._assemblies)
            {
                AssemblyUtilities.ReflectionOnlyLoadReferences(assembly, this._assemblySearchPaths, loadedAssemblies, /*recursive*/ true, this._logger);
            }
        }
    }
}


text:
module Errdo
  module Models
    class ErrorEnvParser

      attr_accessor :exception_class_name, :exception_message, :http_method,
                    :host_name, :url, :backtrace, :ip, :user_agent, :referer,
                    :query_string, :param_values, :cookie_values, :header_values,
                    :experiencer_id, :experiencer_type

      def initialize(env, user_parser)
        set_accessible_params(
          env,
          ActionDispatch::Request.new(env),
          env["action_controller.instance"],
          user_parser.user
        )
      end

      def error_hash
        {
          exception_class_name:   @exception_class_name,
          exception_message:      @exception_message,
          http_method:            @http_method,
          host_name:              @host_name,
          url:                    @url,
          backtrace:              @backtrace,
          last_experiencer_id:    @experiencer_id,
          last_experiencer_type:  @experiencer_type
        }
      end

      def error_occurrence_hash
        {
          ip:                   @ip,
          user_agent:           @user_agent,
          referer:              @referer,
          query_string:         @query_string,
          param_values:         @param_values,
          cookie_values:        @cookie_values,
          header_values:        @header_values,
          experiencer_id:       @experiencer_id,
          experiencer_type:     @experiencer_type
        }
      end

      def exception_name
        @exception_class_name
      end

      def short_backtrace
        @backtrace.first if @backtrace.respond_to?(:first)
      end

      def user
        @experiencer_type.constantize.find_by(id: @experiencer_id) if @experiencer_type && Errdo.error_name
      end

      private

      def set_accessible_params(env, request, controller, new_user)
        @exception_class_name = env["action_dispatch.exception"].class.to_s
        @exception_message =    env["action_dispatch.exception"].try(:message)
        @http_method =          deep_utf8_scrub(request.try(:request_method))
        @host_name =            deep_utf8_scrub(request.try(:server_name))
        @url =                  deep_utf8_scrub(request.try(:original_url))
        @backtrace =            prepare_backtrace(env)
        @ip =                   request.try(:ip)
        @user_agent =           deep_utf8_scrub(request.try(:user_agent))
        @referer =              request.try(:referer)
        @query_string =         deep_utf8_scrub(request.try(:query_string))
        @param_values =         deep_utf8_scrub(scrubbed_params(request))
        @cookie_values =        deep_utf8_scrub(request.try(:cookies))
        @header_values =        deep_utf8_scrub(controller.try(:headers))
        @experiencer_id =       new_user.try(:id)
        @experiencer_type =     new_user.try(:class).try(:name)
      end

      def prepare_backtrace(env)
        env["action_dispatch.exception"].try(:backtrace)
      end

      def scrubbed_params(request)
        params = request.try(:params) || {}
        Errdo.dirty_words.each do |word|
          params[word] = "..." if params[word]
        end
        # Remove all files
        params.each do |key, value|
          params[key] = value.headers if value.is_a? ActionDispatch::Http::UploadedFile
        end
        params
      end

      def deep_utf8_scrub(obj)
        if obj.respond_to? :each
          obj.each { |o| deep_utf8_scrub(o) }
        end
        if obj.is_a? String
          obj = obj.scrub!
        end
        return obj
      end

    end
  end
end

redpajama_set_name: RedPajamaGithub


text:
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace ArchiSteamFarm.Localization {
    using System;

    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    public class Strings {

        private static System.Resources.ResourceManager resourceMan;

        private static System.Globalization.CultureInfo resourceCulture;

        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Strings() {
        }

        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
        public static System.Resources.ResourceManager ResourceManager {
            get {
                if (object.Equals(null, resourceMan)) {
                    System.Resources.ResourceManager temp = new System.Resources.ResourceManager("ArchiSteamFarm.Localization.Strings", typeof(Strings).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }

        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
        public static System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }

        public static string AcceptingTrade {
            get {
                return ResourceManager.GetString("AcceptingTrade", resourceCulture);
            }
        }

        public static string AutoUpdateCheckInfo {
            get {
                return ResourceManager.GetString("AutoUpdateCheckInfo", resourceCulture);
            }
        }

        public static string Content {
            get {
                return ResourceManager.GetString("Content", resourceCulture);
            }
        }

        public static string ErrorConfigPropertyInvalid {
            get {
                return ResourceManager.GetString("ErrorConfigPropertyInvalid", resourceCulture);
            }
        }

        public static string ErrorEarlyFatalExceptionInfo {
            get {
                return ResourceManager.GetString("ErrorEarlyFatalExceptionInfo", resourceCulture);
            }
        }

        public static string ErrorEarlyFatalExceptionPrint {
            get {
                return ResourceManager.GetString("ErrorEarlyFatalExceptionPrint", resourceCulture);
            }
        }

        public static string ErrorExitingWithNonZeroErrorCode {
            get {
                return ResourceManager.GetString("ErrorExitingWithNonZeroErrorCode", resourceCulture);
            }
        }

        public static string ErrorFailingRequest {
            get {
                return ResourceManager.GetString("ErrorFailingRequest", resourceCulture);
            }
        }

        public static string ErrorGlobalConfigNotLoaded {
            get {
                return ResourceManager.GetString("ErrorGlobalConfigNotLoaded", resourceCulture);
            }
        }

        public static string ErrorIsInvalid {
            get {
                return ResourceManager.GetString("ErrorIsInvalid", resourceCulture);
            }
        }

        public static string ErrorNoBotsDefined {
            get {
                return ResourceManager.GetString("ErrorNoBotsDefined", resourceCulture);
            }
        }

        public static string ErrorObjectIsNull {
            get {
                return ResourceManager.GetString("ErrorObjectIsNull", resourceCulture);
            }
        }

        public static string ErrorParsingObject {
            get {
                return ResourceManager.GetString("ErrorParsingObject", resourceCulture);
            }
        }

        public static string ErrorRequestFailedTooManyTimes {
            get {
                return ResourceManager.GetString("ErrorRequestFailedTooManyTimes", resourceCulture);
            }
        }

        public static string ErrorUpdateCheckFailed {
            get {
                return ResourceManager.GetString("ErrorUpdateCheckFailed", resourceCulture);
            }
        }

        public static string ErrorUpdateNoAssetForThisVersion {
            get {
                return ResourceManager.GetString("ErrorUpdateNoAssetForThisVersion", resourceCulture);
            }
        }

        public static string ErrorUpdateNoAssets {
            get {
                return ResourceManager.GetString("ErrorUpdateNoAssets", resourceCulture);
            }
        }

        public static string ErrorUserInputRunningInHeadlessMode {
            get {
                return ResourceManager.GetString("ErrorUserInputRunningInHeadlessMode", resourceCulture);
            }
        }

        public static string Exiting {
            get {
                return ResourceManager.GetString("Exiting", resourceCulture);
            }
        }

        public static string WarningFailed {
            get {
                return ResourceManager.GetString("WarningFailed", resourceCulture);
            }
        }

        public static string GlobalConfigChanged {
            get {
                return ResourceManager.GetString("GlobalConfigChanged", resourceCulture);
            }
        }

        public static string ErrorGlobalConfigRemoved {
            get {
                return ResourceManager.GetString("ErrorGlobalConfigRemoved", resourceCulture);
            }
        }

        public static string IgnoringTrade {
            get {
                return ResourceManager.GetString("IgnoringTrade", resourceCulture);
            }
        }

        public static string LoggingIn {
            get {
                return ResourceManager.GetString("LoggingIn", resourceCulture);
            }
        }

        public static string NoBotsAreRunning {
            get {
                return ResourceManager.GetString("NoBotsAreRunning", resourceCulture);
            }
        }

        public static string RefreshingOurSession {
            get {
                return ResourceManager.GetString("RefreshingOurSession", resourceCulture);
            }
        }

        public static string RejectingTrade {
            get {
                return ResourceManager.GetString("RejectingTrade", resourceCulture);
            }
        }

        public static string Restarting {
            get {
                return ResourceManager.GetString("Restarting", resourceCulture);
            }
        }

        public static string Starting {
            get {
                return ResourceManager.GetString("Starting", resourceCulture);
            }
        }

        public static string Success {
            get {
                return ResourceManager.GetString("Success", resourceCulture);
            }
        }

        public static string UnlockingParentalAccount {
            get {
                return ResourceManager.GetString("UnlockingParentalAccount", resourceCulture);
            }
        }

        public static string UpdateCheckingNewVersion {
            get {
                return ResourceManager.GetString("UpdateCheckingNewVersion", resourceCulture);
            }
        }

        public static string UpdateDownloadingNewVersion {
            get {
                return ResourceManager.GetString("UpdateDownloadingNewVersion", resourceCulture);
            }
        }

        public static string UpdateFinished {
            get {
                return ResourceManager.GetString("UpdateFinished", resourceCulture);
            }
        }

        public static string UpdateNewVersionAvailable {
            get {
                return ResourceManager.GetString("UpdateNewVersionAvailable", resourceCulture);
            }
        }

        public static string UpdateVersionInfo {
            get {
                return ResourceManager.GetString("UpdateVersionInfo", resourceCulture);
            }
        }

        public static string UserInputSteam2FA {
            get {
                return ResourceManager.GetString("UserInputSteam2FA", resourceCulture);
            }
        }

        public static string UserInputSteamGuard {
            get {
                return ResourceManager.GetString("UserInputSteamGuard", resourceCulture);
            }
        }

        public static string UserInputSteamLogin {
            get {
                return ResourceManager.GetString("UserInputSteamLogin", resourceCulture);
            }
        }

        public static string UserInputSteamParentalCode {
            get {
                return ResourceManager.GetString("UserInputSteamParentalCode", resourceCulture);
            }
        }

        public static string UserInputSteamPassword {
            get {
                return ResourceManager.GetString("UserInputSteamPassword", resourceCulture);
            }
        }

        public static string WarningUnknownValuePleaseReport {
            get {
                return ResourceManager.GetString("WarningUnknownValuePleaseReport", resourceCulture);
            }
        }

        public static string IPCReady {
            get {
                return ResourceManager.GetString("IPCReady", resourceCulture);
            }
        }

        public static string IPCStarting {
            get {
                return ResourceManager.GetString("IPCStarting", resourceCulture);
            }
        }

        public static string BotAlreadyStopped {
            get {
                return ResourceManager.GetString("BotAlreadyStopped", resourceCulture);
            }
        }

        public static string BotNotFound {
            get {
                return ResourceManager.GetString("BotNotFound", resourceCulture);
            }
        }

        public static string BotStatusOverview {
            get {
                return ResourceManager.GetString("BotStatusOverview", resourceCulture);
            }
        }

        public static string BotStatusIdling {
            get {
                return ResourceManager.GetString("BotStatusIdling", resourceCulture);
            }
        }

        public static string BotStatusIdlingList {
            get {
                return ResourceManager.GetString("BotStatusIdlingList", resourceCulture);
            }
        }

        public static string CheckingFirstBadgePage {
            get {
                return ResourceManager.GetString("CheckingFirstBadgePage", resourceCulture);
            }
        }

        public static string CheckingOtherBadgePages {
            get {
                return ResourceManager.GetString("CheckingOtherBadgePages", resourceCulture);
            }
        }

        public static string ChosenFarmingAlgorithm {
            get {
                return ResourceManager.GetString("ChosenFarmingAlgorithm", resourceCulture);
            }
        }

        public static string Done {
            get {
                return ResourceManager.GetString("Done", resourceCulture);
            }
        }

        public static string GamesToIdle {
            get {
                return ResourceManager.GetString("GamesToIdle", resourceCulture);
            }
        }

        public static string IdlingFinished {
            get {
                return ResourceManager.GetString("IdlingFinished", resourceCulture);
            }
        }

        public static string IdlingFinishedForGame {
            get {
                return ResourceManager.GetString("IdlingFinishedForGame", resourceCulture);
            }
        }

        public static string IdlingFinishedForGames {
            get {
                return ResourceManager.GetString("IdlingFinishedForGames", resourceCulture);
            }
        }

        public static string IdlingStatusForGame {
            get {
                return ResourceManager.GetString("IdlingStatusForGame", resourceCulture);
            }
        }

        public static string IdlingStopped {
            get {
                return ResourceManager.GetString("IdlingStopped", resourceCulture);
            }
        }

        public static string IgnoredPermanentPauseEnabled {
            get {
                return ResourceManager.GetString("IgnoredPermanentPauseEnabled", resourceCulture);
            }
        }

        public static string NothingToIdle {
            get {
                return ResourceManager.GetString("NothingToIdle", resourceCulture);
            }
        }

        public static string NowIdling {
            get {
                return ResourceManager.GetString("NowIdling", resourceCulture);
            }
        }

        public static string NowIdlingList {
            get {
                return ResourceManager.GetString("NowIdlingList", resourceCulture);
            }
        }

        public static string PlayingNotAvailable {
            get {
                return ResourceManager.GetString("PlayingNotAvailable", resourceCulture);
            }
        }

        public static string StillIdling {
            get {
                return ResourceManager.GetString("StillIdling", resourceCulture);
            }
        }

        public static string StillIdlingList {
            get {
                return ResourceManager.GetString("StillIdlingList", resourceCulture);
            }
        }

        public static string StoppedIdling {
            get {
                return ResourceManager.GetString("StoppedIdling", resourceCulture);
            }
        }

        public static string StoppedIdlingList {
            get {
                return ResourceManager.GetString("StoppedIdlingList", resourceCulture);
            }
        }

        public static string UnknownCommand {
            get {
                return ResourceManager.GetString("UnknownCommand", resourceCulture);
            }
        }

        public static string WarningCouldNotCheckBadges {
            get {
                return ResourceManager.GetString("WarningCouldNotCheckBadges", resourceCulture);
            }
        }

        public static string WarningCouldNotCheckCardsStatus {
            get {
                return ResourceManager.GetString("WarningCouldNotCheckCardsStatus", resourceCulture);
            }
        }

        public static string BotAcceptingGift {
            get {
                return ResourceManager.GetString("BotAcceptingGift", resourceCulture);
            }
        }

        public static string BotAccountLimited {
            get {
                return ResourceManager.GetString("BotAccountLimited", resourceCulture);
            }
        }

        public static string BotAddLicense {
            get {
                return ResourceManager.GetString("BotAddLicense", resourceCulture);
            }
        }

        public static string BotAddLicenseWithItems {
            get {
                return ResourceManager.GetString("BotAddLicenseWithItems", resourceCulture);
            }
        }

        public static string BotAlreadyRunning {
            get {
                return ResourceManager.GetString("BotAlreadyRunning", resourceCulture);
            }
        }

        public static string BotAuthenticatorConverting {
            get {
                return ResourceManager.GetString("BotAuthenticatorConverting", resourceCulture);
            }
        }

        public static string BotAuthenticatorImportFinished {
            get {
                return ResourceManager.GetString("BotAuthenticatorImportFinished", resourceCulture);
            }
        }

        public static string BotAuthenticatorToken {
            get {
                return ResourceManager.GetString("BotAuthenticatorToken", resourceCulture);
            }
        }

        public static string BotAutomaticIdlingNowPaused {
            get {
                return ResourceManager.GetString("BotAutomaticIdlingNowPaused", resourceCulture);
            }
        }

        public static string BotAutomaticIdlingNowResumed {
            get {
                return ResourceManager.GetString("BotAutomaticIdlingNowResumed", resourceCulture);
            }
        }

        public static string BotAutomaticIdlingPausedAlready {
            get {
                return ResourceManager.GetString("BotAutomaticIdlingPausedAlready", resourceCulture);
            }
        }

        public static string BotAutomaticIdlingResumedAlready {
            get {
                return ResourceManager.GetString("BotAutomaticIdlingResumedAlready", resourceCulture);
            }
        }

        public static string BotConnected {
            get {
                return ResourceManager.GetString("BotConnected", resourceCulture);
            }
        }

        public static string BotDisconnected {
            get {
                return ResourceManager.GetString("BotDisconnected", resourceCulture);
            }
        }

        public static string BotDisconnecting {
            get {
                return ResourceManager.GetString("BotDisconnecting", resourceCulture);
            }
        }

        public static string BotEncryptedPassword {
            get {
                return ResourceManager.GetString("BotEncryptedPassword", resourceCulture);
            }
        }

        public static string BotInstanceNotStartingBecauseDisabled {
            get {
                return ResourceManager.GetString("BotInstanceNotStartingBecauseDisabled", resourceCulture);
            }
        }

        public static string BotInvalidAuthenticatorDuringLogin {
            get {
                return ResourceManager.GetString("BotInvalidAuthenticatorDuringLogin", resourceCulture);
            }
        }

        public static string BotLoggedOff {
            get {
                return ResourceManager.GetString("BotLoggedOff", resourceCulture);
            }
        }

        public static string BotLoggedOn {
            get {
                return ResourceManager.GetString("BotLoggedOn", resourceCulture);
            }
        }

        public static string BotLoggingIn {
            get {
                return ResourceManager.GetString("BotLoggingIn", resourceCulture);
            }
        }

        public static string BotLogonSessionReplaced {
            get {
                return ResourceManager.GetString("BotLogonSessionReplaced", resourceCulture);
            }
        }

        public static string BotLootingFailed {
            get {
                return ResourceManager.GetString("BotLootingFailed", resourceCulture);
            }
        }

        public static string BotLootingMasterNotDefined {
            get {
                return ResourceManager.GetString("BotLootingMasterNotDefined", resourceCulture);
            }
        }

        public static string BotLootingSuccess {
            get {
                return ResourceManager.GetString("BotLootingSuccess", resourceCulture);
            }
        }

        public static string BotSendingTradeToYourself {
            get {
                return ResourceManager.GetString("BotSendingTradeToYourself", resourceCulture);
            }
        }

        public static string BotNoASFAuthenticator {
            get {
                return ResourceManager.GetString("BotNoASFAuthenticator", resourceCulture);
            }
        }

        public static string BotNotConnected {
            get {
                return ResourceManager.GetString("BotNotConnected", resourceCulture);
            }
        }

        public static string BotNotOwnedYet {
            get {
                return ResourceManager.GetString("BotNotOwnedYet", resourceCulture);
            }
        }

        public static string BotOwnedAlreadyWithName {
            get {
                return ResourceManager.GetString("BotOwnedAlreadyWithName", resourceCulture);
            }
        }

        public static string BotPointsBalance {
            get {
                return ResourceManager.GetString("BotPointsBalance", resourceCulture);
            }
        }

        public static string BotRateLimitExceeded {
            get {
                return ResourceManager.GetString("BotRateLimitExceeded", resourceCulture);
            }
        }

        public static string BotReconnecting {
            get {
                return ResourceManager.GetString("BotReconnecting", resourceCulture);
            }
        }

        public static string BotRedeem {
            get {
                return ResourceManager.GetString("BotRedeem", resourceCulture);
            }
        }

        public static string BotRedeemWithItems {
            get {
                return ResourceManager.GetString("BotRedeemWithItems", resourceCulture);
            }
        }

        public static string BotRemovedExpiredLoginKey {
            get {
                return ResourceManager.GetString("BotRemovedExpiredLoginKey", resourceCulture);
            }
        }

        public static string BotStatusNotIdling {
            get {
                return ResourceManager.GetString("BotStatusNotIdling", resourceCulture);
            }
        }

        public static string BotStatusLimited {
            get {
                return ResourceManager.GetString("BotStatusLimited", resourceCulture);
            }
        }

        public static string BotStatusConnecting {
            get {
                return ResourceManager.GetString("BotStatusConnecting", resourceCulture);
            }
        }

        public static string BotStatusNotRunning {
            get {
                return ResourceManager.GetString("BotStatusNotRunning", resourceCulture);
            }
        }

        public static string BotStatusPaused {
            get {
                return ResourceManager.GetString("BotStatusPaused", resourceCulture);
            }
        }

        public static string BotStatusPlayingNotAvailable {
            get {
                return ResourceManager.GetString("BotStatusPlayingNotAvailable", resourceCulture);
            }
        }

        public static string BotUnableToLogin {
            get {
                return ResourceManager.GetString("BotUnableToLogin", resourceCulture);
            }
        }

        public static string ErrorIsEmpty {
            get {
                return ResourceManager.GetString("ErrorIsEmpty", resourceCulture);
            }
        }

        public static string UnusedKeys {
            get {
                return ResourceManager.GetString("UnusedKeys", resourceCulture);
            }
        }

        public static string WarningFailedWithError {
            get {
                return ResourceManager.GetString("WarningFailedWithError", resourceCulture);
            }
        }

        public static string BotConnectionLost {
            get {
                return ResourceManager.GetString("BotConnectionLost", resourceCulture);
            }
        }

        public static string BotAccountFree {
            get {
                return ResourceManager.GetString("BotAccountFree", resourceCulture);
            }
        }

        public static string BotAccountOccupied {
            get {
                return ResourceManager.GetString("BotAccountOccupied", resourceCulture);
            }
        }

        public static string BotConnecting {
            get {
                return ResourceManager.GetString("BotConnecting", resourceCulture);
            }
        }

        public static string BotHeartBeatFailed {
            get {
                return ResourceManager.GetString("BotHeartBeatFailed", resourceCulture);
            }
        }

        public static string BotSteamDirectoryInitializationFailed {
            get {
                return ResourceManager.GetString("BotSteamDirectoryInitializationFailed", resourceCulture);
            }
        }

        public static string BotStopping {
            get {
                return ResourceManager.GetString("BotStopping", resourceCulture);
            }
        }

        public static string ErrorBotConfigInvalid {
            get {
                return ResourceManager.GetString("ErrorBotConfigInvalid", resourceCulture);
            }
        }

        public static string ErrorDatabaseInvalid {
            get {
                return ResourceManager.GetString("ErrorDatabaseInvalid", resourceCulture);
            }
        }

        public static string Initializing {
            get {
                return ResourceManager.GetString("Initializing", resourceCulture);
            }
        }

        public static string WarningPrivacyPolicy {
            get {
                return ResourceManager.GetString("WarningPrivacyPolicy", resourceCulture);
            }
        }

        public static string Welcome {
            get {
                return ResourceManager.GetString("Welcome", resourceCulture);
            }
        }

        public static string ErrorInvalidCurrentCulture {
            get {
                return ResourceManager.GetString("ErrorInvalidCurrentCulture", resourceCulture);
            }
        }

        public static string TranslationIncomplete {
            get {
                return ResourceManager.GetString("TranslationIncomplete", resourceCulture);
            }
        }

        public static string IdlingGameNotPossible {
            get {
                return ResourceManager.GetString("IdlingGameNotPossible", resourceCulture);
            }
        }

        public static string WarningIdlingGameMismatch {
            get {
                return ResourceManager.GetString("WarningIdlingGameMismatch", resourceCulture);
            }
        }

        public static string BotVersion {
            get {
                return ResourceManager.GetString("BotVersion", resourceCulture);
            }
        }

        public static string BotAccountLocked {
            get {
                return ResourceManager.GetString("BotAccountLocked", resourceCulture);
            }
        }

        public static string BotStatusLocked {
            get {
                return ResourceManager.GetString("BotStatusLocked", resourceCulture);
            }
        }

        public static string ErrorFunctionOnlyInHeadlessMode {
            get {
                return ResourceManager.GetString("ErrorFunctionOnlyInHeadlessMode", resourceCulture);
            }
        }

        public static string BotOwnedAlready {
            get {
                return ResourceManager.GetString("BotOwnedAlready", resourceCulture);
            }
        }

        public static string ErrorAccessDenied {
            get {
                return ResourceManager.GetString("ErrorAccessDenied", resourceCulture);
            }
        }

        public static string WarningPreReleaseVersion {
            get {
                return ResourceManager.GetString("WarningPreReleaseVersion", resourceCulture);
            }
        }

        public static string BotStats {
            get {
                return ResourceManager.GetString("BotStats", resourceCulture);
            }
        }

        public static string ClearingDiscoveryQueue {
            get {
                return ResourceManager.GetString("ClearingDiscoveryQueue", resourceCulture);
            }
        }

        public static string DoneClearingDiscoveryQueue {
            get {
                return ResourceManager.GetString("DoneClearingDiscoveryQueue", resourceCulture);
            }
        }

        public static string BotOwnsOverviewPerGame {
            get {
                return ResourceManager.GetString("BotOwnsOverviewPerGame", resourceCulture);
            }
        }

        public static string BotRefreshingPackagesData {
            get {
                return ResourceManager.GetString("BotRefreshingPackagesData", resourceCulture);
            }
        }

        public static string WarningDeprecated {
            get {
                return ResourceManager.GetString("WarningDeprecated", resourceCulture);
            }
        }

        public static string BotAcceptedDonationTrade {
            get {
                return ResourceManager.GetString("BotAcceptedDonationTrade", resourceCulture);
            }
        }

        public static string WarningWorkaroundTriggered {
            get {
                return ResourceManager.GetString("WarningWorkaroundTriggered", resourceCulture);
            }
        }

        public static string TargetBotNotConnected {
            get {
                return ResourceManager.GetString("TargetBotNotConnected", resourceCulture);
            }
        }

        public static string BotWalletBalance {
            get {
                return ResourceManager.GetString("BotWalletBalance", resourceCulture);
            }
        }

        public static string BotHasNoWallet {
            get {
                return ResourceManager.GetString("BotHasNoWallet", resourceCulture);
            }
        }

        public static string BotLevel {
            get {
                return ResourceManager.GetString("BotLevel", resourceCulture);
            }
        }

        public static string ActivelyMatchingItems {
            get {
                return ResourceManager.GetString("ActivelyMatchingItems", resourceCulture);
            }
        }

        public static string DoneActivelyMatchingItems {
            get {
                return ResourceManager.GetString("DoneActivelyMatchingItems", resourceCulture);
            }
        }

        public static string ErrorAborted {
            get {
                return ResourceManager.GetString("ErrorAborted", resourceCulture);
            }
        }

        public static string ActivelyMatchingItemsRound {
            get {
                return ResourceManager.GetString("ActivelyMatchingItemsRound", resourceCulture);
            }
        }

        public static string WarningExcessiveBotsCount {
            get {
                return ResourceManager.GetString("WarningExcessiveBotsCount", resourceCulture);
            }
        }

        public static string PluginLoaded {
            get {
                return ResourceManager.GetString("PluginLoaded", resourceCulture);
            }
        }

        public static string PluginLoading {
            get {
                return ResourceManager.GetString("PluginLoading", resourceCulture);
            }
        }

        public static string NothingFound {
            get {
                return ResourceManager.GetString("NothingFound", resourceCulture);
            }
        }

        public static string PluginsWarning {
            get {
                return ResourceManager.GetString("PluginsWarning", resourceCulture);
            }
        }

        public static string PleaseWait {
            get {
                return ResourceManager.GetString("PleaseWait", resourceCulture);
            }
        }

        public static string EnterCommand {
            get {
                return ResourceManager.GetString("EnterCommand", resourceCulture);
            }
        }

        public static string Executing {
            get {
                return ResourceManager.GetString("Executing", resourceCulture);
            }
        }

        public static string InteractiveConsoleEnabled {
            get {
                return ResourceManager.GetString("InteractiveConsoleEnabled", resourceCulture);
            }
        }

        public static string InteractiveConsoleNotAvailable {
            get {
                return ResourceManager.GetString("InteractiveConsoleNotAvailable", resourceCulture);
            }
        }

        public static string BotGamesToRedeemInBackgroundCount {
            get {
                return ResourceManager.GetString("BotGamesToRedeemInBackgroundCount", resourceCulture);
            }
        }

        public static string ErrorSingleInstanceRequired {
            get {
                return ResourceManager.GetString("ErrorSingleInstanceRequired", resourceCulture);
            }
        }

        public static string BotHandledConfirmations {
            get {
                return ResourceManager.GetString("BotHandledConfirmations", resourceCulture);
            }
        }

        public static string BotExtraIdlingCooldown {
            get {
                return ResourceManager.GetString("BotExtraIdlingCooldown", resourceCulture);
            }
        }

        public static string UpdateCleanup {
            get {
                return ResourceManager.GetString("UpdateCleanup", resourceCulture);
            }
        }

        public static string BotGeneratingSteamParentalCode {
            get {
                return ResourceManager.GetString("BotGeneratingSteamParentalCode", resourceCulture);
            }
        }

        public static string IPCConfigChanged {
            get {
                return ResourceManager.GetString("IPCConfigChanged", resourceCulture);
            }
        }

        public static string BotTradeOfferResult {
            get {
                return ResourceManager.GetString("BotTradeOfferResult", resourceCulture);
            }
        }

        public static string BotInvalidPasswordDuringLogin {
            get {
                return ResourceManager.GetString("BotInvalidPasswordDuringLogin", resourceCulture);
            }
        }

        public static string Result {
            get {
                return ResourceManager.GetString("Result", resourceCulture);
            }
        }

        public static string WarningUnsupportedEnvironment {
            get {
                return ResourceManager.GetString("WarningUnsupportedEnvironment", resourceCulture);
            }
        }

        public static string WarningUnknownCommandLineArgument {
            get {
                return ResourceManager.GetString("WarningUnknownCommandLineArgument", resourceCulture);
            }
        }

        public static string ErrorConfigDirectoryNotFound {
            get {
                return ResourceManager.GetString("ErrorConfigDirectoryNotFound", resourceCulture);
            }
        }

        public static string BotIdlingSelectedGames {
            get {
                return ResourceManager.GetString("BotIdlingSelectedGames", resourceCulture);
            }
        }

        public static string AutomaticFileMigration {
            get {
                return ResourceManager.GetString("AutomaticFileMigration", resourceCulture);
            }
        }

        public static string WarningWeakIPCPassword {
            get {
                return ResourceManager.GetString("WarningWeakIPCPassword", resourceCulture);
            }
        }

        public static string WarningWeakSteamPassword {
            get {
                return ResourceManager.GetString("WarningWeakSteamPassword", resourceCulture);
            }
        }

        public static string WarningWeakCryptKey {
            get {
                return ResourceManager.GetString("WarningWeakCryptKey", resourceCulture);
            }
        }

        public static string WarningTooShortCryptKey {
            get {
                return ResourceManager.GetString("WarningTooShortCryptKey", resourceCulture);
            }
        }

        public static string WarningDefaultCryptKeyUsedForHashing {
            get {
                return ResourceManager.GetString("WarningDefaultCryptKeyUsedForHashing", resourceCulture);
            }
        }

        public static string WarningDefaultCryptKeyUsedForEncryption {
            get {
                return ResourceManager.GetString("WarningDefaultCryptKeyUsedForEncryption", resourceCulture);
            }
        }

        public static string WarningRunningAsRoot {
            get {
                return ResourceManager.GetString("WarningRunningAsRoot", resourceCulture);
            }
        }

        public static string WarningRunningInUnsupportedEnvironment {
            get {
                return ResourceManager.GetString("WarningRunningInUnsupportedEnvironment", resourceCulture);
            }
        }
    }
}


text:
<?php
defined('BASEPATH') OR exit('No direct script access allowed');

class Cesta extends CI_Controller {

	function __construct()
	{
		parent::__construct();
		$this->load->database();
		$this->load->library('Template');
		$this->load->library('form_validation');
		$this->load->model('Model');
		$this->load->helper('form');
		$this->load->helper('url');
		$this->load->helper('typography');
	}

	public function index()
        {
		$data['query'] = $this->Model->select_all_cesta('cesta');
		$this->load->view('Template/head')  ;
		$this->load->view('Template/nav')  ;
		$this->load->view('Cesta/Cesta_view', $data) ;
		$this->load->view('Template/foot')  ;
        }

   public function add_cesta() {
               $data['cesta'] = $this->Model->get_cesta_dropdown();
               $this->load->view('Cesta/add_cesta',$data);
    }

       public function adding_cesta() {
            $this->load->library('form_validation');
			$this->form_validation->set_rules('Mesto','Začiatok trasy:','trim|required|htmlspecialchars');
            $this->form_validation->set_rules('Ulica','Koniec trasy:','trim|required|htmlspecialchars');
			$this->form_validation->set_rules('Mesto_ciel','Cieľové mesto:','trim|required|htmlspecialchars');
            $this->form_validation->set_rules('Ulica_ciel','Cieľová ulica:','trim|required|htmlspecialchars');
            $this->form_validation->set_rules('cena','Cena:','trim|required|htmlspecialchars');
			$this->form_validation->set_rules('najazdeneKm','najazdené km:','trim|required|htmlspecialchars');
			$this->form_validation->set_rules('Zakaznik_kontakt','Zákazník kontakt:','trim|required|htmlspecialchars');
			$this->form_validation->set_rules('datum','Dátum:','trim|required|htmlspecialchars');
            $this->form_validation->set_rules('Smena_idSmena','Taxikár:','trim|required|htmlspecialchars');

        if ($this->form_validation->run())
        {

		$data = array(
		'Mesto' => $_POST['Mesto'],
		'Ulica' => $_POST['Ulica'],
		'Mesto_ciel' => $_POST['Mesto_ciel'],
		'Ulica_ciel' => $_POST['Ulica_ciel'],
		'cena' => $_POST['cena'],
		'najazdeneKm' => $_POST['najazdeneKm'],
		'Zakaznik_kontakt' => $_POST['Zakaznik_kontakt'],
		'datum' => $_POST['datum'],
		'Smena_idSmena' => $_POST['Smena_idSmena']
		);
		$this->Model->insert_data('cesta', $data);
		redirect('Cesta');
}
               else
               {
                  $this->load->helper('form');
                 $data['cesta'] = $this->Model->get_cesta_dropdown();
                 $this->load->view('Cesta/add_cesta',$data);
               }

    }
public function edit_cesta() {
		$data['cesta'] = $this->Model->get_cesta_dropdown();
        $id = $this->input->post('idCesta');
        $data['id'] = $id;

        $data['query'] = $this->Model->get_cesta($id);
		if(count($data['query']) == 0) die('cesta nenajdena');
        $this->load->view('Cesta/edit_cesta',$data);
    }

     public function editing_cesta()
    {
			$this->form_validation->set_rules('Mesto','Mesto:','trim|required|htmlspecialchars');
            $this->form_validation->set_rules('Ulica','Ulica:','trim|required|htmlspecialchars');
			$this->form_validation->set_rules('Mesto_ciel','Cieľové mesto:','trim|required|htmlspecialchars');
            $this->form_validation->set_rules('Ulica_ciel','Cieľová ulica:','trim|required|htmlspecialchars');
            $this->form_validation->set_rules('cena','Cena:','trim|required|htmlspecialchars');
			$this->form_validation->set_rules('najazdeneKm','najazdené km:','trim|required|htmlspecialchars');
			$this->form_validation->set_rules('Zakaznik_kontakt','Zákazník kontakt:','trim|required|htmlspecialchars');
			$this->form_validation->set_rules('datum','Dátum:','trim|required|htmlspecialchars');
            $this->form_validation->set_rules('Smena_idSmena','Smena:','trim|required|htmlspecialchars');

        if ($this->form_validation->run())
        {
            $data = array(
                'Mesto' => $_POST['Mesto'],
				'Ulica' => $_POST['Ulica'],
				'Mesto_ciel' => $_POST['Mesto_ciel'],
				'Ulica_ciel' => $_POST['Ulica_ciel'],
				'cena' => $_POST['cena'],
				'najazdeneKm' => $_POST['najazdeneKm'],
				'Zakaznik_kontakt' => $_POST['Zakaznik_kontakt'],
				'datum' => $_POST['datum'],
				'Smena_idSmena' => $_POST['Smena_idSmena']
			);

            $id = $this->input->post('idCesta');
            $this->Model->update_data('idCesta',$id,'cesta',$data);
          redirect('Cesta');
        }
        else
        {
            $data['id'] = $this->input->post('idCesta');

            $in['Mesto'] = $this->input->post('Mesto');

			$in['Ulica'] = $this->input->post('Ulica');

			$in['Mesto_ciel'] = $this->input->post('Mesto_ciel');

			$in['Ulica_ciel'] = $this->input->post('Ulica_ciel');

			$in['cena'] = $this->input->post('cena');

			$in['najazdeneKm'] = $this->input->post('najazdeneKm');

			$in['Zakaznik_kontakt'] = $this->input->post('Zakaznik_kontakt');

			$in['datum'] = $this->input->post('datum');

			// $in['cesta'] = $this->input->post('Smena_idSmena');

			$data['query'] = $in;
			$data['cesta'] = $this->input->post('Smena_idSmena');
            $this->load->helper('form');
            $this->load->view('Cesta/edit_cesta', $data);
        }

    }

 public function delete_cesta() {
        $data['idCesta'] = $this->input->post('idCesta');
        $this->load->view('Cesta/delete_cesta',$data);
    }

    public function deleting_cesta() {
        $id = $this->input->post('idCesta');
        $this->Model->delete_data('idCesta',$id,'cesta');
        redirect('Cesta');
    }

}


text:
require 'spec_helper'

describe 'hadoop::_system_tuning' do
  context 'on CentOS 6.9' do
    let(:chef_run) do
      ChefSpec::SoloRunner.new(platform: 'centos', version: 6.9) do
        allow(::File).to receive_messages(file?: true)
        stub_command(%r{/sys/kernel/mm/(.*)transparent_hugepage/defrag}).and_return(false)
      end.converge(described_recipe)
    end

    it 'disables swap' do
      expect(chef_run).to apply_sysctl_param('vm.swappiness')
    end

    it 'disables transparent hugepage compaction' do
      expect(chef_run).to run_execute('disable-transparent-hugepage-compaction')
    end
  end

  context 'on Ubuntu 14.04' do
    let(:chef_run) do
      ChefSpec::SoloRunner.new(platform: 'ubuntu', version: 14.04) do
        allow(::File).to receive_messages(file?: true)
        stub_command(%r{/sys/kernel/mm/(.*)transparent_hugepage/defrag}).and_return(false)
      end.converge(described_recipe)
    end

    it 'disables transparent hugepage compaction' do
      expect(chef_run).to run_execute('disable-transparent-hugepage-compaction')
    end
  end
end


text:
<?php
class JumpLink_MongoCache_IndexController extends Mage_Core_Controller_Front_Action {

	/*
	* URL: <domain>/mongocache/index/debug
	*
	* @return null
	*/
	function debugAction() {
		echo Mage::helper('jumplink_mongocache')->getServerString(); //ruft eine Funktion im Helper auf
   		Mage::helper('jumplink_mongocache')->testConnection();
	}

}


text:
require('coffee-script')
require('coffee-script/register');
app = module.exports = require('./app')


text:
using System;
using System.IO;
using System.Text;
using Bender.Configuration;
using Bender.Nodes.FormUrlEncoded;

namespace Bender
{
    public static partial class Serialize
    {
        // String

        public static string FormUrlEncoded(object source, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncoded(source);
        }

        public static string FormUrlEncoded(object source, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncoded(source);
        }

        public static string FormUrlEncoded<T>(T source, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncoded(source);
        }

        public static string FormUrlEncoded<T>(T source, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncoded(source);
        }

        public static string FormUrlEncoded(object source, Type type, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncoded(source, type);
        }

        public static string FormUrlEncoded(object source, Type type, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncoded(source, type);
        }

        // String extensions

        public static string SerializeFormUrlEncoded(this object source, Options options)
        {
            return FormUrlEncoded(source, options);
        }

        public static string SerializeFormUrlEncoded(this object source, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncoded(source, configure);
        }

        public static string SerializeFormUrlEncoded<T>(this T source, Options options)
        {
            return FormUrlEncoded(source, options);
        }

        public static string SerializeFormUrlEncoded<T>(this T source, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncoded(source, configure);
        }

        public static string SerializeFormUrlEncoded(this object source, Type type, Options options)
        {
            return FormUrlEncoded(source, type, options);
        }

        public static string SerializeFormUrlEncoded(this object source, Type type, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncoded(source, type, configure);
        }

        // Bytes

        public static byte[] FormUrlEncodedBytes(object source, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedBytes(source);
        }

        public static byte[] FormUrlEncodedBytes(object source, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedBytes(source);
        }

        public static byte[] FormUrlEncodedBytes(object source, Encoding encoding, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedBytes(source, encoding);
        }

        public static byte[] FormUrlEncodedBytes(object source, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedBytes(source, encoding);
        }

        public static byte[] FormUrlEncodedBytes<T>(T source, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedBytes(source);
        }

        public static byte[] FormUrlEncodedBytes<T>(T source, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedBytes(source);
        }

        public static byte[] FormUrlEncodedBytes<T>(T source, Encoding encoding, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedBytes(source, encoding);
        }

        public static byte[] FormUrlEncodedBytes<T>(T source, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedBytes(source, encoding);
        }

        public static byte[] FormUrlEncodedBytes(object source, Type type, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedBytes(source, type);
        }

        public static byte[] FormUrlEncodedBytes(object source, Type type, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedBytes(source, type);
        }

        public static byte[] FormUrlEncodedBytes(object source, Type type, Encoding encoding, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedBytes(source, type, encoding);
        }

        public static byte[] FormUrlEncodedBytes(object source, Type type, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedBytes(source, type, encoding);
        }

        // Bytes extensions

        public static byte[] SerializeFormUrlEncodedBytes(this object source, Options options)
        {
            return FormUrlEncodedBytes(source, options);
        }

        public static byte[] SerializeFormUrlEncodedBytes(this object source, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedBytes(source, configure);
        }

        public static byte[] SerializeFormUrlEncodedBytes(this object source, Encoding encoding, Options options)
        {
            return FormUrlEncodedBytes(source, encoding, options);
        }

        public static byte[] SerializeFormUrlEncodedBytes(this object source, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedBytes(source, encoding, configure);
        }

        public static byte[] SerializeFormUrlEncodedBytes<T>(this T source, Options options)
        {
            return FormUrlEncodedBytes(source, options);
        }

        public static byte[] SerializeFormUrlEncodedBytes<T>(this T source, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedBytes(source, configure);
        }

        public static byte[] SerializeFormUrlEncodedBytes<T>(this T source, Encoding encoding, Options options)
        {
            return FormUrlEncodedBytes(source, encoding, options);
        }

        public static byte[] SerializeFormUrlEncodedBytes<T>(this T source, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedBytes(source, encoding, configure);
        }

        public static byte[] SerializeFormUrlEncodedBytes(this object source, Type type, Options options)
        {
            return FormUrlEncodedBytes(source, type, options);
        }

        public static byte[] SerializeFormUrlEncodedBytes(this object source, Type type, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedBytes(source, type, configure);
        }

        public static byte[] SerializeFormUrlEncodedBytes(this object source, Type type, Encoding encoding, Options options)
        {
            return FormUrlEncodedBytes(source, type, encoding, options);
        }

        public static byte[] SerializeFormUrlEncodedBytes(this object source, Type type, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedBytes(source, type, encoding, configure);
        }

        // Return Stream

        public static Stream FormUrlEncodedStream(object source, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedStream(source);
        }

        public static Stream FormUrlEncodedStream(object source, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedStream(source);
        }

        public static Stream FormUrlEncodedStream(object source, Encoding encoding, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedStream(source, encoding);
        }

        public static Stream FormUrlEncodedStream(object source, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedStream(source, encoding);
        }

        public static Stream FormUrlEncodedStream<T>(T source, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedStream(source);
        }

        public static Stream FormUrlEncodedStream<T>(T source, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedStream(source);
        }

        public static Stream FormUrlEncodedStream<T>(T source, Encoding encoding, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedStream(source, encoding);
        }

        public static Stream FormUrlEncodedStream<T>(T source, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedStream(source, encoding);
        }

        public static Stream FormUrlEncodedStream(object source, Type type, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedStream(source, type);
        }

        public static Stream FormUrlEncodedStream(object source, Type type, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedStream(source, type);
        }

        public static Stream FormUrlEncodedStream(object source, Type type, Encoding encoding, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedStream(source, type, encoding);
        }

        public static Stream FormUrlEncodedStream(object source, Type type, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedStream(source, type, encoding);
        }

        // Return Stream extensions

        public static Stream SerializeFormUrlEncodedStream(this object source, Options options)
        {
            return FormUrlEncodedStream(source, options);
        }

        public static Stream SerializeFormUrlEncodedStream(this object source, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedStream(source, configure);
        }

        public static Stream SerializeFormUrlEncodedStream(this object source, Encoding encoding, Options options)
        {
            return FormUrlEncodedStream(source, encoding, options);
        }

        public static Stream SerializeFormUrlEncodedStream(this object source, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedStream(source, encoding, configure);
        }

        public static Stream SerializeFormUrlEncodedStream<T>(this T source, Options options)
        {
            return FormUrlEncodedStream(source, options);
        }

        public static Stream SerializeFormUrlEncodedStream<T>(this T source, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedStream(source, configure);
        }

        public static Stream SerializeFormUrlEncodedStream<T>(this T source, Encoding encoding, Options options)
        {
            return FormUrlEncodedStream(source, encoding, options);
        }

        public static Stream SerializeFormUrlEncodedStream<T>(this T source, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedStream(source, encoding, configure);
        }

        public static Stream SerializeFormUrlEncodedStream(this object source, Type type, Options options)
        {
            return FormUrlEncodedStream(source, type, options);
        }

        public static Stream SerializeFormUrlEncodedStream(this object source, Type type, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedStream(source, type, configure);
        }

        public static Stream SerializeFormUrlEncodedStream(this object source, Type type, Encoding encoding, Options options)
        {
            return FormUrlEncodedStream(source, type, encoding, options);
        }

        public static Stream SerializeFormUrlEncodedStream(this object source, Type type, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedStream(source, type, encoding, configure);
        }

        // To Stream

        public static void FormUrlEncodedStream(object source, Stream stream, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedStream(source, stream);
        }

        public static void FormUrlEncodedStream(object source, Stream stream, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedStream(source, stream);
        }

        public static void FormUrlEncodedStream(object source, Stream stream, Encoding encoding, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedStream(source, stream, encoding);
        }

        public static void FormUrlEncodedStream(object source, Stream stream, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedStream(source, stream, encoding);
        }

        public static void FormUrlEncodedStream<T>(T source, Stream stream, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedStream(source, stream);
        }

        public static void FormUrlEncodedStream<T>(T source, Stream stream, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedStream(source, stream);
        }

        public static void FormUrlEncodedStream<T>(T source, Stream stream, Encoding encoding, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedStream(source, stream, encoding);
        }

        public static void FormUrlEncodedStream<T>(T source, Stream stream, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedStream(source, stream, encoding);
        }

        public static void FormUrlEncodedStream(object source, Type type, Stream stream, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedStream(source, type, stream);
        }

        public static void FormUrlEncodedStream(object source, Type type, Stream stream, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedStream(source, type, stream);
        }

        public static void FormUrlEncodedStream(object source, Type type, Stream stream, Encoding encoding, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedStream(source, type, stream, encoding);
        }

        public static void FormUrlEncodedStream(object source, Type type, Stream stream, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedStream(source, type, stream, encoding);
        }

        // To Stream extensions

        public static void SerializeFormUrlEncodedStream(this object source, Stream stream, Options options)
        {
            FormUrlEncodedStream(source, stream, options);
        }

        public static void SerializeFormUrlEncodedStream(this object source, Stream stream, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedStream(source, stream, configure);
        }

        public static void SerializeFormUrlEncodedStream(this object source, Stream stream, Encoding encoding, Options options)
        {
            FormUrlEncodedStream(source, stream, encoding, options);
        }

        public static void SerializeFormUrlEncodedStream(this object source, Stream stream, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedStream(source, stream, encoding, configure);
        }

        public static void SerializeFormUrlEncodedStream<T>(this T source, Stream stream, Options options)
        {
            FormUrlEncodedStream(source, stream, options);
        }

        public static void SerializeFormUrlEncodedStream<T>(this T source, Stream stream, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedStream(source, stream, configure);
        }

        public static void SerializeFormUrlEncodedStream<T>(this T source, Stream stream, Encoding encoding, Options options)
        {
            FormUrlEncodedStream(source, stream, encoding, options);
        }

        public static void SerializeFormUrlEncodedStream<T>(this T source, Stream stream, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedStream(source, stream, encoding, configure);
        }

        public static void SerializeFormUrlEncodedStream(this object source, Type type, Stream stream, Options options)
        {
            FormUrlEncodedStream(source, type, stream, options);
        }

        public static void SerializeFormUrlEncodedStream(this object source, Type type, Stream stream, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedStream(source, type, stream, configure);
        }

        public static void SerializeFormUrlEncodedStream(this object source, Type type, Stream stream, Encoding encoding, Options options)
        {
            FormUrlEncodedStream(source, type, stream, encoding, options);
        }

        public static void SerializeFormUrlEncodedStream(this object source, Type type, Stream stream, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedStream(source, type, stream, encoding, configure);
        }

        // File

        public static void FormUrlEncodedFile(object source, string path, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedFile(source, path);
        }

        public static void FormUrlEncodedFile(object source, string path, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedFile(source, path);
        }

        public static void FormUrlEncodedFile(object source, string path, Encoding encoding, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedFile(source, path, encoding);
        }

        public static void FormUrlEncodedFile(object source, string path, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedFile(source, path, encoding);
        }

        public static void FormUrlEncodedFile<T>(T source, string path, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedFile(source, path);
        }

        public static void FormUrlEncodedFile<T>(T source, string path, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedFile(source, path);
        }

        public static void FormUrlEncodedFile<T>(T source, string path, Encoding encoding, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedFile(source, path, encoding);
        }

        public static void FormUrlEncodedFile<T>(T source, string path, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedFile(source, path, encoding);
        }

        public static void FormUrlEncodedFile(object source, Type type, string path, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedFile(source, type, path);
        }

        public static void FormUrlEncodedFile(object source, Type type, string path, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedFile(source, type, path);
        }

        public static void FormUrlEncodedFile(object source, Type type, string path, Encoding encoding, Options options)
        {
            Serializer.Create(options).SerializeFormUrlEncodedFile(source, type, path, encoding);
        }

        public static void FormUrlEncodedFile(object source, Type type, string path, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            Serializer.Create(configure).SerializeFormUrlEncodedFile(source, type, path, encoding);
        }

        // File extensions

        public static void SerializeFormUrlEncodedFile(this object source, string path, Options options)
        {
            FormUrlEncodedFile(source, path, options);
        }

        public static void SerializeFormUrlEncodedFile(this object source, string path, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedFile(source, path, configure);
        }

        public static void SerializeFormUrlEncodedFile(this object source, string path, Encoding encoding, Options options)
        {
            FormUrlEncodedFile(source, path, encoding, options);
        }

        public static void SerializeFormUrlEncodedFile(this object source, string path, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedFile(source, path, encoding, configure);
        }

        public static void SerializeFormUrlEncodedFile<T>(this T source, string path, Options options)
        {
            FormUrlEncodedFile(source, path, options);
        }

        public static void SerializeFormUrlEncodedFile<T>(this T source, string path, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedFile(source, path, configure);
        }

        public static void SerializeFormUrlEncodedFile<T>(this T source, string path, Encoding encoding, Options options)
        {
            FormUrlEncodedFile(source, path, encoding, options);
        }

        public static void SerializeFormUrlEncodedFile<T>(this T source, string path, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedFile(source, path, encoding, configure);
        }

        public static void SerializeFormUrlEncodedFile(this object source, Type type, string path, Options options)
        {
            FormUrlEncodedFile(source, type, path, options);
        }

        public static void SerializeFormUrlEncodedFile(this object source, Type type, string path, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedFile(source, type, path, configure);
        }

        public static void SerializeFormUrlEncodedFile(this object source, Type type, string path, Encoding encoding, Options options)
        {
            FormUrlEncodedFile(source, type, path, encoding, options);
        }

        public static void SerializeFormUrlEncodedFile(this object source, Type type, string path, Encoding encoding, Action<OptionsDsl> configure = null)
        {
            FormUrlEncodedFile(source, type, path, encoding, configure);
        }

        // Nodes

        public static FormNode FormUrlEncodedNodes(object source, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedNodes(source);
        }

        public static FormNode FormUrlEncodedNodes(object source, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedNodes(source);
        }

        public static FormNode FormUrlEncodedNodes<T>(T source, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedNodes(source);
        }

        public static FormNode FormUrlEncodedNodes<T>(T source, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedNodes(source);
        }

        public static FormNode FormUrlEncodedNodes(object source, Type type, Options options)
        {
            return Serializer.Create(options).SerializeFormUrlEncodedNodes(source, type);
        }

        public static FormNode FormUrlEncodedNodes(object source, Type type, Action<OptionsDsl> configure = null)
        {
            return Serializer.Create(configure).SerializeFormUrlEncodedNodes(source, type);
        }

        // Nodes extensions

        public static FormNode SerializeFormUrlEncodedNodes(this object source, Options options)
        {
            return FormUrlEncodedNodes(source, options);
        }

        public static FormNode SerializeFormUrlEncodedNodes(this object source, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedNodes(source, configure);
        }

        public static FormNode SerializeFormUrlEncodedNodes<T>(this T source, Options options)
        {
            return FormUrlEncodedNodes(source, options);
        }

        public static FormNode SerializeFormUrlEncodedNodes<T>(this T source, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedNodes(source, configure);
        }

        public static FormNode SerializeFormUrlEncodedNodes(this object source, Type type, Options options)
        {
            return FormUrlEncodedNodes(source, type, options);
        }

        public static FormNode SerializeFormUrlEncodedNodes(this object source, Type type, Action<OptionsDsl> configure = null)
        {
            return FormUrlEncodedNodes(source, type, configure);
        }
    }
}