text:
package net.mikesu.fastdfs;

import java.util.List;

import net.mikesu.fastdfs.client.StorageClient;
import net.mikesu.fastdfs.client.StorageClientFactory;
import net.mikesu.fastdfs.client.TrackerClient;
import net.mikesu.fastdfs.client.TrackerClientFactory;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
import org.apache.commons.pool2.impl.GenericKeyedObjectPoolConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class FastdfsClientFactory {

    private static Logger logger = LoggerFactory.getLogger(FastdfsClientFactory.class);

	private static volatile FastdfsClient fastdfsClient;
    private static FastdfsClientConfig config = null;

    private final static String configFile = "FastdfsClient.properties";

    public FastdfsClientFactory() {
    }

    public static FastdfsClient getFastdfsClient(){
        if (fastdfsClient == null) {
            synchronized (FastdfsClient.class) {
                if (fastdfsClient == null) {
                    try {
                        config = new FastdfsClientConfig(configFile);
                    } catch (ConfigurationException e) {
                        logger.warn("Load fastdfs config failed.",e);
                    }
                    int connectTimeout = config.getConnectTimeout();
                    int networkTimeout = config.getNetworkTimeout();
                    TrackerClientFactory trackerClientFactory = new TrackerClientFactory(connectTimeout, networkTimeout);
                    StorageClientFactory storageClientFactory = new StorageClientFactory(connectTimeout, networkTimeout);
                    GenericKeyedObjectPoolConfig trackerClientPoolConfig = config.getTrackerClientPoolConfig();
                    GenericKeyedObjectPoolConfig storageClientPoolConfig = config.getStorageClientPoolConfig();
                    GenericKeyedObjectPool<String,TrackerClient> trackerClientPool = new GenericKeyedObjectPool<String,TrackerClient>(trackerClientFactory, trackerClientPoolConfig);
                    GenericKeyedObjectPool<String,StorageClient> storageClientPool = new GenericKeyedObjectPool<String,StorageClient>(storageClientFactory, storageClientPoolConfig);
                    List<String> trackerAddrs = config.getTrackerAddrs();
                    fastdfsClient = new FastdfsClientImpl(trackerAddrs,trackerClientPool,storageClientPool);
                }
            }
        }
        return fastdfsClient;
    }

}


text:
<?php

namespace Ach\PoManagerBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

class AchPoManagerBundle extends Bundle
{
}

redpajama_set_name: RedPajamaGithub


text:
class CreateFeeds < ActiveRecord::Migration

  def change
    create_table :feeds do |t|
      t.string :feed_title
      t.string :feed_url
      t.string :site_url
      t.string :etag

      t.timestamps
    end

    add_index :feeds, :feed_url, unique: true

  end

end


text:
ACCEPTED

#### According to
International Plant Names Index

#### Published in
null

#### Original name
Ferula paucijuga DC.

### Remarks
null


text:
require 'spec_helper'
require 'yaml'

