ffi-yajl 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7af5eee3b4627e919e66d1aea4326bdf251c4256
-  data.tar.gz: 581d8c97420c1313de961eb974b74ded07c44f2b
+  metadata.gz: 22f963e220dde27e277e387e7dfba256859da2c8
+  data.tar.gz: d52391f8a6449ce89cbe3bb39a03cec421769967
 SHA512:
-  metadata.gz: feb427a319145b354c0fc8f506a8b535e56b79d14abe803b9728ef3e6cd633547ed8857245bc58d15c7eeb14332f1bee32007d457afbe8ee46458ae81cfd7ad4
-  data.tar.gz: d02c0c2c853b0d6d9fad1078d32a77e1984383592623121f748249e3cf7e605802b487b258442808341ad8fc559b07d650955d24e25c63f1727e758891df4b7d
+  metadata.gz: bf8965e64e5122273aea126fa4e6d284537e9680d298b4c6a24ff6a0c41f5540a2b22d6fb7181a6df80455909c05e943b55437aec7b54f041f5e99784b821970
+  data.tar.gz: 094122dadd975df2181a4fc51a6462086e37d6800ed05888f9b3c6591493ea3171c02d0b1bc1bd14122af4ec193bd569aafbd8b5dca4b136b17605f9c7a1a1e9

data/README.md

@@ -1,5 +1,5 @@
 
