plyom_user 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/lib/multi_json.rb

@@ -0,0 +1,159 @@
+require 'multi_json/options'
+require 'multi_json/version'
+require 'multi_json/load_error'
+
+module MultiJson
+  include Options
+  extend self
+
+  class << self
+    def cached_options
+      @cached_options ||= {}
+    end
+
+    def reset_cached_options!
+      @cached_options = {}
+    end
+  end
+
+  # Since `default_options` is deprecated, the
+  # reader is aliased to `dump_options` and the
+  # writer sets both `dump_options` and `load_options`
+  alias default_options dump_options
+
+  def default_options=(value)
+    Kernel.warn "MultiJson.default_options setter is deprecated\n" +
+      "Use MultiJson.load_options and MultiJson.dump_options instead"
+
+    self.load_options = self.dump_options = value
+  end
+
+  ALIASES = { 'jrjackson' => :jr_jackson }
+
+  REQUIREMENT_MAP = [
+    ['oj',           :oj],
+    ['yajl',         :yajl],
+    ['jrjackson',    :jr_jackson],
+    ['json/ext',     :json_gem],
+    ['gson',         :gson],
+    ['json/pure',    :json_pure]
+  ]
+
+  # The default adapter based on what you currently
+  # have loaded and installed. First checks to see
+  # if any adapters are already loaded, then checks
+  # to see which are installed if none are loaded.
+  def default_adapter
+    return :oj if defined?(::Oj)
+    return :yajl if defined?(::Yajl)
+    return :jr_jackson if defined?(::JrJackson)
+    return :json_gem if defined?(::JSON::JSON_LOADED)
+    return :gson if defined?(::Gson)
+
+    REQUIREMENT_MAP.each do |library, adapter|
+      begin
+        require library
+        return adapter
+      rescue ::LoadError
+        next
+      end
+    end
+
+    Kernel.warn '[WARNING] MultiJson is using the default adapter (ok_json).' +
+      'We recommend loading a different JSON library to improve performance.'
+
+    :ok_json
+  end
+  alias default_engine default_adapter
+
+  # Get the current adapter class.
+  def adapter
+    return @adapter if defined?(@adapter) && @adapter
+
+    self.use nil # load default adapter
+
+    @adapter
+  end
+  alias engine adapter
+
+  # Set the JSON parser utilizing a symbol, string, or class.
+  # Supported by default are:
+  #
+  # * <tt>:oj</tt>
+  # * <tt>:json_gem</tt>
+  # * <tt>:json_pure</tt>
+  # * <tt>:ok_json</tt>
+  # * <tt>:yajl</tt>
+  # * <tt>:nsjsonserialization</tt> (MacRuby only)
+  # * <tt>:gson</tt> (JRuby only)
+  # * <tt>:jr_jackson</tt> (JRuby only)
+  def use(new_adapter)
+    @adapter = load_adapter(new_adapter)
+  end
+  alias adapter= use
+  alias engine= use
+
+  def load_adapter(new_adapter)
+    case new_adapter
+    when String, Symbol
+      load_adapter_from_string_name new_adapter.to_s
+    when NilClass, FalseClass
+      load_adapter default_adapter
+    when Class, Module
+      new_adapter
+    else
+      raise ::LoadError
+    end
+  rescue ::LoadError
+    raise ArgumentError, 'Did not recognize your adapter specification.'
+  end
+
+  # Decode a JSON string into Ruby.
+  #
+  # <b>Options</b>
+  #
+  # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
+  # <tt>:adapter</tt> :: If set, the selected adapter will be used for this call.
+  def load(string, options={})
+    adapter = current_adapter(options)
+    begin
+      adapter.load(string, options)
+    rescue adapter::ParseError => exception
+      raise LoadError.new(exception.message, exception.backtrace, string)
+    end
+  end
+  alias decode load
+
+  def current_adapter(options={})
+    if new_adapter = options[:adapter]
+      load_adapter(new_adapter)
+    else
+      adapter
+    end
+  end
+
+  # Encodes a Ruby object as JSON.
+  def dump(object, options={})
+    current_adapter(options).dump(object, options)
+  end
+  alias encode dump
+
+  #  Executes passed block using specified adapter.
+  def with_adapter(new_adapter)
+    old_adapter, self.adapter = adapter, new_adapter
+    yield
+  ensure
+    self.adapter = old_adapter
+  end
+  alias with_engine with_adapter
+
+  private
+
+  def load_adapter_from_string_name(name)
+    name = ALIASES.fetch(name, name)
+    require "multi_json/adapters/#{name.downcase}"
+    klass_name = name.to_s.split('_').map(&:capitalize) * ''
+    MultiJson::Adapters.const_get(klass_name)
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/multi_json.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multi_json/version'
+
+Gem::Specification.new do |spec|
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.authors       = ["Michael Bleigh", "Josh Kalderimis", "Erik Michaels-Ober", "Pavel Pravosud"]
+  spec.cert_chain    = %w(certs/rwz.pem)
+  spec.description   = %q{A common interface to multiple JSON libraries, including Oj, Yajl, the JSON gem (with C-extensions), the pure-Ruby JSON gem, NSJSONSerialization, gson.rb, JrJackson, and OkJson.}
+  spec.email         = ['michael@intridea.com', 'josh.kalderimis@gmail.com', 'sferik@gmail.com']
+  spec.files         = Dir['.yardopts', 'CHANGELOG.md', 'CONTRIBUTING.md', 'LICENSE.md', 'README.md', 'Rakefile', 'multi_json.gemspec', 'Gemfile', '.document', '.rspec', '.travis.yml' ,'spec/**/*', 'lib/**/*']
+  spec.homepage      = 'http://github.com/intridea/multi_json'
+  spec.licenses      = ['MIT']
+  spec.name          = 'multi_json'
+  spec.require_paths = ['lib']
+  spec.required_rubygems_version = '>= 1.3.5'
+  spec.signing_key   = File.expand_path("~/.gem/private_key.pem") if $0 =~ /gem\z/
+  spec.summary       = %q{A common interface to multiple JSON libraries.}
+  spec.test_files    = Dir['spec/**/*']
+  spec.version       = MultiJson::Version
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/gson_adapter_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+exit true unless jruby?
+
+require 'shared/adapter'
+require 'multi_json/adapters/gson'
+
+describe MultiJson::Adapters::Gson do
+  it_behaves_like 'an adapter', described_class
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/jr_jackson_adapter_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+exit true unless jruby?
+
+require 'shared/adapter'
+require 'multi_json/adapters/jr_jackson'
+
+describe MultiJson::Adapters::JrJackson do
+  it_behaves_like 'an adapter', described_class
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/json_gem_adapter_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'shared/adapter'
+require 'shared/json_common_adapter'
+require 'multi_json/adapters/json_gem'
+
+describe MultiJson::Adapters::JsonGem do
+  it_behaves_like 'an adapter', described_class
+  it_behaves_like 'JSON-like adapter', described_class
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/json_pure_adapter_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'shared/adapter'
+require 'shared/json_common_adapter'
+require 'multi_json/adapters/json_pure'
+
+describe MultiJson::Adapters::JsonPure do
+  it_behaves_like 'an adapter', described_class
+  it_behaves_like 'JSON-like adapter', described_class
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/multi_json_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+require 'shared/options'
+
+describe MultiJson do
+  before(:all) do
+    # make sure all available libs are required
+    MultiJson::REQUIREMENT_MAP.each do |library, adapter|
+      begin
+        require library
+      rescue ::LoadError
+        next
+      end
+    end
+  end
+
+  context 'when no other json implementations are available' do
+    around do |example|
+      simulate_no_adapters{ example.call }
+    end
+
+    it 'defaults to ok_json if no other json implementions are available' do
+      silence_warnings do
+        expect(MultiJson.default_adapter).to eq(:ok_json)
+      end
+    end
+
+    it 'prints a warning' do
+      expect(Kernel).to receive(:warn).with(/warning/i)
+      MultiJson.default_adapter
+    end
+  end
+
+  context 'caching' do
+    before{ MultiJson.use adapter }
+    let(:adapter){ MultiJson::Adapters::JsonGem }
+    let(:json_string){ '{"abc":"def"}' }
+
+    it 'busts caches on global options change' do
+      MultiJson.load_options = { :symbolize_keys => true }
+      expect(MultiJson.load(json_string)).to eq(:abc => 'def')
+      MultiJson.load_options = nil
+      expect(MultiJson.load(json_string)).to eq('abc' => 'def')
+    end
+
+    it 'busts caches on per-adapter options change' do
+      adapter.load_options = { :symbolize_keys => true }
+      expect(MultiJson.load(json_string)).to eq(:abc => 'def')
+      adapter.load_options = nil
+      expect(MultiJson.load(json_string)).to eq('abc' => 'def')
+    end
+  end
+
+  it 'defaults to the best available gem' do
+    # Clear cache variable already set by previous tests
+    MultiJson.send(:remove_instance_variable, :@adapter) if MultiJson.instance_variable_defined?(:@adapter)
+
+    if jruby?
+      expect(MultiJson.adapter.to_s).to eq('MultiJson::Adapters::JrJackson')
+    else
+      expect(MultiJson.adapter.to_s).to eq('MultiJson::Adapters::Oj')
+    end
+  end
+
+  it 'looks for adapter even if @adapter variable is nil' do
+    MultiJson.send(:instance_variable_set, :@adapter, nil)
+    expect(MultiJson).to receive(:default_adapter).and_return(:ok_json)
+    expect(MultiJson.adapter).to eq(MultiJson::Adapters::OkJson)
+  end
+
+  it 'is settable via a symbol' do
+    MultiJson.use :json_gem
+    expect(MultiJson.adapter).to eq(MultiJson::Adapters::JsonGem)
+  end
+
+  it 'is settable via a case-insensitive string' do
+    MultiJson.use 'Json_Gem'
+    expect(MultiJson.adapter).to eq(MultiJson::Adapters::JsonGem)
+  end
+
+  it 'is settable via a class' do
+    adapter = Class.new
+    MultiJson.use adapter
+    expect(MultiJson.adapter).to eq(adapter)
+  end
+
+  it 'is settable via a module' do
+    adapter = Module.new
+    MultiJson.use adapter
+    expect(MultiJson.adapter).to eq(adapter)
+  end
+
+  it 'throws ArgumentError on bad input' do
+    expect{ MultiJson.use 'bad adapter' }.to raise_error(ArgumentError)
+  end
+
+  context 'using one-shot parser' do
+    before do
+      expect(MultiJson::Adapters::JsonPure).to receive(:dump).once.and_return('dump_something')
+      expect(MultiJson::Adapters::JsonPure).to receive(:load).once.and_return('load_something')
+    end
+
+    it 'should use the defined parser just for the call' do
+      MultiJson.use :json_gem
+      expect(MultiJson.dump('', :adapter => :json_pure)).to eq('dump_something')
+      expect(MultiJson.load('', :adapter => :json_pure)).to eq('load_something')
+      expect(MultiJson.adapter).to eq(MultiJson::Adapters::JsonGem)
+    end
+  end
+
+  it 'can set adapter for a block' do
+    MultiJson.use :ok_json
+    MultiJson.with_adapter(:json_pure) do
+      MultiJson.with_engine(:json_gem) do
+        expect(MultiJson.adapter).to eq(MultiJson::Adapters::JsonGem)
+      end
+      expect(MultiJson.adapter).to eq(MultiJson::Adapters::JsonPure)
+    end
+    expect(MultiJson.adapter).to eq(MultiJson::Adapters::OkJson)
+  end
+
+  it 'JSON gem does not create symbols on parse' do
+    MultiJson.with_engine(:json_gem) do
+      MultiJson.load('{"json_class":"ZOMG"}') rescue nil
+
+      expect{
+        MultiJson.load('{"json_class":"OMG"}') rescue nil
+      }.to_not change{Symbol.all_symbols.count}
+    end
+  end
+
+  unless jruby?
+    it 'Oj does not create symbols on parse' do
+      MultiJson.with_engine(:oj) do
+        MultiJson.load('{"json_class":"ZOMG"}') rescue nil
+
+        expect{
+          MultiJson.load('{"json_class":"OMG"}') rescue nil
+        }.to_not change{Symbol.all_symbols.count}
+      end
+    end
+
+    context 'with Oj.default_settings' do
+      around do |example|
+        options = Oj.default_options
+        Oj.default_options = { :symbol_keys => true }
+        MultiJson.with_engine(:oj){ example.call }
+        Oj.default_options = options
+      end
+
+      it 'ignores global settings' do
+        MultiJson.with_engine(:oj) do
+          example = '{"a": 1, "b": 2}'
+          expected = { 'a' => 1, 'b' => 2 }
+          expect(MultiJson.load(example)).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe 'default options' do
+    after(:all){ MultiJson.load_options = MultiJson.dump_options = nil }
+
+    it 'is deprecated' do
+      expect(Kernel).to receive(:warn).with(/deprecated/i)
+      silence_warnings{ MultiJson.default_options = {:foo => 'bar'} }
+    end
+
+    it 'sets both load and dump options' do
+      expect(MultiJson).to receive(:dump_options=).with(:foo => 'bar')
+      expect(MultiJson).to receive(:load_options=).with(:foo => 'bar')
+      silence_warnings{ MultiJson.default_options = {:foo => 'bar'} }
+    end
+  end
+
+  it_behaves_like 'has options', MultiJson
+
+  describe 'aliases' do
+    if jruby?
+      describe 'jrjackson' do
+        after{ expect(MultiJson.adapter).to eq(MultiJson::Adapters::JrJackson) }
+
+        it 'allows jrjackson alias as symbol' do
+          expect{ MultiJson.use :jrjackson }.not_to raise_error
+        end
+
+        it 'allows jrjackson alias as string' do
+          expect{ MultiJson.use 'jrjackson' }.not_to raise_error
+        end
+
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/nsjsonserialization_adapter_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+exit true unless macruby?
+
+require 'shared/adapter'
+require 'multi_json/adapters/nsjsonserialization'
+
+describe MultiJson::Adapters::Nsjsonserialization do
+  it_behaves_like 'an adapter', described_class
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/oj_adapter_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+exit true if jruby?
+
+require 'shared/adapter'
+require 'multi_json/adapters/oj'
+
+describe MultiJson::Adapters::Oj do
+  it_behaves_like 'an adapter', described_class
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/ok_json_adapter_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'shared/adapter'
+require 'multi_json/adapters/ok_json'
+
+describe MultiJson::Adapters::OkJson do
+  it_behaves_like 'an adapter', described_class
+end

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/spec/shared/adapter.rb

