json_schema_tools 0.2.6 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDAyZTViOWEwMjk1YzMwNDQwZGYzYjBlODhiZDI5NzQ5OGRkOGY4YQ==
+    MmNjZDJjNDRjZTMyNjFjM2U0ZjFhMTRkMTJhZGNkNWVjYmVhZmU2MQ==
   data.tar.gz: !binary |-
-    MTAyYmE1MDAwYTFlZGU2MjcwZDkxZDczODQxZjU3YzM3MWIzMGM3Mg==
+    NzI1OWY0OTU1ZDJmMDVmOTMyMTgzZTQ5ZjE3YjRmNDFjMzJmYzBjYg==
 SHA512:
   metadata.gz: !binary |-
-    NTRlNTI2OGVkYWExZTBkODRiNDVlZDNjMjdmMGFkNTM2MDQ3NTljYjNiM2Uw
-    ZDFhNjc2Yzk3OWY4NjIzODg1ZTMwOWU2ZTlkNzZiYWRlMDg2NjAyZmM0YjE2
-    NzZhOTYwNGRhZjI2NWI0MWFiNTkyNTA2ZjE1ODUzMTBjZDVhODI=
+    OTFmODcwMmM2MDBmZmU0YWZlYjIyODMyNjlkM2EyZWY1NTliZWI1YjQwYTU0
+    NGNlYTI1MmE1Y2FlMWY5ZGIwOGQwNzI2OTc5OTNlYTliMDIxMTZkZGQ2ODlj
+    N2NiNjFlNWQ0ZGVmM2E3M2M1NTZiM2U1NzM2ZjNmMmE2MGQ1MjM=
   data.tar.gz: !binary |-
-    ZGUzOTcxZjJiMTE0MjEwOWJjMTgzNDRlZDNkNWQyYjYxODE0OWQwYWVlNTRm
-    MDIzOGIyOGNkZjQwOGYwM2QxNWQ2ZjkxYjE1Y2MzZGNhMzk3MDBmOWRlYmQ5
-    ODU0MzgzYmE5ZTEwYjRmNTI1YmY0NzlkZWZjY2FmYzNlZTg0ZTA=
+    MmMzNGU5NjkxYWQ1NzFkYzkzODcxNzI2NzY3ZTAwODE0OGY1YWUyOTY3ZTE1
+    ZGNjMGFhNGQ5YjU0YzNhZDJjYWIxNWUwN2M2NTNjMDZiMDI4ZmUwMTI0Njc1
+    ZDcyMzkzOTQ5Y2MzNzUwOTViODNkYjE5ZDIzNjY1NTJhNmFjMmI=

data/.gitignore

@@ -8,3 +8,9 @@ Gemfile.lock
 doc/
 tmp/
 *.swp
+.idea
+.ruby-gemset
+.ruby-version
+*.swp
+*.swo
+tags

data/CHANGELOG.md

@@ -1,6 +1,22 @@
 # Changelog JSON Schema Tools
 
 
+2014-09
+
+* add Schema class to represent a single schema, replaces simple Hash usage. Potentially breaks usage if you've gone crazy with Hash methods in your client.
+
+2014-09
+
+* refacture Reader to de-reference all pointers when initialized
+* remove :exclude_root option for object to schema_hash BREAKING change if you want nesting define your schema accordingly
+* add :links option for object to schema_hash, to include the links inline in an object
+* support items definition for array type properties - BREAKING you must change old simple property definitions
+* support oneOf definitions
+
+2014-08
+
+* add $ref resolver to merge property definitions from another file
+
 2013-10
 * allow all object properties in link href placeholders => contacts/{id}/{number}
 * add base_url option to schema hash creation. Prepends an url to all links of a rendered object

data/README.md