RSpec.describe "Money" do
  let (:money) { Money.new(1) }
  let (:amount_money) { Money.new(1.23, 'USD') }
  let (:non_fractional_money) { Money.new(1, 'JPY') }
  let (:zero_money) { Money.new(0) }

  it "has a version" do
    expect(Money::VERSION).not_to(eq(nil))
  end

  context "default currency not set" do
    it "raises an error" do
      configure(default_currency: nil) do
        expect { money }.to raise_error(ArgumentError)
      end
    end
  end

  it ".zero has no currency" do
    expect(Money.new(0, Money::NULL_CURRENCY).currency).to be_a(Money::NullCurrency)
  end

  it ".zero is a 0$ value" do
    expect(Money.new(0, Money::NULL_CURRENCY)).to eq(Money.new(0))
  end

  it "returns itself with to_money" do
    expect(money.to_money).to eq(money)
  end

  it "#to_money uses the provided currency when it doesn't already have one" do
    expect(Money.new(1).to_money('CAD')).to eq(Money.new(1, 'CAD'))
  end

  it "legacy_deprecations #to_money doesn't overwrite the money object's currency" do
    configure(legacy_deprecations: true) do
      expect(Money).to receive(:deprecate).once
      expect(Money.new(1, 'USD').to_money('CAD')).to eq(Money.new(1, 'USD'))
    end
  end

  it "#to_money raises when changing currency" do
    expect{ Money.new(1, 'USD').to_money('CAD') }.to raise_error(Money::IncompatibleCurrencyError)
  end

  it "defaults to 0 when constructed with no arguments" do
    expect(Money.new).to eq(Money.new(0))
  end

  it "defaults to 0 when constructed with an empty string" do
    expect(Money.new('')).to eq(Money.new(0))
  end

  it "legacy_deprecations defaults to 0 when constructed with an invalid string" do
    configure(legacy_deprecations: true) do
      expect(Money).to receive(:deprecate).once
      expect(Money.new('invalid', 'USD')).to eq(Money.new(0.00, 'USD'))
    end
  end

  it "raises when constructed with an invalid string" do
    expect{ Money.new('invalid') }.to raise_error(ArgumentError)
  end

  it "to_s correctly displays the right number of decimal places" do
    expect(money.to_s).to eq("1.00")
    expect(non_fractional_money.to_s).to eq("1")
  end

  it "to_fs with a legacy_dollars style" do
    expect(amount_money.to_fs(:legacy_dollars)).to eq("1.23")
    expect(non_fractional_money.to_fs(:legacy_dollars)).to eq("1.00")
  end

  it "to_fs with a amount style" do
    expect(amount_money.to_fs(:amount)).to eq("1.23")
    expect(non_fractional_money.to_fs(:amount)).to eq("1")
  end

  it "to_s correctly displays negative numbers" do
    expect((-money).to_s).to eq("-1.00")
    expect((-amount_money).to_s).to eq("-1.23")
    expect((-non_fractional_money).to_s).to eq("-1")
    expect((-Money.new("0.05")).to_s).to eq("-0.05")
  end

  it "to_s rounds when  more fractions than currency allows" do
    expect(Money.new("9.999", "USD").to_s).to eq("10.00")
    expect(Money.new("9.889", "USD").to_s).to eq("9.89")
  end

  it "to_s does not round when fractions same as currency allows" do
    expect(Money.new("1.25", "USD").to_s).to eq("1.25")
    expect(Money.new("9.99", "USD").to_s).to eq("9.99")
    expect(Money.new("9.999", "BHD").to_s).to eq("9.999")
  end

  it "to_s does not round if amount is larger than float allows" do
    expect(Money.new("99999999999999.99", "USD").to_s).to eq("99999999999999.99")
    expect(Money.new("999999999999999999.99", "USD").to_s).to eq("999999999999999999.99")
  end

  it "to_fs raises ArgumentError on unsupported style" do
    expect{ money.to_fs(:some_weird_style) }.to raise_error(ArgumentError)
  end

  it "to_fs is aliased as to_s for backward compatibility" do
    expect(money.method(:to_s)).to eq(money.method(:to_fs))
  end

  it "to_fs is aliased as to_formatted_s for backward compatibility" do
    expect(money.method(:to_formatted_s)).to eq(money.method(:to_fs))
  end

  it "legacy_json_format makes as_json return the legacy format" do
    configure(legacy_json_format: true) do
      expect(Money.new(1, 'CAD').as_json).to eq("1.00")
    end
  end

  it "legacy_format correctly sets the json format" do
    expect(Money.new(1, 'CAD').as_json(legacy_format: true)).to eq("1.00")
    expect(Money.new(1, 'CAD').to_json(legacy_format: true)).to eq("1.00")
  end

  it "as_json as a json containing the value and currency" do
    expect(money.as_json).to eq(value: "1.00", currency: "CAD")
  end

  it "is constructable with a BigDecimal" do
    expect(Money.new(BigDecimal("1.23"))).to eq(Money.new(1.23))
  end

  it "is constructable with an Integer" do
    expect(Money.new(3)).to eq(Money.new(3.00))
  end

  it "is construcatable with a Float" do
    expect(Money.new(3.00)).to eq(Money.new(BigDecimal('3.00')))
  end

  it "is construcatable with a String" do
    expect(Money.new('3.00')).to eq(Money.new(3.00))
  end

  it "is aware of the currency" do
    expect(Money.new(1.00, 'CAD').currency.iso_code).to eq('CAD')
  end

  it "is addable" do
    expect((Money.new(1.51) + Money.new(3.49))).to eq(Money.new(5.00))
  end

  it "keeps currency across calculations" do
    expect(Money.new(1, 'USD') - Money.new(1, 'USD') + Money.new(1.23, Money::NULL_CURRENCY)).to eq(Money.new(1.23, 'USD'))
  end

  it "raises error if added other is not compatible" do
    expect{ Money.new(5.00) + nil }.to raise_error(TypeError)
  end

  it "is able to add $0 + $0" do
    expect((Money.new + Money.new)).to eq(Money.new)
  end

  it "legacy_deprecations adds inconsistent currencies" do
    configure(legacy_deprecations: true) do
      expect(Money).to receive(:deprecate).once
      expect(Money.new(5, 'USD') + Money.new(1, 'CAD')).to eq(Money.new(6, 'USD'))
    end
  end

  it "raises when adding inconsistent currencies" do
    expect{ Money.new(5, 'USD') + Money.new(1, 'CAD') }.to raise_error(Money::IncompatibleCurrencyError)
  end

  it "is subtractable" do
    expect((Money.new(5.00) - Money.new(3.49))).to eq(Money.new(1.51))
  end

  it "raises error if subtracted other is not compatible" do
    expect{ Money.new(5.00) - nil }.to raise_error(TypeError)
  end

  it "is subtractable to $0" do
    expect((Money.new(5.00) - Money.new(5.00))).to eq(Money.new)
  end

  it "logs a deprecation warning when adding across currencies" do
    configure(legacy_deprecations: true) do
      expect(Money).to receive(:deprecate)
      expect(Money.new(10, 'USD') - Money.new(1, 'JPY')).to eq(Money.new(9, 'USD'))
    end
  end

  it "keeps currency when doing a computation with a null currency" do
    currency = Money.new(10, 'JPY')
    no_currency = Money.new(1, Money::NULL_CURRENCY)
    expect((no_currency + currency).currency).to eq(Money::Currency.find!('JPY'))
    expect((currency - no_currency).currency).to eq(Money::Currency.find!('JPY'))
  end

  it "does not log a deprecation warning when adding with a null currency value" do
    currency = Money.new(10, 'USD')
    no_currency = Money.new(1, Money::NULL_CURRENCY)
    expect(Money).not_to receive(:deprecate)
    expect(no_currency + currency).to eq(Money.new(11, 'USD'))
    expect(currency - no_currency).to eq(Money.new(9, 'USD'))
  end

  it "is substractable to a negative amount" do
    expect((Money.new(0.00) - Money.new(1.00))).to eq(Money.new("-1.00"))
  end

  it "is never negative zero" do
    expect(Money.new(-0.00).to_s).to eq("0.00")
    expect((Money.new(0) * -1).to_s).to eq("0.00")
  end

  it "#inspects to a presentable string" do
    expect(money.inspect).to eq("#<Money value:1.00 currency:CAD>")
    expect(Money.new(1, 'JPY').inspect).to eq("#<Money value:1 currency:JPY>")
    expect(Money.new(1, 'JOD').inspect).to eq("#<Money value:1.000 currency:JOD>")
  end

  it "is inspectable within an array" do
    expect([money].inspect).to eq("[#<Money value:1.00 currency:CAD>]")
  end

  it "correctly support eql? as a value object" do
    expect(money).to eq(Money.new(1))
    expect(money).to eq(Money.new(1, 'CAD'))
  end

  it "does not eql? with a non money object" do
    expect(money).to_not eq(1)
    expect(money).to_not eq(OpenStruct.new(value: 1))
  end

  it "does not eql? when currency missmatch" do
    expect(money).to_not eq(Money.new(1, 'JPY'))
  end

  it "is addable with integer" do
    expect((Money.new(1.33) + 1)).to eq(Money.new(2.33))
    expect((1 + Money.new(1.33))).to eq(Money.new(2.33))
  end

  it "is addable with float" do
    expect((Money.new(1.33) + 1.50)).to eq(Money.new(2.83))
    expect((1.50 + Money.new(1.33))).to eq(Money.new(2.83))
  end

  it "is subtractable with integer" do
    expect((Money.new(1.66) - 1)).to eq(Money.new(0.66))
    expect((2 - Money.new(1.66))).to eq(Money.new(0.34))
  end

  it "is subtractable with float" do
    expect((Money.new(1.66) - 1.50)).to eq(Money.new(0.16))
    expect((1.50 - Money.new(1.33))).to eq(Money.new(0.17))
  end

  it "is multipliable with an integer" do
    expect((Money.new(1.00) * 55)).to eq(Money.new(55.00))
    expect((55 * Money.new(1.00))).to eq(Money.new(55.00))
  end

  it "is multiplable with a float" do
    expect((Money.new(1.00) * 1.50)).to eq(Money.new(1.50))
    expect((1.50 * Money.new(1.00))).to eq(Money.new(1.50))
  end

  it "is multipliable by a rational" do
    expect((Money.new(3.3) * Rational(1, 12))).to eq(Money.new(0.28))
    expect((Rational(1, 12) * Money.new(3.3))).to eq(Money.new(0.28))
  end

  it "is multipliable by a repeatable floating point number" do
    expect((Money.new(24.00) * (1 / 30.0))).to eq(Money.new(0.80))
    expect(((1 / 30.0) * Money.new(24.00))).to eq(Money.new(0.80))
  end

  it "is multipliable by a repeatable floating point number where the floating point error rounds down" do
    expect((Money.new(3.3) * (1.0 / 12))).to eq(Money.new(0.28))
    expect(((1.0 / 12) * Money.new(3.3))).to eq(Money.new(0.28))
  end

  it "legacy_deprecations is multipliable by a money object" do
    configure(legacy_deprecations: true) do
      expect(Money).to receive(:deprecate).once
      expect((Money.new(3.3, 'USD') * Money.new(1, 'USD'))).to eq(Money.new(3.3, 'USD'))
    end
  end

  it "raises when multiplied by a money object" do
    expect{ (Money.new(3.3) * Money.new(1)) }.to raise_error(ArgumentError)
  end

  it "rounds multiplication result with fractional penny of 5 or higher up" do
    expect((Money.new(0.03) * 0.5)).to eq(Money.new(0.02))
    expect((0.5 * Money.new(0.03))).to eq(Money.new(0.02))
  end

  it "rounds multiplication result with fractional penny of 4 or lower down" do
    expect((Money.new(0.10) * 0.33)).to eq(Money.new(0.03))
    expect((0.33 * Money.new(0.10))).to eq(Money.new(0.03))
  end

  it "is less than a bigger integer" do
    expect(Money.new(1)).to be < 2
    expect(2).to be > Money.new(1)
  end

  it "is less than or equal to a bigger integer" do
    expect(Money.new(1)).to be <= 2
    expect(2).to be >= Money.new(1)
  end

  it "is greater than a lesser integer" do
    expect(Money.new(2)).to be > 1
    expect(1).to be < Money.new(2)
  end

  it "is greater than or equal to a lesser integer" do
    expect(Money.new(2)).to be >= 1
    expect(1).to be <= Money.new(2)
  end

  it "raises if divided" do
    expect { Money.new(55.00) / 55 }.to raise_error(RuntimeError)
  end

  it "returns cents in to_json" do
    configure(legacy_json_format: true) do
      expect(Money.new('1.23', 'USD').to_json).to eq('1.23')
    end
  end

  it "returns value and currency in to_json" do
    expect(Money.new(1.00).to_json).to eq('{"value":"1.00","currency":"CAD"}')
    expect(JSON.dump(Money.new(1.00, "CAD"))).to eq('{"value":"1.00","currency":"CAD"}')
  end

  it "supports absolute value" do
    expect(Money.new(-1.00).abs).to eq(Money.new(1.00))
  end

  it "supports to_i" do
    expect(Money.new(1.50).to_i).to eq(1)
  end

  it "supports to_d" do
    expect(Money.new(1.29).to_d).to eq(BigDecimal('1.29'))
  end

  it "supports to_f" do
    expect(Money.new(1.50).to_f.to_s).to eq("1.5")
  end

  describe '#from_subunits' do
    it "creates Money object from an integer value in cents and currency" do
      expect(Money.from_subunits(1950, 'CAD')).to eq(Money.new(19.50))
    end

    it "creates Money object from an integer value in dollars and currency with no cents" do
      expect(Money.from_subunits(1950, 'JPY')).to eq(Money.new(1950, 'JPY'))
    end

    describe 'with format specified' do
      it 'overrides the subunit_to_unit amount' do
        expect(Money.from_subunits(100, 'ISK', format: :stripe)).to eq(Money.new(1, 'ISK'))
      end

      it 'fallbacks to the default subunit_to_unit amount if no override is specified' do
        expect(Money.from_subunits(100, 'USD', format: :stripe)).to eq(Money.new(1, 'USD'))
      end

      it 'raises if the format is not found' do
        expect { Money.from_subunits(100, 'ISK', format: :unknown) }.to(raise_error(ArgumentError))
      end
    end
  end

  it "raises when constructed with a NaN value" do
    expect { Money.new( 0.0 / 0) }.to raise_error(ArgumentError)
  end

  it "is comparable with non-money objects" do
    expect(money).not_to eq(nil)
  end

  it "supports floor" do
    expect(Money.new(15.52).floor).to eq(Money.new(15.00))
    expect(Money.new(18.99).floor).to eq(Money.new(18.00))
    expect(Money.new(21).floor).to eq(Money.new(21))
  end

  it "generates a true rational" do
    expect(Money.rational(Money.new(10.0, 'USD'), Money.new(15.0, 'USD'))).to eq(Rational(2,3))

    configure(legacy_deprecations: true) do
      expect(Money).to receive(:deprecate).once
      expect(Money.rational(Money.new(10.0, 'USD'), Money.new(15.0, 'JPY'))).to eq(Rational(2,3))
    end
  end

  it "does not allocate a new money object when multiplying by 1" do
    expect((money * 1).object_id).to eq(money.object_id)
  end

  it "does not allocate a new money object when adding 0" do
    expect((money + 0).object_id).to eq(money.object_id)
  end

  it "does not allocate a new money object when subtracting 0" do
    expect((money - 0).object_id).to eq(money.object_id)
  end

  it "does not allocate when computing absolute value when already positive" do
    expect((money.abs).object_id).to eq(money.object_id)
  end

  it "does not allocate when computing floor value when already floored" do
    expect((money.floor).object_id).to eq(money.object_id)
  end

  it "does not allocate when computing floor value when already rounded" do
    expect((money.round).object_id).to eq(money.object_id)
  end

  describe "frozen with amount of $1" do
    let (:money) { Money.new(1.00) }

    it "is equals to $1" do
      expect(money).to eq(Money.new(1.00))
    end

    it "is not equals to $2" do
      expect(money).not_to eq(Money.new(2.00))
    end

    it "<=> $1 is 0" do
      expect((money <=> Money.new(1.00))).to eq(0)
    end

    it "<=> $2 is -1" do
      expect((money <=> Money.new(2.00))).to eq(-1)
    end

    it "<=> $0.50 equals 1" do
      expect((money <=> Money.new(0.50))).to eq(1)
    end

    it "<=> works with non-money objects" do
      expect((money <=> 1)).to eq(0)
      expect((money <=> 2)).to eq(-1)
      expect((money <=> 0.5)).to eq(1)
      expect((1 <=> money)).to eq(0)
      expect((2 <=> money)).to eq(1)
      expect((0.5 <=> money)).to eq(-1)
    end

    it "have the same hash value as $1" do
      expect(money.hash).to eq(Money.new(1.00).hash)
    end

    it "does not have the same hash value as $2" do
      expect(money.hash).to_not eq(Money.new(2.00).hash)
    end
  end

  describe('Comparable') do
    let (:cad_05) { Money.new(5.00, 'CAD') }
    let (:cad_10) { Money.new(10.00, 'CAD') }
    let (:cad_20) { Money.new(20.00, 'CAD') }
    let (:nil_05) { Money.new(5.00, Money::NULL_CURRENCY) }
    let (:nil_10) { Money.new(10.00, Money::NULL_CURRENCY) }
    let (:nil_20) { Money.new(20.00, Money::NULL_CURRENCY) }
    let (:usd_10) { Money.new(10.00, 'USD') }

    it "<=> can compare with and without currency" do
      expect(Money.new(1000, Money::NULL_CURRENCY) <=> Money.new(2000, 'JPY')).to eq(-1)
      expect(Money.new(2000, 'JPY') <=> Money.new(1000, Money::NULL_CURRENCY)).to eq(1)
    end

    it "<=> issues deprecation warning when comparing incompatible currency" do
      configure(legacy_deprecations: true) do
        expect(Money).to receive(:deprecate).twice
        expect(Money.new(1000, 'USD') <=> Money.new(2000, 'JPY')).to eq(-1)
        expect(Money.new(2000, 'JPY') <=> Money.new(1000, 'USD')).to eq(1)
      end
    end

    describe('same values') do
      describe('same currencies') do
        it { expect(cad_10 <=> cad_10).to(eq(0)) }
        it { expect(cad_10 >  cad_10).to(eq(false)) }
        it { expect(cad_10 >= cad_10).to(eq(true)) }
        it { expect(cad_10 == cad_10).to(eq(true)) }
        it { expect(cad_10 <= cad_10).to(eq(true)) }
        it { expect(cad_10 <  cad_10).to(eq(false)) }
      end

      describe('null currency') do
        it { expect(cad_10 <=> nil_10).to(eq(0)) }
        it { expect(cad_10 >  nil_10).to(eq(false)) }
        it { expect(cad_10 >= nil_10).to(eq(true)) }
        it { expect(cad_10 == nil_10).to(eq(true)) }
        it { expect(cad_10 <= nil_10).to(eq(true)) }
        it { expect(cad_10 <  nil_10).to(eq(false)) }
      end

      describe('legacy different currencies') do
        around(:each) do |test|
          configure(legacy_deprecations: true) { test.run }
        end

        it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <=> usd_10).to(eq(0)) }
        it { expect(Money).to(receive(:deprecate).once); expect(cad_10 >  usd_10).to(eq(false)) }
        it { expect(Money).to(receive(:deprecate).once); expect(cad_10 >= usd_10).to(eq(true)) }
        it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <= usd_10).to(eq(true)) }
        it { expect(Money).to(receive(:deprecate).once); expect(cad_10 <  usd_10).to(eq(false)) }
      end

      describe('different currencies') do
        it { expect(cad_10 == usd_10).to(eq(false)) }
      end

      describe('to_money types') do
        it { expect(cad_10 <=> 10.00).to(eq(0)) }
        it { expect(cad_10 >   10.00).to(eq(false)) }
        it { expect(cad_10 >=  10.00).to(eq(true)) }
        it { expect(cad_10 ==  10.00).to(eq(false)) }
        it { expect(cad_10 <=  10.00).to(eq(true)) }
        it { expect(cad_10 <   10.00).to(eq(false)) }
      end
    end

    describe('left lower than right') do
      describe('same currencies') do
        it { expect(cad_10 <=> cad_20).to(eq(-1)) }
        it { expect(cad_10 >   cad_20).to(eq(false)) }
        it { expect(cad_10 >=  cad_20).to(eq(false)) }
        it { expect(cad_10 ==  cad_20).to(eq(false)) }
        it { expect(cad_10 <=  cad_20).to(eq(true)) }
        it { expect(cad_10 <   cad_20).to(eq(true)) }
      end

      describe('null currency') do
        it { expect(cad_10 <=> nil_20).to(eq(-1)) }
        it { expect(cad_10 >   nil_20).to(eq(false)) }
        it { expect(cad_10 >=  nil_20).to(eq(false)) }
        it { expect(cad_10 ==  nil_20).to(eq(false)) }
        it { expect(cad_10 <=  nil_20).to(eq(true)) }
        it { expect(cad_10 <   nil_20).to(eq(true)) }
      end

      describe('to_money types') do
        it { expect(cad_10 <=> 20.00).to(eq(-1)) }
        it { expect(cad_10 >   20.00).to(eq(false)) }
        it { expect(cad_10 >=  20.00).to(eq(false)) }
        it { expect(cad_10 ==  20.00).to(eq(false)) }
        it { expect(cad_10 <=  20.00).to(eq(true)) }
        it { expect(cad_10 <   20.00).to(eq(true)) }
      end
    end

    describe('left greater than right') do
      describe('same currencies') do
        it { expect(cad_10 <=> cad_05).to(eq(1)) }
        it { expect(cad_10 >   cad_05).to(eq(true)) }
        it { expect(cad_10 >=  cad_05).to(eq(true)) }
        it { expect(cad_10 ==  cad_05).to(eq(false)) }
        it { expect(cad_10 <=  cad_05).to(eq(false)) }
        it { expect(cad_10 <   cad_05).to(eq(false)) }
      end

      describe('null currency') do
        it { expect(cad_10 <=> nil_05).to(eq(1)) }
        it { expect(cad_10 >   nil_05).to(eq(true)) }
        it { expect(cad_10 >=  nil_05).to(eq(true)) }
        it { expect(cad_10 ==  nil_05).to(eq(false)) }
        it { expect(cad_10 <=  nil_05).to(eq(false)) }
        it { expect(cad_10 <   nil_05).to(eq(false)) }
      end

      describe('to_money types') do
        it { expect(cad_10 <=> 5.00).to(eq(1)) }
        it { expect(cad_10 >   5.00).to(eq(true)) }
        it { expect(cad_10 >=  5.00).to(eq(true)) }
        it { expect(cad_10 ==  5.00).to(eq(false)) }
        it { expect(cad_10 <=  5.00).to(eq(false)) }
        it { expect(cad_10 <   5.00).to(eq(false)) }
      end
    end

    describe('any values, non-to_money types') do
      it { expect(cad_10 <=> nil).to(eq(nil)) }
      it { expect { cad_10 >  nil }.to(raise_error(ArgumentError)) }
      it { expect { cad_10 >= nil }.to(raise_error(ArgumentError)) }
      it { expect(cad_10 == nil).to(eq(false)) }
      it { expect { cad_10 <= nil }.to(raise_error(ArgumentError)) }
      it { expect { cad_10 <  nil }.to(raise_error(ArgumentError)) }
    end
  end

  describe "#subunits" do
    it 'multiplies by the number of decimal places for the currency' do
      expect(Money.new(1, 'USD').subunits).to eq(100)
      expect(Money.new(1, 'JPY').subunits).to eq(1)
      expect(Money.new(1, 'IQD').subunits).to eq(1000)
      expect(Money.new(1).subunits).to eq(100)
    end

    describe 'with format specified' do
      it 'overrides the subunit_to_unit amount' do
        expect(Money.new(1, 'ISK').subunits(format: :stripe)).to eq(100)
      end

      it 'fallbacks to the default subunit_to_unit amount if no override is specified' do
        expect(Money.new(1, 'USD').subunits(format: :stripe)).to eq(100)
      end

      it 'raises if the format is not found' do
        expect { Money.new(1, 'ISK').subunits(format: :unknown) }.to(raise_error(ArgumentError))
      end
    end
  end

  describe "value" do
    it "rounds to the number of minor units provided by the currency" do
      expect(Money.new(1.1111, 'USD').value).to eq(1.11)
      expect(Money.new(1.1111, 'JPY').value).to eq(1)
      expect(Money.new(1.1111, 'IQD').value).to eq(1.111)
    end
  end

  describe "with amount of $0" do
    let (:money) { Money.new(0) }

    it "is zero" do
      expect(money).to be_zero
    end

    it "is greater than -$1" do
      expect(money).to be > Money.new("-1.00")
    end

    it "is greater than or equal to $0" do
      expect(money).to be >= Money.new
    end

    it "is less than or equal to $0" do
      expect(money).to be <= Money.new
    end

    it "is less than $1" do
      expect(money).to be < Money.new(1.00)
    end
  end

  describe "with amount of $1" do
    let (:money) { Money.new(1.00) }

    it "is not zero" do
      expect(money).not_to be_zero
    end

    it "returns cents as a decimal value = 1.00" do
      expect(money.value).to eq(BigDecimal("1.00"))
    end

    it "returns cents as 100 cents" do
      expect(money.subunits).to eq(100)
    end

    it "is greater than $0" do
      expect(money).to be > Money.new(0.00)
    end

    it "is less than $2" do
      expect(money).to be < Money.new(2.00)
    end

    it "is equal to $1" do
      expect(money).to eq(Money.new(1.00))
    end
  end

  describe "allocation"do
    specify "#allocate is calculated by Money::Allocator#allocate" do
      expected = [Money.new(1), [Money.new(1)]]
      expect_any_instance_of(Money::Allocator).to receive(:allocate).with([0.5, 0.5], :roundrobin).and_return(expected)
      expect(Money.new(2).allocate([0.5, 0.5])).to eq(expected)
    end

    specify "#allocate does not lose pennies (integration test)" do
      moneys = Money.new(0.05).allocate([0.3,0.7])
      expect(moneys[0]).to eq(Money.new(0.02))
      expect(moneys[1]).to eq(Money.new(0.03))
    end

    specify "#allocate_max_amounts is calculated by Money::Allocator#allocate_max_amounts" do
      expected = [Money.new(1), [Money.new(1)]]
      expect_any_instance_of(Money::Allocator).to receive(:allocate_max_amounts).and_return(expected)
      expect(Money.new(2).allocate_max_amounts([0.5, 0.5])).to eq(expected)
    end

    specify "#allocate_max_amounts returns the weighted allocation without exceeding the maxima when there is room for the remainder (integration test)" do
      expect(
        Money.new(30.75).allocate_max_amounts([Money.new(26), Money.new(4.75)]),
      ).to eq([Money.new(26), Money.new(4.75)])
    end
  end

  describe "split" do
    specify "#split needs at least one party" do
      expect {Money.new(1).split(0)}.to raise_error(ArgumentError)
      expect {Money.new(1).split(-1)}.to raise_error(ArgumentError)
    end

    specify "#gives 1 cent to both people if we start with 2" do
      expect(Money.new(0.02).split(2)).to eq([Money.new(0.01), Money.new(0.01)])
    end

    specify "#split may distribute no money to some parties if there isnt enough to go around" do
      expect(Money.new(0.02).split(3)).to eq([Money.new(0.01), Money.new(0.01), Money.new(0)])
    end

    specify "#split does not lose pennies" do
      expect(Money.new(0.05).split(2)).to eq([Money.new(0.03), Money.new(0.02)])
    end

    specify "#split does not lose dollars with non-decimal currencies" do
      expect(Money.new(5, 'JPY').split(2)).to eq([Money.new(3, 'JPY'), Money.new(2, 'JPY')])
    end

    specify "#split a dollar" do
      moneys = Money.new(1).split(3)
      expect(moneys[0].subunits).to eq(34)
      expect(moneys[1].subunits).to eq(33)
      expect(moneys[2].subunits).to eq(33)
    end

    specify "#split a 100 yen" do
      moneys = Money.new(100, 'JPY').split(3)
      expect(moneys[0].value).to eq(34)
      expect(moneys[1].value).to eq(33)
      expect(moneys[2].value).to eq(33)
    end
  end

  describe "calculate_splits" do
    specify "#calculate_splits gives 1 cent to both people if we start with 2" do
      actual = Money.new(0.02, 'CAD').calculate_splits(2)

      expect(actual).to eq({
        Money.new(0.01, 'CAD') => 2,
      })
    end

    specify "#calculate_splits gives an extra penny to one" do
      actual = Money.new(0.04, 'CAD').calculate_splits(3)

      expect(actual).to eq({
        Money.new(0.02, 'CAD') => 1,
        Money.new(0.01, 'CAD') => 2,
      })
    end
  end

  describe "fraction" do
    specify "#fraction needs a positive rate" do
      expect {Money.new(1).fraction(-0.5)}.to raise_error(ArgumentError)
    end

    specify "#fraction returns the amount minus a fraction" do
      expect(Money.new(1.15).fraction(0.15)).to eq(Money.new(1.00))
      expect(Money.new(2.50).fraction(0.15)).to eq(Money.new(2.17))
      expect(Money.new(35.50).fraction(0)).to eq(Money.new(35.50))
    end
  end

  describe "with amount of $1 with created with 3 decimal places" do
    let (:money) { Money.new(1.125) }

    it "rounds 3rd decimal place" do
      expect(money.value).to eq(BigDecimal("1.13"))
    end
  end

  describe "round" do

    it "rounds to 0 decimal places by default" do
      expect(Money.new(54.1).round).to eq(Money.new(54))
      expect(Money.new(54.5).round).to eq(Money.new(55))
    end

    # Overview of standard vs. banker's rounding for next 4 specs:
    # http://www.xbeat.net/vbspeed/i_BankersRounding.htm
    it "implements standard rounding for 2 digits" do
      expect(Money.new(54.1754).round(2)).to eq(Money.new(54.18))
      expect(Money.new(343.2050).round(2)).to eq(Money.new(343.21))
      expect(Money.new(106.2038).round(2)).to eq(Money.new(106.20))
    end

    it "implements standard rounding for 1 digit" do
      expect(Money.new(27.25).round(1)).to eq(Money.new(27.3))
      expect(Money.new(27.45).round(1)).to eq(Money.new(27.5))
      expect(Money.new(27.55).round(1)).to eq(Money.new(27.6))
    end

  end

  describe "from_amount quacks like RubyMoney" do
    it "accepts an optional currency parameter" do
      expect { Money.from_amount(1, "CAD") }.to_not raise_error
    end

    it "accepts Rational number" do
      expect(Money.from_amount(Rational("999999999999999999.999")).value).to eql(BigDecimal("1000000000000000000", Money::Helpers::MAX_DECIMAL))
      expect(Money.from_amount(Rational("999999999999999999.99")).value).to eql(BigDecimal("999999999999999999.99", Money::Helpers::MAX_DECIMAL))
    end

    it "raises ArgumentError with unsupported argument" do
      expect { Money.from_amount(Object.new) }.to raise_error(ArgumentError)
    end
  end

  describe "YAML serialization" do
    it "accepts values with currencies" do
      money = YAML.dump(Money.new(750, 'usd'))
      expect(money).to eq("--- !ruby/object:Money\nvalue: '750.0'\ncurrency: USD\n")
    end

    it "does not change BigDecimal value to Integer while rounding for currencies without subunits" do
      money = Money.new(100, 'JPY').to_yaml
      expect(money).to eq("--- !ruby/object:Money\nvalue: '100.0'\ncurrency: JPY\n")
    end
  end

  describe "YAML deserialization" do
    it "accepts values with currencies" do
      money = yaml_load("--- !ruby/object:Money\nvalue: '750.0'\ncurrency: USD\n")
      expect(money).to eq(Money.new(750, 'usd'))
    end

    it "accepts values with null currencies" do
      money = yaml_load("--- !ruby/object:Money\nvalue: '750.0'\ncurrency: XXX\n")
      expect(money).to eq(Money.new(750))
    end

    it "accepts serialized NullCurrency objects" do
      money = yaml_load(<<~EOS)
        ---
        !ruby/object:Money
          currency: !ruby/object:Money::NullCurrency
            symbol: >-
              $
            disambiguate_symbol:
            iso_code: >-
              XXX
            iso_numeric: >-
              999
            name: >-
              No Currency
            smallest_denomination: 1
            subunit_to_unit: 100
            minor_units: 2
          value: !ruby/object:BigDecimal 27:0.6935E2
          cents: 6935
      EOS
      expect(money).to eq(Money.new(69.35, Money::NULL_CURRENCY))
    end

    it "accepts BigDecimal values" do
      money = yaml_load(<<~EOS)
        ---
        !ruby/object:Money
          value: !ruby/object:BigDecimal 18:0.75E3
          cents: 75000
      EOS
      expect(money).to be == Money.new(750)
      expect(money.value).to be_a BigDecimal
    end

    it "accepts old float values..." do
      money = yaml_load(<<~EOS)
        ---
        !ruby/object:Money
          value: 750.00
          cents: 75000
      EOS
      expect(money).to be == Money.new(750)
      expect(money.value).to be_a BigDecimal
    end
  end

  describe('.deprecate') do
    it "uses ruby warn if active support is not defined" do
      stub_const("ACTIVE_SUPPORT_DEFINED", false)
      expect(Kernel).to receive(:warn).once
      Money.deprecate('ok')
    end

    it "uses active support warn if active support is defined" do
      expect(Kernel).to receive(:warn).never
      expect_any_instance_of(ActiveSupport::Deprecation).to receive(:warn).once
      Money.deprecate('ok')
    end

    it "only sends a callstack of events outside of the money gem" do
      expect_any_instance_of(ActiveSupport::Deprecation).to receive(:warn).with(
        -> (message) { message == "[Shopify/Money] message\n" },
        -> (callstack) { !callstack.first.to_s.include?('gems/money') && callstack.size > 0 }
      )
      Money.deprecate('message')
    end
  end

  describe '#use_currency' do
    it "allows setting the implicit default currency for a block scope" do
      money = nil
      Money.with_currency('CAD') do
        money = Money.new(1.00)
      end

      expect(money.currency.iso_code).to eq('CAD')
    end

    it "does not use the currency for a block scope when explicitly set" do
      money = nil
      Money.with_currency('CAD') do
        money = Money.new(1.00, 'USD')
      end

      expect(money.currency.iso_code).to eq('USD')
    end

    context "with .default_currency set" do
      around(:each) { |test| configure(default_currency: Money::Currency.new('EUR')) { test.run }}

      it "can be nested and falls back to default_currency outside of the blocks" do
        money2, money3 = nil

        money1 = Money.new(1.00)
        Money.with_currency('CAD') do
          Money.with_currency('USD') do
            money2 = Money.new(1.00)
          end
          money3 = Money.new(1.00)
        end
        money4 = Money.new(1.00)

        expect(money1.currency.iso_code).to eq('EUR')
        expect(money2.currency.iso_code).to eq('USD')
        expect(money3.currency.iso_code).to eq('CAD')
        expect(money4.currency.iso_code).to eq('EUR')
      end
    end
  end

  describe '.clamp' do
    let(:max) { 9000 }
    let(:min) { -max }

    it 'returns the same value if the value is within the min..max range' do
      money = Money.new(5000, 'EUR').clamp(min, max)
      expect(money.value).to eq(5000)
      expect(money.currency.iso_code).to eq('EUR')
    end

    it 'returns the max value if the original value is larger' do
      money = Money.new(9001, 'EUR').clamp(min, max)
      expect(money.clamp(min, max).value).to eq(9000)
      expect(money.clamp(min, max).currency.iso_code).to eq('EUR')
    end

    it 'returns the min value if the original value is smaller' do
      money = Money.new(-9001, 'EUR').clamp(min, max)
      expect(money.value).to eq(-9000)
      expect(money.currency.iso_code).to eq('EUR')
    end
  end
