mcollective-2.3.3/lib/mcollective/vendor/json/lib/json/common.rb

   1 require 'json/version'
   2
   3 module JSON
   4   class << self
   5     # If _object_ is string-like, parse the string and return the parsed result
   6     # as a Ruby data structure. Otherwise generate a JSON text from the Ruby
   7     # data structure object and return it.
   8     #
   9     # The _opts_ argument is passed through to generate/parse respectively. See
  10     # generate and parse for their documentation.
  11     def [](object, opts = {})
  12       if object.respond_to? :to_str
  13         JSON.parse(object.to_str, opts)
  14       else
  15         JSON.generate(object, opts)
  16       end
  17     end
  18
  19     # Returns the JSON parser class that is used by JSON. This is either
  20     # JSON::Ext::Parser or JSON::Pure::Parser.
  21     attr_reader :parser
  22
  23     # Set the JSON parser class _parser_ to be used by JSON.
  24     def parser=(parser) # :nodoc:
  25       @parser = parser
  26       remove_const :Parser if JSON.const_defined_in?(self, :Parser)
  27       const_set :Parser, parser
  28     end
  29
  30     # Return the constant located at _path_. The format of _path_ has to be
  31     # either ::A::B::C or A::B::C. In any case, A has to be located at the top
  32     # level (absolute namespace path?). If there doesn't exist a constant at
  33     # the given path, an ArgumentError is raised.
  34     def deep_const_get(path) # :nodoc:
  35       path.to_s.split(/::/).inject(Object) do |p, c|
  36         case
  37         when c.empty?                     then p
  38         when JSON.const_defined_in?(p, c) then p.const_get(c)
  39         else
  40           begin
  41             p.const_missing(c)
  42           rescue NameError => e
  43             raise ArgumentError, "can't get const #{path}: #{e}"
  44           end
  45         end
  46       end
  47     end
  48
  49     # Set the module _generator_ to be used by JSON.
  50     def generator=(generator) # :nodoc:
  51       old, $VERBOSE = $VERBOSE, nil
  52       @generator = generator
  53       generator_methods = generator::GeneratorMethods
  54       for const in generator_methods.constants
  55         klass = deep_const_get(const)
  56         modul = generator_methods.const_get(const)
  57         klass.class_eval do
  58           instance_methods(false).each do |m|
  59             m.to_s == 'to_json' and remove_method m
  60           end
  61           include modul
  62         end
  63       end
  64       self.state = generator::State
  65       const_set :State, self.state
  66       const_set :SAFE_STATE_PROTOTYPE, State.new
  67       const_set :FAST_STATE_PROTOTYPE, State.new(
  68         :indent         => '',
  69         :space          => '',
  70         :object_nl      => "",
  71         :array_nl       => "",
  72         :max_nesting    => false
  73       )
  74       const_set :PRETTY_STATE_PROTOTYPE, State.new(
  75         :indent         => '  ',
  76         :space          => ' ',
  77         :object_nl      => "\n",
  78         :array_nl       => "\n"
  79       )
  80     ensure
  81       $VERBOSE = old
  82     end
  83
  84     # Returns the JSON generator module that is used by JSON. This is
  85     # either JSON::Ext::Generator or JSON::Pure::Generator.
  86     attr_reader :generator
  87
  88     # Returns the JSON generator state class that is used by JSON. This is
  89     # either JSON::Ext::Generator::State or JSON::Pure::Generator::State.
  90     attr_accessor :state
  91
  92     # This is create identifier, which is used to decide if the _json_create_
  93     # hook of a class should be called. It defaults to 'json_class'.
  94     attr_accessor :create_id
  95   end
  96   self.create_id = 'json_class'
  97
  98   NaN           = 0.0/0
  99
 100   Infinity      = 1.0/0
 101
 102   MinusInfinity = -Infinity
 103
 104   # The base exception for JSON errors.
 105   class JSONError < StandardError; end
 106
 107   # This exception is raised if a parser error occurs.
 108   class ParserError < JSONError; end
 109
 110   # This exception is raised if the nesting of parsed data structures is too
 111   # deep.
 112   class NestingError < ParserError; end
 113
 114   # :stopdoc:
 115   class CircularDatastructure < NestingError; end
 116   # :startdoc:
 117
 118   # This exception is raised if a generator or unparser error occurs.
 119   class GeneratorError < JSONError; end
 120   # For backwards compatibility
 121   UnparserError = GeneratorError
 122
 123   # This exception is raised if the required unicode support is missing on the
 124   # system. Usually this means that the iconv library is not installed.
 125   class MissingUnicodeSupport < JSONError; end
 126
 127   module_function
 128
 129   # Parse the JSON document _source_ into a Ruby data structure and return it.
 130   #
 131   # _opts_ can have the following
 132   # keys:
 133   # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
 134   #   structures. Disable depth checking with :max_nesting => false. It defaults
 135   #   to 19.
 136   # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
 137   #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
 138   #   to false.
 139   # * *symbolize_names*: If set to true, returns symbols for the names
 140   #   (keys) in a JSON object. Otherwise strings are returned. Strings are
 141   #   the default.
 142   # * *create_additions*: If set to false, the Parser doesn't create
 143   #   additions even if a matching class and create_id was found. This option
 144   #   defaults to false.
 145   # * *object_class*: Defaults to Hash
 146   # * *array_class*: Defaults to Array
 147   def parse(source, opts = {})
 148     Parser.new(source, opts).parse
 149   end
 150
 151   # Parse the JSON document _source_ into a Ruby data structure and return it.
 152   # The bang version of the parse method defaults to the more dangerous values
 153   # for the _opts_ hash, so be sure only to parse trusted _source_ documents.
 154   #
 155   # _opts_ can have the following keys:
 156   # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
 157   #   structures. Enable depth checking with :max_nesting => anInteger. The parse!
 158   #   methods defaults to not doing max depth checking: This can be dangerous
 159   #   if someone wants to fill up your stack.
 160   # * *allow_nan*: If set to true, allow NaN, Infinity, and -Infinity in
 161   #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
 162   #   to true.
 163   # * *create_additions*: If set to false, the Parser doesn't create
 164   #   additions even if a matching class and create_id was found. This option
 165   #   defaults to false.
 166   def parse!(source, opts = {})
 167     opts = {
 168       :max_nesting  => false,
 169       :allow_nan    => true
 170     }.update(opts)
 171     Parser.new(source, opts).parse
 172   end
 173
 174   # Generate a JSON document from the Ruby data structure _obj_ and return
 175   # it. _state_ is * a JSON::State object,
 176   # * or a Hash like object (responding to to_hash),
 177   # * an object convertible into a hash by a to_h method,
 178   # that is used as or to configure a State object.
 179   #
 180   # It defaults to a state object, that creates the shortest possible JSON text
 181   # in one line, checks for circular data structures and doesn't allow NaN,
 182   # Infinity, and -Infinity.
 183   #
 184   # A _state_ hash can have the following keys:
 185   # * *indent*: a string used to indent levels (default: ''),
 186   # * *space*: a string that is put after, a : or , delimiter (default: ''),
 187   # * *space_before*: a string that is put before a : pair delimiter (default: ''),
 188   # * *object_nl*: a string that is put at the end of a JSON object (default: ''),
 189   # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
 190   # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
 191   #   generated, otherwise an exception is thrown if these values are
 192   #   encountered. This options defaults to false.
 193   # * *max_nesting*: The maximum depth of nesting allowed in the data
 194   #   structures from which JSON is to be generated. Disable depth checking
 195   #   with :max_nesting => false, it defaults to 19.
 196   #
 197   # See also the fast_generate for the fastest creation method with the least
 198   # amount of sanity checks, and the pretty_generate method for some
 199   # defaults for pretty output.
 200   def generate(obj, opts = nil)
 201     if State === opts
 202       state, opts = opts, nil
 203     else
 204       state = SAFE_STATE_PROTOTYPE.dup
 205     end
 206     if opts
 207       if opts.respond_to? :to_hash
 208         opts = opts.to_hash
 209       elsif opts.respond_to? :to_h
 210         opts = opts.to_h
 211       else
 212         raise TypeError, "can't convert #{opts.class} into Hash"
 213       end
 214       state = state.configure(opts)
 215     end
 216     state.generate(obj)
 217   end
 218
 219   # :stopdoc:
 220   # I want to deprecate these later, so I'll first be silent about them, and
 221   # later delete them.
 222   alias unparse generate
 223   module_function :unparse
 224   # :startdoc:
 225
 226   # Generate a JSON document from the Ruby data structure _obj_ and return it.
 227   # This method disables the checks for circles in Ruby objects.
 228   #
 229   # *WARNING*: Be careful not to pass any Ruby data structures with circles as
 230   # _obj_ argument because this will cause JSON to go into an infinite loop.
 231   def fast_generate(obj, opts = nil)
 232     if State === opts
 233       state, opts = opts, nil
 234     else
 235       state = FAST_STATE_PROTOTYPE.dup
 236     end
 237     if opts
 238       if opts.respond_to? :to_hash
 239         opts = opts.to_hash
 240       elsif opts.respond_to? :to_h
 241         opts = opts.to_h
 242       else
 243         raise TypeError, "can't convert #{opts.class} into Hash"
 244       end
 245       state.configure(opts)
 246     end
 247     state.generate(obj)
 248   end
 249
 250   # :stopdoc:
 251   # I want to deprecate these later, so I'll first be silent about them, and later delete them.
 252   alias fast_unparse fast_generate
 253   module_function :fast_unparse
 254   # :startdoc:
 255
 256   # Generate a JSON document from the Ruby data structure _obj_ and return it.
 257   # The returned document is a prettier form of the document returned by
 258   # #unparse.
 259   #
 260   # The _opts_ argument can be used to configure the generator. See the
 261   # generate method for a more detailed explanation.
 262   def pretty_generate(obj, opts = nil)
 263     if State === opts
 264       state, opts = opts, nil
 265     else
 266       state = PRETTY_STATE_PROTOTYPE.dup
 267     end
 268     if opts
 269       if opts.respond_to? :to_hash
 270         opts = opts.to_hash
 271       elsif opts.respond_to? :to_h
 272         opts = opts.to_h
 273       else
 274         raise TypeError, "can't convert #{opts.class} into Hash"
 275       end
 276       state.configure(opts)
 277     end
 278     state.generate(obj)
 279   end
 280
 281   # :stopdoc:
 282   # I want to deprecate these later, so I'll first be silent about them, and later delete them.
 283   alias pretty_unparse pretty_generate
 284   module_function :pretty_unparse
 285   # :startdoc:
 286
 287   # Load a ruby data structure from a JSON _source_ and return it. A source can
 288   # either be a string-like object, an IO-like object, or an object responding
 289   # to the read method. If _proc_ was given, it will be called with any nested
 290   # Ruby object as an argument recursively in depth first order. To modify the
 291   # default options pass in the optional _options_ argument as well.
 292   #
 293   # This method is part of the implementation of the load/dump interface of
 294   # Marshal and YAML.
 295   def load(source, proc = nil, options = {})
 296     load_default_options = {
 297       :max_nesting      => false,
 298       :allow_nan        => true,
 299       :create_additions => false
 300     }
 301     opts = load_default_options.merge options
 302     if source.respond_to? :to_str
 303       source = source.to_str
 304     elsif source.respond_to? :to_io
 305       source = source.to_io.read
 306     else
 307       source = source.read
 308     end
 309     result = parse(source, opts)
 310     recurse_proc(result, &proc) if proc
 311     result
 312   end
 313
 314   # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_
 315   def recurse_proc(result, &proc)
 316     case result
 317     when Array
 318       result.each { |x| recurse_proc x, &proc }
 319       proc.call result
 320     when Hash
 321       result.each { |x, y| recurse_proc x, &proc; recurse_proc y, &proc }
 322       proc.call result
 323     else
 324       proc.call result
 325     end
 326   end
 327
 328   alias restore load
 329   module_function :restore
 330
 331   # Dumps _obj_ as a JSON string, i.e. calls generate on the object and returns
 332   # the result.
 333   #
 334   # If anIO (an IO-like object or an object that responds to the write method)
 335   # was given, the resulting JSON is written to it.
 336   #
 337   # If the number of nested arrays or objects exceeds _limit_, an ArgumentError
 338   # exception is raised. This argument is similar (but not exactly the
 339   # same!) to the _limit_ argument in Marshal.dump.
 340   #
 341   # This method is part of the implementation of the load/dump interface of
 342   # Marshal and YAML.
 343   def dump(obj, anIO = nil, limit = nil)
 344     if anIO and limit.nil?
 345       anIO = anIO.to_io if anIO.respond_to?(:to_io)
 346       unless anIO.respond_to?(:write)
 347         limit = anIO
 348         anIO = nil
 349       end
 350     end
 351     limit ||= 0
 352     result = generate(obj, :allow_nan => true, :max_nesting => limit)
 353     if anIO
 354       anIO.write result
 355       anIO
 356     else
 357       result
 358     end
 359   rescue JSON::NestingError
 360     raise ArgumentError, "exceed depth limit"
 361   end
 362
 363   # Swap consecutive bytes of _string_ in place.
 364   def self.swap!(string) # :nodoc:
 365     0.upto(string.size / 2) do |i|
 366       break unless string[2 * i + 1]
 367       string[2 * i], string[2 * i + 1] = string[2 * i + 1], string[2 * i]
 368     end
 369     string
 370   end
 371
 372   # Shortuct for iconv.
 373   if ::String.method_defined?(:encode)
 374     # Encodes string using Ruby's _String.encode_
 375     def self.iconv(to, from, string)
 376       string.encode(to, from)
 377     end
 378   else
 379     require 'iconv'
 380     # Encodes string using _iconv_ library
 381     def self.iconv(to, from, string)
 382       Iconv.conv(to, from, string)
 383     end
 384   end
 385
 386   if ::Object.method(:const_defined?).arity == 1
 387     def self.const_defined_in?(modul, constant)
 388       modul.const_defined?(constant)
 389     end
 390   else
 391     def self.const_defined_in?(modul, constant)
 392       modul.const_defined?(constant, false)
 393     end
 394   end
 395 end
 396
 397 module ::Kernel
 398   private
 399
 400   # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in
 401   # one line.
 402   def j(*objs)
 403     objs.each do |obj|
 404       puts JSON::generate(obj, :allow_nan => true, :max_nesting => false)
 405     end
 406     nil
 407   end
 408
 409   # Ouputs _objs_ to STDOUT as JSON strings in a pretty format, with
 410   # indentation and over many lines.
 411   def jj(*objs)
 412     objs.each do |obj|
 413       puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)
 414     end
 415     nil
 416   end
 417
 418   # If _object_ is string-like, parse the string and return the parsed result as
 419   # a Ruby data structure. Otherwise, generate a JSON text from the Ruby data
 420   # structure object and return it.
 421   #
 422   # The _opts_ argument is passed through to generate/parse respectively. See
 423   # generate and parse for their documentation.
 424   def JSON(object, *args)
 425     if object.respond_to? :to_str
 426       JSON.parse(object.to_str, args.first)
 427     else
 428       JSON.generate(object, args.first)
 429     end
 430   end
 431 end
 432
 433 # Extends any Class to include _json_creatable?_ method.
 434 class ::Class
 435   # Returns true if this class can be used to create an instance
 436   # from a serialised JSON string. The class has to implement a class
 437   # method _json_create_ that expects a hash as first parameter. The hash
 438   # should include the required data.
 439   def json_creatable?
 440     respond_to?(:json_create)
 441   end
 442 end