nano-safe-gem 0.0.1

data/oj-3.17.3/lib/oj/saj.rb

@@ -0,0 +1,80 @@
+module Oj
+  # A SAX style parse handler for JSON hence the acronym SAJ for Simple API
+  # for JSON. The Oj::Saj handler class can be subclassed and then used with
+  # the Oj::Saj key_parse() method or with the more resent
+  # Oj::Parser.new(:saj). The Saj methods will then be called as the file is
+  # parsed.
+  #
+  # With Oj::Parser.new(:saj) each method can also include a line and column
+  # argument so hash_start(key) could also be hash_start(key, line,
+  # column). The error() method is no used with Oj::Parser.new(:saj) so it
+  # will never be called.
+  #
+  # @example
+  #
+  #  require 'oj'
+  #
+  #  class MySaj < ::Oj::Saj
+  #    def initialize()
+  #      @hash_cnt = 0
+  #    end
+  #
+  #    def hash_start(key)
+  #      @hash_cnt += 1
+  #    end
+  #  end
+  #
+  #  cnt = MySaj.new()
+  #  File.open('any.json', 'r') do |f|
+  #    Oj.saj_parse(cnt, f)
+  #  end
+  #
+  # or
+  #
+  #  p = Oj::Parser.new(:saj)
+  #  p.handler = MySaj.new()
+  #  File.open('any.json', 'r') do |f|
+  #    p.parse(f.read)
+  #  end
+  #
+  # To make the desired methods active while parsing the desired method should
+  # be made public in the subclasses. If the methods remain private they will
+  # not be called during parsing.
+  #
+  #    def hash_start(key); end
+  #    def hash_end(key); end
+  #    def array_start(key); end
+  #    def array_end(key); end
+  #    def add_value(value, key); end
+  #    def error(message, line, column); end
+  #
+  class Saj
+    # Create a new instance of the Saj handler class.
+    def initialize()
+    end
+
+    # To make the desired methods active while parsing the desired method should
+    # be made public in the subclasses. If the methods remain private they will
+    # not be called during parsing.
+    private
+
+    def hash_start(key)
+    end
+
+    def hash_end(key)
+    end
+
+    def array_start(key)
+    end
+
+    def array_end(key)
+    end
+
+    def add_value(value, key)
+    end
+
+    def error(message, line, column)
+    end
+
+  end # Saj
+end # Oj

data/oj-3.17.3/lib/oj/schandler.rb

@@ -0,0 +1,143 @@
+module Oj
+  # A Simple Callback Parser (SCP) for JSON. The Oj::ScHandler class should be
+  # subclassed and then used with the Oj.sc_parse() method. The Scp methods will
+  # then be called as the file is parsed. The handler does not have to be a
+  # subclass of the ScHandler class as long as it responds to the desired
+  # methods.
+  #
+  # @example
+  #
+  #  require 'oj'
+  #
+  #  class MyHandler < ::Oj::ScHandler
+  #    def hash_start
+  #      {}
+  #    end
+  #
+  #    def hash_set(h,k,v)
+  #      h[k] = v
+  #    end
+  #
+  #    def array_start
+  #      []
+  #    end
+  #
+  #    def array_append(a,v)
+  #      a << v
+  #    end
+  #
+  #    def add_value(v)
+  #      p v
+  #    end
+  #
+  #    def error(message, line, column)
+  #      p "ERROR: #{message}"
+  #    end
+  #  end
+  #
+  #  File.open('any.json', 'r') do |f|
+  #    Oj.sc_parse(MyHandler.new, f)
+  #  end
+  #
+  # To make the desired methods active while parsing the desired method should
+  # be made public in the subclasses. If the methods remain private they will
+  # not be called during parsing.
+  #
+  #    def hash_start(); end
+  #    def hash_end(); end
+  #    def hash_key(key); end
+  #    def hash_set(h, key, value); end
+  #    def array_start(); end
+  #    def array_end(); end
+  #    def array_append(a, value); end
+  #    def add_value(value); end
+  #
+  # As certain elements of a JSON document are reached during parsing the
+  # callbacks are called. The parser helps by keeping track of objects created
+  # by the callbacks but does not create those objects itself.
+  #
+  #    hash_start
+  #
+  # When a JSON object element starts the hash_start() callback is called if
+  # public. It should return what ever Ruby Object is to be used as the element
+  # that will later be included in the hash_set() callback.
+  #
+  #    hash_end
+  #
+  #  At the end of a JSON object element the hash_end() callback is called if
+  #  public.
+  #
+  #    hash_key
+  #
+  # When a hash key is encountered the hash_key() method is called with the
+  # parsed hash value key. The return value from the call is then used as the
+  # key in the key-value pair that follows.
+  #
+  #    hash_set
+  #
+  # When a key value pair is encountered during parsing the hash_set() callback
+  # is called if public. The first element will be the object returned from the
+  # enclosing hash_start() callback. The second argument is the key and the last
+  # is the value.
+  #
+  #    array_start
+  #
+  # When a JSON array element is started the array_start() callback is called if
+  # public. It should return what ever Ruby Object is to be used as the element
+  # that will later be included in the array_append() callback.
+  #
+  #    array_end
+  #
+  # At the end of a JSON array element the array_end() callback is called if public.
+  #
+  #    array_append
+  #
+  # When a element is encountered that is an element of an array the
+  # array_append() callback is called if public. The first argument to the
+  # callback is the Ruby object returned from the enclosing array_start()
+  # callback.
+  #
+  #    add_value
+  #
+  # The handler is expected to handle multiple JSON elements in one stream,
+  # file, or string. When a top level JSON has been read completely the
+  # add_value() callback is called. Even if only one element was ready this
+  # callback returns the Ruby object that was constructed during the parsing.
+  #
+  class ScHandler
+    # Create a new instance of the ScHandler class.
+    def initialize()
+    end
+
+    # To make the desired methods active while parsing the desired method should
+    # be made public in the subclasses. If the methods remain private they will
+    # not be called during parsing.
+    private
+
+    def hash_start()
+    end
+
+    def hash_end()
+    end
+
+    def hash_key(key)
+      key
+    end
+
+    def hash_set(h, key, value)
+    end
+
+    def array_start()
+    end
+
+    def array_end()
+    end
+
+    def add_value(value)
+    end
+
+    def array_append(a, value)
+    end
+
+  end # ScHandler
+end # Oj