end


text:
//// [derivedClassSuperProperties.ts]
declare const decorate: any;

class Base {
    constructor(a?) { }

    receivesAnything(param?) { }
}

class Derived1 extends Base {
    prop = true;
    constructor() {
        super.receivesAnything();
        super();
    }
}

class Derived2 extends Base {
    prop = true;
    constructor() {
        super.receivesAnything(this);
        super();
    }
}

class Derived3 extends Base {
    prop = true;
    constructor() {
        super.receivesAnything();
        super(this);
    }
}

class Derived4 extends Base {
    prop = true;
    constructor() {
        super.receivesAnything(this);
        super(this);
    }
}

class Derived5 extends Base {
    prop = true;
    constructor() {
        super();
        super.receivesAnything();
    }
}

class Derived6 extends Base {
    prop = true;
    constructor() {
        super(this);
        super.receivesAnything();
    }
}

class Derived7 extends Base {
    prop = true;
    constructor() {
        super();
        super.receivesAnything(this);
    }
}

class Derived8 extends Base {
    prop = true;
    constructor() {
        super(this);
        super.receivesAnything(this);
    }
}

class DerivedWithArrowFunction extends Base {
    prop = true;
    constructor() {
        (() => this)();
        super();
    }
}

class DerivedWithArrowFunctionParameter extends Base {
    prop = true;
    constructor() {
        const lambda = (param = this) => {};
        super();
    }
}

