json_schema_tools 0.2.5 → 0.2.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MGQwMzVlNmIwYjkxYjhkY2UxNGVjMTdhMGNmMDRhMjJkNmU3MmUwZQ==
+    MDAyZTViOWEwMjk1YzMwNDQwZGYzYjBlODhiZDI5NzQ5OGRkOGY4YQ==
   data.tar.gz: !binary |-
-    Yjc3N2MyM2NjMDYzOGU2YTRlM2ZlNTkyMmNmOTU4ZGI3MmYyOTU4ZQ==
+    MTAyYmE1MDAwYTFlZGU2MjcwZDkxZDczODQxZjU3YzM3MWIzMGM3Mg==
 SHA512:
   metadata.gz: !binary |-
-    Zjk2ZDQwNDNiYzM5NTRkYWY2NzcyYTMwNWQzZGI3YTc4ZjkzNTQxNTJhMjAw
-    MDA2YWQxN2QwNmU0NzZmZDJhMzI2ZDBlNzQ2ZDE4OWI1YTE4YjA2YjFlNzll
-    OTcxNWE3NjkwYWU4ZWRjY2ZkYzQwODIxMjcxOWEzOWQwMTUyNGI=
+    NTRlNTI2OGVkYWExZTBkODRiNDVlZDNjMjdmMGFkNTM2MDQ3NTljYjNiM2Uw
+    ZDFhNjc2Yzk3OWY4NjIzODg1ZTMwOWU2ZTlkNzZiYWRlMDg2NjAyZmM0YjE2
+    NzZhOTYwNGRhZjI2NWI0MWFiNTkyNTA2ZjE1ODUzMTBjZDVhODI=
   data.tar.gz: !binary |-
-    Y2Y3NmZjZmY0Y2Q4NGVmNTRmYWMyMGQ4NzMyN2E4OTBmZDUyNmE3MTllM2Q3
-    MzUyYmIzMWQwNjI5ODk2ZjFjOWY3OWZkYjdiNmQyNWY1ZjRjMmEwNjI0Njc0
-    N2ViNWUyMGY0YWM5YzY3YzUzYmZhZmI3NDlmYTc3YThhYjEyZTg=
+    ZGUzOTcxZjJiMTE0MjEwOWJjMTgzNDRlZDNkNWQyYjYxODE0OWQwYWVlNTRm
+    MDIzOGIyOGNkZjQwOGYwM2QxNWQ2ZjkxYjE1Y2MzZGNhMzk3MDBmOWRlYmQ5
+    ODU0MzgzYmE5ZTEwYjRmNTI1YmY0NzlkZWZjY2FmYzNlZTg0ZTA=

data/lib/schema_tools/modules/read.rb

@@ -31,7 +31,7 @@ module SchemaTools
       # @param [String|Symbol] schema name to be read from schema path directory
       # @param [String|Hash] either the path to retrieve schema_name from,
       #                      or a Schema in Ruby hash form
-      # @return[HashWithIndifferentAccess] schema as hash
+      # @return[HashWithIndifferentAccess|Nil] schema as hash, nil if schema is not an object
       def read(schema_name, path_or_schema=nil)
         schema_name = schema_name.to_sym
         return registry[schema_name] if registry[schema_name]
@@ -55,6 +55,8 @@ module SchemaTools
         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|
@@ -67,18 +69,27 @@ module SchemaTools
         registry[ schema_name ] = schema
       end
 
-      # Read all available schemas from a given path(folder) and return
-      # them as array
+      # Read all available schemas from a given path(folder +subfolders) and
+      # return the found object definitions them as array. Also populates the
+      # registry
       #
       # @param [String] path to schema files
       # @return [Array<HashWithIndifferentAccess>] array of schemas as hash
       def read_all(path=nil)
         schemas = []
-        file_path = File.join(path || SchemaTools.schema_path, '*.json')
-        Dir.glob( file_path ).each do |file|
+        file_paths = if path
+                       [File.join(path, '*.json')]
+                     else
+                       [ File.join( SchemaTools.schema_path, '*.json'),
+                         File.join( SchemaTools.schema_path, '**/*', '*.json')
+                       ]
+                     end
+
+        Dir.glob( file_paths ).each do |file|
           schema_name = File.basename(file, '.json').to_sym
           schemas << read(schema_name, path)
         end
