jsi 0.0.1

data/lib/jsi/base/to_rb.rb

@@ -0,0 +1,127 @@
+module JSI
+  # base class for representing an instance of an instance described by a schema
+  class Base
+    class << self
+      def class_comment
+        lines = []
+
+        description = schema &&
+          schema['description'].respond_to?(:to_str) &&
+          schema['description'].to_str
+        if description
+          description.split("\n", -1).each do |descline|
+            lines << "# " + descline
+          end
+          lines << "#"
+        end
+
+        schema.described_hash_property_names.each_with_index do |propname, i|
+          lines << "#" unless i == 0
+          lines << "# @!attribute [rw] #{propname}"
+
+          property_schema = schema['properties'].respond_to?(:to_hash) &&
+            schema['properties'][propname].respond_to?(:to_hash) &&
+            schema['properties'][propname]
+
+          required = property_schema && property_schema['required']
+          required ||= schema['required'].respond_to?(:to_ary) && schema['required'].include?(propname)
+          lines << "#   @required" if required
+
+          type = property_schema &&
+            property_schema['type'].respond_to?(:to_str) &&
+            property_schema['type'].to_str
+          simple = {'string' => 'String', 'number' => 'Numeric', 'boolean' => 'Boolean', 'null' => 'nil'}
+          rettypes = []
+          if simple.key?(type)
+            rettypes << simple[type]
+          elsif type == 'object' || type == 'array'
+            rettypes = []
+            schema_class = JSI.class_for_schema(property_schema)
+            unless schema_class.name =~ /\AJSI::SchemaClasses::/
+              rettypes << schema_class.name
+            end
+            rettypes << {'object' => '#to_hash', 'array' => '#to_ary'}[type]
+          elsif type
+            # not really valid, but there's some information in there. whatever it is.
+            rettypes << type
+          end
+          # we'll add Object to all because the accessor methods have no enforcement that their value is
+          # of the specified type, and may return anything really. TODO: consider if this is of any value?
+          rettypes << 'Object'
+          lines << "#   @return [#{rettypes.join(', ')}]"
+
+          description = property_schema &&
+            property_schema['description'].respond_to?(:to_str) &&
+            property_schema['description'].to_str
+          if description
+            description.split("\n", -1).each do |descline|
+              lines << "#     " + descline
+            end
+          end
+        end
+        lines.join("\n")
+      end
+
+      def to_rb
+        lines = []
+        description = schema &&
+          schema['description'].respond_to?(:to_str) &&
+          schema['description'].to_str
+        if description
+          description.split("\n", -1).each do |descline|
+            lines << "# " + descline
+          end
+        end
+        lines << "class #{name}"
+        schema.described_hash_property_names.each_with_index do |propname, i|
+          lines << "" unless i == 0
+          property_schema = schema['properties'].respond_to?(:to_hash) &&
+            schema['properties'][propname].respond_to?(:to_hash) &&
+            schema['properties'][propname]
+          description = property_schema &&
+            property_schema['description'].respond_to?(:to_str) &&
+            property_schema['description'].to_str
+          if description
+            description.split("\n", -1).each do |descline|
+              lines << "  # " + descline
+            end
+            lines << "  #" # blank comment line between description and @return
+          end
+
+          required = property_schema && property_schema['required']
+          required ||= schema['required'].respond_to?(:to_ary) && schema['required'].include?(propname)
+          lines << "  # @required" if required
+
+          type = property_schema &&
+            property_schema['type'].respond_to?(:to_str) &&
+            property_schema['type'].to_str
+          simple = {'string' => 'String', 'number' => 'Numeric', 'boolean' => 'Boolean', 'null' => 'nil'}
+          rettypes = []
+          if simple.key?(type)
+            rettypes << simple[type]
+          elsif type == 'object' || type == 'array'
+            rettypes = []
+            schema_class = JSI.class_for_schema(property_schema)
+            unless schema_class.name =~ /\AJSI::SchemaClasses::/
+              rettypes << schema_class.name
+            end
+            rettypes << {'object' => '#to_hash', 'array' => '#to_ary'}[type]
+          elsif type
+            # not really valid, but there's some information in there. whatever it is.
+            rettypes << type
+          end
+          # we'll add Object to all because the accessor methods have no enforcement that their value is
+          # of the specified type, and may return anything really. TODO: consider if this is of any value?
+          rettypes << 'Object'
+          lines << "  # @return [#{rettypes.join(', ')}]"
+
+          lines << "  def #{propname}"
+          lines << "    super"
+          lines << "  end"
+        end
+        lines << "end"
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/jsi/json-schema-fragments.rb