class DerivedWithDecoratorOnClass extends Base {
    prop = true;
    constructor() {
        @decorate(this)
        class InnerClass { }

        super();
    }
}

class DerivedWithDecoratorOnClassMethod extends Base {
    prop = true;
    constructor() {
        class InnerClass {
            @decorate(this)
            innerMethod() { }
        }

        super();
    }
}

class DerivedWithDecoratorOnClassProperty extends Base {
    prop = true;
    constructor() {
        class InnerClass {
            @decorate(this)
            innerProp = true;
        }

        super();
    }
}

class DerivedWithFunctionDeclaration extends Base {
    prop = true;
    constructor() {
        function declaration() {
            return this;
        }
        super();
    }
}

class DerivedWithFunctionDeclarationAndThisParam extends Base {
    prop = true;
    constructor() {
        function declaration(param = this) {
            return param;
        }
        super();
    }
}

class DerivedWithFunctionExpression extends Base {
    prop = true;
    constructor() {
        (function () {
            return this;
        })();
        super();
    }
}

class DerivedWithParenthesis extends Base {
    prop = true;
    constructor() {
        (super());
    }
}

class DerivedWithParenthesisAfterStatement extends Base {
    prop = true;
    constructor() {
        this.prop;
        (super());
    }
}

class DerivedWithParenthesisBeforeStatement extends Base {
    prop = true;
    constructor() {
        (super());
        this.prop;
    }
}

class DerivedWithClassDeclaration extends Base {
    prop = true;
    constructor() {
        class InnerClass {
            private method() {
                return this;
            }
            private property = 7;
            constructor() {
                this.property;
                this.method();
            }
        }
        super();
    }
}

class DerivedWithClassDeclarationExtendingMember extends Base {
    memberClass = class { };
    constructor() {
        class InnerClass extends this.memberClass {
            private method() {
                return this;
            }
            private property = 7;
            constructor() {
                super();
                this.property;
                this.method();
            }
        }
        super();
    }
}

class DerivedWithClassExpression extends Base {
    prop = true;
    constructor() {
        console.log(class {
            private method() {
                return this;
            }
            private property = 7;
            constructor() {
                this.property;
                this.method();
            }
        });
        super();
    }
}

class DerivedWithClassExpressionExtendingMember extends Base {
    memberClass = class { };
    constructor() {
        console.log(class extends this.memberClass { });
        super();
    }
}

class DerivedWithDerivedClassExpression extends Base {
    prop = true;
    constructor() {
        console.log(class extends Base {
            constructor() {
                super();
            }
            public foo() {
                return this;
            }
            public bar = () => this;
        });
        super();
    }
}

class DerivedWithNewDerivedClassExpression extends Base {
    prop = true;
    constructor() {
        console.log(new class extends Base {
            constructor() {
                super();
            }
        }());
        super();
    }
}