data/oj-3.17.3/lib/oj/state.rb

@@ -0,0 +1,135 @@
+module JSON
+  module Ext
+    module Generator
+      unless defined?(::JSON::Ext::Generator::State)
+        # This class exists for json gem compatibility only. While it can be
+        # used as the options for other than compatibility a simple Hash is
+        # recommended as it is simpler and performs better. The only bit
+        # missing by not using a state object is the depth availability which
+        # may be the depth during dumping or maybe not since it can be set and
+        # the docs for depth= is the same as max_nesting. Note: Had to make
+        # this a subclass of Object instead of Hash like EashyHash due to
+        # conflicts with the json gem.
+        class State
+
+          def self.from_state(opts)
+            s = self.new()
+            s.clear()
+            s.merge(opts)
+            s
+          end
+
+          def initialize(opts = {})
+            @attrs = {}
+
+            # Populate with all vars then merge in opts. This class deviates from
+            # the json gem in that any of the options can be set with the opts
+            # argument. The json gem limits the opts use to 7 of the options.
+            @attrs[:indent] = ''
+            @attrs[:space] = ''
+            @attrs[:space_before] = ''
+            @attrs[:array_nl] = ''
+            @attrs[:object_nl] = ''
+            @attrs[:allow_nan] = false
+            @attrs[:buffer_initial_length] = 1024 # completely ignored by Oj
+            @attrs[:depth] = 0
+            @attrs[:max_nesting] = 100
+            @attrs[:check_circular?] = true
+            @attrs[:ascii_only] = false
+
+            @attrs.merge!(opts)
+          end
+
+          def to_h()
+            return @attrs.dup
+          end
+
+          def to_hash()
+            return @attrs.dup
+          end
+
+          def allow_nan?()
+            @attrs[:allow_nan]
+          end
+
+          def ascii_only?()
+            @attrs[:ascii_only]
+          end
+
+          def configure(opts)
+            raise TypeError.new('expected a Hash') unless opts.respond_to?(:to_h)
+
+            @attrs.merge!(opts.to_h)
+          end
+
+          def generate(obj)
+            JSON.generate(obj)
+          end
+
+          def merge(opts)
+            @attrs.merge!(opts)
+          end
+
+          # special rule for this.
+          def buffer_initial_length=(len)
+            len = 1024 if 0 >= len
+            @attrs[:buffer_initial_length] = len
+          end
+
+          # Replaces the Object.respond_to?() method.
+          # @param [Symbol] m method symbol
+          # @return [Boolean] true for any method that matches an instance
+          #                   variable reader, otherwise false.
+          def respond_to?(m, include_all = false)
+            return true if super
+            return true if has_key?(key)
+            return true if has_key?(key.to_s)
+
+            has_key?(key.to_sym)
+          end
+
+          def [](key)
+            key = key.to_sym
+            @attrs.fetch(key, nil)
+          end
+
+          def []=(key, value)
+            key = key.to_sym
+            @attrs[key] = value
+          end
+
+          def clear()
+            @attrs.clear()
+          end
+
+          def has_key?(k)
+            @attrs.has_key?(key.to_sym)
+          end
+
+          # Handles requests for Hash values. Others cause an Exception to be raised.
+          # @param [Symbol|String] m method symbol
+          # @return [Boolean] the value of the specified instance variable.
+          # @raise [ArgumentError] if an argument is given. Zero arguments expected.
+          # @raise [NoMethodError] if the instance variable is not defined.
+          def method_missing(m, *args, &block)
+            if m.to_s.end_with?('=')
+              raise ArgumentError.new("wrong number of arguments (#{args.size} for 1 with #{m}) to method #{m}") if args.nil? or 1 != args.length
+
+              m = m.to_s[0..-2]
+              m = m.to_sym
+              return @attrs.store(m, args[0])
+            end
+            if @attrs.has_key?(m.to_sym)
+              raise ArgumentError.new("wrong number of arguments (#{args.size} for 0 with #{m}) to method #{m}") unless args.nil? or args.empty?
+
+              return @attrs[m.to_sym]
+            end
+            return @attrs.send(m, *args, &block)
+          end
+
+        end # State
+      end # defined check
+    end # Generator
+  end # Ext
+
+end # JSON