@@ -0,0 +1,191 @@
+require "json-schema"
+
+# apply the changes from https://github.com/ruby-json-schema/json-schema/pull/382 
+
+# json-schema/pointer.rb
+require 'addressable/uri'
+
+module JSON
+  class Schema
+    # a JSON Pointer, as described by RFC 6901 https://tools.ietf.org/html/rfc6901
+    class Pointer
+      class Error < JSON::Schema::SchemaError
+      end
+      class PointerSyntaxError < Error
+      end
+      class ReferenceError < Error
+      end
+
+      # parse a fragment to an array of reference tokens
+      #
+      # #/foo/bar
+      #
+      # => ['foo', 'bar']
+      #
+      # #/foo%20bar
+      #
+      # => ['foo bar']
+      def self.parse_fragment(fragment)
+        fragment = Addressable::URI.unescape(fragment)
+        match = fragment.match(/\A#/)
+        if match
+          parse_pointer(match.post_match)
+        else
+          raise(PointerSyntaxError, "Invalid fragment syntax in #{fragment.inspect}: fragment must begin with #")
+        end
+      end
+
+      # parse a pointer to an array of reference tokens
+      #
+      # /foo
+      #
+      # => ['foo']
+      #
+      # /foo~0bar/baz~1qux
+      #
+      # => ['foo~bar', 'baz/qux']
+      def self.parse_pointer(pointer_string)
+        tokens = pointer_string.split('/', -1).map! do |piece|
+          piece.gsub('~1', '/').gsub('~0', '~')
+        end
+        if tokens[0] == ''
+          tokens[1..-1]
+        elsif tokens.empty?
+          tokens
+        else
+          raise(PointerSyntaxError, "Invalid pointer syntax in #{pointer_string.inspect}: pointer must begin with /")
+        end
+      end
+
+      # initializes a JSON::Schema::Pointer from the given representation.
+      #
+      # type may be one of:
+      #
+      # - :fragment - the representation is a fragment containing a pointer (starting with #)
+      # - :pointer - the representation is a pointer (starting with /)
+      # - :reference_tokens - the representation is an array of tokens referencing a path in a document
+      def initialize(type, representation)
+        @type = type
+        if type == :reference_tokens
+          reference_tokens = representation
+        elsif type == :fragment
+          reference_tokens = self.class.parse_fragment(representation)
+        elsif type == :pointer
+          reference_tokens = self.class.parse_pointer(representation)
+        else
+          raise ArgumentError, "invalid initialization type: #{type.inspect} with representation #{representation.inspect}"
+        end
+        @reference_tokens = reference_tokens.map(&:freeze).freeze
+      end
+
+      attr_reader :reference_tokens
+
+      # takes a root json document and evaluates this pointer through the document, returning the value
+      # pointed to by this pointer.
+      def evaluate(document)
+        reference_tokens.inject(document) do |value, token|
+          if value.is_a?(Array)
+            if token.is_a?(String) && token =~ /\A\d|[1-9]\d+\z/
+              token = token.to_i
+            end
+            unless token.is_a?(Integer)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not an integer and cannot be resolved in array #{value.inspect}")
+            end
+            unless (0...value.size).include?(token)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid index of #{value.inspect}")
+            end
+          elsif value.is_a?(Hash)
+            unless value.key?(token)
+              raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} is not a valid key of #{value.inspect}")
+            end
+          else
+            raise(ReferenceError, "Invalid resolution for #{to_s}: #{token.inspect} cannot be resolved in #{value.inspect}")
+          end
+          value[token]
+        end
+      end
+
+      # the pointer string representation of this Pointer
+      def pointer
+        reference_tokens.map { |t| '/' + t.to_s.gsub('~', '~0').gsub('/', '~1') }.join('')
+      end
+
+      # the fragment string representation of this Pointer
+      def fragment
+        '#' + Addressable::URI.escape(pointer)
+      end
+
+      def to_s
+        "#<#{self.class.inspect} #{@type} = #{representation_s}>"
+      end
+
+      private
+
+      def representation_s
+        if @type == :fragment
+          fragment
+        elsif @type == :pointer
+          pointer
+        else
+          reference_tokens.inspect
+        end
+      end
+    end
+  end
+end
+
+# json-schema/validator.rb
+
+module JSON
+  class Validator
+    def initialize(schema_data, data, opts={})
+      @options = @@default_opts.clone.merge(opts)
+      @errors = []
+
+      validator = self.class.validator_for_name(@options[:version])
+      @options[:version] = validator
+      @options[:schema_reader] ||= self.class.schema_reader
+
+      @validation_options = @options[:record_errors] ? {:record_errors => true} : {}
+      @validation_options[:insert_defaults] = true if @options[:insert_defaults]
+      @validation_options[:strict] = true if @options[:strict] == true
+      @validation_options[:clear_cache] = true if !@@cache_schemas || @options[:clear_cache]
+
+      @@mutex.synchronize { @base_schema = initialize_schema(schema_data) }
+      @original_data = data
+      @data = initialize_data(data)
+      @@mutex.synchronize { build_schemas(@base_schema) }
+
+      # If the :fragment option is set, try and validate against the fragment
+      if opts[:fragment]
+        @base_schema = schema_from_fragment(@base_schema, opts[:fragment])
+      end
+
+      # validate the schema, if requested
+      if @options[:validate_schema]
+        if @base_schema.schema["$schema"]
+          base_validator = self.class.validator_for_name(@base_schema.schema["$schema"])
+        end
+        metaschema = base_validator ? base_validator.metaschema : validator.metaschema
+        # Don't clear the cache during metaschema validation!
+        self.class.validate!(metaschema, @base_schema.schema, {:clear_cache => false})
+      end
+    end
+
+    def schema_from_fragment(base_schema, fragment)
+      schema_uri = base_schema.uri
+
+      pointer = JSON::Schema::Pointer.new(:fragment, fragment)
+
+      base_schema = JSON::Schema.new(pointer.evaluate(base_schema.schema), schema_uri, @options[:version])
+
+      if @options[:list]
+        base_schema.to_array_schema
+      elsif base_schema.is_a?(Hash)
+        JSON::Schema.new(base_schema, schema_uri, @options[:version])
+      else
+        base_schema
+      end
+    end
+  end
+end