class DerivedWithObjectAccessors extends Base {
    prop = true;
    constructor() {
        const obj = {
            get prop() {
                return true;
            },
            set prop(param) {
                this._prop = param;
            }
        };
        super();
    }
}

class DerivedWithObjectAccessorsUsingThisInKeys extends Base {
    propName = "prop";
    constructor() {
        const obj = {
            _prop: "prop",
            get [this.propName]() {
                return true;
            },
            set [this.propName](param) {
                this._prop = param;
            }
        };
        super();
    }
}

class DerivedWithObjectAccessorsUsingThisInBodies extends Base {
    propName = "prop";
    constructor() {
        const obj = {
            _prop: "prop",
            get prop() {
                return this._prop;
            },
            set prop(param) {
                this._prop = param;
            }
        };
        super();
    }
}

class DerivedWithObjectComputedPropertyBody extends Base {
    propName = "prop";
    constructor() {
        const obj = {
            prop: this.propName,
        };
        super();
    }
}

class DerivedWithObjectComputedPropertyName extends Base {
    propName = "prop";
    constructor() {
        const obj = {
            [this.propName]: true,
        };
        super();
    }
}

class DerivedWithObjectMethod extends Base {
    prop = true;
    constructor() {
        const obj = {
            getProp() {
                return this;
            },
        };
        super();
    }
}

let a, b;

const DerivedWithLoops = [
    class extends Base {
        prop = true;
        constructor() {
            for(super();;) {}
        }
    },
    class extends Base {
        prop = true;
        constructor() {
            for(a; super();) {}
        }
    },
    class extends Base {
        prop = true;
        constructor() {
            for(a; b; super()) {}
        }
    },
    class extends Base {
        prop = true;
        constructor() {
            for(; ; super()) { break; }
        }
    },
    class extends Base {
        prop = true;
        constructor() {
            for (const x of super()) {}
        }
    },
    class extends Base {
        prop = true;
        constructor() {
            while (super()) {}
        }
    },
    class extends Base {
        prop = true;
        constructor() {
            do {} while (super());
        }
    },
    class extends Base {
        prop = true;
        constructor() {
            if (super()) {}
        }
    },
    class extends Base {
        prop = true;
        constructor() {
            switch (super()) {}
        }
    },
]