+        schemas.compact!
         schemas
       end
 

data/lib/schema_tools/version.rb

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

data/spec/fixtures/nested_schemas/person.json

@@ -0,0 +1,23 @@
+{ "type":"object",
+  "title": "Person",
+  "name": "person",
+  "description": "A simple person, nested in subfolder",
+  "properties":{
+    "id":{
+      "description":"Unique identifier ",
+      "identity":true,
+      "readonly":true,
+      "type":"number"
+    },
+    "last_name":{
+      "description": "Last name of a person. ",
+      "type":"string",
+      "maxLength": 50
+    },
+    "first_name":{
+      "description": "First name of a person.",
+      "type":"string",
+      "maxLength": 50
+    }
+  }
+}

data/spec/fixtures/one_of_definition.json

@@ -0,0 +1,15 @@
+{
+  "type":"object",
+  "title":"test_oneOf_object",
+  "name":"one_of_definition",
+  "description":"test_object parsing of nested oneOf object definition",
+  "properties": {
+    "person": {
+      "type" : "object",
+      "oneOf" : [
+       { "$ref" : "./client.json.json#properties"},
+       { "$ref" : "./contact.json.json#properties"}
+      ]
+    }
+  }
+}

data/spec/schema_tools/hash_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 # json schema is derived from it
 ################################################################################
 class Client
-  attr_accessor :first_name, :id, :addresses,  :work_address
+  attr_accessor :first_name, :id, :addresses, :work_address
 end
 class Address
   attr_accessor :city, :zip
@@ -13,6 +13,10 @@ end
 
 class Contact
   attr_accessor :first_name, :last_name, :addresses, :id
+  end
+
+class OneOfDefinition
+  attr_accessor :person
 end
 
 # see fixtures/lead.json
@@ -69,12 +73,12 @@ describe SchemaTools::Hash do
       hash['_class_name'].should == 'contact'
     end
 
-    it 'should have _links on object if exclude root' do
+    it 'has _links on object if exclude root' do
       hash = SchemaTools::Hash.from_schema(contact, exclude_root: true, class_name: :client)
       hash['_links'].length.should == 7
     end
 
-    it 'should have _class_name on object if exclude root' do
+    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
@@ -84,17 +88,17 @@ describe SchemaTools::Hash do
 
     let(:client){Client.new}
 
-    it 'should have an empty array if values are missing' do
+    it 'has an empty array if values are missing' do
       hash = SchemaTools::Hash.from_schema(client)
       hash['client']['addresses'].should == []
     end
 
-    it 'should have nil if nested object is missing' do
+    it 'has nil if nested object is missing' do
       hash = SchemaTools::Hash.from_schema(client)
       hash['client']['work_address'].should be_nil
     end
 
-    it 'should have nested array values' do
+    it 'has nested array values' do
       a1 = Address.new
       a1.city = 'Cologne'
       a1.zip = 50733
@@ -103,7 +107,7 @@ describe SchemaTools::Hash do
       hash['client']['addresses'].should == [{"address"=>{"city"=>"Cologne", "zip"=>50733}}]
     end
 
-    it 'should have nested array values without root' do
+    it 'has nested array values without root' do
       a1 = Address.new
       a1.city = 'Cologne'
       a1.zip = 50733
@@ -112,7 +116,7 @@ describe SchemaTools::Hash do
       hash['addresses'].should == [{"city"=>"Cologne", "zip"=>50733, "_class_name"=>"address"}]
     end
 
-    it 'should have nested object value' do
+    it 'has nested object value' do
       a1 = Address.new
       a1.city = 'Cologne'
       a1.zip = 50733
@@ -121,7 +125,7 @@ describe SchemaTools::Hash do
       hash['client']['work_address'].should == {"address"=>{"city"=>"Cologne", "zip"=>50733}}
     end
 
-    it 'should have nested object value without root' do
+    it 'has nested object value without root' do
       a1 = Address.new
       a1.city = 'Cologne'
       a1.zip = 50733
@@ -130,6 +134,18 @@ describe SchemaTools::Hash do
       hash['work_address'].should == {"city"=>"Cologne", "zip"=>50733, "_class_name"=>"address"}
     end
 