-[![Build Status](https://travis-ci.org/opscode/ffi-yajl.png)](https://travis-ci.org/opscode/ffi-yajl)  [![Code Climate](https://codeclimate.com/github/opscode/ffi-yajl.png)](https://codeclimate.com/github/opscode/ffi-yajl)
+[![Build Status](https://travis-ci.org/chef/ffi-yajl.png)](https://travis-ci.org/chef/ffi-yajl)  [![Code Climate](https://codeclimate.com/github/chef/ffi-yajl.png)](https://codeclimate.com/github/chef/ffi-yajl)
 
 # FFI YAJL
 

data/lib/ffi_yajl/version.rb

@@ -1,3 +1,3 @@
 module FFI_Yajl
-  VERSION = "1.4.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-yajl
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Lamont Granquist
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-17 00:00:00.000000000 Z
+date: 2015-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -154,15 +154,13 @@ files:
 - lib/ffi_yajl/ffi.rb
 - lib/ffi_yajl/ffi/encoder.rb
 - lib/ffi_yajl/ffi/parser.rb
-- lib/ffi_yajl/json_gem.rb
 - lib/ffi_yajl/parser.rb
 - lib/ffi_yajl/platform.rb
 - lib/ffi_yajl/version.rb
 - spec/ffi_yajl/encoder_spec.rb
-- spec/ffi_yajl/json_gem_spec.rb
 - spec/ffi_yajl/parser_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/opscode/ffi-yajl
+homepage: http://github.com/chef/ffi-yajl
 licenses:
 - Apache-2.0
 metadata: {}

data/lib/ffi_yajl/json_gem.rb

@@ -1,140 +0,0 @@
-
-# JSON compatibility layer, largely plagarized from yajl-ruby
-
-require 'ffi_yajl' unless defined?(FFI_Yajl::Parser)
-
-warn "ffi-yajl/json_gem is deprecated, these monkeypatches will be dropped shortly"
-
-module JSON
-  class JSONError < StandardError; end unless defined?(JSON::JSONError)
-  class GeneratorError < JSONError; end unless defined?(JSON::GeneratorError)
-  class ParserError < JSONError; end unless defined?(JSON::ParserError)
-
-  def self.generate(obj, opts=nil)
-    opts ||= {}
-    options_map = {}
-    if opts.has_key?(:indent)
-      options_map[:pretty] = true
-      options_map[:indent] = opts[:indent]
-    end
-    FFI_Yajl::Encoder.encode(obj, options_map)
-  rescue FFI_Yajl::EncodeError => e
-    raise JSON::GeneratorError, e.message
-  end
-
-  def self.pretty_generate(obj, opts=nil)
-    opts ||= {}
-    options_map = {}
-    options_map[:pretty] = true
-    options_map[:indent] = opts[:indent] if opts.has_key?(:indent)
-    FFI_Yajl::Encoder.encode(obj, options_map).chomp
-  rescue FFI_Yajl::EncodeError => e
-    raise JSON::GeneratorError, e.message
-  end
-
-  def self.dump(obj, io=nil, *args)
-    FFI_Yajl::Encoder.encode(obj, io)
-  rescue FFI_Yajl::EncodeError => e
-    raise JSON::GeneratorError, e.message
-  end
-
-  def self.default_options
-    @default_options ||= {:symbolize_keys => false}
-  end
-
-  def self.parse(str, opts=JSON.default_options)
-    FFI_Yajl::Parser.parse(str, opts)
-  rescue FFI_Yajl::ParseError => e
-    raise JSON::ParserError, e.message
-  end
-
-  def self.load(input, *args)
-    FFI_Yajl::Parser.parse(input, default_options)
-  rescue FFI_Yajl::ParseError => e
-    raise JSON::ParserError, e.message
-  end
-end
-
-class Array
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class Hash
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class Fixnum
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class Float
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class String
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class TrueClass
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class FalseClass
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class NilClass
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class Date
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class Time
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-class DateTime
-  def to_json(*opts, &block)
-    FFI_Yajl::Encoder.encode(self, *opts)
-  end
-end
-
-module ::Kernel
-  def JSON(object, opts = {})
-    if object.respond_to? :to_s
-      JSON.parse(object.to_s, JSON.default_options.merge(opts))
-    else
-      JSON.generate(object,opts)
-    end
-  end
-end
-
-class Object
-  unless defined?(ActiveSupport)
-    def to_json(*args, &block)
-      "\"#{to_s}\""
-    end
-  end
-end

data/spec/ffi_yajl/json_gem_spec.rb

@@ -1,382 +0,0 @@
-# encoding: UTF-8
-
-# This started life as yajl-ruby's json_gem_compatibility/compatibility_spec.rb file.
-# Kinda looks like they stole it from the JSON gem.  I updated the syntax a lot.
-
-require 'spec_helper'
-require 'date'
-
-class Dummy; end
-
-describe "JSON Gem Compat API" do
-
-  # Magic to make the before loading tests actually run before loading
-  RSpec.configure do |config|
-    config.register_ordering(:global) do |list|
-      list.sort_by { |item| item.description }
-    end
-  end
-
-  context "A: before loading the compat library" do
-    it "should not mixin #to_json on random objects" do
-      d = Dummy.new
-      expect(d.respond_to?(:to_json)).to be false
-    end
-
-    it "should not mixin #to_json to a string" do
-      expect("".respond_to?(:to_json)).to be false
-    end
-
-    it "should not mixin #to_json to a fixnum" do
-      expect(1.respond_to?(:to_json)).to be false
-    end
-
-    it "should not mixin #to_json on a float" do
-      expect("1.5".to_f.respond_to?(:to_json)).to be false
-    end
-
-    it "should not mixin #to_json on an array" do
-      expect([].respond_to?(:to_json)).to be false
-    end
-
-    it "should not mixin #to_json on a hash" do
-      expect({ :foo => "bar" }.respond_to?(:to_json)).to be false
-    end
-
-    it "should not mixin #to_json on a trueclass" do
-      expect(true.respond_to?(:to_json)).to be false
-    end
-
-    it "should not mixin #to_json on a falseclass" do
-      expect(false.respond_to?(:to_json)).to be false
-    end
-
-    it "should not mixin #to_json on a nilclass" do
-      expect(nil.respond_to?(:to_json)).to be false
-    end
-  end
-
-  context "B: when in compat mode" do
-
-    before(:all) do
-      require 'ffi_yajl/json_gem'
-    end
-
-    it "should define JSON class" do
-      expect(defined?(JSON)).to be_truthy
-    end
-
-    it "should implement JSON#parse" do
-      expect(JSON.respond_to?(:parse)).to be true
-    end
-
-    it "should implement JSON#generate" do
-      expect(JSON.respond_to?(:generate)).to be true
-    end
-
-    it "should implement JSON#pretty_generate" do
-      expect(JSON.respond_to?(:pretty_generate)).to be true
-    end
-
-    it "should implement JSON#load" do
-      expect(JSON.respond_to?(:load)).to be true
-    end
-
-    it "should implement JSON#dump" do
-      expect(JSON.respond_to?(:dump)).to be true
-    end
-
-    it "JSON#pretty_generate should work with an explicit nil for options" do
-      expect(JSON.pretty_generate({'foo' => 1234}, nil)).to eql("{\n  \"foo\": 1234\n}")
-    end
-
-    it "JSON#pretty_generate should work without options" do
-      expect(JSON.pretty_generate({'foo' => 1234})).to eql("{\n  \"foo\": 1234\n}")
-    end
-
-    it "JSON#pretty_generate should work with an empty options hash" do
-      expect(JSON.pretty_generate({'foo' => 1234}, {})).to eql("{\n  \"foo\": 1234\n}")
-    end
-
-    class Foo
-      def to_json(*a)
-        {'foo' => 1234}.to_json(*a)
-      end
-    end
-
-    it "JSON#pretty_generate should work with an Object that implements #to_json" do
-      f = Foo.new
-      expect(JSON.pretty_generate(f)).to eql("{\n  \"foo\": 1234\n}\n")
-    end
-
-    context "when setting symbolize_keys via JSON.default_options" do
-      after(:each) { JSON.default_options[:symbolize_keys] = false }
-
-      it "the default behavior should be to not symbolize keys" do
-        expect(JSON.parse('{"foo": 1234}')).to eq( "foo" => 1234 )
-      end
-
-      it "changing the default_options should change the behavior to true" do
-        JSON.default_options[:symbolize_keys] = true
-        expect(JSON.parse('{"foo": 1234}')).to eq( :foo => 1234 )
-      end
-    end
-
-    context "when setting symbolize_names via JSON.default_options" do
-      after { JSON.default_options.delete(:symbolize_names)}
-
-      it "the default behavior should be to not symbolize keys" do
-        expect(JSON.parse('{"foo": 1234}')).to eq( "foo" => 1234 )
-      end
-
-      it "changing the default_options should change the behavior to true" do
-        JSON.default_options[:symbolize_names] = true
-        expect(JSON.parse('{"foo": 1234}')).to eq( :foo => 1234 )
-      end
-    end
-
-    it "should support passing symbolize_names to JSON.parse" do
-      expect(JSON.parse('{"foo": 1234}', :symbolize_names => true)).to eq( :foo => 1234 )
-    end
-
-    it "should support passing symbolize_keys to JSON.parse" do
-      expect(JSON.parse('{"foo": 1234}', :symbolize_keys => true)).to eq( :foo => 1234 )
-    end
-
-    context "when encode arbitrary classes via their default to_json method" do
-      it "encodes random classes correctly" do
-        d = Dummy.new
-        expect(d.to_json).to eq( %Q{"#{d.to_s}"} )
-      end
-
-      context "when encoding Time objects in UTC timezone" do
-        before do
-          @saved_tz = ENV['TZ']
-          ENV['TZ'] = 'UTC'
-        end
-
-        after do
-          ENV['TZ'] = @saved_tz
-        end
-
-        it "encodes Time values correctly" do
-          t = Time.local(2001, 02, 02, 21, 05, 06)
-          expect(t.to_json).to eq( %Q{"2001-02-02 21:05:06 +0000"} )
-        end
-      end
-
-      it "encodes Date values correctly" do
-        da = Date.parse('2001-02-03')
-        expect(da.to_json).to eq( %Q{"2001-02-03"} )
-      end
-
-      it "encodes DateTime values correctly" do
-        dt = DateTime.parse('2001-02-03T04:05:06.1+07:00')
-        expect(dt.to_json).to eq( %Q{"2001-02-03T04:05:06+07:00"} )
-      end
-    end
-
-    context "JSON exception classes" do
-      it "should define JSON::JSONError as a StandardError" do
-        expect(JSON::JSONError.new.is_a?(StandardError)).to be true
-      end
-      it "should define JSON::ParserError as a JSON::JSONError" do
-        expect(JSON::ParserError.new.is_a?(JSON::JSONError)).to be true
-      end
-      it "should define JSON::GeneratorError as a JSON::JSONError" do
-        expect(JSON::GeneratorError.new.is_a?(JSON::JSONError)).to be true
-      end
-      it "should raise JSON::ParserError on a bad parse" do
-        expect{ JSON.parse("blah") }.to raise_error(JSON::ParserError)
-      end
-      it "should raise JSON::GeneratorError on encoding NaN" do
-        expect{ JSON.generate(0.0/0.0) }.to raise_error(JSON::GeneratorError)
-      end
-      it "should raise JSON::GeneratorError on encoding -Infinity" do
-        expect{ JSON.generate(-1.0/0.0) }.to raise_error(JSON::GeneratorError)
-      end
-      it "should raise JSON::GeneratorError on encoding Infinity" do
-        expect{ JSON.generate(1.0/0.0) }.to raise_error(JSON::GeneratorError)
-      end
-      it "should raise JSON::GeneratorError on encoding a partial UTF-8 character" do
-        expect{ JSON.generate(["\xea"]) }.to raise_error(JSON::GeneratorError)
-      end
-    end
-
-    shared_examples_for "handles encoding and parsing correctly" do
-      it "should encode the content correctly" do
-        expect(ruby.to_json).to eq(json)
-      end
-      it "should parse the content correctly" do
-        expect(JSON.parse(json)).to eq(ruby)
-      end
-    end
-
-  context "when encoding strings" do
-    it "should render empty string correctly" do
-      expect(''.to_json).to eq( %q{""} )
-    end
-    it "should encode backspace character" do
-      expect("\b".to_json).to eq( %q{"\\b"} )
-    end
-    it "should encode \u0001 correctly" do
-      expect(0x1.chr.to_json).to eq( %q{"\u0001"} )
-    end
-
-    it "should encode \u001f correctly" do
-      expect(0x1f.chr.to_json).to eq( %q{"\u001F"} )
-    end
-
-    it "should encode a string with a space correctly" do
-      expect(' '.to_json).to eq( %q{" "} )
-    end
-
-    it "should encode 0x75 correctly" do
-      expect(0x7f.chr.to_json).to eq( %Q{"#{0x7f.chr}"} )
-    end
-
-    context "when dealing with bignums" do
-      let(:ruby) { [ 12345678901234567890 ] }
-      let(:json) { "[12345678901234567890]" }
-
-      it_behaves_like "handles encoding and parsing correctly"
-    end
-
-    context "when dealing with common UTF-8 symbols" do
-      let(:ruby) { [ "© ≠ €! \01" ] }
-      let(:json) { "[\"© ≠ €! \\u0001\"]" }
-
-      it_behaves_like "handles encoding and parsing correctly"
-    end
-
-    context "when dealing with Hiragana UTF-8 characters" do
-      let(:ruby) { ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"] }
-      let(:json) { "[\"あいうえお\"]" }
-
-      it_behaves_like "handles encoding and parsing correctly"
-    end
-
-    context "whatever this is" do
-      let(:ruby) { ['საქართველო'] }
-      let(:json) { "[\"საქართველო\"]" }
-
-      it_behaves_like "handles encoding and parsing correctly"
-    end
-
-    context "accents" do
-      let(:ruby) { ["Ã"] }
-      let(:json) { '["Ã"]' }
-
-      it_behaves_like "handles encoding and parsing correctly"
-    end
-
-    context "euro symbol" do
-      let(:ruby) { ["€"] }
-      let(:json) { '["\u20ac"]' }
-      it "should parse the content correctly" do
-        expect(JSON.parse(json)).to eq(ruby)
-      end
-    end
-
-    context "and whatever this is" do
-
-      utf8_str = "\xf0\xa0\x80\x81"
-      let(:ruby) {  [utf8_str] }
-      let(:json) { "[\"#{utf8_str}\"]" }
-
-      it_behaves_like "handles encoding and parsing correctly"
-    end
-  end
-
-    context "when encoding basic types with #to_json" do
-      it "Array#to_json should work" do
-        expect([ "a", "b", "c" ].to_json).to eq(%Q{["a","b","c"]})
-      end
-
-      it "Hash#to_json should work" do
-        expect({ "a"=>"b" }.to_json).to eq(%Q{{"a":"b"}})
-      end
-
-      it "Fixnum#to_json should work" do
-        expect(1.to_json).to eq("1")
-      end
-
-      it "Float#to_json should work" do
-        expect(1.1.to_json).to eq("1.1")
-      end
-
-      it "String#to_json should work" do
-        expect("foo".to_json).to eq(%Q{"foo"})
-      end
-
-      it "TrueClass#to_json should work" do
-        expect(true.to_json).to eq("true")
-      end
-
-      it "FalseClass#to_json should work" do
-        expect(false.to_json).to eq("false")
-      end
-
-      it "NilClass#to_json should work" do
-        expect(nil.to_json).to eq("null")
-      end
-    end
-
-    context "ported tests for generation" do
-      before(:all) do
-        @hash = {
-          'a' => 2,
-          'b' => 3.141,
-          'c' => 'c',
-          'd' => [ 1, "b", 3.14 ],
-          'e' => { 'foo' => 'bar' },
-          'g' => "blah",
-          'h' => 1000.0,
-          'i' => 0.001,
-        }
-
-        @json2 = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},"g":"blah","h":1000.0,"i":0.001}'
-
-        @json3 = %{
-        {
-          "a": 2,
-          "b": 3.141,
-          "c": "c",
-          "d": [1, "b", 3.14],
-          "e": {"foo": "bar"},
-          "g": "blah",
-          "h": 1000.0,
-          "i": 0.001
-        }
-        }.chomp
-      end
-
-      it "should be able to unparse" do
-        json = JSON.generate(@hash)
-        expect(JSON.parse(@json2)).to eq(JSON.parse(json))
-        parsed_json = JSON.parse(json)
-        expect(@hash).to eq(parsed_json)
-        json = JSON.generate( 1=>2 )
-        expect('{"1":2}').to eql(json)
-        parsed_json = JSON.parse(json)
-        expect( "1"=>2 ).to eq(parsed_json)
-      end
-
-      it "should be able to unparse pretty" do
-        json = JSON.pretty_generate(@hash)
-        expect(JSON.parse(@json3)).to eq(JSON.parse(json))
-        parsed_json = JSON.parse(json)
-        expect(@hash).to eq(parsed_json)
-        json = JSON.pretty_generate( 1=>2 )
-        test = "{\n  \"1\": 2\n}".chomp
-        expect(test).to eq(json)
-        parsed_json = JSON.parse(json)
-        expect( "1"=>2 ).to eq(parsed_json)
-      end
-
-      it "JSON.generate should handle nil second argument" do
-        expect(JSON.generate(["foo"], nil)).to eql(%q{["foo"]})
-      end
-    end
-  end
-end