//// [derivedClassSuperProperties.js]
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var Base = /** @class */ (function () {
    function Base(a) {
    }
    Base.prototype.receivesAnything = function (param) { };
    return Base;
}());
var Derived1 = /** @class */ (function (_super) {
    __extends(Derived1, _super);
    function Derived1() {
        var _this = this;
        _super.prototype.receivesAnything.call(_this);
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return Derived1;
}(Base));
var Derived2 = /** @class */ (function (_super) {
    __extends(Derived2, _super);
    function Derived2() {
        var _this = this;
        _super.prototype.receivesAnything.call(_this, _this);
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return Derived2;
}(Base));
var Derived3 = /** @class */ (function (_super) {
    __extends(Derived3, _super);
    function Derived3() {
        var _this = this;
        _super.prototype.receivesAnything.call(_this);
        _this = _super.call(this, _this) || this;
        _this.prop = true;
        return _this;
    }
    return Derived3;
}(Base));
var Derived4 = /** @class */ (function (_super) {
    __extends(Derived4, _super);
    function Derived4() {
        var _this = this;
        _super.prototype.receivesAnything.call(_this, _this);
        _this = _super.call(this, _this) || this;
        _this.prop = true;
        return _this;
    }
    return Derived4;
}(Base));
var Derived5 = /** @class */ (function (_super) {
    __extends(Derived5, _super);
    function Derived5() {
        var _this = _super.call(this) || this;
        _this.prop = true;
        _super.prototype.receivesAnything.call(_this);
        return _this;
    }
    return Derived5;
}(Base));
var Derived6 = /** @class */ (function (_super) {
    __extends(Derived6, _super);
    function Derived6() {
        var _this = _super.call(this, _this) || this;
        _this.prop = true;
        _super.prototype.receivesAnything.call(_this);
        return _this;
    }
    return Derived6;
}(Base));
var Derived7 = /** @class */ (function (_super) {
    __extends(Derived7, _super);
    function Derived7() {
        var _this = _super.call(this) || this;
        _this.prop = true;
        _super.prototype.receivesAnything.call(_this, _this);
        return _this;
    }
    return Derived7;
}(Base));
var Derived8 = /** @class */ (function (_super) {
    __extends(Derived8, _super);
    function Derived8() {
        var _this = _super.call(this, _this) || this;
        _this.prop = true;
        _super.prototype.receivesAnything.call(_this, _this);
        return _this;
    }
    return Derived8;
}(Base));
var DerivedWithArrowFunction = /** @class */ (function (_super) {
    __extends(DerivedWithArrowFunction, _super);
    function DerivedWithArrowFunction() {
        var _this = this;
        (function () { return _this; })();
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithArrowFunction;
}(Base));
var DerivedWithArrowFunctionParameter = /** @class */ (function (_super) {
    __extends(DerivedWithArrowFunctionParameter, _super);
    function DerivedWithArrowFunctionParameter() {
        var _this = this;
        var lambda = function (param) {
            if (param === void 0) { param = _this; }
        };
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithArrowFunctionParameter;
}(Base));
var DerivedWithDecoratorOnClass = /** @class */ (function (_super) {
    __extends(DerivedWithDecoratorOnClass, _super);
    function DerivedWithDecoratorOnClass() {
        var _this = this;
        var InnerClass = /** @class */ (function () {
            function InnerClass() {
            }
            InnerClass = __decorate([
                decorate(this)
            ], InnerClass);
            return InnerClass;
        }());
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithDecoratorOnClass;
}(Base));
var DerivedWithDecoratorOnClassMethod = /** @class */ (function (_super) {
    __extends(DerivedWithDecoratorOnClassMethod, _super);
    function DerivedWithDecoratorOnClassMethod() {
        var _this = this;
        var InnerClass = /** @class */ (function () {
            function InnerClass() {
            }
            InnerClass.prototype.innerMethod = function () { };
            __decorate([
                decorate(this)
            ], InnerClass.prototype, "innerMethod", null);
            return InnerClass;
        }());
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithDecoratorOnClassMethod;
}(Base));
var DerivedWithDecoratorOnClassProperty = /** @class */ (function (_super) {
    __extends(DerivedWithDecoratorOnClassProperty, _super);
    function DerivedWithDecoratorOnClassProperty() {
        var _this = this;
        var InnerClass = /** @class */ (function () {
            function InnerClass() {
                this.innerProp = true;
            }
            __decorate([
                decorate(this)
            ], InnerClass.prototype, "innerProp", void 0);
            return InnerClass;
        }());
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithDecoratorOnClassProperty;
}(Base));
var DerivedWithFunctionDeclaration = /** @class */ (function (_super) {
    __extends(DerivedWithFunctionDeclaration, _super);
    function DerivedWithFunctionDeclaration() {
        var _this = this;
        function declaration() {
            return this;
        }
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithFunctionDeclaration;
}(Base));
var DerivedWithFunctionDeclarationAndThisParam = /** @class */ (function (_super) {
    __extends(DerivedWithFunctionDeclarationAndThisParam, _super);
    function DerivedWithFunctionDeclarationAndThisParam() {
        var _this = this;
        function declaration(param) {
            if (param === void 0) { param = this; }
            return param;
        }
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithFunctionDeclarationAndThisParam;
}(Base));
var DerivedWithFunctionExpression = /** @class */ (function (_super) {
    __extends(DerivedWithFunctionExpression, _super);
    function DerivedWithFunctionExpression() {
        var _this = this;
        (function () {
            return this;
        })();
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithFunctionExpression;
}(Base));
var DerivedWithParenthesis = /** @class */ (function (_super) {
    __extends(DerivedWithParenthesis, _super);
    function DerivedWithParenthesis() {
        var _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithParenthesis;
}(Base));
var DerivedWithParenthesisAfterStatement = /** @class */ (function (_super) {
    __extends(DerivedWithParenthesisAfterStatement, _super);
    function DerivedWithParenthesisAfterStatement() {
        var _this = this;
        _this.prop;
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithParenthesisAfterStatement;
}(Base));
var DerivedWithParenthesisBeforeStatement = /** @class */ (function (_super) {
    __extends(DerivedWithParenthesisBeforeStatement, _super);
    function DerivedWithParenthesisBeforeStatement() {
        var _this = _super.call(this) || this;
        _this.prop = true;
        _this.prop;
        return _this;
    }
    return DerivedWithParenthesisBeforeStatement;
}(Base));
var DerivedWithClassDeclaration = /** @class */ (function (_super) {
    __extends(DerivedWithClassDeclaration, _super);
    function DerivedWithClassDeclaration() {
        var _this = this;
        var InnerClass = /** @class */ (function () {
            function InnerClass() {
                this.property = 7;
                this.property;
                this.method();
            }
            InnerClass.prototype.method = function () {
                return this;
            };
            return InnerClass;
        }());
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithClassDeclaration;
}(Base));
var DerivedWithClassDeclarationExtendingMember = /** @class */ (function (_super) {
    __extends(DerivedWithClassDeclarationExtendingMember, _super);
    function DerivedWithClassDeclarationExtendingMember() {
        var _this = this;
        var InnerClass = /** @class */ (function (_super) {
            __extends(InnerClass, _super);
            function InnerClass() {
                var _this = _super.call(this) || this;
                _this.property = 7;
                _this.property;
                _this.method();
                return _this;
            }
            InnerClass.prototype.method = function () {
                return this;
            };
            return InnerClass;
        }(_this.memberClass));
        _this = _super.call(this) || this;
        _this.memberClass = /** @class */ (function () {
            function class_1() {
            }
            return class_1;
        }());
        return _this;
    }
    return DerivedWithClassDeclarationExtendingMember;
}(Base));
var DerivedWithClassExpression = /** @class */ (function (_super) {
    __extends(DerivedWithClassExpression, _super);
    function DerivedWithClassExpression() {
        var _this = this;
        console.log(/** @class */ (function () {
            function class_2() {
                this.property = 7;
                this.property;
                this.method();
            }
            class_2.prototype.method = function () {
                return this;
            };
            return class_2;
        }()));
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithClassExpression;
}(Base));
var DerivedWithClassExpressionExtendingMember = /** @class */ (function (_super) {
    __extends(DerivedWithClassExpressionExtendingMember, _super);
    function DerivedWithClassExpressionExtendingMember() {
        var _this = this;
        console.log(/** @class */ (function (_super) {
            __extends(class_3, _super);
            function class_3() {
                return _super !== null && _super.apply(this, arguments) || this;
            }
            return class_3;
        }(_this.memberClass)));
        _this = _super.call(this) || this;
        _this.memberClass = /** @class */ (function () {
            function class_4() {
            }
            return class_4;
        }());
        return _this;
    }
    return DerivedWithClassExpressionExtendingMember;
}(Base));
var DerivedWithDerivedClassExpression = /** @class */ (function (_super) {
    __extends(DerivedWithDerivedClassExpression, _super);
    function DerivedWithDerivedClassExpression() {
        var _this = this;
        console.log(/** @class */ (function (_super) {
            __extends(class_5, _super);
            function class_5() {
                var _this = _super.call(this) || this;
                _this.bar = function () { return _this; };
                return _this;
            }
            class_5.prototype.foo = function () {
                return this;
            };
            return class_5;
        }(Base)));
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithDerivedClassExpression;
}(Base));
var DerivedWithNewDerivedClassExpression = /** @class */ (function (_super) {
    __extends(DerivedWithNewDerivedClassExpression, _super);
    function DerivedWithNewDerivedClassExpression() {
        var _this = this;
        console.log(new /** @class */ (function (_super) {
            __extends(class_6, _super);
            function class_6() {
                return _super.call(this) || this;
            }
            return class_6;
        }(Base))());
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithNewDerivedClassExpression;
}(Base));
var DerivedWithObjectAccessors = /** @class */ (function (_super) {
    __extends(DerivedWithObjectAccessors, _super);
    function DerivedWithObjectAccessors() {
        var _this = this;
        var obj = {
            get prop() {
                return true;
            },
            set prop(param) {
                this._prop = param;
            }
        };
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithObjectAccessors;
}(Base));
var DerivedWithObjectAccessorsUsingThisInKeys = /** @class */ (function (_super) {
    var _a;
    __extends(DerivedWithObjectAccessorsUsingThisInKeys, _super);
    function DerivedWithObjectAccessorsUsingThisInKeys() {
        var _this = this;
        var obj = (_a = {
                _prop: "prop"
            },
            Object.defineProperty(_a, _this.propName, {
                get: function () {
                    return true;
                },
                enumerable: false,
                configurable: true
            }),
            Object.defineProperty(_a, _this.propName, {
                set: function (param) {
                    this._prop = param;
                },
                enumerable: false,
                configurable: true
            }),
            _a);
        _this = _super.call(this) || this;
        _this.propName = "prop";
        return _this;
    }
    return DerivedWithObjectAccessorsUsingThisInKeys;
}(Base));
var DerivedWithObjectAccessorsUsingThisInBodies = /** @class */ (function (_super) {
    __extends(DerivedWithObjectAccessorsUsingThisInBodies, _super);
    function DerivedWithObjectAccessorsUsingThisInBodies() {
        var _this = this;
        var obj = {
            _prop: "prop",
            get prop() {
                return this._prop;
            },
            set prop(param) {
                this._prop = param;
            }
        };
        _this = _super.call(this) || this;
        _this.propName = "prop";
        return _this;
    }
    return DerivedWithObjectAccessorsUsingThisInBodies;
}(Base));
var DerivedWithObjectComputedPropertyBody = /** @class */ (function (_super) {
    __extends(DerivedWithObjectComputedPropertyBody, _super);
    function DerivedWithObjectComputedPropertyBody() {
        var _this = this;
        var obj = {
            prop: _this.propName,
        };
        _this = _super.call(this) || this;
        _this.propName = "prop";
        return _this;
    }
    return DerivedWithObjectComputedPropertyBody;
}(Base));
var DerivedWithObjectComputedPropertyName = /** @class */ (function (_super) {
    var _b;
    __extends(DerivedWithObjectComputedPropertyName, _super);
    function DerivedWithObjectComputedPropertyName() {
        var _this = this;
        var obj = (_b = {},
            _b[_this.propName] = true,
            _b);
        _this = _super.call(this) || this;
        _this.propName = "prop";
        return _this;
    }
    return DerivedWithObjectComputedPropertyName;
}(Base));
var DerivedWithObjectMethod = /** @class */ (function (_super) {
    __extends(DerivedWithObjectMethod, _super);
    function DerivedWithObjectMethod() {
        var _this = this;
        var obj = {
            getProp: function () {
                return this;
            },
        };
        _this = _super.call(this) || this;
        _this.prop = true;
        return _this;
    }
    return DerivedWithObjectMethod;
}(Base));
var a, b;
var DerivedWithLoops = [
    /** @class */ (function (_super) {
        __extends(class_7, _super);
        function class_7() {
            var _this = this;
            _this.prop = true;
            for (_this = _super.call(this) || this;;) { }
            return _this;
        }
        return class_7;
    }(Base)),
    /** @class */ (function (_super) {
        __extends(class_8, _super);
        function class_8() {
            var _this = this;
            _this.prop = true;
            for (a; _this = _super.call(this) || this;) { }
            return _this;
        }
        return class_8;
    }(Base)),
    /** @class */ (function (_super) {
        __extends(class_9, _super);
        function class_9() {
            var _this = this;
            _this.prop = true;
            for (a; b; _this = _super.call(this) || this) { }
            return _this;
        }
        return class_9;
    }(Base)),
    /** @class */ (function (_super) {
        __extends(class_10, _super);
        function class_10() {
            var _this = this;
            _this.prop = true;
            for (;; _this = _super.call(this) || this) {
                break;
            }
            return _this;
        }
        return class_10;
    }(Base)),
    /** @class */ (function (_super) {
        __extends(class_11, _super);
        function class_11() {
            var _this = this;
            _this.prop = true;
            for (var _i = 0, _a = _this = _super.call(this) || this; _i < _a.length; _i++) {
                var x = _a[_i];
            }
            return _this;
        }
        return class_11;
    }(Base)),
    /** @class */ (function (_super) {
        __extends(class_12, _super);
        function class_12() {
            var _this = this;
            _this.prop = true;
            while (_this = _super.call(this) || this) { }
            return _this;
        }
        return class_12;
    }(Base)),
    /** @class */ (function (_super) {
        __extends(class_13, _super);
        function class_13() {
            var _this = this;
            _this.prop = true;
            do { } while (_this = _super.call(this) || this);
            return _this;
        }
        return class_13;
    }(Base)),
    /** @class */ (function (_super) {
        __extends(class_14, _super);
        function class_14() {
            var _this = this;
            _this.prop = true;
            if (_this = _super.call(this) || this) { }
            return _this;
        }
        return class_14;
    }(Base)),
    /** @class */ (function (_super) {
        __extends(class_15, _super);
        function class_15() {
            var _this = this;
            _this.prop = true;
            switch (_this = _super.call(this) || this) {
            }
            return _this;
        }
        return class_15;
    }(Base)),
];


text:
using System;
using System.Net.WebSockets;
using System.Runtime.InteropServices;

internal static partial class Interop
{
    internal static partial class WebSocket
    {
        [StructLayout(LayoutKind.Explicit)]
        internal struct Buffer
        {
            [FieldOffset(0)]
            internal DataBuffer Data;
            [FieldOffset(0)]
            internal CloseBuffer CloseStatus;
        }

        [StructLayout(LayoutKind.Sequential)]
        internal struct Property
        {
            internal WebSocketProtocolComponent.PropertyType Type;
            internal IntPtr PropertyData;
            internal uint PropertySize;
        }

        [StructLayout(LayoutKind.Sequential)]
        internal struct DataBuffer
        {
            internal IntPtr BufferData;
            internal uint BufferLength;
        }

        [StructLayout(LayoutKind.Sequential)]
        internal struct CloseBuffer
        {
            internal IntPtr ReasonData;
            internal uint ReasonLength;
            internal ushort CloseStatus;
        }

        [StructLayout(LayoutKind.Sequential)]
        internal struct HttpHeader
        {
            [MarshalAs(UnmanagedType.LPStr)]
            internal string Name;
            internal uint NameLength;
            [MarshalAs(UnmanagedType.LPStr)]
            internal string Value;
            internal uint ValueLength;
        }
    }
}


text:
namespace draco {

// Factory class for creating mesh prediction schemes. The factory implements
// operator() that is used to create an appropriate mesh prediction scheme in
// CreateMeshPredictionScheme() function in prediction_scheme_factory.h
template <typename DataTypeT>
struct MeshPredictionSchemeDecoderFactory {
  // Operator () specialized for the wrap transform. Wrap transform can be used
  // for all mesh prediction schemes. The specialization is done in compile time
  // to prevent instantiations of unneeded combinations of prediction schemes +
  // prediction transforms.
  template <class TransformT, class MeshDataT,
            PredictionSchemeTransformType Method>
  struct DispatchFunctor {
    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
        PredictionSchemeMethod method, const PointAttribute *attribute,
        const TransformT &transform, const MeshDataT &mesh_data,
        uint16_t bitstream_version) {
      if (method == MESH_PREDICTION_PARALLELOGRAM) {
        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
            new MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
                                                         MeshDataT>(
                attribute, transform, mesh_data));
      }
#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
      else if (method == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
            new MeshPredictionSchemeMultiParallelogramDecoder<
                DataTypeT, TransformT, MeshDataT>(attribute, transform,
                                                  mesh_data));
      }
#endif
      else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
            new MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
                DataTypeT, TransformT, MeshDataT>(attribute, transform,
                                                  mesh_data));
      }
#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
      else if (method == MESH_PREDICTION_TEX_COORDS_DEPRECATED) {
        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
            new MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT,
                                                     MeshDataT>(
                attribute, transform, mesh_data, bitstream_version));
      }
#endif
      else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
            new MeshPredictionSchemeTexCoordsPortableDecoder<
                DataTypeT, TransformT, MeshDataT>(attribute, transform,
                                                  mesh_data));
      }
#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
      else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
            new MeshPredictionSchemeGeometricNormalDecoder<
                DataTypeT, TransformT, MeshDataT>(attribute, transform,
                                                  mesh_data));
      }
#endif
      return nullptr;
    }
  };

#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
  // Operator () specialized for normal octahedron transforms. These transforms
  // are currently used only by the geometric normal prediction scheme (the
  // transform is also used by delta coding, but delta predictor is not
  // constructed in this function).
  template <class TransformT, class MeshDataT>
  struct DispatchFunctor<TransformT, MeshDataT,
                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED> {
    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
        PredictionSchemeMethod method, const PointAttribute *attribute,
        const TransformT &transform, const MeshDataT &mesh_data,
        uint16_t bitstream_version) {
      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
            new MeshPredictionSchemeGeometricNormalDecoder<
                DataTypeT, TransformT, MeshDataT>(attribute, transform,
                                                  mesh_data));
      }
      return nullptr;
    }
  };
  template <class TransformT, class MeshDataT>
  struct DispatchFunctor<TransformT, MeshDataT,
                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON> {
    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
        PredictionSchemeMethod method, const PointAttribute *attribute,
        const TransformT &transform, const MeshDataT &mesh_data,
        uint16_t bitstream_version) {
      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
            new MeshPredictionSchemeGeometricNormalDecoder<
                DataTypeT, TransformT, MeshDataT>(attribute, transform,
                                                  mesh_data));
      }
      return nullptr;
    }
  };
#endif

  template <class TransformT, class MeshDataT>
  std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
      PredictionSchemeMethod method, const PointAttribute *attribute,
      const TransformT &transform, const MeshDataT &mesh_data,
      uint16_t bitstream_version) {
    return DispatchFunctor<TransformT, MeshDataT, TransformT::GetType()>()(
        method, attribute, transform, mesh_data, bitstream_version);
  }
};

// Creates a prediction scheme for a given decoder and given prediction method.
// The prediction schemes are automatically initialized with decoder specific
// data if needed.
template <typename DataTypeT, class TransformT>
std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>
CreatePredictionSchemeForDecoder(PredictionSchemeMethod method, int att_id,
                                 const PointCloudDecoder *decoder,
                                 const TransformT &transform) {
  if (method == PREDICTION_NONE) {
    return nullptr;
  }
  const PointAttribute *const att = decoder->point_cloud()->attribute(att_id);
  if (decoder->GetGeometryType() == TRIANGULAR_MESH) {
    // Cast the decoder to mesh decoder. This is not necessarily safe if there
    // is some other decoder decides to use TRIANGULAR_MESH as the return type,
    // but unfortunately there is not nice work around for this without using
    // RTTI (double dispatch and similar concepts will not work because of the
    // template nature of the prediction schemes).
    const MeshDecoder *const mesh_decoder =
        static_cast<const MeshDecoder *>(decoder);

    auto ret = CreateMeshPredictionScheme<
        MeshDecoder, PredictionSchemeDecoder<DataTypeT, TransformT>,
        MeshPredictionSchemeDecoderFactory<DataTypeT>>(
        mesh_decoder, method, att_id, transform, decoder->bitstream_version());
    if (ret) {
      return ret;
    }
    // Otherwise try to create another prediction scheme.
  }
  // Create delta decoder.
  return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
      new PredictionSchemeDeltaDecoder<DataTypeT, TransformT>(att, transform));
}