data/oj-3.17.3/lib/oj/version.rb

@@ -0,0 +1,4 @@
+module Oj
+  # Current version of the module.
+  VERSION = '3.17.3'
+end

data/oj-3.17.3/lib/oj.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Oj module is defined in oj.c.
+module Oj
+end
+
+require 'oj/version'
+require 'oj/bag'
+require 'oj/easy_hash'
+require 'oj/error'
+require 'oj/mimic'
+require 'oj/saj'
+require 'oj/schandler'
+
+require 'oj/oj' # C extension

data/oj-3.17.3/pages/Advanced.md

@@ -0,0 +1,22 @@
+# Advanced Features
+
+Optimized JSON (Oj), as the name implies, was written to provide speed optimized
+JSON handling. It was designed as a faster alternative to Yajl and other
+common Ruby JSON parsers. So far it has achieved that, and is about 2 times faster
+than any other Ruby JSON parser, and 3 or more times faster at serializing JSON.
+
+Oj has several `dump` or serialization modes which control how Ruby `Object`s are
+converted to JSON. These modes are set with the `:mode` option in either the
+default options or as one of the options to the `dump` method. In addition to
+the various options there are also alternative APIs for parsing JSON.
+
+The fastest alternative parser API is the `Oj::Doc` API. The `Oj::Doc` API takes
+a completely different approach by opening a JSON document and providing calls
+to navigate around the JSON while it is open. With this approach, JSON access
+can be well over 20 times faster than conventional JSON parsing.
+
+The `Oj::Saj` and `Oj::ScHandler` APIs are callback parsers that
+walk the JSON document depth first and makes callbacks for each element.
+Both callback parser are useful when only portions of the JSON are of
+interest. Performance up to 20 times faster than conventional JSON is
+possible if only a few elements of the JSON are of interest.

data/oj-3.17.3/pages/Compatibility.md

