scout 5.7.1 → 5.7.2.pre

data/vendor/multi_json/lib/multi_json/version.rb

@@ -0,0 +1,20 @@
+module MultiJson
+  class Version
+    MAJOR = 1 unless defined? MultiJson::Version::MAJOR
+    MINOR = 7 unless defined? MultiJson::Version::MINOR
+    PATCH = 9 unless defined? MultiJson::Version::PATCH
+    PRE = nil unless defined? MultiJson::Version::PRE
+
+    class << self
+
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+      end
+
+    end
+
+  end
+
+  VERSION = Version.to_s.freeze
+end

data/vendor/multi_json/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/multi_json/spec/adapter_shared_example.rb

@@ -0,0 +1,235 @@
+# encoding: UTF-8
+
+shared_examples_for 'an adapter' do |adapter|
+
+  before do
+    begin
+      MultiJson.use adapter
+    rescue LoadError
+      pending "Adapter #{adapter} couldn't be loaded (not installed?)"
+    end
+  end
+
+  it_behaves_like 'has options', lambda{ MultiJson.adapter }
+
+  it 'does not modify argument hashes' do
+    options = { :symbolize_keys => true, :pretty => false, :adapter => :json_pure }
+    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
+
+        # time does not respond to to_json method
+        class << time
+          undef_method :to_json
+        end
+
+        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 %w(gson jr_jackson).include?(adapter)
+      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
+
+    it 'does not modify input encoding' do
+      pending 'only in 1.9' unless RUBY_VERSION > '1.9'
+
+      input = '[123]'
+      input.force_encoding('iso-8859-1')
+
+      expect{
+        MultiJson.load(input)
+      }.to_not change{ input.encoding }
+    end
+
+    it 'properly loads valid JSON' do
+      expect(MultiJson.load('{"abc":"def"}')).to eq({'abc' => 'def'})
+    end
+
+    it 'raises MultiJson::LoadError on invalid JSON' do
+      expect{MultiJson.load('{"abc"}')}.to raise_error(MultiJson::LoadError)
+    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

data/vendor/multi_json/spec/has_options.rb

@@ -0,0 +1,119 @@
+shared_examples_for 'has options' do |object|
+
+  if object.respond_to?(:call)
+    subject{ object.call }
+  else
+    subject{ object }
+  end
+
+  describe "dump options" do
+
+    before do
+      subject.dump_options = nil
+    end
+
+    after do
+      subject.dump_options = nil
+    end
+
+    it 'returns default options if not set' do
+      expect(subject.dump_options).to eq(subject.default_dump_options)
+    end
+
+    it 'allows hashes' do
+      subject.dump_options = {:foo => 'bar'}
+      expect(subject.dump_options).to eq(:foo => 'bar')
+    end
+
+    it 'allows objects that implement #to_hash' do
+      value = Class.new do
+        def to_hash
+          {:foo => 'bar'}
+        end
+      end.new
+
+      subject.dump_options = value
+      expect(subject.dump_options).to eq(:foo => 'bar')
+    end
+
+    it 'evaluates lambda returning options (with args)' do
+      subject.dump_options = lambda{ |a1, a2| { a1 => a2 }}
+      expect(subject.dump_options('1', '2')).to eq('1' => '2')
+    end
+
+    it 'evaluates lambda returning options (with no args)' do
+      subject.dump_options = lambda{{:foo => 'bar'}}
+      expect(subject.dump_options).to eq(:foo => 'bar')
+    end
+
+    it 'returns empty hash in all other cases' do
+      subject.dump_options = true
+      expect(subject.dump_options).to eq(subject.default_dump_options)
+
+      subject.dump_options = false
+      expect(subject.dump_options).to eq(subject.default_dump_options)
+
+      subject.dump_options = 10
+      expect(subject.dump_options).to eq(subject.default_dump_options)
+
+      subject.dump_options = nil
+      expect(subject.dump_options).to eq(subject.default_dump_options)
+    end
+  end
+
+  describe "load options" do
+
+    before do
+      subject.load_options = nil
+    end
+
+    after do
+      subject.load_options = nil
+    end
+
+    it 'returns default options if not set' do
+      expect(subject.load_options).to eq(subject.default_load_options)
+    end
+
+    it 'allows hashes' do
+      subject.load_options = {:foo => 'bar'}
+      expect(subject.load_options).to eq(:foo => 'bar')
+    end
+
+    it 'allows objects that implement #to_hash' do
+      value = Class.new do
+        def to_hash
+          {:foo => 'bar'}
+        end
+      end.new
+
+      subject.load_options = value
+      expect(subject.load_options).to eq(:foo => 'bar')
+    end
+
+    it 'evaluates lambda returning options (with args)' do
+      subject.load_options = lambda{ |a1, a2| { a1 => a2 }}
+      expect(subject.load_options('1', '2')).to eq('1' => '2')
+    end
+
+    it 'evaluates lambda returning options (with no args)' do
+      subject.load_options = lambda{{:foo => 'bar'}}
+      expect(subject.load_options).to eq(:foo => 'bar')
+    end
+
+    it 'returns empty hash in all other cases' do
+      subject.load_options = true
+      expect(subject.load_options).to eq(subject.default_load_options)
+
+      subject.load_options = false
+      expect(subject.load_options).to eq(subject.default_load_options)
+
+      subject.load_options = 10
+      expect(subject.load_options).to eq(subject.default_load_options)
+
+      subject.load_options = nil
+      expect(subject.load_options).to eq(subject.default_load_options)
+    end
+  end
+
+end

data/vendor/multi_json/spec/helper.rb

@@ -0,0 +1,35 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter 'spec'
+  add_filter 'vendor'
+end
+
+require 'multi_json'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+def silence_warnings
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = old_verbose
+end
+
+def macruby?
+  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'macruby'
+end
+
+def jruby?
+  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+end

data/vendor/multi_json/spec/json_common_shared_example.rb

@@ -0,0 +1,30 @@
+shared_examples_for 'JSON-like adapter' do |adapter|
+  before{ MultiJson.use adapter }
+
+  describe '.dump' do
+    before{ MultiJson.dump_options = MultiJson.adapter.dump_options = nil }
+
+    describe 'with :pretty option set to true' do
+      it 'passes default pretty options' do
+        object = 'foo'
+        expect(object).to receive(:to_json).with(JSON::PRETTY_STATE_PROTOTYPE.to_h)
+        MultiJson.dump(object, :pretty => true)
+      end
+    end
+
+    describe 'with :indent option' do
+      it 'passes it on dump' do
+        object = 'foo'
+        expect(object).to receive(:to_json).with(:indent => "\t")
+        MultiJson.dump(object, :indent => "\t")
+      end
+    end
+  end
+
+  describe '.load' do
+    it 'passes :quirks_mode option' do
+      expect(::JSON).to receive(:parse).with('[123]', {:quirks_mode => false, :create_additions => false})
+      MultiJson.load('[123]', :quirks_mode => false)
+    end
+  end
+end