+    it 'has nested oneOf type object ' do
+      contact = Contact.new
+      contact.first_name = 'Pit'
+
+      i = OneOfDefinition.new
+      i.person = contact
+
+      hash = SchemaTools::Hash.from_schema(i, exclude_root: true)
+      hash['person']['first_name'].should == 'Pit'
+      hash['person']['_class_name'].should == 'contact'
+    end
+
   end
 
   context 'with plain nested values' do
@@ -168,7 +184,7 @@ describe SchemaTools::Hash do
       SchemaTools::Reader.registry_reset
     end
 
-    it 'should have links' do
+    it 'has links' do
       hash = SchemaTools::Hash.from_schema(client)
       hash['links'].length.should == 7
     end

data/spec/schema_tools/reader_spec.rb

@@ -2,20 +2,34 @@ require 'spec_helper'
 
 describe SchemaTools::Reader do
 
-  context 'class methods' do
+  context '.read_all' do
+    after :each do
+      SchemaTools::Reader.registry_reset
+    end
+
+    it 'reads all schemas' do
+      schemas = SchemaTools::Reader.read_all
+      schemas.length.should == SchemaTools::Reader.registry.length
+      person_schema = schemas.detect{|i| i['name'] = 'person'}
+      person_schema.should be
+    end
+
+  end
+
+  context '.read' do
 
     after :each do
       SchemaTools::Reader.registry_reset
     end
 
-    it 'should read a single schema' do
+    it 'reads a single schema' do
       schema = SchemaTools::Reader.read(:page)
       schema[:name].should == 'page'
       schema[:properties].should_not be_empty
       SchemaTools::Reader.registry.should_not be_empty
     end
 
-    it 'should read a schema with inheritance' do
+    it 'reads a schema with inheritance' do
       schema = SchemaTools::Reader.read(:lead) # extends contact
 
       SchemaTools::Reader.registry[:contact].should_not be_empty
@@ -25,7 +39,7 @@ describe SchemaTools::Reader do
       schema[:properties][:lead_source].should_not be_empty
     end
 
-    it 'should read a schema from a Ruby Hash' do
+    it 'reads a schema from a Ruby Hash' do
       schema = SchemaTools::Reader.read(:numbers, schema_as_ruby_object)
 
       SchemaTools::Reader.registry[:numbers].should_not be_empty
@@ -33,7 +47,7 @@ describe SchemaTools::Reader do
       schema[:properties][:numbers].should_not be_empty
     end
 
-    it 'should deal with referenced parameters properly' do
+    it 'deals with referenced parameters properly' do
       schema = SchemaTools::Reader.read(:includes_basic_definitions)
       schema[:properties].should_not be_empty
       schema[:properties].length.should eq 3
@@ -42,23 +56,28 @@ describe SchemaTools::Reader do
       schema[:properties][:id]["$ref"].should be_nil
     end
 
-    it 'should enforce correct parameter usage' do
+    it 'enforces correct parameter usage' do
       expect { SchemaTools::Reader.read(:contact, []) }.to raise_error ArgumentError
     end
+
+    it 'reads from sub folder' do
+      schema = SchemaTools::Reader.read(:person)
+      schema[:name].should == 'person'
+    end
   end
 
   context 'instance methods' do
 
     let(:reader){ SchemaTools::Reader.new }
 
-    it 'should read a single schema' do
+    it 'reads a single schema' do
       schema = reader.read(:client)
       schema[:name].should == 'client'
       schema[:properties].should_not be_empty
       reader.registry[:client].should_not be_empty
     end
 
-    it 'should read a single schema from Ruby Hash' do
+    it 'reads a single schema from Ruby Hash' do
       schema = reader.read(:numbers, schema_as_ruby_object)
       schema[:name].should == 'numbers'
       schema[:properties].should_not be_empty

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_schema_tools
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Georg Leciejewski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-10 00:00:00.000000000 Z
+date: 2014-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -101,6 +101,8 @@ files:
 - spec/fixtures/contact.json
 - spec/fixtures/includes_basic_definitions.json
 - spec/fixtures/lead.json
+- spec/fixtures/nested_schemas/person.json
+- spec/fixtures/one_of_definition.json
 - spec/fixtures/page.json
 - spec/schema_tools/cleaner_spec.rb
 - spec/schema_tools/hash_spec.rb