@@ -245,6 +245,20 @@ reader = SchemaTools::Reader.new
 SchemaTools::KlassFactory.build reader: reader, path: HappyPdf::Schema.path
 ```
 
+## $ref
+
+Provides some basic support for JSON Pointer. JSON Pointer expressions must reference local
+files and must contain a fragment identifier, i.e.
+
+     ./some_include.json#properties
+
+is a resolvable pointer, while
+
+     http://example.com/public_schema.json
+
+is not.
+
+
 ## Real world examples
 
 * [DocTag ruby gem](https://github.com/docTag/doctag_rb) and [DocTag json-schema](https://github.com/docTag/doctag_json_schema)

data/lib/schema_tools.rb

@@ -5,6 +5,7 @@ require 'schema_tools/modules/hash'
 require 'schema_tools/modules/as_schema'
 require 'schema_tools/modules/attributes'
 require 'schema_tools/modules/validations'
+require 'schema_tools/schema'
 require 'schema_tools/reader'
 require 'schema_tools/cleaner'
 require 'schema_tools/hash'
@@ -13,6 +14,7 @@ require 'schema_tools/ref_resolver'
 
 
 module SchemaTools
+  SCHEMA_BASE_TYPES = %w(string number integer boolean)
   class << self
 
     # @param [String] path to schema json files

data/lib/schema_tools/modules/attributes.rb

@@ -34,7 +34,8 @@ module SchemaTools
           reader          = opts[:reader] || SchemaTools::Reader
           schema_location = opts[:path]   || opts[:schema]
           # remember schema + name on class level
-          self.schema( reader.read(schema_name, schema_location) )
+
+          self.schema= reader.read(schema_name, schema_location)
           self.schema_name(schema_name)
           # make getter / setter
           self.schema[:properties].each do |key, prop|
@@ -45,8 +46,10 @@ module SchemaTools
         end
 
         # @param [Hash] schema_hash
-        def schema(schema_hash=nil)
-          @schema = schema_hash if schema_hash
+        def schema= schema_hash
+          @schema = schema_hash
+        end
+        def schema
           @schema
         end
 

data/lib/schema_tools/modules/hash.rb

@@ -34,8 +34,8 @@ module SchemaTools
       # properties are used.
       # @options opts [String] :path of the schema files overriding global one
       # @options opts [String] :base_url used in all links
-      # @options opts [Boolean] :exclude_root if set objects are not nested under
-      # their class name and the object hash gets _links and _class_name inline.
+      # @options opts [Boolean] :links if set the object hash gets its _links
+      # array inline.
       #
       # @return [Hash{String=>{String=>Mixed}}] The object as hash:
       #   { 'invoice' => {'title'=>'hello world', 'number'=>'4711' } }
@@ -47,31 +47,30 @@ module SchemaTools
         class_name = opts[:class_name] || real_class_name
 
         # get schema
-        schema = SchemaTools::Reader.read(class_name, opts[:path])
+        inline_schema = opts.delete(:schema) if opts[:schema].present?
+        schema =  inline_schema || SchemaTools::Reader.read(class_name, opts[:path])
+
         # iterate over the defined schema fields
         data = parse_properties(obj, schema, opts)
-        #get links if present
-        links = parse_links(obj, schema, opts)
-
-        if opts[:exclude_root]
-          hsh = data
-          hsh['_class_name'] = "#{class_name}"
-          links && hsh['_links'] = links
-        else
-          hsh = { "#{class_name}" => data }
-          links && hsh['links'] = links
+        if opts[:links]
+          links = parse_links(obj, schema, opts)
+          links && data['_links'] = links
         end
-        hsh
+        data
       end
 
       private
 
+      # @param [Object] obj from which to grab the properties
+      # @param [Hash] schema
+      # @param [Hash] opts
       def parse_properties(obj, schema, opts)
         fields = opts[:fields]
         data = {}
         schema['properties'].each do |field, prop|
           next if fields && !fields.include?(field)
           if prop['type'] == 'array'
+            # ensure the nested object gets its own class name
             opts.delete(:class_name)
             data[field] = parse_list(obj, field, prop, opts)
           elsif prop['type'] == 'object' # a singular related object
@@ -121,16 +120,29 @@ module SchemaTools
       # @return [Array<Hash{String=>String}>]
       def parse_list(obj, field, prop, opts)
         res = []
-        if obj.respond_to?( field ) && rel_objects = obj.send( field )
-          rel_objects.each do |rel_obj|
-            res << if prop['properties'] && prop['properties']['$ref']
-                      #got schema describing the objects
-                      from_schema(rel_obj, opts)
-                    else
-                      rel_obj
-                    end
+        # TODO should we raise errors if one of those is missing?
+        return nil if !obj.respond_to?( field )
+        return nil if !prop['items']
+
+        rel_objects = obj.send( field )
+        # force an empty array if values are not present
+        return res if !rel_objects
+
+        if prop['items'].is_a?(Hash) || prop['items'].is_a?(ActiveSupport::HashWithIndifferentAccess)
+          # array of plain values e.g number, strings e.g
+          # "items": { "type": "string" },
+          # should we convert the values? according to the type?
+          if SCHEMA_BASE_TYPES.include?(prop['items']['type'])
+            res = rel_objects
+          elsif prop['items']['type'] == 'object'
+            rel_objects.each { |rel_obj| res << from_schema(rel_obj, opts) }
           end
         end
+
+        if prop['items'].is_a?(Array)
+          #TODO recurse
+          # res << rel_objects.each { |rel_obj| parse_list(rel_obj, field, prop opts) }
+        end
         res
       end
 
@@ -141,24 +153,19 @@ module SchemaTools
       # @param [Hash] opts to_schema options
       # @return [Array<Hash{String=>String}>]
       def parse_object(obj, field, prop, opts)
-        res = nil
-        if obj.respond_to?( field ) && rel_obj = obj.send( field )
-          if prop['properties'] && prop['properties']['$ref']
-            res = from_schema(rel_obj, opts)
-          elsif prop['oneOf']
-            # auto-detects which schema to use depending on the rel_object type
-            # Simpler than detecting the object type or $ref to use inside the
-            # oneOf array
-            res = from_schema(rel_obj, opts)
-          else
-            # NO recursion directly get values from related object. Does
-            # NOT allow deeper nesting so you MUST define an own schema to be save
-            res = { }
-            prop['properties'].each do |fld, prp|
-              res[fld] = rel_obj.send(fld) if rel_obj.respond_to?(fld)
-            end
-          end
-        end
+        return if !obj.respond_to?( field )
+        rel_obj = obj.send( field )
+        return if !rel_obj
+
+        res = if prop['properties']
+                opts[:schema] = prop
+                from_schema(rel_obj, opts)
+              elsif prop['oneOf']
+                # auto-detects which schema to use depending on the rel_object type
+                # Simpler than detecting the object type or $ref to use inside the
+                # oneOf array
+                from_schema(rel_obj, opts)
+              end
         res
       end
 

data/lib/schema_tools/modules/read.rb

@@ -35,10 +35,9 @@ module SchemaTools
       def read(schema_name, path_or_schema=nil)
         schema_name = schema_name.to_sym
         return registry[schema_name] if registry[schema_name]
-
+        
         if path_or_schema.is_a?(::Hash)
-          path       = nil
-          plain_data = path_or_schema.to_json
+          schema = Schema.new(path_or_schema) 
         elsif path_or_schema.is_a?(::String) || path_or_schema.nil?
           path       = path_or_schema
           file_path  = File.join(path || SchemaTools.schema_path, "#{schema_name}.json")
@@ -48,25 +47,16 @@ module SchemaTools
             # use only if we found something, else keep path which will throw error on file.open later
             file_path = recursive_search || file_path
           end
+          schema = Schema.new(file_path)
         else
           raise ArgumentError, 'Second parameter must be a path or a schema!'
         end
 
-        plain_data ||= File.open(file_path, 'r'){|f| f.read}
 
-        schema = ActiveSupport::JSON.decode(plain_data).with_indifferent_access
         # only import object definitions, shared property definitions are handled separate
         return unless schema[:type] == 'object'
-        if schema[:extends]
-          extends = schema[:extends].is_a?(Array) ? schema[:extends] : [ schema[:extends] ]
-          extends.each do |ext_name|
-            ext = read(ext_name, path)
-            # current schema props win
-            schema[:properties] = ext[:properties].merge(schema[:properties])
-          end
-        end
-        _handle_reference_properties schema
         registry[ schema_name ] = schema
+        return schema
       end
 
       # Read all available schemas from a given path(folder +subfolders) and
@@ -93,24 +83,6 @@ module SchemaTools
         schemas
       end
 
-      # Merge referenced property definitions into the given schema.
-      # e.g. each object has an updated_at field which we define in a single
-      # location(external file) instead of repeating the property def in each
-      # schema.
-      # @param [HashWithIndifferentAccess] schema - single schema
-      def _handle_reference_properties(schema)
-        return unless schema["properties"]
-        schema["properties"].each { |key, value|
-          next unless value["$ref"]
-
-          json_pointer = value["$ref"]
-          values_from_pointer = RefResolver.load_json_pointer json_pointer
-          schema["properties"][key].merge!(values_from_pointer) {|key, old, new|
-            old
-          }
-          schema["properties"][key].delete("$ref")
-        }
-      end
     end
   end
 end

data/lib/schema_tools/ref_resolver.rb

@@ -16,7 +16,7 @@ module SchemaTools
   # @param [Hash] schema if the pointer refers to a local schema, this is this
   # the hash to evaluate it against. If the pointer contains a uri to a
   # referenced schema, an attempt is made to load
-  def self.load_json_pointer json_pointer, schema = {}
+  def self.load_json_pointer json_pointer, relative_to = nil
     # JSON Pointer is a big, abandoned WIP and we're going to
     # start by only implementing the part's we need ...
     if nil ==  (json_pointer =~ /^(.*)#(.*)/ )
@@ -25,14 +25,17 @@ module SchemaTools
 
     uri     = $1.strip
     pointer = $2
-
+    schema  = {}
     if ! uri.empty?
       uri = URI.parse(uri)
       raise "must currently be a relative uri: #{json_pointer}" if uri.absolute?
-      path = SchemaTools.schema_path + "/" + uri.path
-      open (path) {|f|
-        schema = JSON.parse(f.read)
-      }
+      # TODO use locale tools instance or base path from global SchemaTools.schema_path
+      if relative_to
+        path = relative_to.absolute_dir + "/" + uri.path
+      else
+        path = SchemaTools.schema_path + "/" + uri.path
+      end
+      open (path) {|f| schema = JSON.parse(f.read) }
     end
 
     return self._retrieve_pointer_from_object pointer, schema

data/lib/schema_tools/schema.rb

@@ -0,0 +1,139 @@
+
+
+module SchemaTools
+  # Internal representation of a Schema. This is basically a wrapper around a
+  # HashWithIndifferentAccess ( for historical purposes ) as well as information
+  # concerning where the Schema was loaded from in order to resolve relative paths.
+
+  class Schema
+    #@param [String|Hash] name_or_hash Schema may be initialized with either a filename or a hash
+    def initialize(name_or_hash)
+      case name_or_hash
+        when (::Hash)
+          @hash = name_or_hash.with_indifferent_access
+        when (::String)
+          src = File.open(name_or_hash, 'r') { |f| f.read }
+          self.absolute_filename= name_or_hash
+          decode src
+      end
+      handle_extends
+      resolve_refs
+    end
+
+    ##################################################################################
+    # Wrappers for internal Hash
+    ##################################################################################
+
+    # @param [String|Symbol] key
+    def [](key)
+      @hash[key]
+    end
+
+    # @param [String|Symbol] key
+    # @param [Mixed] value e.g String|Array|Hash
+    def []=(key, value)
+      @hash[key] = value
+    end
+
+    def empty?
+      @hash.empty?
+    end
+
+    def keys
+      @hash.keys
+    end
+
+    def ==(other)
+      case other
+        when (::Hash)
+          return other.with_indifferent_access == hash
+        when (ActiveSupport::HashWithIndifferentAccess)
+          return other == hash
+        when (Schema)
+          return other.hash == hash
+        else
+          return false
+      end
+    end
+
+    ##################################################################################
+    # /Wrappers for internal Hash
+    ##################################################################################
+
+
+    # set the filename the Schema was loaded from
+    # @param [String] fn
+    def absolute_filename=(fn)
+      @absolute_filename = File.absolute_path(fn)
+      @absolute_dir = File.dirname (@absolute_filename)
+    end
+
+    # retrieve the filename the Schema was loaded from or nil if the Schema
+    # was constructed from a Hash
+    def absolute_filename
+      @absolute_filename || nil
+    end
+
+    # retrieve the base directory against which refs should be resolved.
+    def absolute_dir
+      @absolute_dir || SchemaTools.schema_path
+    end
+
+
+
+    protected
+
+    def hash
+      @hash
+    end
+
+    private
+
+    # @param [String] src schema json string
+    def decode(src)
+      @hash = ActiveSupport::JSON.decode(src).with_indifferent_access
+    end
+
+    def handle_extends
+      if self[:extends]
+        extends = self[:extends].is_a?(Array) ? self[:extends] : [ self[:extends] ]
+        extends.each do |ext_name|
+          ext = Reader.read(ext_name, absolute_dir)
+          # current schema props win
+          self[:properties] = ext[:properties].merge(self[:properties] || {})
+        end
+      end
+    end
+
+    # Merge referenced property definitions into the given schema.
+    # e.g. each object has an updated_at field which we define in a single
+    # location(external file) instead of repeating the property def in each
+    # schema.
+    # any hash found along the way is processed recursively, we look for a
+    # "$ref" param and resolve it. Other params are checked for nested hashes
+    # and those are processed.
+    # @param [HashWithIndifferentAccess] schema - single schema
+    def resolve_refs schema = nil
+      schema ||= @hash
+
+       def resolve_reference hash
+          json_pointer = hash["$ref"]
+          values_from_pointer = RefResolver.load_json_pointer json_pointer, self
+          hash.merge!(values_from_pointer) { |key, old, new| old }
+          hash.delete("$ref")
+        end
+
+      keys = schema.keys # in case you are wondering: RuntimeError: can't add a new key into hash during iteration
+      keys.each do |k|
+        v = schema[k]
+        if k == "$ref"
+          resolve_reference schema
+        elsif v.is_a?(ActiveSupport::HashWithIndifferentAccess)
+          resolve_refs v
+        end
+      end
+
+    end
+  end
+end
+

data/lib/schema_tools/version.rb

@@ -1,3 +1,3 @@
 module SchemaTools
-  VERSION = '0.2.6'
+  VERSION = '0.3.0'
 end

data/spec/fixtures/basic_definitions.json

@@ -8,6 +8,13 @@
         "some_other_property": {
             "description": "whatever",
             "type": "string"
+        },
+        "nested_object" : {
+          "type": "object",
+          "properties" : {
+            "prop1" : { "type" : "string"},
+            "prop2" : { "type" : "string"}
+          }
         }
     }
 }

data/spec/fixtures/client.json

@@ -63,7 +63,12 @@
     "addresses":{
       "description": "A client can have many addresses, sorted by date descending(new first). Default address is the most recent one.",
       "type":"array",
-      "properties" : {"$ref":"./address.json#properties"}
+      "items" : {
+        "type" : "object",
+        "properties":{
+          "$ref":"./address.json#properties"
+        }
+      }
     },
     "work_address":{
       "description": "The work address as an example for a single nested/related object",

data/spec/fixtures/contact.json

@@ -9,6 +9,10 @@
       "readonly":true,
       "type":"number"
     },
+    "contact_source":{
+      "description": "Where did the contact came from.",
+      "type":"string"
+    },
     "organisation":{
       "description": "Name of a company. ",
       "required" : true,

data/spec/fixtures/includes_deep_nested_refs.json

@@ -0,0 +1,21 @@
+{
+  "type" : "object",
+  "description" : "deeply nested",
+  "properties" : {
+    "contains_nesting" : {
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties" : {
+          "own_property" : { "type" : "string" },
+          "nested_ref"   : {
+            "type" : "object",
+            "properties" : {
+              "$ref" : "./basic_definitions.json#definitions/nested_object/properties"
+            }
+          }
+        }
+      }
+    }
+  }
+}

data/spec/fixtures/lead.json

@@ -12,7 +12,7 @@
     "links_clicked":{
       "description": "Timestamps of clicks. Test nested array values without object reference",
       "type":"array",
-      "properties":{
+      "items":{
         "type": "string"
       }
     },

data/spec/fixtures/page.json

@@ -2,7 +2,7 @@
   "type": "object",
   "title": "Page",
   "name": "page",
-  "description": "A page of a PDF which can either belong to a PDF template or archived PDF.",
+  "description": "A page of a PDF which can either belong to a PDF template or archived PDF. Example taken from happyPDF",
   "properties": {
     "id": {
       "description": "The object identifier.",
@@ -57,11 +57,15 @@
       "type": "integer"
     },
     "blocks": {
-      "description": "Placeholder blocks on this page,, if it belongs to a PDF Template",
+      "description": "Placeholder blocks on this page, if it belongs to a PDF Template",
       "type": "array",
-      "properties": {"$ref":"./block.json#properties"}
+      "items" : {
+        "type" : "object",
+        "properties":{
+          "$ref": "./basic_definitions.json#definitions/nested_object/properties"
+        }
+      }
     }
-
   },
   "links": [
     {

data/spec/fixtures/relative_paths/includes_relative_path.json

@@ -0,0 +1,6 @@
+{
+  "type" : "object",
+  "properties" : {
+    "$ref" : "../basic_definitions.json#definitions/nested_object/properties"
+  }
+}

data/spec/schema_tools/hash_spec.rb

@@ -45,43 +45,33 @@ describe SchemaTools::Hash do
 
     it 'should return hash' do
       hash = SchemaTools::Hash.from_schema(contact)
-      hash['contact']['last_name'].should == 'Paul'
+      hash['last_name'].should == 'Paul'
     end
 
     it 'should use custom schema path' do
       custom_path = File.expand_path('../../fixtures', __FILE__)
       hash = SchemaTools::Hash.from_schema(contact, path: custom_path)
-      hash['contact']['last_name'].should == 'Paul'
+      hash['last_name'].should == 'Paul'
     end
 
     it 'should use custom schema' do
       hash = SchemaTools::Hash.from_schema(contact, class_name: :client)
-      hash['client']['last_name'].should == 'Paul'
+      hash['last_name'].should == 'Paul'
     end
 
     it 'should use only give fields' do
       hash = SchemaTools::Hash.from_schema(contact, fields: ['id', 'last_name'])
-      hash['contact'].keys.length.should == 2
-      hash['contact']['last_name'].should == contact.last_name
-      hash['contact']['id'].should == contact.id
-      hash['contact']['first_name'].should be_nil
-    end
-
-    it 'should exclude root' do
-      hash = SchemaTools::Hash.from_schema(contact, exclude_root: true)
-      hash['last_name'].should == 'Paul'
-      hash['_class_name'].should == 'contact'
+      hash.keys.length.should == 2
+      hash['last_name'].should == contact.last_name
+      hash['id'].should == contact.id
+      hash['first_name'].should be_nil
     end
 
     it 'has _links on object if exclude root' do
-      hash = SchemaTools::Hash.from_schema(contact, exclude_root: true, class_name: :client)
+      hash = SchemaTools::Hash.from_schema(contact, links: true, class_name: :client)
       hash['_links'].length.should == 7
     end
 
-    it 'has _class_name on object if exclude root' do
-      hash = SchemaTools::Hash.from_schema(contact, exclude_root: true, class_name: :client)
-      hash['_class_name'].should == 'client'
-    end
   end
 
   context 'with nested values referencing a schema' do
@@ -90,12 +80,12 @@ describe SchemaTools::Hash do
 
     it 'has an empty array if values are missing' do
       hash = SchemaTools::Hash.from_schema(client)
-      hash['client']['addresses'].should == []
+      hash['addresses'].should == []
     end
 
     it 'has nil if nested object is missing' do
       hash = SchemaTools::Hash.from_schema(client)
-      hash['client']['work_address'].should be_nil
+      hash['work_address'].should be_nil
     end
 
     it 'has nested array values' do
@@ -104,7 +94,7 @@ describe SchemaTools::Hash do
       a1.zip = 50733
       client.addresses = [a1]
       hash = SchemaTools::Hash.from_schema(client)
-      hash['client']['addresses'].should == [{"address"=>{"city"=>"Cologne", "zip"=>50733}}]
+      hash['addresses'].should == [{"city"=>"Cologne", "zip"=>50733}]
     end
 
     it 'has nested array values without root' do
@@ -113,7 +103,7 @@ describe SchemaTools::Hash do
       a1.zip = 50733
       client.addresses = [a1]
       hash = SchemaTools::Hash.from_schema(client, exclude_root: true)
-      hash['addresses'].should == [{"city"=>"Cologne", "zip"=>50733, "_class_name"=>"address"}]
+      hash['addresses'].should == [{"city"=>"Cologne", "zip"=>50733}]
     end
 
     it 'has nested object value' do
@@ -122,16 +112,7 @@ describe SchemaTools::Hash do
       a1.zip = 50733
       client.work_address = a1
       hash = SchemaTools::Hash.from_schema(client)
-      hash['client']['work_address'].should == {"address"=>{"city"=>"Cologne", "zip"=>50733}}
-    end
-
-    it 'has nested object value without root' do
-      a1 = Address.new
-      a1.city = 'Cologne'
-      a1.zip = 50733
-      client.work_address = a1
-      hash = SchemaTools::Hash.from_schema(client, exclude_root: true)
-      hash['work_address'].should == {"city"=>"Cologne", "zip"=>50733, "_class_name"=>"address"}
+      hash['work_address'].should == {"city"=>"Cologne", "zip"=>50733}
     end
 
     it 'has nested oneOf type object ' do
@@ -143,7 +124,6 @@ describe SchemaTools::Hash do
 
       hash = SchemaTools::Hash.from_schema(i, exclude_root: true)
       hash['person']['first_name'].should == 'Pit'
-      hash['person']['_class_name'].should == 'contact'
     end
 
   end
@@ -164,12 +144,12 @@ describe SchemaTools::Hash do
     end
 
     it 'should create array with values' do
-      @hash['lead']['links_clicked'].should == lead.links_clicked
+      @hash['links_clicked'].should == lead.links_clicked
     end
 
     it 'should create object with values' do
-      @hash['lead']['conversion']['from'].should == lead.conversion.from
-      @hash['lead']['conversion']['to'].should == lead.conversion.to
+      @hash['conversion']['from'].should == lead.conversion.from
+      @hash['conversion']['to'].should == lead.conversion.to
     end
 
   end
@@ -185,19 +165,19 @@ describe SchemaTools::Hash do
     end
 
     it 'has links' do
-      hash = SchemaTools::Hash.from_schema(client)
-      hash['links'].length.should == 7
+      hash = SchemaTools::Hash.from_schema(client, links: true)
+      hash['_links'].length.should == 7
     end
 
     it 'should prepend base_url' do
-      hash = SchemaTools::Hash.from_schema(client, base_url: 'http://json-hell.com')
-      hash['links'].first['href'].should include( 'http://json-hell.com')
+      hash = SchemaTools::Hash.from_schema(client, base_url: 'http://json-hell.com', links: true)
+      hash['_links'].first['href'].should include( 'http://json-hell.com')
     end
 
     it 'should replace placeholders' do
       client.id = 123
-      hash = SchemaTools::Hash.from_schema(client, base_url: 'http://json-hell.com')
-      hash['links'].last['href'].should == 'http://json-hell.com/clients/123/Peter'
+      hash = SchemaTools::Hash.from_schema(client, base_url: 'http://json-hell.com', links: true)
+      hash['_links'].last['href'].should == 'http://json-hell.com/clients/123/Peter'
     end
 
   end

data/spec/schema_tools/modules/as_schema_spec.rb

@@ -3,9 +3,11 @@ require 'spec_helper'
 class ClassWithSchemaAttrs
   include SchemaTools::Modules::Attributes
   has_schema_attrs :client
+  # test override of schema name
+  attr_accessor :contact_source
 end
 
-class ClassWithSchemaName
+class ClassWithSchemaNameLead
   include SchemaTools::Modules::AsSchema
   schema_name :lead
 end
@@ -14,6 +16,7 @@ end
 module Test
   class Address
     include SchemaTools::Modules::AsSchema
+    attr_accessor :id, :city
   end
 end
 
@@ -34,14 +37,14 @@ describe SchemaTools::Modules::AsSchema do
     it 'should return hash' do
       subject.last_name = 'Hogan'
       hsh = subject.as_schema_hash
-      hsh['client']['last_name'].should == 'Hogan'
+      hsh['last_name'].should == 'Hogan'
     end
 
     it 'should return json' do
       subject.last_name = 'Hogan'
       json_str = subject.as_schema_json
       hsh = ActiveSupport::JSON.decode(json_str)
-      hsh['client']['last_name'].should == 'Hogan'
+      hsh['last_name'].should == 'Hogan'
     end
 
   end
@@ -49,15 +52,15 @@ describe SchemaTools::Modules::AsSchema do
   describe 'schema name detection' do
 
     it 'should use name from has_schema_attrs' do
-      ClassWithSchemaAttrs.new.as_schema_hash.keys.should include('client', 'links')
+      ClassWithSchemaAttrs.new.as_schema_hash.keys.should include('phone_mobile', 'cash_discount')
     end
 
     it 'should use schema_name defined in class' do
-      ClassWithSchemaName.new.as_schema_hash.keys.should include('lead')
+      ClassWithSchemaNameLead.new.as_schema_hash.keys.should include('links_clicked')
     end
 
-    it 'should use class name ' do
-      Test::Address.new.as_schema_hash.keys.should include('address')
+    it 'should infer schema from class name' do
+      Test::Address.new.as_schema_hash.keys.should include('city')
     end
   end
 
@@ -65,19 +68,11 @@ describe SchemaTools::Modules::AsSchema do
     subject { ClassWithSchemaAttrs.new }
 
     it 'should override schema name from' do
-      subject.as_schema_hash(class_name:'contact').keys.should include('contact')
+      subject.as_schema_hash(class_name:'contact').keys.should include('contact_source')
     end
 
     it 'should use fields' do
-      subject.as_schema_hash(fields:['id'])['client'].keys.should == ['id']
-    end
-
-    it 'should exclude root' do
-      subject.as_schema_hash(exclude_root: true).keys.should include('id')
-    end
-
-    it 'should use class name ' do
-      Test::Address.new.as_schema_hash.keys.should include('address')
+      subject.as_schema_hash(fields:['id']).keys.should == ['id']
     end
   end
 

data/spec/schema_tools/reader_spec.rb

@@ -56,6 +56,11 @@ describe SchemaTools::Reader do
       schema[:properties][:id]["$ref"].should be_nil
     end
 
+    it 'deals with nested referenced parameters properly' do
+      schema = SchemaTools::Reader.read(:includes_deep_nested_refs)
+      schema[:properties].should_not be_empty
+    end
+
     it 'enforces correct parameter usage' do
       expect { SchemaTools::Reader.read(:contact, []) }.to raise_error ArgumentError
     end

data/spec/schema_tools/ref_resolver_spec.rb

@@ -66,6 +66,12 @@ describe SchemaTools::RefResolver do
   it 'should load local ref' do
     pointer = "./basic_definitions.json#definitions"
     obj = SchemaTools::RefResolver.load_json_pointer(pointer)
-    obj.length.should eq 2
+    obj.length.should eq 3
+  end
+
+  it 'should load the entire document' do
+    pointer = "./basic_definitions.json#"
+    obj = SchemaTools::RefResolver.load_json_pointer(pointer)
+    obj["definitions"].keys.length.should eq 3
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema_tools
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Georg Leciejewski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-11 00:00:00.000000000 Z
+date: 2014-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -94,16 +94,19 @@ files:
 - lib/schema_tools/modules/validations.rb
 - lib/schema_tools/reader.rb
 - lib/schema_tools/ref_resolver.rb
+- lib/schema_tools/schema.rb
 - lib/schema_tools/version.rb
 - spec/fixtures/address.json
 - spec/fixtures/basic_definitions.json
 - spec/fixtures/client.json
 - spec/fixtures/contact.json
 - spec/fixtures/includes_basic_definitions.json
+- spec/fixtures/includes_deep_nested_refs.json
 - spec/fixtures/lead.json
 - spec/fixtures/nested_schemas/person.json
 - spec/fixtures/one_of_definition.json
 - spec/fixtures/page.json
+- spec/fixtures/relative_paths/includes_relative_path.json
 - spec/schema_tools/cleaner_spec.rb
 - spec/schema_tools/hash_spec.rb
 - spec/schema_tools/klass_factory_spec.rb