json-schematized 0.1.0 → 0.2.0

data/Gemfile

@@ -1,3 +1,10 @@
 source :rubygems
 
 gemspec
+
+# RUBY_VERSION ~> "1.9.0"
+# gem "debugger"
+
+# RUBY_VERSION ~> "1.8.0"
+# gem "ruby-debug"
+# gem "linecache", "0.43"

data/Gemfile.lock

@@ -2,22 +2,33 @@ 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)
-    json (1.7.5)
+    i18n (0.6.1)
+    json (1.7.6)
     multi_json (1.5.0)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.1)
-    rspec-expectations (2.10.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.10.1)
+    rspec-mocks (2.12.1)
+    virtus (0.5.4)
+      backports (~> 2.6.1)
+      descendants_tracker (~> 0.0.1)
 
 PLATFORMS
   ruby

data/README.md

@@ -1,6 +1,8 @@
 # JSON::Schematized
 
-Template builder based on JSON-Schema.
+[![Build Status](https://travis-ci.org/abril/json-schematized.png?branch=master)](https://travis-ci.org/abril/json-schematized)
+
+Object builder based on JSON-Schema.
 
 ## Sample usage
 
@@ -9,24 +11,26 @@ Consider the following JSON-Schema (escaped as YAML, for better viewing):
 ```yaml
 # person.yml
 person:
-  name:
-    type: string
-  birth:
-    type: object
-    properties:
-      name:
-        type: string
-  children:
-    type: array
-    required: true
-    items:
+  type: object
+  properties:
+    name:
+      type: string
+    birth:
       type: object
       properties:
         name:
           type: string
+    children:
+      type: array
+      required: true
+      items:
+        type: object
+        properties:
+          name:
+            type: string
 ```
 
-Usage:
+### Basic Wrapper Usage:
 
 ```ruby
 require "json-schematized"
@@ -37,8 +41,30 @@ class Person < JSON::Schematized::Base
   end
 end
 
-person = Person.new name: "John", birth: {name: "John Smith"}
-person.children        # => []
-person.name            # => "John"
-person.birth.name      # => "John Smith"
+person = Person.new name: "John", children: [{name: "William"}]
+person.name                     # => "John"
+person.children                 # => [{"name" => "William"}]
+person.children.class           # => Person::ChildrenCollection
+person.children.first.class     # => Person::Child
+person.children.first.name      # => "William"
+```
+
+### Virtus Wrapper Usage:
+
+```ruby
+require "json-schematized"
+
+class Person
+  include JSON::Schematized
+  json_schema wrapper: :virtus do  # block called only once
+    YAML.load(File.read(File.expand_path("../person.yml", __FILE__)))["person"]
+  end
+end
+
+person = Person.new name: "John", children: [{name: "William"}]
+person.name                     # => "John"
+person.children                 # => [#<Person::Child:0x007fc990906fd0 @name="William">]
+person.children.class           # => Person::ChildrenCollection
+person.children.first.class     # => Person::Child
+person.children.first.name      # => "William"
 ```

data/lib/json/schematized/base.rb

@@ -1,17 +1,8 @@
 # encoding: UTF-8
 module JSON
   module Schematized
-    class Base
-      extend DSL
-      include SchematizedObject
-
-      attr_reader :__json__
-
-      def initialize(attrs = nil)
-        @__json__ = {}
-        @__schema__ = Builder.new(self.class.json_schema)
-        __schema__.copy_to(__json__, attrs)
-      end
+    class Base < BasicWrapper.model_superclass
+      include Schematized
     end
   end
 end

data/lib/json/schematized/basic_wrapper.rb

@@ -0,0 +1,209 @@
+# encoding: UTF-8
+
+require "virtus"
+
+module JSON
+  module Schematized
+    module BasicWrapper
+      extend Wrapper
+
+      def self.included(base)
+        raise TypeError, "#{base.inspect} should inherits #{model_superclass}" unless base < model_superclass
+        base.send(:include, Models)
+        base.extend ClassMethods
+        prepare_schema!(base, base.json_schema, :complex_types)
+      end
+
+      module ClassMethods
+        def attribute_set
+          BasicWrapper.modularize(json_schema).attribute_set
+        end
+      end
+
+      def initialize(attrs = nil)
+        self.json_schema = self.class.json_schema
+        mass_assign!(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 = []
+              json_schema[:properties].each_pair do |field_name, meta|
+                set << Virtus::Attribute.build(field_name, BasicWrapper.meta_type(self, field_name, meta))
+              end
+              @attribute_set = Virtus::AttributeSet.new(nil, set)
+            end
+            @attribute_set
+          end
+
+          def self.extend_object(base)
+            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
+              end
+              base.extend klass
+            end
+          end
+        end
+      end
+
+      def self.prepare_model(ref, field_name, model_class, json_schema)
+        model_class.extend BasicWrapper::ClassMethods
+        parent_namespace = {:ref => ref, :field => field_name.to_sym}
+        model_class.instance_variable_set(:@parent_namespace, parent_namespace)
+        def model_class.json_schema
+          json_schema = @parent_namespace[:ref].json_schema
+          meta = json_schema[:properties][@parent_namespace[:field]] || {}
+          meta = meta[:items] if meta[:type] == "array"
+          meta
+        end
+        prepare_schema!(model_class, json_schema, :complex_types)
+      end
+
+      def self.model_superclass
+        ::Hash
+      end
+
+      module Models
+        def attributes
+          self
+        end
+
+        def json_schema=(json_schema)
+          extend BasicWrapper.modularize(json_schema)
+        end
+      end
+
+      module Collections
+        def coerce_members_to(member_type, json_schema)
+          extend BasicWrapper::SchematizedArray
+          self.members_type = member_type
+          self.members_module = BasicWrapper.modularize(json_schema)
+        end
+      end
+
+      module SchematizedArray
+        attr_accessor :members_type
+        attr_accessor :members_module
+
+        def coerce_members_to(*args); end
+
+        def <<(value)
+          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)
+            super(new_value)
+          else
+            super
+          end
+        end
+
+        def mass_assign!(array)
+          array.each do |value|
+            self << value
+          end
+        end
+      end
+
+      module SchematizedHash
+        def method_missing(name, *args)
+          key = name.to_s
+          if key =~ /=\z/
+            key = $`.to_sym
+            if json_schema[:properties][key]
+              self[key] = args.first
+            else
+              super
+            end
+          else
+            read_attribute key
+          end
+        end
+
+        def respond_to?(method_name)
+          json_schema[:properties].has_key?(method_name.to_sym) || super
+        end
+
+        def subclasses_namespace
+          self.class
+        end
+
+        def []=(key, value)
+          if meta = json_schema[:properties][key.to_sym]
+            case meta[:type]
+            when "array"
+              collection = BasicWrapper.build_collection(subclasses_namespace, 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)
+              new_value = model_class.new
+              new_value.json_schema = meta
+              new_value.mass_assign!(value) if value.is_a?(Hash)
+              value = new_value
+            end
+          end
+          super(key.to_s, value)
+        end
+
+        def mass_assign!(hash)
+          return unless hash.is_a?(Hash)
+          hash.each_pair do |key, value|
+            self[key] = value
+          end
+        ensure
+          SchematizedHash.ensure_structure!(self, json_schema)
+        end
+
+        def read_attribute(name)
+          name = name.to_s
+          value = self[name]
+          if !has_key?(name) && (meta = json_schema[:properties][name.to_sym])
+            case meta[:type]
+            when "array"
+              self[name] = []
+              value = self[name]
+            when "object"
+              self[name] = {}
+              value = self[name]
+            end
+          end
+          value
+        end
+
+        def self.ensure_structure!(json, schema)
+          meta = schema[:properties]
+          meta.each_pair do |key, schema|
+            if !json.has_key?(key.to_s) && schema[:required]
+              json[key.to_s] = case schema[:type]
+                when "object" then {}
+                when "array" then []
+                else nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/schematized/dsl.rb

@@ -5,16 +5,22 @@ require "multi_json"
 module JSON
   module Schematized
     module DSL
-      def json_schema(json = nil, &block)
-        if instance_variable_defined?(:"@json_schema")
-          schema = @json_schema[:loader].call
+      def json_schema(*args, &block)
+        if instance_variable_defined?(:"@json_schema_loader")
+          schema = @json_schema_loader.call
           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}
+          @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
+          self
         end
       end
     end

data/lib/json/schematized/virtus_wrapper.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+require "virtus"
+
+module JSON
+  module Schematized
+    module DSL
+      def virtus_module
+        VirtusWrapper.modularize(json_schema)
+      end
+    end
+
+    module VirtusWrapper
+      extend Wrapper
+
+      def self.included(base)
+        base.send(:include, modularize(base.json_schema))
+      end
+
+      def self.modularize(json_schema)
+        super(json_schema) do
+          include ::Virtus
+
+          VirtusWrapper.prepare_schema!(self, self.json_schema, :simple_types)
+          def self.included(base)
+            super
+            VirtusWrapper.prepare_schema!(base, json_schema, :complex_types)
+          end
+
+          def self.extend_object(base)
+            class_name = :ComplexTypes
+            (const_defined?(class_name) ?
+              const_get(class_name) :
+              const_set(class_name, Module.new)
+            ).tap do |klass|
+              klass.send(:include, self) unless klass.include?(self)
+              base.extend klass
+            end
+          end
+        end
+      end
+
+      def self.prepare_model(ref, field_name, model_class, json_schema)
+        model_class.send(:include, modularize(json_schema))
+      end
+
+      def self.add_attribute!(ref, field_name, meta, kind)
+        opts = {}
+        klass =  (kind.is_a?(Class) ? kind : kind.class)
+        if kind.is_a?(Class)
+          opts[:default] = klass.new if meta[:required] && kind.include?(::Virtus)
+        else
+          opts[:default] = kind.class.new
+        end
+        ref.attribute field_name, kind, opts
+      end
+
+      def self.collection_superclass
+        Array
+      end
+
+      class Array < ::Array
+      end
+
+      module Attribute
+        class Array < ::Virtus::Attribute::Array
+          primitive VirtusWrapper::Array
+          default primitive.new
+
+          def new_collection
+            (@primitive || self.class.primitive).new
+          end
+
+          def self.merge_options(type, options)
+            merged_options = super
+            klass = type.is_a?(Class) ? type : type.class
+            merged_options.merge(:primitive => klass)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json/schematized/wrapper.rb

@@ -0,0 +1,122 @@
+# encoding: UTF-8
+
+module JSON
+  module Schematized
+    module Wrapper
+      def self.extended(base)
+        base.const_set(:Models, Module.new).send(:include, Schematized::Models)
+        base.const_set(:Collections, Module.new).send(:include, Schematized::Collections)
+      end
+
+      def modularize(json_schema, &block)
+        json_schema = MultiJson.dump(json_schema) unless json_schema.is_a?(String)
+        json_schema = MultiJson.load(json_schema, :symbolize_keys => true)
+        module_name = "JSD#{json_schema.hash}".gsub(/\-/, "_").to_sym # JSON-Schema Definition
+        if const_defined?(module_name)
+          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)
+            m.module_eval do
+              define_method :json_schema do
+                m.json_schema
+              end
+            end
+            m.module_eval(&block) if block_given?
+          end
+        end
+      end
+
+      def prepare_schema!(ref, json_schema, mode)
+        modes = {
+          :complex_types => 1,
+          :simple_types => 2,
+          :all_types => 3
+        }
+        mode = [modes[mode].to_i, 0].max
+        accept_complex_types = (modes[:complex_types] & mode) > 0
+        accept_simple_types = (modes[:simple_types] & mode) > 0
+        json_schema[:properties].each_pair do |field_name, meta|
+          kind = nil
+          case meta[:type]
+          when "array"
+            next unless accept_complex_types
+            collection = build_collection(ref, field_name, meta[:items])
+            kind = collection
+          when "object"
+            next unless accept_complex_types
+            model = build_model(ref, field_name, meta)
+            kind = model
+          else
+            next unless accept_simple_types
+            kind = meta_type(ref, field_name, meta)
+          end
+          add_attribute! ref, field_name, meta, kind
+        end
+      end
+
+      def add_attribute!(ref, field_name, meta, kind)
+      end
+
+      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)
+        else
+          parse_json_schema_type meta[:type]
+        end
+      end
+
+      def parse_json_schema_type(type)
+        Object
+      end
+
+      def build_class_name(field_name)
+        field_name.to_s.gsub(/(?:\A_*|_)([^_])/){ $1.upcase }
+      end
+
+      def collection_superclass
+        Array
+      end
+
+      def build_collection(ref, field_name, meta)
+        class_name = [build_class_name(field_name), "Collection"].join.to_sym
+        (ref.const_defined?(class_name) ?
+          ref.const_get(class_name) :
+          ref.const_set(class_name, Class.new(collection_superclass))
+        ).tap do |klass|
+          unless klass.include?(Schematized::Collections)
+            klass.send(:include, self::Collections)
+          end
+        end[meta_type(ref, field_name, meta, true)]
+      end
+
+      def model_superclass
+      end
+
+      def build_model(ref, field_name, json_schema, singularize = false)
+        name = field_name
+        name = ::ActiveSupport::Inflector.singularize(field_name.to_s).to_sym if singularize
+        class_name = build_class_name(name).to_sym
+        (ref.const_defined?(class_name) ?
+          ref.const_get(class_name) :
+          ref.const_set(class_name, Class.new(*[model_superclass].compact))
+        ).tap do |klass|
+          unless klass.include?(Schematized::Models)
+            klass.send(:include, self::Models)
+            prepare_model(ref, field_name, klass, json_schema)
+          end
+        end
+      end
+
+      def prepare_model(ref, field_name, model_class, json_schema)
+      end
+    end
+  end
+end

data/lib/json-schematized.rb

@@ -2,13 +2,21 @@
 $:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__))
 
 require "rubygems"
+require "active_support"
 
 module JSON
   module Schematized
     autoload :Base, "json/schematized/base"
-    autoload :Builder, "json/schematized/builder"
     autoload :DSL, "json/schematized/dsl"
+    autoload :Wrapper, "json/schematized/wrapper"
+    autoload :BasicWrapper, "json/schematized/basic_wrapper"
+    autoload :VirtusWrapper, "json/schematized/virtus_wrapper"
+
+    def self.included(base)
+      base.extend DSL
+    end
+
+    module Models; end
+    module Collections; end
   end
 end
-
-require "json/schematized_objects"

metadata

@@ -1,116 +1,108 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: json-schematized
-version: !ruby/object:Gem::Version 
-  hash: 27
+version: !ruby/object:Gem::Version
+  version: 0.2.0
   prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
 platform: ruby
-authors: 
+authors:
 - Marcelo Manzan
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-01-15 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: multi_json
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70120517130240 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70120517130240
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70120517129800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70120517129800
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: &70120517129340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: json
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70120517129340
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70120517128840 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 1
-        - 4
-        version: "1.4"
+      - !ruby/object:Gem::Version
+        version: '1.4'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70120517128840
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70120517128340 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 2
-        - 6
-        version: "2.6"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.6'
   type: :development
-  version_requirements: *id003
-description: ""
+  prerelease: false
+  version_requirements: *70120517128340
+description: ''
 email: manzan@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/json/schematized/base.rb
-- lib/json/schematized/builder.rb
+- lib/json/schematized/basic_wrapper.rb
 - lib/json/schematized/dsl.rb
-- lib/json/schematized_objects.rb
+- lib/json/schematized/virtus_wrapper.rb
+- lib/json/schematized/wrapper.rb
 - lib/json-schematized.rb
 - README.md
 - Gemfile
 - Gemfile.lock
 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 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Template builder based on JSON-Schema
 test_files: []
-

data/lib/json/schematized/builder.rb

@@ -1,77 +0,0 @@
-# encoding: UTF-8
-module JSON
-  module Schematized
-    class Builder
-      attr_reader :schema
-
-      def initialize(schema)
-        @schema = schema
-      end
-
-      def member?(key)
-        schema[:properties][key.to_sym]
-      end
-
-      def copy_to(json, attrs)
-        if json.is_a?(Array)
-          return unless attrs.is_a?(Array)
-          attrs.each{ |value| assign!(json, nil, schema, value) }
-        else
-          return unless attrs.is_a?(Hash)
-          attrs.each_pair do |key, value|
-            meta = member?(key)
-            assign!(json, key, meta, value) if meta
-          end
-        end
-        ensure_structure(json, schema)
-        json
-      end
-
-      def ensure_structure(json, schema)
-        case json
-        when Array
-          meta = schema[:items]
-          case meta && meta[:type]
-          when "object", "array"
-            json.each do |value|
-              ensure_structure(value, meta)
-            end
-          end
-        when Hash
-          meta = schema[:properties]
-          meta.each_pair do |key, schema|
-            case value = json[key.to_s]
-            when Hash
-              ensure_structure(value, schema) if schema[:type] == "object"
-            when Array
-              ensure_structure(value, schema) if schema[:type] == "array"
-            when nil
-              if schema[:required]
-                case schema[:type]
-                when "object"
-                  ensure_structure(json[key.to_s] = {}, schema)
-                when "array"
-                  ensure_structure(json[key.to_s] = [], schema)
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def assign!(json, key, meta, value)
-        case meta[:type]
-        when "object"
-          value = self.class.new(meta).copy_to({}, value)
-        when "array"
-          value = self.class.new(meta[:items]).copy_to([], value)
-        end
-        if json.is_a?(Array)
-          json << value
-        else
-          json[key.to_s] = value
-        end
-      end
-    end
-  end
-end

data/lib/json/schematized_objects.rb

@@ -1,51 +0,0 @@
-# encoding: UTF-8
-module JSON
-  module SchematizedObject
-    attr_accessor :__schema__
-
-    def __json__
-      self
-    end
-
-   protected
-
-    def method_missing(name, *args)
-      key = name.to_s
-      if key =~ /=\z/
-        key = $`.to_sym
-        meta = __schema__.member?(key)
-        meta ? __schema__.assign!(__json__, key, meta, args.first) : super
-      else
-        read_attribute key
-      end
-    end
-
-    def read_attribute(name)
-      name = name.to_s
-      value = __json__[name]
-      if !__json__.has_key?(name) && (meta = __schema__.member?(name))
-        case meta[:type]
-        when "array"
-          value = __json__[name] = [].tap do |array|
-            array.extend SchematizedArray
-            array.__schema__ = __schema__.class.new(meta[:items])
-          end
-        when "object"
-          value = __json__[name] = {}.tap do |hash|
-            hash.extend SchematizedObject
-            hash.__schema__ = __schema__.class.new(meta)
-          end
-        end
-      end
-      value
-    end
-  end
-
-  module SchematizedArray
-    attr_accessor :__schema__
-
-    def __json__
-      self
-    end
-  end
-end