sumaki 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b7187ea951d6b5b682b054303d696ce2c65e205519c151aed52a7e6a542cdf7
-  data.tar.gz: 70631c497947954364961b3fde444bcc56be61b534687826872cab5efa139e86
+  metadata.gz: 4cc5d96c3a979b46ace35c6bcae70136875b415af2dbe971f45731ff69aa61ff
+  data.tar.gz: dbae61d4d18b0c6e3034620ea3dbe77467b4133da5df1eb45b9d89c927d98504
 SHA512:
-  metadata.gz: a913803fdde6db3a69bce4ad967048673c6d3b089d05265029d21e09074b817d45cb7b3c2f1570cc50e3ec034bdb85420eb7f38a0b6625803d2054bbb4fad733
-  data.tar.gz: 355746b7f56600a79023a056aaaee86a599f9b5951b371b8b6a600086428cf392528f8447bc03f71f3173a91cd939b661d1134cb80cae4d99c993053e9973987
+  metadata.gz: 9a7ecf9d761bf8b6f8ff2b5236090f83105795dcb78e45d27c109a7377ead5ed323a38e51a6b3be5996bedd95917e7676e13894dd16517bac180de6ea589be6f
+  data.tar.gz: 1c3624fdf113f3d260e58e00f68c96f51abcdac1fe1f55e7f30ec93a3b62159b3a051618a3bfe4b9c791f66499d6160429083c73eb90d2661d97e027c74c0f16

data/.rubocop.yml

@@ -5,12 +5,12 @@ AllCops:
 
 Lint/ConstantDefinitionInBlock:
   Exclude:
-    - 'spec/sumaki/model/association_spec.rb'
+    - 'spec/sumaki/model/associations_spec.rb'
     - 'spec/sumaki/model/attribute_spec.rb'
     - 'spec/sumaki/model/enum_spec.rb'
 
 RSpec/LeakyConstantDeclaration:
   Exclude:
-    - 'spec/sumaki/model/association_spec.rb'
+    - 'spec/sumaki/model/associations_spec.rb'
     - 'spec/sumaki/model/attribute_spec.rb'
     - 'spec/sumaki/model/enum_spec.rb'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sumaki (0.1.0)
+    sumaki (0.3.0)
       minenum
 
 GEM
@@ -14,14 +14,14 @@ GEM
     diff-lcs (1.5.1)
     docile (1.4.0)
     io-console (0.7.2)
-    irb (1.12.0)
-      rdoc
+    irb (1.13.1)
+      rdoc (>= 4.0.0)
       reline (>= 0.4.2)
     json (2.7.2)
     language_server-protocol (3.17.0.3)
     minenum (0.1.0)
     parallel (1.24.0)
-    parser (3.3.0.5)
+    parser (3.3.1.0)
       ast (~> 2.4.1)
       racc
     psych (5.1.2)
@@ -31,10 +31,11 @@ GEM
     rake (13.2.1)
     rdoc (6.6.3.1)
       psych (>= 4.0.0)
-    regexp_parser (2.9.0)
-    reline (0.5.2)
+    regexp_parser (2.9.2)
+    reline (0.5.7)
       io-console (~> 0.5)
-    rexml (3.2.6)
+    rexml (3.2.8)
+      strscan (>= 3.0.9)
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
@@ -44,11 +45,11 @@ GEM
     rspec-expectations (3.13.0)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.0)