// Create a prediction scheme using a default transform constructor.
template <typename DataTypeT, class TransformT>
std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>
CreatePredictionSchemeForDecoder(PredictionSchemeMethod method, int att_id,
                                 const PointCloudDecoder *decoder) {
  return CreatePredictionSchemeForDecoder<DataTypeT, TransformT>(
      method, att_id, decoder, TransformT());
}

}  // namespace draco

#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_


text:
using System.Collections.Generic;

public interface IFragmentSubsets : IDictionary<string, string>
{
    IFragment OwningFragment { get; set; }
}


text:
<?php

namespace common\models;

use Yii;

/**
 * This is the model class for table "homeworks".
 *
 * @property integer $id
 * @property string $name
 * @property integer $mark
 */
class Homework extends \yii\db\ActiveRecord
{
    /**
     * @inheritdoc
     */
    public static function tableName()
    {
        return 'homeworks';
    }

    /**
     * @inheritdoc
     */
    public function rules()
    {
        return [

            [['name'], 'string', 'max' => 25],
            [['subject_id'], 'integer'],
        ];
    }

    public function getSubject()
    {
        return $this->hasOne(Subject::className(), ['id' => 'subject_id']);
    }

    /**
     * @inheritdoc
     */
    public function attributeLabels()
    {
        return [
            'id' => 'ID',
            'name' => 'Name',

            'subject_id' => 'Department ID',
        ];
    }
}


text:
<?php
/**
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 */

namespace MediaWiki\Logger;

use MediaWiki\Logger\Monolog\BufferHandler;
use Monolog\Logger;
use ObjectFactory;

/**
 * LoggerFactory service provider that creates loggers implemented by
 * Monolog.
 *
 * Configured using an array of configuration data with the keys 'loggers',
 * 'processors', 'handlers' and 'formatters'.
 *
 * The ['loggers']['\@default'] configuration will be used to create loggers
 * for any channel that isn't explicitly named in the 'loggers' configuration
 * section.
 *
 * Configuration will most typically be provided in the $wgMWLoggerDefaultSpi
 * global configuration variable used by LoggerFactory to construct its
 * default SPI provider:
 * @code
 * $wgMWLoggerDefaultSpi = array(
 *   'class' => '\\MediaWiki\\Logger\\MonologSpi',
 *   'args' => array( array(
 *       'loggers' => array(
 *           '@default' => array(
 *               'processors' => array( 'wiki', 'psr', 'pid', 'uid', 'web' ),
 *               'handlers'   => array( 'stream' ),
 *           ),
 *           'runJobs' => array(
 *               'processors' => array( 'wiki', 'psr', 'pid' ),
 *               'handlers'   => array( 'stream' ),
 *           )
 *       ),
 *       'processors' => array(
 *           'wiki' => array(
 *               'class' => '\\MediaWiki\\Logger\\Monolog\\WikiProcessor',
 *           ),
 *           'psr' => array(
 *               'class' => '\\Monolog\\Processor\\PsrLogMessageProcessor',
 *           ),
 *           'pid' => array(
 *               'class' => '\\Monolog\\Processor\\ProcessIdProcessor',
 *           ),
 *           'uid' => array(
 *               'class' => '\\Monolog\\Processor\\UidProcessor',
 *           ),
 *           'web' => array(
 *               'class' => '\\Monolog\\Processor\\WebProcessor',
 *           ),
 *       ),
 *       'handlers' => array(
 *           'stream' => array(
 *               'class'     => '\\Monolog\\Handler\\StreamHandler',
 *               'args'      => array( 'path/to/your.log' ),
 *               'formatter' => 'line',
 *           ),
 *           'redis' => array(
 *               'class'     => '\\Monolog\\Handler\\RedisHandler',
 *               'args'      => array( function() {
 *                       $redis = new Redis();
 *                       $redis->connect( '127.0.0.1', 6379 );
 *                       return $redis;
 *                   },
 *                   'logstash'
 *               ),
 *               'formatter' => 'logstash',
 *               'buffer' => true,
 *           ),
 *           'udp2log' => array(
 *               'class' => '\\MediaWiki\\Logger\\Monolog\\LegacyHandler',
 *               'args' => array(
 *                   'udp://127.0.0.1:8420/mediawiki
 *               ),
 *               'formatter' => 'line',
 *           ),
 *       ),
 *       'formatters' => array(
 *           'line' => array(
 *               'class' => '\\Monolog\\Formatter\\LineFormatter',
 *            ),
 *            'logstash' => array(
 *                'class' => '\\Monolog\\Formatter\\LogstashFormatter',
 *                'args'  => array( 'mediawiki', php_uname( 'n' ), null, '', 1 ),
 *            ),
 *       ),
 *   ) ),
 * );
 * @endcode
 *
 * @see https://github.com/Seldaek/monolog
 * @since 1.25
 * @author Bryan Davis <bd808@wikimedia.org>
 * @copyright © 2014 Bryan Davis and Wikimedia Foundation.
 */
class MonologSpi implements Spi {

	/**
	 * @var array $singletons
	 */
	protected $singletons;

	/**
	 * Configuration for creating new loggers.
	 * @var array $config
	 */
	protected $config;

	/**
	 * @param array $config Configuration data.
	 */
	public function __construct( array $config ) {
		$this->config = array();
		$this->mergeConfig( $config );
	}

	/**
	 * Merge additional configuration data into the configuration.
	 *
	 * @since 1.26
	 * @param array $config Configuration data.
	 */
	public function mergeConfig( array $config ) {
		foreach ( $config as $key => $value ) {
			if ( isset( $this->config[$key] ) ) {
				$this->config[$key] = array_merge( $this->config[$key], $value );
			} else {
				$this->config[$key] = $value;
			}
		}
		$this->reset();
	}

	/**
	 * Reset internal caches.
	 *
	 * This is public for use in unit tests. Under normal operation there should
	 * be no need to flush the caches.
	 */
	public function reset() {
		$this->singletons = array(
			'loggers'    => array(),
			'handlers'   => array(),
			'formatters' => array(),
			'processors' => array(),
		);
	}

	/**
	 * Get a logger instance.
	 *
	 * Creates and caches a logger instance based on configuration found in the
	 * $wgMWLoggerMonologSpiConfig global. Subsequent request for the same channel
	 * name will return the cached instance.
	 *
	 * @param string $channel Logging channel
	 * @return \\Psr\\Log\\LoggerInterface Logger instance
	 */
	public function getLogger( $channel ) {
		if ( !isset( $this->singletons['loggers'][$channel] ) ) {
			// Fallback to using the '@default' configuration if an explict
			// configuration for the requested channel isn't found.
			$spec = isset( $this->config['loggers'][$channel] ) ?
				$this->config['loggers'][$channel] :
				$this->config['loggers']['@default'];

			$monolog = $this->createLogger( $channel, $spec );
			$this->singletons['loggers'][$channel] = $monolog;
		}

		return $this->singletons['loggers'][$channel];
	}

	/**
	 * Create a logger.
	 * @param string $channel Logger channel
	 * @param array $spec Configuration
	 * @return \\Monolog\\Logger
	 */
	protected function createLogger( $channel, $spec ) {
		$obj = new Logger( $channel );

		if ( isset( $spec['processors'] ) ) {
			foreach ( $spec['processors'] as $processor ) {
				$obj->pushProcessor( $this->getProcessor( $processor ) );
			}
		}

		if ( isset( $spec['handlers'] ) ) {
			foreach ( $spec['handlers'] as $handler ) {
				$obj->pushHandler( $this->getHandler( $handler ) );
			}
		}
		return $obj;
	}

	/**
	 * Create or return cached processor.
	 * @param string $name Processor name
	 * @return callable
	 */
	public function getProcessor( $name ) {
		if ( !isset( $this->singletons['processors'][$name] ) ) {
			$spec = $this->config['processors'][$name];
			$processor = ObjectFactory::getObjectFromSpec( $spec );
			$this->singletons['processors'][$name] = $processor;
		}
		return $this->singletons['processors'][$name];
	}

	/**
	 * Create or return cached handler.
	 * @param string $name Processor name
	 * @return \\Monolog\\Handler\\HandlerInterface
	 */
	public function getHandler( $name ) {
		if ( !isset( $this->singletons['handlers'][$name] ) ) {
			$spec = $this->config['handlers'][$name];
			$handler = ObjectFactory::getObjectFromSpec( $spec );
			if ( isset( $spec['formatter'] ) ) {
				$handler->setFormatter(
					$this->getFormatter( $spec['formatter'] )
				);
			}
			if ( isset( $spec['buffer'] ) && $spec['buffer'] ) {
				$handler = new BufferHandler( $handler );
			}
			$this->singletons['handlers'][$name] = $handler;
		}
		return $this->singletons['handlers'][$name];
	}