@@ -0,0 +1,25 @@
+# Compatibility
+
+**Ruby**
+
+Oj is compatible with Ruby 2.4+ and RBX.
+Support for JRuby has been removed as JRuby no longer supports C extensions and
+there are bugs in the older versions that are not being fixed.
+
+**Rails**
+
+Although up until 4.1 Rails uses [multi_json](https://github.com/intridea/multi_json), an [issue in Rails](https://github.com/rails/rails/issues/9212) causes ActiveSupport to fail to make use Oj for JSON handling.
+There is a
+[gem to patch this](https://github.com/GoodLife/rails-patch-json-encode) for
+Rails 3.2 and 4.0. As of the Oj 2.6.0 release the default behavior is to not use
+the `to_json()` method unless the `:use_to_json` option is set. This provides
+another work around to the rails older and newer behavior.
+
+The latest ActiveRecord is able to work with Oj by simply using the line:
+
+```
+serialize :metadata, Oj
+```
+
+In version Rails 4.1, multi_json has been removed, and this patch is unnecessary and will no longer work.
+See {file:Rails.md}.

data/oj-3.17.3/pages/Custom.md

@@ -0,0 +1,23 @@
+# Custom mode
+
+The `:custom` mode is the most configurable mode and honors almost all
+options. It provides the most flexibility although it can not be configured to
+be exactly like any of the other modes. Each mode has some special aspect that
+makes it unique. For example, the `:object` mode has it's own unique format
+for object dumping and loading. The `:compat` mode mimic the json gem
+including methods called for encoding and inconsistencies between
+`JSON.dump()`, `JSON.generate()`, and `JSON()`.
+
+The `:custom` mode is the default mode. It can be configured either by passing
+options to the `Oj.dump()` and `Oj.load()` methods or by modifying the default
+options.
+
+The ability to create objects from JSON object elements is supported and
+considers the `:create_additions` option. Special treatment is given to the
+`:create_id` though. If the `:create_id` is set to `"^o"` then the Oj internal
+encoding and decoding is used. These are more efficient than calling out to a
+`to_json` method or `create_json` method on the classes. Those method do not
+have to exist for the `"^o"` behavior to be utilized. Any other `:create_id`
+value behaves similar to the json gem by calling `to_json` and `create_json`
+as appropriate.
+

data/oj-3.17.3/pages/Encoding.md

@@ -0,0 +1,65 @@
+# Oj `:object` Mode Encoding
+
+Object mode is for fast Ruby object serialization and deserialization. That
+was the primary purpose of Oj when it was first developed. As such it is the
+default mode unless changed in the Oj default options. In :object mode Oj
+generates JSON that follows conventions which allow Class and other
+information such as Object IDs for circular reference detection to be encoded
+in a JSON document. The formatting follows these rules.
+
+ * JSON native types, true, false, nil, String, Hash, Array, and Number are
+   encoded normally.
+
+ * A Symbol is encoded as a JSON string with a preceding `':'` character.
+
+ * The `'^'` character denotes a special key value when in a JSON Object sequence.
+
+ * A Ruby String that starts with `':'`or the sequence `'^i'` or `'^r'` are
+   encoded by escaping the first character so that it appears as `'\u005e'` or
+   `'\u003a'` instead of `':'` or `'^'`.
+
+ * A `"^c"` JSON Object key indicates the value should be converted to a Ruby
+   class. The sequence `{"^c":"Oj::Bag"}` is read as the Oj::Bag class.
+
+ * A `"^t"` JSON Object key indicates the value should be converted to a Ruby
+   Time. The sequence `{"^t":1325775487.000000}` is read as Jan 5, 2012 at
+   23:58:07.
+
+ * A `"^o"` JSON Object key indicates the value should be converted to a Ruby
+   Object. The first entry in the JSON Object must be a class with the `"^o"`
+   key. After that each entry is treated as a variable of the Object where the
+   key is the variable name without the preceding `'@'`. An example is
+   `{"^o":"Oj::Bag","x":58,"y":"marbles"}`. `"^O"`is the same except that it
+   is for built in or odd classes that don't obey the normal Ruby
+   rules. Examples are Rational, Date, and DateTime.
+
+ * A `"^u"` JSON Object key indicates the value should be converted to a Ruby
+   Struct. The first entry in the JSON Object must be a class with the
+   `"^u"` key. After that each entry is is given a numeric position in the
+   struct and that is used as the key in the JSON Object. An example is
+   `{"^u":["Range",1,7,false]}`.
+
+ * When encoding an Object, if the variable name does not begin with an
+   `'@'`character then the name preceded by a `'~'` character. This occurs in
+   the Exception class. An example is `{"^o":"StandardError","~mesg":"A
+   Message","~bt":[".\/tests.rb:345:in 'test_exception'"]}`.
+
+ * If a Hash entry has a key that is not a String or Symbol then the entry is
+   encoded with a key of the form `"^#n"` where n is a hex number. The value
+   is an Array where the first element is the key in the Hash and the second
+   is the value. An example is `{"^#3":[2,5]}`.
+
+ * A `"^i"` JSON entry in either an Object or Array is the ID of the Ruby
+   Object being encoded. It is used when the :circular flag is set. It can
+   appear in either a JSON Object or in a JSON Array. In an Object the
+   `"^i"` key has a corresponding reference Fixnum. In an array the sequence
+   will include an embedded reference number. An example is
+   `{"^o":"Oj::Bag","^i":1,"x":["^i2",true],"me":"^r1"}`.
+
+ * A `"^r"`JSON entry in an Object is a references to a Object or Array that
+   already appears in the JSON String. It must match up with a previous
+   `"^i"` ID. An example is `{"^o":"Oj::Bag","^i":1,"x":3,"me":"^r1"}`.
+
+ * If an Array element is a String and starts with `"^i"` then the first
+   character, the `'^'` is encoded as a hex character sequence. An example is
+   `["\u005ei37",3]`.

data/oj-3.17.3/pages/InstallOptions.md

@@ -0,0 +1,20 @@
+# Oj Install Options
+
+### Enable trace log
+
+```
+$ gem install oj -- --enable-trace-log
+```
+
+To enable Oj trace feature, it uses `--enable-trace-log` option when installing the gem.
+Then, the trace logs will be displayed when `:trace` option is set to `true`.
+
+
+### Enable SIMD instructions
+
+```
+$ gem install oj -- --with-sse42
+```
+
+To enable the use of SIMD instructions in Oj, it uses the `--with-sse42` option when installing the gem.
+This will enable the use of the SSE4.2 instructions in the internal.

data/oj-3.17.3/pages/JsonGem.md

@@ -0,0 +1,94 @@
+# JSON Quickstart
+
+To have Oj universally "take over" many methods on the JSON constant (`load`, `parse`, etc.) with
+their faster Oj counterparts, in a mode that is compatible with the json gem:
+
+```ruby
+Oj.mimic_JSON()
+```
+
+If the project does not already use the json gem, `JSON` will become available.
+If the project does require the json gem, `Oj.mimic_JSON()` should be invoked after the
+json gem has been required.
+
+For more details and options, read on...
+
+# Oj JSON Gem Compatibility
+
+The `:compat` mode mimics the json gem. The json gem is built around the use
+of the `to_json(*)` method defined for a class. Oj attempts to provide the
+same functionality by being a drop in replacement for the 2.0.x version of the
+json gem with a few exceptions. First a description of the json gem behavior
+and then the differences between the json gem and the Oj.mimic_JSON behavior.
+
+```ruby
+require 'oj'
+
+Oj.mimic_JSON()
+Oj.add_to_json(Array, BigDecimal, Complex, Date, DateTime, Exception, Hash, Integer, OpenStruct, Range, Rational, Regexp, Struct, Time)
+# Alternativel just call without arguments to add all available.
+# Oj.add_to_json()
+```
+
+The json gem monkey patches core and base library classes with a `to_json(*)`
+method. This allows calls such as `obj.to_json()` to be used to generate a
+JSON string. The json gem also provides the JSON.generate(), JSON.dump(), and
+JSON() functions. These functions generally act the same with some exceptions
+such as JSON.generate(), JSON(), and to_json raise an exception when
+attempting to encode infinity while JSON.dump() returns a the string
+"Infinity". The String class is also monkey patched with to_json_raw() and
+to_json_raw_object(). Oj in mimic mode mimics this behavior including the
+seemly inconsistent behavior with NaN and Infinity.
+
+Any class can define a to_json() method and JSON.generate(), JSON.dump(), and
+JSON() functions will call that method when an object of that type is
+encountered when traversing a Hash or Array. The core classes monkey patches
+can be over-ridden but unless the to_json() method is called directory the
+to_json() method will be ignored. Oj in mimic mode follow the same logic,
+
+The json gem includes additions. These additions change the behavior of some
+library and core classes. These additions also add the as_json() method and
+json_create() class method. They are activated by requiring the appropriate
+files. As an example, to get the modified to_json() for the Rational class
+this line would be added.
+
+```ruby
+require 'json/add/rational'
+```
+
+Oj in mimic mode does not include these files although it will support the
+modified to_json() methods. In keeping with the goal of providing a faster
+encoder Oj offers an alternative. To activate faster addition version of the
+to_json() method call
+
+```ruby
+Oj.add_to_json(Rational)
+```
+
+To revert back to the unoptimized version, just remove the Oj flag on that
+class.
+
+```ruby
+Oj.remove_to_json(Rational)
+```
+
+The classes that can be added are:
+
+ * Array
+ * BigDecimal
+ * Complex
+ * Date
+ * DateTime
+ * Exception
+ * Hash
+ * Integer
+ * OpenStruct
+ * Range
+ * Rational
+ * Regexp
+ * Struct
+ * Time
+
+The compatibility target version is 2.0.3. The json gem unit tests were used
+to verify compatibility with a few changes to use Oj instead of the original
+gem.