json-schematized 0.2.0 → 0.2.1

data/.rspec

@@ -0,0 +1,2 @@
+--color
+#-fs

data/Gemfile

@@ -2,6 +2,8 @@ source :rubygems
 
 gemspec
 
+gem 'virtus', :git => 'https://github.com/solnic/virtus'
+
 # RUBY_VERSION ~> "1.9.0"
 # gem "debugger"
 

data/README.md

@@ -30,7 +30,7 @@ person:
             type: string
 ```
 
-### Basic Wrapper Usage:
+### Basic Wrapper Usage
 
 ```ruby
 require "json-schematized"
@@ -49,7 +49,18 @@ person.children.first.class     # => Person::Child
 person.children.first.name      # => "William"
 ```
 
-### Virtus Wrapper Usage:
+Another way to use Basic Wrapper is as follows:
+
+```ruby
+class Person < Hash
+  include JSON::Schematized
+  json_schema wrapper: :basic do  # block called for each new instance
+    YAML.load(File.read(File.expand_path("../person.yml", __FILE__)))["person"]
+  end
+end
+```
+
+### Virtus Wrapper Usage
 
 ```ruby
 require "json-schematized"
@@ -68,3 +79,14 @@ person.children.class           # => Person::ChildrenCollection
 person.children.first.class     # => Person::Child
 person.children.first.name      # => "William"
 ```
+
+### Object with Basic Wrapper usage
+
+```ruby
+person = Hash.new
+json_schema = YAML.load(File.read(File.expand_path("../person.yml", __FILE__)))["person"]
+person.extend JSON::Schematized::BasicWrapper.modularize(json_schema)
+
+person.children << {}
+# ...
+```

data/json-schematized.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name          = "json-schematized"
+  s.version       = "0.2.1"
+  s.platform      = Gem::Platform::RUBY
+  s.summary       = "Object builder based on JSON-Schema"
+  s.require_paths = ["lib"]
+  s.files         = `git ls-files -- Gemfile README.md lib/ script/ *.gemspec`.split("\n")
+  s.test_files    = `git ls-files -- .rspec Gemfile spec/`.split("\n")
+
+  s.description   = ""
+  s.authors       = ["Marcelo Manzan"]
+  s.email         = "manzan@gmail.com"
+  s.homepage      = "http://github.com/abril"
+
+  s.add_runtime_dependency "multi_json", "~> 1.0"
+  s.add_runtime_dependency "activesupport"
+  s.add_runtime_dependency "virtus"
+
+  s.add_development_dependency "json", "~> 1.4"
+  s.add_development_dependency "rspec", ">= 2.6"
+end

data/lib/json/schematized/basic_wrapper.rb

@@ -16,21 +16,23 @@ module JSON
 
       module ClassMethods
         def attribute_set
-          BasicWrapper.modularize(json_schema).attribute_set
+          json_schema_module.attribute_set
+        end
+
+        def json_schema_module
+          BasicWrapper.modularize(json_schema)
         end
       end
 
       def initialize(attrs = nil)
         self.json_schema = self.class.json_schema
-        mass_assign!(attrs)
+        self.attributes = attrs
       end
 
       def self.modularize(json_schema)
         super(json_schema) do
           include BasicWrapper::SchematizedHash
 
-          def json_schema=(*args); end
-
           def self.attribute_set
             unless defined?(@attribute_set)
               set = []
@@ -46,20 +48,17 @@ module JSON
             super
             return if base.class.include? BasicWrapper::Models
             class_name = :ComplexTypes
-            (const_defined?(class_name) ?
-              const_get(class_name) :
-              const_set(class_name, Module.new)
-            ).tap do |klass|
-              unless klass.include?(self)
-                klass.send(:include, self)
-                klass.module_eval do
-                  define_method :subclasses_namespace do
-                    klass
-                  end
-                end
+            if const_defined?(class_name)
+              klass = const_get(class_name)
+            else
+              klass = const_set(class_name, Module.new)
+              _mod = self
+              klass.module_eval do
+                define_method(:submodels_scope){ _mod }
               end
-              base.extend klass
             end
+            base.extend klass
+            BasicWrapper::SchematizedHash.ensure_structure!(base, base.json_schema)
           end
         end
       end
@@ -82,10 +81,6 @@ module JSON
       end
 
       module Models
-        def attributes
-          self
-        end
-
         def json_schema=(json_schema)
           extend BasicWrapper.modularize(json_schema)
         end
@@ -109,7 +104,7 @@ module JSON
           if members_module.json_schema[:type] == "object"
             new_value = members_type.new
             new_value.extend members_module
-            new_value.mass_assign!(value) if value.is_a?(Hash)
+            new_value.attributes = value if value.is_a?(Hash)
             super(new_value)
           else
             super
@@ -138,11 +133,17 @@ module JSON
           end
         end
 
+        def attributes
+          self
+        end
+
+        def json_schema=(*args); end
+
         def respond_to?(method_name)
           json_schema[:properties].has_key?(method_name.to_sym) || super
         end
 
-        def subclasses_namespace
+        def submodels_scope
           self.class
         end
 
@@ -150,23 +151,27 @@ module JSON
           if meta = json_schema[:properties][key.to_sym]
             case meta[:type]
             when "array"
-              collection = BasicWrapper.build_collection(subclasses_namespace, key, meta[:items])
+              collection = BasicWrapper.build_collection(submodels_scope, key, meta[:items])
               new_value = collection.class.new
               new_value.coerce_members_to(collection.first, meta[:items])
               new_value.mass_assign!(value) if value.is_a?(Array)
               value = new_value
             when "object"
-              model_class = BasicWrapper.build_model(subclasses_namespace, key, meta)
+              model_class = BasicWrapper.build_model(submodels_scope, key, meta)
               new_value = model_class.new
               new_value.json_schema = meta
-              new_value.mass_assign!(value) if value.is_a?(Hash)
+              new_value.attributes = value if value.is_a?(Hash)
               value = new_value
+            else
+              attribute = submodels_scope.attribute_set[key.to_sym]
+              attribute = attribute.writer if attribute.respond_to?(:writer)
+              value = attribute.coerce(value)
             end
           end
           super(key.to_s, value)
         end
 
-        def mass_assign!(hash)
+        def attributes=(hash)
           return unless hash.is_a?(Hash)
           hash.each_pair do |key, value|
             self[key] = value

data/lib/json/schematized/dsl.rb

@@ -11,15 +11,13 @@ module JSON
           schema = MultiJson.dump(schema) unless schema.is_a?(String)
           MultiJson.load(schema, :symbolize_keys => true)
         else
-          return if self === Base
           opts = args.last.is_a?(Hash) ? args.pop : {}
           json = args.first
           raise ArgumentError, "JSON or block expected" if block_given? ^ json.nil?
           block = Proc.new{ json } unless block_given?
           @json_schema_loader = block
           wrapper = "#{opts.fetch(:wrapper, :basic)}_wrapper".gsub(/(?:\A_*|_)([^_])/){ $1.upcase }.to_sym
-          wrapper =  Schematized.const_defined?(wrapper) ? Schematized.const_get(wrapper) : nil
-          send(:include, wrapper) if wrapper
+          include Schematized.const_get(wrapper) if Schematized.const_defined?(wrapper)
           self
         end
       end

data/lib/json/schematized/virtus_wrapper.rb

@@ -15,6 +15,13 @@ module JSON
 
       def self.included(base)
         base.send(:include, modularize(base.json_schema))
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def json_schema_module
+          VirtusWrapper.modularize(json_schema)
+        end
       end
 
       def self.modularize(json_schema)

data/lib/json/schematized/wrapper.rb

@@ -16,13 +16,11 @@ module JSON
           const_get(module_name)
         else
           const_set(module_name, Module.new).tap do |m|
-            m.instance_variable_set(:@json_schema, json_schema)
-            def m.json_schema; @json_schema; end
             m.send(:include, self::Models)
+            def m.json_schema; @json_schema end
             m.module_eval do
-              define_method :json_schema do
-                m.json_schema
-              end
+              @json_schema = json_schema.freeze
+              define_method(:json_schema){ m.json_schema }
             end
             m.module_eval(&block) if block_given?
           end
@@ -62,19 +60,25 @@ module JSON
 
       def meta_type(ref, field_name, meta, singularize = false)
         case meta[:type]
-        when "string"
-          String
         when "array"
           build_collection(ref, field_name, meta[:items])
         when "object"
           build_model(ref, field_name, meta, singularize)
+        when "boolean"
+          TrueClass
+        when "integer"
+          Integer
         else
-          parse_json_schema_type meta[:type]
+          parse_json_schema_type ref, field_name, meta[:type]
         end
       end
 
-      def parse_json_schema_type(type)
-        Object
+      def parse_json_schema_type(ref, field_name, type)
+        case type
+        when "string" then String
+        when "number" then Numeric
+        else Object
+        end
       end
 
       def build_class_name(field_name)

data/script/console

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+begin
+  require "rubygems"
+  require "bundler"
+rescue LoadError
+  raise "Could not load the bundler gem. Install it with `gem install bundler`."
+end
+
+begin
+  # Set up load paths for all bundled gems
+  ENV["BUNDLE_GEMFILE"] = File.expand_path("../../Gemfile", __FILE__)
+  Bundler.setup
+rescue Bundler::GemNotFound
+  raise RuntimeError, "Bundler couldn't find some gems." +
+    "Did you run `bundle install`?"
+end
+
+require "json-schematized"
+require "json"
+
+class Person < JSON::Schematized::Base
+  json_schema do
+    YAML.load(File.read(File.expand_path("../../spec/fixtures/person.yml", __FILE__)))["person"]
+  end
+end
+
+class VPerson
+  include JSON::Schematized
+  json_schema :wrapper => :virtus do
+    YAML.load(File.read(File.expand_path("../../spec/fixtures/person.yml", __FILE__)))["person"]
+  end
+end
+
+require "irb"
+IRB.start(__FILE__)

data/spec/fixtures/person.yml

@@ -0,0 +1,38 @@
+person:
+  type: object
+  properties:
+    email:
+      type: string
+    age:
+      type: integer
+    phones:
+      type: array
+      required: true
+      items:
+        type: string
+    address:
+      type: object
+      required: true
+      properties:
+        street_name:
+          type: string
+        number:
+          type: number
+    children:
+      type: array
+      items:
+        type: object
+        properties:
+          name:
+            type: string
+          age:
+            type: integer
+          born_location:
+            type: object
+            properties:
+              country:
+                type: string
+              state:
+                type: string
+              city:
+                type: string

data/spec/lib/json/schematized/base_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+class SimplePerson < JSON::Schematized::Base
+  json_schema do
+    YAML.load(File.read(File.expand_path("../../../../fixtures/person.yml", __FILE__)))["person"]
+  end
+end
+
+describe JSON::Schematized::Base do
+  let(:described_class){ JSON::Schematized::BasicWrapper }
+  it_should_behave_like "a JSON::Schematized::Wrapper" do
+    let(:model_class){ SimplePerson }
+  end
+end

data/spec/lib/json/schematized/basic_wrapper_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+class BPerson < Hash
+  include JSON::Schematized
+  json_schema :wrapper => :basic do
+    YAML.load(File.read(File.expand_path("../../../../fixtures/person.yml", __FILE__)))["person"]
+  end
+end
+
+describe ::JSON::Schematized::BasicWrapper do
+  it_should_behave_like "a JSON::Schematized::Wrapper" do
+    let(:model_class){ ::BPerson }
+    context "model instances" do
+      subject { model_class.new }
+      its(:attributes){ should == {"phones" => [], "address" => {}} }
+      its(:children){ should be_instance_of model_class::ChildrenCollection }
+    end
+
+    context "object" do
+      let(:object_model){ Hash.new.extend(modularized_schema) }
+      subject { object_model }
+      it { should == {"phones" => [], "address" => {}} }
+    end
+  end
+end

data/spec/lib/json/schematized/virtus_wrapper_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+class VPerson
+  include JSON::Schematized
+  json_schema :wrapper => :virtus do
+    YAML.load(File.read(File.expand_path("../../../../fixtures/person.yml", __FILE__)))["person"]
+  end
+end
+
+describe ::JSON::Schematized::VirtusWrapper do
+  it_should_behave_like "a JSON::Schematized::Wrapper" do
+    let(:model_class){ ::VPerson }
+    let(:object_model_module) { modularized_schema::ComplexTypes }
+
+    context "model classes" do
+      subject { model_class }
+      it { should be_include described_class.modularize(schema) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+gemlib = File.expand_path("../../lib", __FILE__)
+$:.unshift(gemlib) unless $:.include?(gemlib)
+
+require "json-schematized"
+require "json"
+require "yaml"
+
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each{ |f| require f }

data/spec/support/general_shared_excamples.rb

@@ -0,0 +1,151 @@
+# encoding: UTF-8
+
+shared_examples "a model with submodel types" do
+  subject { model_scope } # model_scope must be defined inside `it_should_behave_like` block
+  it { should be_const_defined :Address }
+  it { should be_const_defined :ChildrenCollection }
+  it { should be_const_defined :Child }
+  it { should be_const_defined :PhonesCollection }
+  it { should_not be_const_defined :BornLocation }
+
+  context "submodel Child types" do
+    subject { model_scope::Child }
+    it { should be_const_defined :BornLocation }
+  end
+
+  context "submodel Address attribute set names" do
+    subject { model_scope::Address.attribute_set.map(&:name) }
+    it { should be_include :street_name }
+    it { should be_include :number }
+  end
+
+  context "submodel Child attribute set names" do
+    subject { model_scope::Child.attribute_set.map(&:name) }
+    it { should be_include :name }
+    it { should be_include :age }
+    it { should be_include :born_location }
+  end
+
+  context "submodel Child::BornLocation attribute set names" do
+    subject { model_scope::Child::BornLocation.attribute_set.map(&:name) }
+    it { should be_include :country }
+    it { should be_include :state }
+    it { should be_include :city }
+  end
+end
+
+shared_examples "a JSON::Schematized::Wrapper" do
+  let(:schema_fixture_file){ File.expand_path("../../fixtures/person.yml", __FILE__) }
+  let(:schema_str){ MultiJson.dump(YAML.load(File.read(schema_fixture_file))["person"]) }
+
+  let(:schema){ MultiJson.load(schema_str, :symbolize_keys => true) }
+  let(:modularized_schema){ described_class.modularize(schema) }
+  let(:object_model_module){ modularized_schema }
+
+  context "wrapper module" do
+    subject { modularized_schema }
+    it { should be_kind_of Module }
+    it { should be_include JSON::Schematized::Models }
+    it { should be_include described_class::Models }
+    its(:name){ should =~ /\A#{described_class}::JSD/ }
+    its(:json_schema){ should == schema }
+  end
+
+  it_should_behave_like "a model with submodel types" do
+    let(:model_scope){ model_class }
+  end
+
+  context "model classes" do
+    subject { model_class } # model_class must be defined inside `it_should_behave_like` block
+    it { should be_include described_class }
+    it { should be_include JSON::Schematized::Models }
+    it { should be_include described_class::Models }
+    its(:json_schema){ should == schema }
+    its(:json_schema_module){ should be modularized_schema }
+
+    context "attribute set names" do
+      subject { model_class.attribute_set.map(&:name) }
+      it { should be_include :address }
+      it { should be_include :children }
+      it { should be_include :email }
+      it { should be_include :phones }
+    end
+  end
+
+  context "model instances" do
+    subject { model_class.new }
+    its(:address){ should be_instance_of model_class::Address }
+    its(:phones){ should be_instance_of model_class::PhonesCollection }
+    its(:children){ should be_instance_of model_class::ChildrenCollection }
+    its(:children){ should be_kind_of ::Array }
+
+    context "with mass assignment" do
+      let(:phones){ ["555-1234"] }
+      let(:address){ {:street_name => "Wall Street", :number => 1000} }
+      let(:born_location){ {} }
+      let(:child){ {:name => "John", :age => "10", :born_location => born_location} }
+      let :attrs do
+        {
+          :email => "me@email.com", :phones => phones,
+          :age => "45",
+          :address => address, :children => [child]
+        }
+      end
+      subject { model_class.new attrs }
+      its(:email){ should == "me@email.com" }
+      its(:age){ should be 45 }
+      its(:phones){ should be_instance_of model_class::PhonesCollection }
+      its(:"phones.size"){ should be 1 }
+      its(:"phones.first"){ should == "555-1234" }
+      its(:address){ should be_instance_of model_class::Address }
+      its(:"address.street_name"){ should == address[:street_name] }
+      its(:"address.number"){ should == address[:number] }
+      its(:children){ should be_instance_of model_class::ChildrenCollection }
+      its(:"children.size"){ should be 1 }
+      its(:"children.first"){ should be_instance_of model_class::Child }
+      its(:"children.first.name"){ should == child[:name] }
+      its(:"children.first.age"){ should == child[:age].to_i }
+      its(:"children.first.born_location"){ should be_instance_of model_class::Child::BornLocation }
+    end
+  end
+
+  context "collection classes" do
+    subject { model_class::ChildrenCollection }
+    it { should be_include JSON::Schematized::Collections }
+    it { should be_include described_class::Collections }
+  end
+
+  context "extended object" do
+    let(:object_model){ Hash.new.extend(modularized_schema) }
+    subject { object_model }
+    before do
+      object_model.age = "45"
+      object_model.children = [{:age => "10", :born_location => {}}]
+    end
+
+    its(:class){ should_not be_const_defined :Address }
+    its(:class){ should_not be_const_defined :ChildrenCollection }
+    its(:class){ should_not be_const_defined :Child }
+    its(:class){ should_not be_const_defined :PhonesCollection }
+    its(:class){ should_not be_const_defined :BornLocation }
+    it { should be_kind_of object_model_module }
+    it { should be_respond_to :age }
+    it { should be_respond_to :email }
+    it { should be_respond_to :address }
+    it { should be_respond_to :children }
+    it { should be_respond_to :phones }
+    its(:age){ should be 45 }
+    its(:address){ subject.should be_instance_of object_model_module::Address }         # adapted to ruby-1.8.x
+    its(:phones){ subject.should be_instance_of object_model_module::PhonesCollection } # adapted to ruby-1.8.x
+    its(:children){ should be_instance_of object_model_module::ChildrenCollection }
+    its(:children){ should be_kind_of ::Array }
+    its(:"children.size"){ should be 1 }
+    its(:"children.first"){ should be_instance_of object_model_module::Child }
+    its(:"children.first.age"){ should be 10 }
+    its(:"children.first.born_location"){ should be_instance_of object_model_module::Child::BornLocation }
+
+    it_should_behave_like "a model with submodel types" do
+      let(:model_scope){ object_model_module }
+    end
+  end
+end

metadata

@@ -1,108 +1,160 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: json-schematized
-version: !ruby/object:Gem::Version
-  version: 0.2.0
+version: !ruby/object:Gem::Version 
+  hash: 21
   prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 1
+  version: 0.2.1
 platform: ruby
-authors:
+authors: 
 - Marcelo Manzan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-28 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2013-02-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: multi_json
-  requirement: &70120517130240 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
   type: :runtime
-  prerelease: false
-  version_requirements: *70120517130240
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: activesupport
-  requirement: &70120517129800 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
-  prerelease: false
-  version_requirements: *70120517129800
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: virtus
-  requirement: &70120517129340 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
-  prerelease: false
-  version_requirements: *70120517129340
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: json
-  requirement: &70120517128840 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.4'
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        version: "1.4"
   type: :development
-  prerelease: false
-  version_requirements: *70120517128840
-- !ruby/object:Gem::Dependency
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: &70120517128340 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2.6'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 6
+        version: "2.6"
   type: :development
-  prerelease: false
-  version_requirements: *70120517128340
-description: ''
+  version_requirements: *id005
+description: ""
 email: manzan@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
+- Gemfile
+- README.md
+- json-schematized.gemspec
+- lib/json-schematized.rb
 - lib/json/schematized/base.rb
 - lib/json/schematized/basic_wrapper.rb
 - lib/json/schematized/dsl.rb
 - lib/json/schematized/virtus_wrapper.rb
 - lib/json/schematized/wrapper.rb
-- lib/json-schematized.rb
-- README.md
-- Gemfile
-- Gemfile.lock
+- script/console
+- .rspec
+- spec/fixtures/person.yml
+- spec/lib/json/schematized/base_spec.rb
+- spec/lib/json/schematized/basic_wrapper_spec.rb
+- spec/lib/json/schematized/virtus_wrapper_spec.rb
+- spec/spec_helper.rb
+- spec/support/general_shared_excamples.rb
 homepage: http://github.com/abril
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: Template builder based on JSON-Schema
-test_files: []
+summary: Object builder based on JSON-Schema
+test_files: 
+- .rspec
+- Gemfile
+- spec/fixtures/person.yml
+- spec/lib/json/schematized/base_spec.rb
+- spec/lib/json/schematized/basic_wrapper_spec.rb
+- spec/lib/json/schematized/virtus_wrapper_spec.rb
+- spec/spec_helper.rb
+- spec/support/general_shared_excamples.rb

data/Gemfile.lock

@@ -1,39 +0,0 @@
-PATH
-  remote: .
-  specs:
-    json-schematized (0.1.0)
-      activesupport
-      multi_json (~> 1.0)
-      virtus
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activesupport (3.2.7)
-      i18n (~> 0.6)
-      multi_json (~> 1.0)
-    backports (2.6.7)
-    descendants_tracker (0.0.1)
-    diff-lcs (1.1.3)
-    i18n (0.6.1)
-    json (1.7.6)
-    multi_json (1.5.0)
-    rspec (2.12.0)
-      rspec-core (~> 2.12.0)
-      rspec-expectations (~> 2.12.0)
-      rspec-mocks (~> 2.12.0)
-    rspec-core (2.12.2)
-    rspec-expectations (2.12.1)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.12.1)
-    virtus (0.5.4)
-      backports (~> 2.6.1)
-      descendants_tracker (~> 0.0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  json (~> 1.4)
-  json-schematized!
-  rspec (>= 2.6)