	/**
	 * Create or return cached formatter.
	 * @param string $name Formatter name
	 * @return \\Monolog\\Formatter\\FormatterInterface
	 */
	public function getFormatter( $name ) {
		if ( !isset( $this->singletons['formatters'][$name] ) ) {
			$spec = $this->config['formatters'][$name];
			$formatter = ObjectFactory::getObjectFromSpec( $spec );
			$this->singletons['formatters'][$name] = $formatter;
		}
		return $this->singletons['formatters'][$name];
	}
}


text:
var WebdriverManager = require('./lib/index');

var wm = new WebdriverManager('my-selenium-path');

// { standalone: 'not present', chrome: 'not present', ie: 'not present' }
console.log(wm.status());

// Install Selenium Standalone and Google Chrome
wm.install(['standalone', 'chrome'], function (err, filenames) {

  console.log(filenames);

  // { standalone: 'ready', chrome: 'ready', ie: 'not present' }
  console.log(wm.status());

  // Start selenium
  wm.start();
});


text:
layout: recipe
keywords:
  - altele
  - pește
  - somon
title: Sandviș cu somon
ingrediente:
  - pâine
  - somon afumat file
  - unt
  - piper
  - verdețuri
  - maioneză
  - morcov (opțional)
mod_de_preparare:
  - prăjim pâinea și o ungem cu unt
  - depinde de cum e preparat somonul, daca poți să îl pisezi puțin, să arate a ton din conservă, fă asta și adaugă maioneza, dacă nu, unge tonul cu maioneză
  - punem somonul pe pâine
  - multă lămâie, multe verdețuri, mult piper
  - pune morcov tras prin răzătoare
trivia: Something smells fishy
---


text:
#include "util/string/str_agent.h"
#include <string.h>
#include <strings.h>
#include <errno.h>

/*
 * These function declarations represents binary interface definition of
 *   Linux Standard Base Core Specification 3.1
 *   Copyright (c) 2004, 2005 Free Standards Group
 *
 *   See section 'Data Definitions for libc'.
 *
 *   Why is it absent in 'string.h'?
 */
char * __strdup(const char* string);

/********************************************************************/
/**                         Agent Commands                         **/
/********************************************************************/

static TACommandVerdict __stpcpy_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = __stpcpy(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict __strdup_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    errno = 0;
    res = __strdup(s1);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    writeInt(thread, errno);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict rindex_cmd(TAThread thread,TAInputStream stream)
{
    char* s;
    int   c;
    char* res;

    // Prepare
    s = (char*)readPointer(&stream);
    c = readInt(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = rindex(s, c);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict stpcpy_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = stpcpy(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict stpncpy_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    size_t n;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = stpncpy(s1, s2, n);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strcat_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strcat(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict index_cmd(TAThread thread,TAInputStream stream)
{
    char* s;
    int   c;
    char* res;

    // Prepare
    s = (char*)readPointer(&stream);
    c = readInt(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = index(s, c);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strchr_cmd(TAThread thread,TAInputStream stream)
{
    char* s;
    int   c;
    char* res;

    // Prepare
    s = (char*)readPointer(&stream);
    c = readInt(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strchr(s, c);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strcmp_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    int res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strcmp(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writeInt(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strcpy_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strcpy(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strcspn_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    size_t res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strcspn(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writeSize(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strdup_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    errno = 0;
    res = strdup(s1);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    writeInt(thread, errno);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strlen_cmd(TAThread thread, TAInputStream stream)
{
    char* s;
    size_t res;

    // Prepare
    s = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strlen(s);

    END_TARGET_OPERATION(thread);

    // Response
    writeSize(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strncat_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    size_t n;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strncat(s1, s2, n);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strncmp_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    size_t n;
    int res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strncmp(s1, s2, n);

    END_TARGET_OPERATION(thread);

    // Response
    writeInt(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strncpy_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    size_t n;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strncpy(s1, s2, n);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strndup_cmd(TAThread thread, TAInputStream stream)
{
    char* s;
    size_t n;
    char* res;

    // Prepare
    s = (char*)readPointer(&stream);
    n = readSize(&stream);

   START_TARGET_OPERATION(thread);

    // Execute
    errno = 0;
    res = strndup(s,n);

    END_TARGET_OPERATION(thread);
    // Execute

    // Response
    writePointer(thread, res);
    writeInt(thread, errno);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strnlen_cmd(TAThread thread, TAInputStream stream)
{
    char* s;
    size_t n;
    size_t res;

    // Prepare
    s = (char*)readPointer(&stream);
    n = readSize(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strnlen(s,n);

    END_TARGET_OPERATION(thread);

    // Response
    writeSize(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strpbrk_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strpbrk(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strrchr_cmd(TAThread thread, TAInputStream stream)
{
    char* s;
    int   c;
    char* res;

    // Prepare
    s = (char*)readPointer(&stream);
    c = readInt(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strrchr(s, c);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strspn_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    size_t res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strspn(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writeSize(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

static TACommandVerdict strstr_cmd(TAThread thread, TAInputStream stream)
{
    char* s1;
    char* s2;
    char* res;

    // Prepare
    s1 = (char*)readPointer(&stream);
    s2 = (char*)readPointer(&stream);

    START_TARGET_OPERATION(thread);

    // Execute
    res = strstr(s1, s2);

    END_TARGET_OPERATION(thread);

    // Response
    writePointer(thread, res);
    sendResponse(thread);

    return taDefaultVerdict;
}

/********************************************************************/
/**                      Agent Initialization                      **/
/********************************************************************/
void register_util_string_str_commands(void)
{
    ta_register_command("__stpcpy",__stpcpy_cmd);
    ta_register_command("__strdup",__strdup_cmd);
    ta_register_command("rindex",rindex_cmd);
    ta_register_command("stpcpy",stpcpy_cmd);
    ta_register_command("stpncpy",stpncpy_cmd);
    ta_register_command("strcat",strcat_cmd);
    ta_register_command("index",index_cmd);
    ta_register_command("strchr",strchr_cmd);
    ta_register_command("strcmp",strcmp_cmd);
    ta_register_command("strcpy",strcpy_cmd);
    ta_register_command("strcspn",strcspn_cmd);
    ta_register_command("strdup",strdup_cmd);
    ta_register_command("strlen",strlen_cmd);
    ta_register_command("strncat",strncat_cmd);
    ta_register_command("strncmp",strncmp_cmd);
    ta_register_command("strncpy",strncpy_cmd);
    ta_register_command("strndup",strndup_cmd);
    ta_register_command("strnlen",strnlen_cmd);
    ta_register_command("strpbrk",strpbrk_cmd);
    ta_register_command("strrchr",strrchr_cmd);
    ta_register_command("strspn",strspn_cmd);
    ta_register_command("strstr",strstr_cmd);
}


text:
import declare from 'dojo/_base/declare';
import lang from 'dojo/_base/lang';
import List from 'argos/List';
import format from 'crm/Format';
import MODEL_NAMES from '../../Models/Names';
import getResource from 'argos/I18n';

const resource = getResource('unitsOfMeasureList');

const __class = declare('crm.Integrations.BOE.Views.UnitsOfMeasure.List', [List], {
  formatter: format,
  // Templates
  itemTemplate: new Simplate([
    '
{%: $.Name %}
',
  ]),

  // Localization
  titleText: resource.titleText,

  // View Properties
  id: 'unitofmeasure_list',
  detailView: '',
  modelName: MODEL_NAMES.UNITOFMEASURE,
  resourceKind: 'unitsOfMeasure',
  enableActions: false,
  expose: false,

  // Card layout
  itemIconClass: '',

  // Metrics
  entityName: 'Unit of Measure',

  createToolLayout: function createToolLayout() {
    return this.tools || (this.tools = {
    });
  },
  formatSearchQuery: function formatSearchQuery(searchQuery) {
    const q = this.escapeSearchQuery(searchQuery.toUpperCase());
    return `upper(Name) like "${q}%"`;
  },
});

lang.setObject('icboe.Views.UnitsOfMeasure.List', __class);
export default __class;


text:
<!DOCTYPE html>

<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Jogos | novos jogos</title>
<link rel="profile" href="http://gmpg.org/xfn/11">
<link rel="pingback" href="http://localhost/meusite/xmlrpc.php">
<link rel="stylesheet" href="http://localhost/meusite/wp-content/themes/contango/style.css" type="text/css" media="all" />

<link rel="alternate" type="application/rss+xml" title="Feed de Jogos »" href="http://localhost/meusite/?feed=rss2" />
<link rel="alternate" type="application/rss+xml" title="Jogos »  Feed de comentários" href="http://localhost/meusite/?feed=comments-rss2" />
<link rel='stylesheet' id='contango-css-960-css'  href='http://localhost/meusite/wp-content/themes/contango/lib/css/960.css?ver=4.0' type='text/css' media='all' />
<link rel='stylesheet' id='contango-google-fonts-css'  href='http://fonts.googleapis.com/css?family=Open+Sans%7CNixie+One&ver=4.0' type='text/css' media='all' />

<link rel="EditURI" type="application/rsd+xml" title="RSD" href="http://localhost/meusite/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="http://localhost/meusite/wp-includes/wlwmanifest.xml" />
<meta name="generator" content="WordPress 4.0" />

Início

PS4

Ps3

Xbox-One

Xbox-360

Pcs

Videos

Noticias

Comentários

Blog

      <time class="entry-date entry-time updated" datetime="2014-09-27T21:32:20+00:00">27set 2014</time>

Destiny

          by admin ⋅ Leave a Comment ⋅  Video

“Game promete ser ambicioso, terá como principal pretensão, ser grandioso e abrangente para o universo online”.

      <time class="entry-date entry-time updated" datetime="2014-09-27T20:48:26+00:00">27set 2014</time>

Fifa 2015

          by admin ⋅ Leave a Comment ⋅  Video

Para muitos, o “Melhor” jogo de futebol.

      <time class="entry-date entry-time updated" datetime="2014-09-27T04:56:48+00:00">27set 2014</time>

Project- Car

          by admin ⋅ Leave a Comment ⋅  Video

“O Jogo de corrida mais esperado do ano.”

pesquisar…

  <form method="get" class="searchform" action="http://localhost/meusite/">
    Search for:
    <input type="text" class="field" name="s" id="s" value="Search" onfocus="if(this.value==this.defaultValue)this.value='';" onblur="if(this.value=='')this.value=this.defaultValue;" />
    <input type="submit" class="submit" name="submit" id="searchsubmit" value="Search" />
  </form>

Categorias

Arcage

Corrida

Esportes

Guerra

Tópicos recentes

                Destiny

                Fifa 2015

                Project- Car

1

2

3

4

5

6

Proximo>

    © Copyright 2014 - Jogos

    Contango Theme ⋅ lançamentos


text:
pimcore.registerNS("pimcore.object.tags.country");
pimcore.object.tags.country = Class.create(pimcore.object.tags.select, {

    type: "country",

    initialize: function (data, fieldConfig) {
        this.data = data;
        this.fieldConfig = fieldConfig;
        this.fieldConfig.width = 350;
    }
});