plyom_user 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/README.md

@@ -0,0 +1,108 @@
+# MultiJSON
+
+[![Gem Version](https://badge.fury.io/rb/multi_json.png)][gem]
+[![Build Status](https://secure.travis-ci.org/intridea/multi_json.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/intridea/multi_json.png?travis)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/intridea/multi_json.png)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/intridea/multi_json/badge.png?branch=master)][coveralls]
+
+[gem]: https://rubygems.org/gems/multi_json
+[travis]: http://travis-ci.org/intridea/multi_json
+[gemnasium]: https://gemnasium.com/intridea/multi_json
+[codeclimate]: https://codeclimate.com/github/intridea/multi_json
+
+Lots of Ruby libraries parse JSON and everyone has their favorite JSON coder.
+Instead of choosing a single JSON coder and forcing users of your library to be
+stuck with it, you can use MultiJSON instead, which will simply choose the
+fastest available JSON coder. Here's how to use it:
+
+```ruby
+require 'multi_json'
+
+MultiJson.load('{"abc":"def"}') #=> {"abc" => "def"}
+MultiJson.load('{"abc":"def"}', :symbolize_keys => true) #=> {:abc => "def"}
+MultiJson.dump({:abc => 'def'}) # convert Ruby back to JSON
+MultiJson.dump({:abc => 'def'}, :pretty => true) # encoded in a pretty form (if supported by the coder)
+```
+
+When loading invalid JSON, multiJSON will throw a `MultiJson::LoadError`. `MultiJson::DecodeError` is an alias for backwards compatibility.
+
+```ruby
+MultiJson.load('invalid json') #=> MultiJson::LoadError
+```
+
+The `use` method, which sets the MultiJson adapter, takes either a symbol or a
+class (to allow for custom JSON parsers) that responds to both `.load` and `.dump`
+at the class level.
+
+MultiJSON tries to have intelligent defaulting. That is, if you have any of the
+supported engines already loaded, it will utilize them before attempting to
+load any. When loading, libraries are ordered by speed. First Oj, then Yajl,
+then the JSON gem, then JSON pure. If no other JSON library is available,
+MultiJSON falls back to [OkJson][], a simple, vendorable JSON parser.
+
+[okjson]: https://github.com/kr/okjson
+
+## Supported JSON Engines
+
+* [Oj](https://github.com/ohler55/oj) Optimized JSON by Peter Ohler
+* [Yajl](https://github.com/brianmario/yajl-ruby) Yet Another JSON Library by Brian Lopez
+* [JSON](https://github.com/flori/json) The default JSON gem with C-extensions (ships with Ruby 1.9)
+* [JSON Pure](https://github.com/flori/json) A Ruby variant of the JSON gem
+* [NSJSONSerialization](https://developer.apple.com/library/ios/#documentation/Foundation/Reference/NSJSONSerialization_Class/Reference/Reference.html) Wrapper for Apple's NSJSONSerialization in the Cocoa Framework (MacRuby only)
+* [gson.rb](https://github.com/avsej/gson.rb) A Ruby wrapper for google-gson library (JRuby only)
+* [JrJackson](https://github.com/guyboertje/jrjackson) JRuby wrapper for Jackson (JRuby only)
+* [OkJson][okjson] A simple, vendorable JSON parser
+
+## Supported Ruby Versions
+This library aims to support and is [tested against][travis] the following Ruby
+implementations:
+
+* Ruby 1.8.7
+* Ruby 1.9.2
+* Ruby 1.9.3
+* Ruby 2.0.0
+* [JRuby][]
+* [Rubinius][]
+* [MacRuby][] (not tested on Travis CI)
+
+[jruby]: http://www.jruby.org/
+[rubinius]: http://rubini.us/
+[macruby]: http://www.macruby.org/
+
+If something doesn't work on one of these interpreters, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby
+implementations, however support will only be provided for the versions listed
+above.
+
+If you would like this library to support another Ruby version, you may
+volunteer to be a maintainer. Being a maintainer entails making sure all tests
+run and pass on that implementation. When something breaks on your
+implementation, you will be responsible for providing patches in a timely
+fashion. If critical issues for a particular implementation exist at the time
+of a major release, support for that Ruby version may be dropped.
+
+## Versioning
+
+This library aims to adhere to [Semantic Versioning 2.0.0][semver]. Violations
+of this scheme should be reported as bugs. Specifically, if a minor or patch
+version is released that breaks backward compatibility, that version should be
+immediately yanked and/or a new version should be immediately released that
+restores compatibility. Breaking changes to the public API will only be
+introduced with new major versions. As a result of this policy, you can (and
+should) specify a dependency on this gem using the [Pessimistic Version
+Constraint][pvc] with two digits of precision. For example:
+
+```ruby
+spec.add_dependency 'multi_json', '~> 1.0'
+```
+
+[semver]: http://semver.org/
+[pvc]: http://docs.rubygems.org/read/chapter/16#page74
+
+## Copyright
+Copyright (c) 2010-2013 Michael Bleigh, Josh Kalderimis, Erik Michaels-Ober,
+and Pavel Pravosud. See [LICENSE][] for details.
+
+[license]: LICENSE.md

data/vendor/bundle/ruby/2.0.0/gems/multi_json-1.8.2/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:base_spec) do |task|
+  task.pattern = 'spec/multi_json_spec.rb'
+end
+
+namespace :adapters do
+  Dir['spec/*_adapter_spec.rb'].each do |adapter_spec|
+    adapter_name = adapter_spec[/(\w+)_adapter_spec/, 1]
+    desc "Run #{adapter_name} adapter specs"
+    RSpec::Core::RakeTask.new(adapter_name) do |task|
+      task.pattern = adapter_spec
+    end
+  end
+end
+
+task :spec => %w[base_spec adapters:oj adapters:yajl adapters:json_gem adapters:json_pure adapters:ok_json adapters:gson adapters:jr_jackson adapters:nsjsonserialization]
+
+task :default => :spec
+task :test => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

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

@@ -0,0 +1,57 @@
+require 'singleton'
+require 'multi_json/options'
+
+module MultiJson
+  class Adapter
+    extend Options
+    include Singleton
+    class << self
+
+      def defaults(action, value)
+        metaclass = class << self; self; end
+
+        metaclass.instance_eval do
+          define_method("default_#{action}_options"){ value }
+        end
+      end
+
+      def load(string, options={})
+        raise self::ParseError if blank?(string)
+        instance.load(string, collect_load_options(options).clone)
+      end
+
+      def dump(object, options={})
+        instance.dump(object, collect_dump_options(options).clone)
+      end
+
+    protected
+
+      def collect_load_options(options)
+        cache('load', options){ collect_options(:load_options, options).merge(options) }
+      end
+
+      def collect_dump_options(options)
+        cache('dump', options){ collect_options(:dump_options, options).merge(options) }
+      end
+
+      def collect_options(method, *args)
+        global, local = *[MultiJson, self].map{ |r| r.send(method, *args) }
+        local.merge(global)
+      end
+
+      def cache(method, options)
+        cache_key = [self, options].map(&:hash).join + method
+        MultiJson.cached_options[cache_key] ||= yield
+      end
+
+    private
+
+      def blank?(input)
+        input.nil? || /\A\s*\z/ === input
+      rescue ArgumentError # invalid byte sequence in UTF-8
+        false
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'gson'
+require 'multi_json/adapter'
+
+module MultiJson
+  module Adapters
+    # Use the gson.rb library to dump/load.
+    class Gson < Adapter
+      ParseError = ::Gson::DecodeError
+
+      def load(string, options={})
+        ::Gson::Decoder.new(options).decode(string)
+      end
+
+      def dump(object, options={})
+        ::Gson::Encoder.new(options).encode(object)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'jrjackson' unless defined?(::JrJackson)
+require 'multi_json/adapter'
+
+module MultiJson
+  module Adapters
+    # Use the jrjackson.rb library to dump/load.
+    class JrJackson < Adapter
+      ParseError = ::JrJackson::ParseError
+
+      def load(string, options={}) #:nodoc:
+        ::JrJackson::Json.load(string, options)
+      end
+
+      def dump(object, options={}) #:nodoc:
+        ::JrJackson::Json.dump(object)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'multi_json/adapter'
+
+module MultiJson
+  module Adapters
+    class JsonCommon < Adapter
+      defaults :load, :create_additions => false, :quirks_mode => true
+
+      def load(string, options={})
+        string = string.read if string.respond_to?(:read)
+
+        if string.respond_to?(:force_encoding)
+          string = string.dup.force_encoding(::Encoding::ASCII_8BIT)
+        end
+
+        options[:symbolize_names] = true if options.delete(:symbolize_keys)
+        ::JSON.parse(string, options)
+      end
+
+      def dump(object, options={})
+        options.merge!(::JSON::PRETTY_STATE_PROTOTYPE.to_h) if options.delete(:pretty)
+        object.to_json(options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'json/ext'
+require 'multi_json/adapters/json_common'
+
+module MultiJson
+  module Adapters
+    # Use the JSON gem to dump/load.
+    class JsonGem < JsonCommon
+      ParseError = ::JSON::ParserError
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'json/pure'
+require 'multi_json/adapters/json_common'
+
+module MultiJson
+  module Adapters
+    # Use JSON pure to dump/load.
+    class JsonPure < JsonCommon
+      ParseError = ::JSON::ParserError
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+framework 'Foundation'
+require 'multi_json/adapters/ok_json'
+
+module MultiJson
+  module Adapters
+    class Nsjsonserialization < MultiJson::Adapters::OkJson
+      ParseError = ::MultiJson::OkJson::Error
+
+      def load(string, options={})
+        string = string.read if string.respond_to?(:read)
+        data = string.dataUsingEncoding(NSUTF8StringEncoding)
+        object = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves, error: nil)
+        if object
+          object = symbolize_keys(object) if options[:symbolize_keys]
+          object
+        else
+          super(string, options={})
+        end
+      end
+
+      def dump(object, options={})
+        pretty = options[:pretty] ? NSJSONWritingPrettyPrinted : 0
+        object = object.as_json if object.respond_to?(:as_json)
+        if NSJSONSerialization.isValidJSONObject(object)
+          data = NSJSONSerialization.dataWithJSONObject(object, options: pretty, error: nil)
+          NSMutableString.alloc.initWithData(data, encoding: NSUTF8StringEncoding)
+        else
+          super(object, options)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'oj'
+require 'multi_json/adapter'
+
+module MultiJson
+  module Adapters
+    # Use the Oj library to dump/load.
+    class Oj < Adapter
+      defaults :load, :mode => :strict, :symbolize_keys => false
+      defaults :dump, :mode => :compat, :time_format => :ruby
+
+      ParseError = defined?(::Oj::ParseError) ? ::Oj::ParseError : SyntaxError
+
+      def load(string, options={})
+        options[:symbol_keys] = options.delete(:symbolize_keys)
+        ::Oj.load(string, options)
+      end
+
+      def dump(object, options={})
+        options.merge!(:indent => 2) if options[:pretty]
+        ::Oj.dump(object, options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'multi_json/adapter'
+require 'multi_json/convertible_hash_keys'
+require 'multi_json/vendor/okjson'
+
+module MultiJson
+  module Adapters
+    class OkJson < Adapter
+      include ConvertibleHashKeys
+      ParseError = ::MultiJson::OkJson::Error
+
+      def load(string, options={})
+        string = string.read if string.respond_to?(:read)
+        result = ::MultiJson::OkJson.decode("[#{string}]").first
+        options[:symbolize_keys] ? symbolize_keys(result) : result
+      rescue ArgumentError # invalid byte sequence in UTF-8
+        raise ParseError
+      end
+
+      def dump(object, options={})
+        ::MultiJson::OkJson.valenc(stringify_keys(object))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'yajl'
+require 'multi_json/adapter'
+
+module MultiJson
+  module Adapters
+    # Use the Yajl-Ruby library to dump/load.
+    class Yajl < Adapter
+      ParseError = ::Yajl::ParseError
+
+      def load(string, options={})
+        ::Yajl::Parser.new(:symbolize_keys => options[:symbolize_keys]).parse(string)
+      end
+
+      def dump(object, options={})
+        ::Yajl::Encoder.encode(object, options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module MultiJson
+  module ConvertibleHashKeys
+    private
+
+    def symbolize_keys(object)
+      prepare_object(object) do |key|
+        key.respond_to?(:to_sym) ? key.to_sym : key
+      end
+    end
+
+    def stringify_keys(object)
+      prepare_object(object) do |key|
+        key.respond_to?(:to_s) ? key.to_s : key
+      end
+    end
+
+    def prepare_object(object, &key_modifier)
+      return object unless block_given?
+      case object
+      when Array
+        object.map do |value|
+          prepare_object(value, &key_modifier)
+        end
+      when Hash
+        object.inject({}) do |result, (key, value)|
+          new_key   = key_modifier.call(key)
+          new_value = prepare_object(value, &key_modifier)
+          result.merge! new_key => new_value
+        end
+      when String, Numeric, true, false, nil
+        object
+      else
+        if object.respond_to?(:to_json)
+          object
+        elsif object.respond_to?(:to_s)
+          object.to_s
+        else
+          object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module MultiJson
+  class LoadError < StandardError
+    attr_reader :data
+    def initialize(message='', backtrace=[], data='')
+      super(message)
+      self.set_backtrace(backtrace)
+      @data = data
+    end
+  end
+  DecodeError = LoadError # Legacy support
+end

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

@@ -0,0 +1,48 @@
+module MultiJson
+  module Options
+
+    def load_options=(options)
+      MultiJson.reset_cached_options!
+      @load_options = options
+    end
+
+    def dump_options=(options)
+      MultiJson.reset_cached_options!
+      @dump_options = options
+    end
+
+    def load_options(*args)
+      get_options :load_options, *args
+    end
+
+    def dump_options(*args)
+      get_options :dump_options, *args
+    end
+
+    def default_load_options
+      @default_load_options ||= {}
+    end
+
+    def default_dump_options
+      @default_dump_options ||= {}
+    end
+
+    private
+
+    def get_options(ivar, *args)
+      defaults = send("default_#{ivar}")
+
+      return defaults unless instance_variable_defined?("@#{ivar}")
+
+      value = instance_variable_get("@#{ivar}")
+
+      if value.respond_to?(:call) and value.arity
+        value.arity == 0 ? value[] : value[*args]
+      elsif Hash === value or value.respond_to?(:to_hash)
+        value.to_hash
+      else
+        defaults
+      end
+    end
+  end
+end