+    rspec-mocks (3.13.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-support (3.13.1)
-    rubocop (1.63.3)
+    rubocop (1.63.5)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
@@ -59,13 +60,13 @@ GEM
       rubocop-ast (>= 1.31.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.31.2)
-      parser (>= 3.3.0.4)
+    rubocop-ast (1.31.3)
+      parser (>= 3.3.1.0)
     rubocop-capybara (2.20.0)
       rubocop (~> 1.41)
     rubocop-factory_bot (2.25.1)
       rubocop (~> 1.41)
-    rubocop-rspec (2.29.1)
+    rubocop-rspec (2.29.2)
       rubocop (~> 1.40)
       rubocop-capybara (~> 2.17)
       rubocop-factory_bot (~> 2.22)
@@ -80,6 +81,7 @@ GEM
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
     stringio (3.1.0)
+    strscan (3.1.0)
     unicode-display_width (2.5.0)
 
 PLATFORMS

data/README.md

@@ -93,12 +93,22 @@ class Anime
   field :title
   field :url
 end
+```
 
+```ruby
+# Read the field values
 anime = Anime.new({ title: 'The Vampire Dies in No Time', url: 'https://sugushinu-anime.jp/' })
 anime.title #=> 'The Vampire Dies in No Time'
 anime.url #=> 'https://sugushinu-anime.jp/'
 ```
 
+```ruby
+# Write the field value
+anime = Anime.new({})
+anime.title = 'The Vampire Dies in No Time'
+anime.title #=> 'The Vampire Dies in No Time'
+```
+
 If the data contains attributes not declared in the field, it raises no error and is simply ignored.
 
 ### Access to the sub object
@@ -114,23 +124,31 @@ class Book
   class Company
     include Sumaki::Model
     field :name
-    field :prefecture
   end
 end
+```
 
+```ruby
 data = {
   title: 'The Ronaldo Chronicles',
   company: {
     name: 'Autumn Books',
-    prefecture: 'Tokyo'
   }
 }
 
-comic = Book.new(data)
-comic.company.name #=> 'Autumn Books'
+# Read from the sub object
+book = Book.new(data)
+book.company.name #=> 'Autumn Books'
+```
+
+```ruby
+# Build a sub object
+book = Book.new({})
+book.build_company(name: 'Autumn Books')
+book.company #=> #<Book::Company:0x000073a618e31e80 name: "Autumn Books">
 ```
 
-sub object is wrapped with the class inferred from the field name under the original class.
+Sub object is wrapped with the class inferred from the field name under the original class.
 
 This can be changed by specifying the class to wrap.
 
@@ -172,7 +190,9 @@ class Company
     field :name
   end
 end
+```
 
+```ruby
 data = {
   name: 'The Ronaldo Vampire Hunter Agency',
   member: [
@@ -182,11 +202,19 @@ data = {
   ]
 }
 
+# Read from the sub object
 company = Company.new(data)
 company.member.size #=> 3
 company.member[2].name #=> 'John'
 ```
 
+```ruby
+# Build a sub object
+company = Company.new({})
+company.member.build(name: 'John')
+company.member[0].name #=> 'John'
+```
+
 The `class_name` option can also be used to specify the class to wrap.
 
 ### Access to the parent object
@@ -227,14 +255,25 @@ class Character
   field :name
   enum :type, { vampire: 1, vampire_hunter: 2, familier: 3, editor: 4 }
 end
+```
 
+```ruby
 data = {
   name: 'John',
   type: 3
 }
 
+# Read the enum
 character = Character.new(data)
-character.type #=> :familier
+character.type.name #=> :familier
+character.type.familier? #=> true
+```
+
+```ruby
+# Write the enum value
+character = Character.new({})
+character.type = 1
+character.type.name #=> :vampire
 ```
 
 

data/lib/sumaki/adapter/hash.rb

@@ -7,6 +7,22 @@ module Sumaki
       def get(data, key)
         data[key]
       end
+
+      def set(data, key, value)
+        data[key] = value
+      end
+
+      def build_singular(data, name)
+        data[name] = {}
+      end
+
+      def build_repeated_element(_data, _name)
+        {}
+      end
+
+      def apply_repeated(data, name, objects)
+        data[name] = objects
+      end
     end
   end
 end

data/lib/sumaki/model/associations/association.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Sumaki
+  module Model
+    module Associations
+      module Association
+        class Singular # :nodoc:
+          def initialize(owner, reflection)
+            @owner = owner
+            @reflection = reflection
+          end
+
+          def model
+            @model ||= begin
+              object = @owner.get(@reflection.name)
+              object.nil? ? nil : @reflection.model_class.new(object, parent: @owner)
+            end
+          end
+
+          def build_model(attrs = {})
+            assoc = @owner.object_accessor.build_singular(@reflection.name)
+
+            model = @reflection.model_class.new(assoc, parent: @owner)
+            model.assign(attrs)
+
+            @model = model
+          end
+        end
+
+        class Repeated # :nodoc:
+          def initialize(owner, reflection)
+            @owner = owner
+            @reflection = reflection
+          end
+
+          def collection
+            @collection ||= begin
+              objects_or_value = @owner.get(@reflection.name)
+              models = if objects_or_value.is_a?(Array)
+                         model_class = @reflection.model_class
+                         objects_or_value.map { |object| model_class.new(object, parent: @owner) }
+                       else
+                         []
+                       end
+
+              @reflection.collection_class.new(models, owner: @owner)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sumaki/model/associations/collection.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Sumaki
+  module Model
+    module Associations
+      class Collection # :nodoc:
+        include Enumerable
+        extend Forwardable
+
+        singleton_class.attr_accessor :reflection
+
+        def_delegators :@models, :each, :[]
+        def_delegators :@models, :inspect, :pretty_print
+        def_delegators 'self.class', :reflection
+
+        def self.build_subclass(reflection)
+          subclass = Class.new(self)
+          subclass.reflection = reflection
+          subclass
+        end
+
+        def initialize(models = [], owner:)
+          @models = models
+          @owner = owner
+        end
+
+        def build(attrs = {})
+          object = @owner.object_accessor.build_repeated_element(reflection.name)
+          model = reflection.model_class.new(object, parent: @owner)
+          model.assign(attrs)
+
+          self << model
+
+          model
+        end
+
+        def <<(...)
+          r = @models.<<(...)
+          apply
+          r
+        end
+
+        private
+
+        def apply
+          @owner.object_accessor.apply_repeated(reflection.name, @models)
+        end
+      end
+    end
+  end
+end

data/lib/sumaki/model/associations/reflection.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'collection'
+
+module Sumaki
+  module Model
+    module Associations
+      module Reflection
+        class Base # :nodoc:
+          def initialize(owner_class, name, class_name: nil)
+            @owner_class = owner_class
+            @name = name
+            @class_name = class_name
+          end
+
+          def name = @name.to_sym
+
+          def model_class
+            @model_class ||= begin
+              basename = @class_name&.to_s || classify(@name.to_s)
+              klass = if @owner_class.const_defined?(basename)
+                        @owner_class.const_get(basename)
+                      else
+                        @owner_class.const_set(basename, Class.new { include Model })
+                      end
+              klass.parent = @owner_class
+              klass
+            end
+          end
+
+          def association_for(model)
+            self.class.association_class.new(model, self)
+          end
+
+          private
+
+          def classify(str)
+            str.gsub(/([a-z\d]+)_?/) { |_| Regexp.last_match(1).capitalize }
+          end
+        end
+
+        class Singular < Base # :nodoc:
+          def self.association_class = Association::Singular
+        end
+
+        class Repeated < Base # :nodoc:
+          def self.association_class = Association::Repeated
+
+          def collection_class
+            @collection_class ||= begin
+              class_name = "#{model_class.name[/(\w+)$/]}Collection"
+
+              if @owner_class.const_defined?(class_name)
+                @owner_class.const_get(class_name)
+              else
+                @owner_class.const_set(class_name, Collection.build_subclass(self))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sumaki/model/associations.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative 'associations/reflection'
+require_relative 'associations/association'
+
+module Sumaki
+  module Model
+    # = Sumaki::Model::Associations
+    module Associations
+      def self.included(base)
+        base.extend ClassMethods
+        base.include InstanceMethods
+      end
+
+      module AccessorAdder
+        module Singular # :nodoc:
+          def add(model_class, methods_module, reflection)
+            add_getter(methods_module, reflection.name)
+            add_builder(methods_module, reflection.name)
+
+            model_class.reflections[reflection.name] = reflection
+          end
+
+          private
+
+          def add_getter(methods_module, name)
+            methods_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{name}                   # def author
+                association(:#{name}).model #   association(:author).model
+              end                           # end
+            RUBY
+          end
+
+          def add_builder(methods_module, name)
+            methods_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def build_#{name}(attrs = {})              # def build_author(attrs = {})
+                association(:#{name}).build_model(attrs) #   association(:author).build_model(attrs)
+              end                                        # end
+            RUBY
+          end
+
+          module_function :add, :add_getter, :add_builder
+        end
+
+        module Repeated # :nodoc:
+          def add(model_class, methods_module, reflection)
+            methods_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{reflection.name}                        # def book
+                association(:#{reflection.name}).collection #   association(:book).collection
+              end                                           # end
+            RUBY
+
+            model_class.reflections[reflection.name] = reflection
+          end
+          module_function :add
+        end
+      end
+
+      module ClassMethods # :nodoc:
+        # Access to the sub object.
+        #
+        #   class Book
+        #     include Sumaki::Model
+        #     singular :company
+        #
+        #     class Company
+        #       include Sumaki::Model
+        #     end
+        #   end
+        #
+        #   data = {
+        #     title: 'The Ronaldo Chronicles',
+        #     company: {
+        #       name: 'Autumn Books',
+        #     }
+        #   }
+        #   book = Book.new(data)
+        #   book.company.class #=> Book::Company
+        #
+        # Sub object can also be created.
+        #
+        #   book = Book.new({})
+        #   book.build_company(name: 'Autumn Books')
+        #   book.company #=> #<Book::Company:0x000073a618e31e80 name: "Autumn Books">
+        #
+        # == Options
+        #
+        # [:class_name]
+        #   Specify the name of the class to wrap. Use this if the name of the class
+        #   to wrap is not inferred from the nested field names.
+        def singular(name, class_name: nil)
+          reflection = Reflection::Singular.new(self, name, class_name: class_name)
+          AccessorAdder::Singular.add(self, association_methods_module, reflection)
+        end
+
+        # Access to the repeated sub objects
+        #
+        #   class Company
+        #     include Sumaki::Model
+        #     repeated :member
+        #
+        #     class Member
+        #       include Sumaki::Model
+        #     end
+        #   end
+        #
+        #   data = {
+        #     name: 'The Ronaldo Vampire Hunter Agency',
+        #     member: [
+        #       { name: 'Ronaldo' },
+        #       { name: 'Draluc' },
+        #       { name: 'John' }
+        #     ]
+        #   }
+        #   company = Company.new(data)
+        #   company.member[2].class #=> Company::Member
+        #
+        # Sub object can also be created.
+        #
+        #   company = Company.new({})
+        #   company.member.build(name: 'John')
+        #   company.member[0].name #=> 'John'
+        #
+        # == Options
+        #
+        # [:class_name]
+        #   Specify the name of the class to wrap. Use this if the name of the class
+        #   to wrap is not inferred from the nested field names.
+        def repeated(name, class_name: nil)
+          reflection = Reflection::Repeated.new(self, name, class_name: class_name)
+          AccessorAdder::Repeated.add(self, association_methods_module, reflection)
+        end
+
+        def reflections
+          @reflections ||= {}
+        end
+
+        private
+
+        def association_methods_module
+          @association_methods_module ||= begin
+            mod = Module.new
+            include mod
+            mod
+          end
+        end
+      end
+
+      module InstanceMethods # :nodoc:
+        private
+
+        def association(name)
+          @associations ||= {}
+          @associations[name.to_sym] ||= self.class.reflections[name.to_sym].association_for(self)
+        end
+      end
+    end
+  end
+end

data/lib/sumaki/model/attribute.rb

@@ -6,6 +6,31 @@ module Sumaki
     module Attribute
       def self.included(base)
         base.extend ClassMethods
+        base.include InstanceMethods
+      end
+
+      module AccessorAdder # :nodoc:
+        def add(methods_module, field_name)
+          add_getter(methods_module, field_name)
+          add_setter(methods_module, field_name)
+        end
+
+        def add_getter(methods_module, field_name)
+          methods_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{field_name}       # def title
+              get(:'#{field_name}') #   get(:'title')
+            end                     # end
+          RUBY
+        end
+
+        def add_setter(methods_module, field_name)
+          methods_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{field_name}=(value)      # def title=(value)
+              set(:'#{field_name}', value) #   set(:'title', value)
+            end                            # end
+          RUBY
+        end
+        module_function :add, :add_getter, :add_setter
       end
 
       module ClassMethods # :nodoc:
@@ -20,12 +45,19 @@ module Sumaki
         #   anime = Anime.new({ title: 'The Vampire Dies in No Time', url: 'https://sugushinu-anime.jp/' })
         #   anime.title #=> 'The Vampire Dies in No Time'
         #   anime.url #=> 'https://sugushinu-anime.jp/'
+        #
+        # The Field value cam be set.
+        #
+        #   anime = Anime.new({})
+        #   anime.title = 'The Vampire Dies in No Time'
+        #   anime.title #=> 'The Vampire Dies in No Time'
         def field(name)
-          attribute_methods_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}       # def title
-              get(:'#{name}') #   get(:'title')
-            end               # end
-          RUBY
+          field_names << name.to_sym
+          AccessorAdder.add(attribute_methods_module, name)
+        end
+
+        def field_names
+          @field_names ||= []
         end
 
         private
@@ -38,6 +70,12 @@ module Sumaki
           end
         end
       end
+
+      module InstanceMethods # :nodoc:
+        def fields
+          self.class.field_names.map.with_object({}) { |e, r| r[e] = public_send(e) }
+        end
+      end
     end
   end
 end

data/lib/sumaki/model/enum.rb

@@ -15,7 +15,11 @@ module Sumaki
         def get(model, name)
           model.get(name)
         end
-        module_function :get
+
+        def set(model, name, value)
+          model.set(name, value)
+        end
+        module_function :get, :set
       end
 
       module ClassMethods # :nodoc:
@@ -36,6 +40,12 @@ module Sumaki
         #   character.type.name #=> :familier
         #   character.type.familier? #=> true
         #   character.type.vampire? #=> false
+        #
+        # Enum can also be set.
+        #
+        #   character = Character.new({})
+        #   character.type = 1
+        #   character.type.name #=> :vampire
         def enum(name, values)
           super(name, values, adapter: EnumAttrAccessor)
         end
@@ -49,11 +59,6 @@ module Sumaki
             mod
           end
         end
-
-        # TODO: remove this
-        def classify(key)
-          key.gsub(/([a-z\d]+)_?/) { |_| Regexp.last_match(1).capitalize }
-        end
       end
     end
   end

data/lib/sumaki/model.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'model/attribute'
-require_relative 'model/association'
+require_relative 'model/associations'
 require_relative 'model/enum'
 
 module Sumaki
@@ -164,7 +164,7 @@ module Sumaki
       base.include InstanceMethods
 
       base.include Attribute
-      base.include Association
+      base.include Associations
       base.include Enum
     end
 
@@ -177,6 +177,33 @@ module Sumaki
       end
     end
 
+    class ObjectAccessor # :nodoc:
+      def initialize(object, adapter)
+        @object = object
+        @adapter = adapter
+      end
+
+      def get(name)
+        @adapter.get(@object, name)
+      end
+
+      def set(name, value)
+        @adapter.set(@object, name, value)
+      end
+
+      def build_singular(name)
+        @adapter.build_singular(@object, name)
+      end
+
+      def build_repeated_element(name)
+        @adapter.build_repeated_element(@object, name)
+      end
+
+      def apply_repeated(name, models)
+        @adapter.apply_repeated(@object, name, models.map(&:object))
+      end
+    end
+
     module InstanceMethods # :nodoc:
       attr_reader :object, :parent
 
@@ -184,6 +211,43 @@ module Sumaki
         @object = object
         @parent = parent
       end
+
+      def object_accessor
+        @object_accessor ||= ObjectAccessor.new(object, self.class.adapter)
+      end
+
+      def get(name)
+        object_accessor.get(name)
+      end
+
+      def set(name, value)
+        object_accessor.set(name, value)
+      end
+
+      def assign(attrs)
+        attrs.each do |attr, value|
+          public_send(:"#{attr}=", value)
+        end
+      end
+
+      def inspect
+        inspection = fields
+                     .map { |name, value| "#{name}: #{value.inspect}" }
+                     .join(', ')
+        "#<#{self.class.name} #{inspection}>"
+      end
+
+      def pretty_print(pp)
+        pp.object_address_group(self) do
+          pp.seplist(fields) do |field, value|
+            pp.breakable
+            pp.group(1) do
+              pp.text "#{field}: "
+              pp.pp value
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/sumaki/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sumaki
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sumaki
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Loose Coupling
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-23 00:00:00.000000000 Z
+date: 2024-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minenum
@@ -48,7 +48,10 @@ files:
 - lib/sumaki/adapter/hash.rb
 - lib/sumaki/config.rb
 - lib/sumaki/model.rb
-- lib/sumaki/model/association.rb
+- lib/sumaki/model/associations.rb
+- lib/sumaki/model/associations/association.rb
+- lib/sumaki/model/associations/collection.rb
+- lib/sumaki/model/associations/reflection.rb
 - lib/sumaki/model/attribute.rb
 - lib/sumaki/model/enum.rb
 - lib/sumaki/version.rb

data/lib/sumaki/model/association.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Sumaki
-  module Model
-    # = Sumaki::Model::Association
-    module Association
-      def self.included(base)
-        base.extend ClassMethods
-        base.include InstanceMethods
-
-        base.instance_variable_set(:@classes, {})
-      end
-
-      module ClassMethods # :nodoc:
-        # Access to the sub object.
-        #
-        #   class Book
-        #     include Sumaki::Model
-        #     singular :company
-        #
-        #     class Company
-        #       include Sumaki::Model
-        #     end
-        #   end
-        #
-        #   data = {
-        #     title: 'The Ronaldo Chronicles',
-        #     company: {
-        #       name: 'Autumn Books',
-        #     }
-        #   }
-        #   book = Book.new(data)
-        #   book.company.class #=> Book::Company
-        #
-        # == Options
-        #
-        # [:class_name]
-        #   Specify the name of the class to wrap. Use this if the name of the class
-        #   to wrap is not inferred from the nested field names.
-        def singular(name, class_name: nil)
-          association_methods_module.define_method(name) do
-            klass = self.class.class_for(name, class_name)
-            klass.new(get(name), parent: self)
-          end
-        end
-
-        # Access to the repeated sub objects
-        #
-        #   class Company
-        #     include Sumaki::Model
-        #     repeated :member
-        #
-        #     class Member
-        #       include Sumaki::Model
-        #     end
-        #   end
-        #
-        #   data = {
-        #     name: 'The Ronaldo Vampire Hunter Agency',
-        #     member: [
-        #       { name: 'Ronaldo' },
-        #       { name: 'Draluc' },
-        #       { name: 'John' }
-        #     ]
-        #   }
-        #   company = Company.new(data)
-        #   company.member[2].class #=> Company::Member
-        #
-        # == Options
-        #
-        # [:class_name]
-        #   Specify the name of the class to wrap. Use this if the name of the class
-        #   to wrap is not inferred from the nested field names.
-        def repeated(name, class_name: nil)
-          association_methods_module.define_method(name) do
-            klass = self.class.class_for(name, class_name)
-            get(name).map { |object| klass.new(object, parent: self) }
-          end
-        end
-
-        def class_for(name, class_name = nil)
-          return @classes[name] if @classes.key?(name)
-
-          basename = class_name || classify(name.to_s)
-          klass = if const_defined?(basename)
-                    const_get(basename)
-                  else
-                    const_set(basename, Class.new { include Model })
-                  end
-          klass.parent ||= self
-          @classes[name] = klass
-        end
-
-        private
-
-        def association_methods_module
-          @association_methods_module ||= begin
-            mod = Module.new
-            include mod
-            mod
-          end
-        end
-
-        def classify(key)
-          key.gsub(/([a-z\d]+)_?/) { |_| Regexp.last_match(1).capitalize }
-        end
-      end
-
-      module InstanceMethods # :nodoc:
-        def get(name)
-          self.class.adapter.get(object, name)
-        end
-      end
-    end
-  end
-end