data/lib/jsi/json.rb

@@ -0,0 +1,7 @@
+module JSI
+  module JSON
+    autoload :Node, 'jsi/json/node'
+    autoload :ArrayNode, 'jsi/json/node'
+    autoload :HashNode, 'jsi/json/node'
+  end
+end

data/lib/jsi/json/node.rb

@@ -0,0 +1,256 @@
+module JSI
+  module JSON
+    # JSI::JSON::Node is an abstraction of a node within a JSON document.
+    # it aims to act like the underlying data type of the node's content
+    # (Hash or Array, generally) in most cases, defining methods of Hash
+    # and Array which delegate to the content. However, destructive methods
+    # are not defined, as modifying the content of a node would change it
+    # for any other nodes in the document that contain or refer to it.
+    #
+    # methods that return a modified copy such as #merge are defined, and
+    # return a copy of the document with the content of the node modified.
+    # the original node's document and content are untouched.
+    class Node
+      # if the content of the document at the given path is a Hash, returns
+      # a HashNode; if an Array, returns ArrayNode. otherwise returns a
+      # regular Node, though, for the most part this will be called with Hash
+      # or Array content.
+      def self.new_by_type(document, path)
+        node = Node.new(document, path)
+        content = node.content
+        if content.is_a?(Hash)
+          HashNode.new(document, path)
+        elsif content.is_a?(Array)
+          ArrayNode.new(document, path)
+        else
+          node
+        end
+      end
+
+      # a Node represents the content of a document at a given path.
+      def initialize(document, path)
+        raise(ArgumentError, "path must be an array. got: #{path.pretty_inspect.chomp} (#{path.class})") unless path.is_a?(Array)
+        @document = document
+        @path = path.dup.freeze
+        @pointer = ::JSON::Schema::Pointer.new(:reference_tokens, path)
+      end
+
+      # the path of this Node within its document
+      attr_reader :path
+      # the document containing this Node at is path
+      attr_reader :document
+      # ::JSON::Schema::Pointer representing the path to this node within its document
+      attr_reader :pointer
+
+      # the raw content of this Node from the underlying document at this Node's path.
+      def content
+        pointer.evaluate(document)
+      end
+
+      def [](k)
+        node = self
+        content = node.content
+        if content.is_a?(Hash) && !content.key?(k)
+          node = node.deref
+          content = node.content
+        end
+        begin
+          el = content[k]
+        rescue TypeError => e
+          raise(e.class, e.message + "\nsubscripting with #{k.pretty_inspect.chomp} (#{k.class}) from #{content.class.inspect}. self is: #{pretty_inspect.chomp}", e.backtrace)
+        end
+        if el.is_a?(Hash) || el.is_a?(Array)
+          self.class.new_by_type(node.document, node.path + [k])
+        else
+          el
+        end
+      end
+
+      def []=(k, v)
+        if v.is_a?(Node)
+          content[k] = v.content
+        else
+          content[k] = v
+        end
+      end
+
+      def deref
+        content = self.content
+
+        return self unless content.is_a?(Hash) && content['$ref'].is_a?(String)
+
+        if content['$ref'][/\A#/]
+          return self.class.new_by_type(document, ::JSON::Schema::Pointer.parse_fragment(content['$ref'])).deref
+        end
+
+        # HAX for how google does refs and ids
+        if document_node['schemas'].respond_to?(:to_hash)
+          if document_node['schemas'][content['$ref']]
+            return document_node['schemas'][content['$ref']]
+          end
+          _, deref_by_id = document_node['schemas'].detect { |_k, schema| schema['id'] == content['$ref'] }
+          if deref_by_id
+            return deref_by_id
+          end
+        end
+
+        #raise(NotImplementedError, "cannot dereference #{content['$ref']}") # TODO
+        return self
+      end
+
+      # a Node at the root of the document
+      def document_node
+        Node.new_by_type(document, [])
+      end
+
+      # the parent of this node. if this node is the document root (its path is empty), raises
+      # ::JSON::Schema::Pointer::ReferenceError.
+      def parent_node
+        if path.empty?
+          raise(::JSON::Schema::Pointer::ReferenceError, "cannot access parent of root node: #{pretty_inspect.chomp}")
+        else
+          Node.new_by_type(document, path[0...-1])
+        end
+      end
+
+      # the pointer path to this node within the document, per RFC 6901 https://tools.ietf.org/html/rfc6901
+      def pointer_path
+        pointer.pointer
+      end
+      # the pointer fragment to this node within the document, per RFC 6901 https://tools.ietf.org/html/rfc6901
+      def fragment
+        pointer.fragment
+      end
+
+      def as_json(*opt)
+        Typelike.as_json(content, *opt)
+      end
+
+      # takes a block. the block is yielded the content of this node. the block MUST return a modified
+      # copy of that content (and NOT modify the object it is given).
+      def modified_copy
+        # we need to preserve the rest of the document, but modify the content at our path.
+        #
+        # this is actually a bit tricky. we can't modify the original document, obviously.
+        # we could do a deep copy, but that's expensive. instead, we make a copy of each array
+        # or hash in the path above this node. this node's content is modified by the caller, and
+        # that is recursively merged up to the document root. the recursion is done with a
+        # y combinator, for no other reason than that was a fun way to implement it.
+        modified_document = JSI.ycomb do |rec|
+          proc do |subdocument, subpath|
+            if subpath == []
+              yield(subdocument)
+            else
+              car = subpath[0]
+              cdr = subpath[1..-1]
+              if subdocument.respond_to?(:to_hash)
+                car_object = rec.call(subdocument[car], cdr)
+                if car_object.object_id == subdocument[car].object_id
+                  subdocument
+                else
+                  subdocument.merge({car => car_object})
+                end
+              elsif subdocument.respond_to?(:to_ary)
+                if car.is_a?(String) && car =~ /\A\d+\z/
+                  car = car.to_i
+                end
+                unless car.is_a?(Integer)
+                  raise(TypeError, "bad subscript #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for array: #{subdocument.pretty_inspect.chomp}")
+                end
+                car_object = rec.call(subdocument[car], cdr)
+                if car_object.object_id == subdocument[car].object_id
+                  subdocument
+                else
+                  subdocument.dup.tap do |arr|
+                    arr[car] = car_object
+                  end
+                end
+              else
+                raise(TypeError, "bad subscript: #{car.pretty_inspect.chomp} with remaining subpath: #{cdr.inspect} for content: #{subdocument.pretty_inspect.chomp}")
+              end
+            end
+          end
+        end.call(document, path)
+        Node.new_by_type(modified_document, path)
+      end
+
+      def object_group_text
+        "fragment=#{fragment.inspect}"
+      end
+      def inspect
+        "\#<#{self.class.inspect} #{object_group_text} #{content.inspect}>"
+      end
+      def pretty_print(q)
+        q.instance_exec(self) do |obj|
+          text "\#<#{obj.class.inspect} #{obj.object_group_text}"
+          group_sub {
+            nest(2) {
+              breakable ' '
+              pp obj.content
+            }
+          }
+          breakable ''
+          text '>'
+        end
+      end
+
+      def fingerprint
+        {is_node: self.is_a?(JSI::JSON::Node), document: document, path: path}
+      end
+      include FingerprintHash
+    end
+
+    class ArrayNode < Node
+      def each
+        return to_enum(__method__) { content.size } unless block_given?
+        content.each_index { |i| yield self[i] }
+        self
+      end
+
+      def to_ary
+        to_a
+      end
+
+      include Enumerable
+      include Arraylike
+
+      def as_json(*opt) # needs redefined after including Enumerable
+        Typelike.as_json(content, *opt)
+      end
+
+      # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_a).
+      # we override these methods from Arraylike
+      SAFE_INDEX_ONLY_METHODS.each do |method_name|
+        define_method(method_name) { |*a, &b| content.public_send(method_name, *a, &b) }
+      end
+    end
+
+    class HashNode < Node
+      def each(&block)
+        return to_enum(__method__) { content.size } unless block_given?
+        if block.arity > 1
+          content.each_key { |k| yield k, self[k] }
+        else
+          content.each_key { |k| yield [k, self[k]] }
+        end
+        self
+      end
+
+      def to_hash
+        inject({}) { |h, (k, v)| h[k] = v; h }
+      end
+
+      include Enumerable
+      include Hashlike
+
+      def as_json(*opt) # needs redefined after including Enumerable
+        Typelike.as_json(content, *opt)
+      end
+
+      # methods that don't look at the value; can skip the overhead of #[] (invoked by #to_hash)
+      SAFE_KEY_ONLY_METHODS.each do |method_name|
+        define_method(method_name) { |*a, &b| content.public_send(method_name, *a, &b) }
+      end
+    end
+  end
+end