@@ -0,0 +1,230 @@
+# encoding: UTF-8
+
+require 'shared/options'
+
+shared_examples_for 'an adapter' do |adapter|
+
+  before{ MultiJson.use adapter }
+
+  it_behaves_like 'has options', adapter
+
+  it 'does not modify argument hashes' do
+    options = { :symbolize_keys => true, :pretty => false, :adapter => :ok_json }
+    expect{MultiJson.load('{}', options)}.to_not change{options}
+    expect{MultiJson.dump([42], options)}.to_not change{options}
+  end
+
+  describe '.dump' do
+    describe '#dump_options' do
+      before{ MultiJson.dump_options = MultiJson.adapter.dump_options = {} }
+
+      after do
+        expect(MultiJson.adapter.instance).to receive(:dump).with(1, :foo => 'bar', :fizz => 'buzz')
+        MultiJson.dump(1, :fizz => 'buzz')
+        MultiJson.dump_options = MultiJson.adapter.dump_options = nil
+      end
+
+      it 'respects global dump options' do
+        MultiJson.dump_options = {:foo => 'bar'}
+      end
+
+      it 'respects per-adapter dump options' do
+        MultiJson.adapter.dump_options = {:foo => 'bar'}
+      end
+
+      it 'adapter-specific are overridden by global options' do
+        MultiJson.adapter.dump_options = {:foo => 'foo'}
+        MultiJson.dump_options = {:foo => 'bar'}
+      end
+    end
+
+    it 'writes decodable JSON' do
+      [
+        {'abc' => 'def'},
+        [1, 2, 3, '4', true, false, nil]
+      ].each do |example|
+        expect(MultiJson.load(MultiJson.dump(example))).to eq example
+      end
+    end
+
+    unless 'json_pure' == adapter || 'json_gem' == adapter
+      it 'dumps time in correct format' do
+        time = Time.at(1355218745).utc
+
+        dumped_json = MultiJson.dump(time)
+        expected = if RUBY_VERSION > '1.9'
+          '2012-12-11 09:39:05 UTC'
+        else
+          'Tue Dec 11 09:39:05 UTC 2012'
+        end
+        expect(MultiJson.load(dumped_json)).to eq expected
+      end
+    end
+
+    it 'dumps symbol and fixnum keys as strings' do
+      [
+        [
+          {:foo => {:bar => 'baz'}},
+          {'foo' => {'bar' => 'baz'}},
+        ],
+        [
+          [{:foo => {:bar => 'baz'}}],
+          [{'foo' => {'bar' => 'baz'}}],
+        ],
+        [
+          {:foo => [{:bar => 'baz'}]},
+          {'foo' => [{'bar' => 'baz'}]},
+        ],
+        [
+          {1 => {2 => {3 => 'bar'}}},
+          {'1' => {'2' => {'3' => 'bar'}}}
+        ]
+      ].each do |example, expected|
+        dumped_json = MultiJson.dump(example)
+        expect(MultiJson.load(dumped_json)).to eq expected
+      end
+    end
+
+    it 'dumps rootless JSON' do
+      expect(MultiJson.dump('random rootless string')).to eq '"random rootless string"'
+      expect(MultiJson.dump(123)).to eq '123'
+    end
+
+    it 'passes options to the adapter' do
+      expect(MultiJson.adapter).to receive(:dump).with('foo', {:bar => :baz})
+      MultiJson.dump('foo', :bar => :baz)
+    end
+
+    # This behavior is currently not supported by gson.rb
+    # See discussion at https://github.com/intridea/multi_json/pull/71
+    unless adapter.name == 'MultiJson::Adapters::Gson'
+      it 'dumps custom objects that implement to_json' do
+        klass = Class.new do
+          def to_json(*)
+            '"foobar"'
+          end
+        end
+        expect(MultiJson.dump(klass.new)).to eq '"foobar"'
+      end
+    end
+
+    it 'allows to dump JSON values' do
+      expect(MultiJson.dump(42)).to eq '42'
+    end
+
+    it 'allows to dump JSON with UTF-8 characters' do
+      expect(MultiJson.dump('color' => 'żółć')).to eq('{"color":"żółć"}')
+    end
+  end
+
+  describe '.load' do
+    describe '#load_options' do
+      before{ MultiJson.load_options = MultiJson.adapter.load_options = {} }
+
+      after do
+        expect(MultiJson.adapter.instance).to receive(:load).with('1', :foo => 'bar', :fizz => 'buzz')
+        MultiJson.load('1', :fizz => 'buzz')
+        MultiJson.load_options = MultiJson.adapter.load_options = nil
+      end
+
+      it 'respects global load options' do
+        MultiJson.load_options = {:foo => 'bar'}
+      end
+
+      it 'respects per-adapter load options' do
+        MultiJson.adapter.load_options = {:foo => 'bar'}
+      end
+
+      it 'adapter-specific are overridden by global options' do
+        MultiJson.adapter.load_options = {:foo => 'foo'}
+        MultiJson.load_options = {:foo => 'bar'}
+      end
+    end
+
+    it 'does not modify input' do
+      input = %Q{\n\n  {"foo":"bar"} \n\n\t}
+      expect{
+        MultiJson.load(input)
+      }.to_not change{ input }
+    end
+
+    # Ruby 1.8 doesn't support String encodings
+    if RUBY_VERSION > '1.9'
+      it 'does not modify input encoding' do
+
+        input = '[123]'
+        input.force_encoding('iso-8859-1')
+
+        expect{
+          MultiJson.load(input)
+        }.to_not change{ input.encoding }
+      end
+    end
+
+    it 'properly loads valid JSON' do
+      expect(MultiJson.load('{"abc":"def"}')).to eq('abc' => 'def')
+    end
+
+    it 'raises MultiJson::LoadError on blank input or invalid input' do
+      [nil, '{"abc"}', ' ', "\t\t\t", "\n", "\x82\xAC\xEF"].each do |input|
+        expect{MultiJson.load(input)}.to raise_error(MultiJson::LoadError)
+      end
+    end
+
+    it 'raises MultiJson::LoadError with data on invalid JSON' do
+      data = '{invalid}'
+      begin
+        MultiJson.load(data)
+      rescue MultiJson::LoadError => le
+        expect(le.data).to eq data
+      end
+    end
+
+    it 'catches MultiJson::DecodeError for legacy support' do
+      data = '{invalid}'
+      begin
+        MultiJson.load(data)
+      rescue MultiJson::DecodeError => de
+        expect(de.data).to eq data
+      end
+    end
+
+    it 'stringifys symbol keys when encoding' do
+      dumped_json = MultiJson.dump(:a => 1, :b => {:c => 2})
+      loaded_json = MultiJson.load(dumped_json)
+      expect(loaded_json).to eq('a' => 1, 'b' => {'c' => 2})
+    end
+
+    it 'properly loads valid JSON in StringIOs' do
+      json = StringIO.new('{"abc":"def"}')
+      expect(MultiJson.load(json)).to eq('abc' => 'def')
+    end
+
+    it 'allows for symbolization of keys' do
+      [
+        [
+          '{"abc":{"def":"hgi"}}',
+          {:abc => {:def => 'hgi'}},
+        ],
+        [
+          '[{"abc":{"def":"hgi"}}]',
+          [{:abc => {:def => 'hgi'}}],
+        ],
+        [
+          '{"abc":[{"def":"hgi"}]}',
+          {:abc => [{:def => 'hgi'}]},
+        ],
+      ].each do |example, expected|
+        expect(MultiJson.load(example, :symbolize_keys => true)).to eq expected
+      end
+    end
+
+    it 'allows to load JSON values' do
+      expect(MultiJson.load('42')).to eq 42
+    end
+
+    it 'allows to load JSON with UTF-8 characters' do
+      expect(MultiJson.load('{"color":"żółć"}')).to eq('color' => 'żółć')
+    end
+  end
+end