sumaki 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 743c9cc65c7fb7b06a254d6f96ccacd405101fbd87b12b9ba9a0283341f0203b
-  data.tar.gz: 922c9652b6a0bee5fcca21e261b653a8fe9362ad0ee174050f6a0e8fae9986d1
+  metadata.gz: 4cc5d96c3a979b46ace35c6bcae70136875b415af2dbe971f45731ff69aa61ff
+  data.tar.gz: dbae61d4d18b0c6e3034620ea3dbe77467b4133da5df1eb45b9d89c927d98504
 SHA512:
-  metadata.gz: 3d368a98fe977ba95aad3b0d01233a46eb00391e0c2825faa6b4fe9991b6394808a90dbfe37af1648ddf3bed13b904fb3dee72f5ee83237c4c0d876a628df660
-  data.tar.gz: 122196f48283f4e23f3a9ba52d84aff764487066016da59bb42e5fe5e405780bde902f41bf45bc25ead3b6fcc5347935b786d4723e17328f137052b0ff0836ed
+  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,70 +1,91 @@
 PATH
   remote: .
   specs:
-    sumaki (0.1.0)
+    sumaki (0.3.0)
+      minenum
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
-    debug (1.7.1)
-      irb (>= 1.5.0)
-      reline (>= 0.3.1)
-    diff-lcs (1.5.0)
+    debug (1.9.2)
+      irb (~> 1.10)
+      reline (>= 0.3.8)
+    diff-lcs (1.5.1)
     docile (1.4.0)
-    io-console (0.6.0)
-    irb (1.6.2)
-      reline (>= 0.3.0)
-    json (2.6.3)
-    parallel (1.22.1)
-    parser (3.2.0.0)
+    io-console (0.7.2)
+    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.1.0)
       ast (~> 2.4.1)
+      racc
+    psych (5.1.2)
+      stringio
+    racc (1.7.3)
     rainbow (3.1.1)
-    rake (13.0.6)
-    regexp_parser (2.6.2)
-    reline (0.3.2)
+    rake (13.2.1)
+    rdoc (6.6.3.1)
+      psych (>= 4.0.0)
+    regexp_parser (2.9.2)
+    reline (0.5.7)
       io-console (~> 0.5)
-    rexml (3.2.5)
-    rspec (3.12.0)
-      rspec-core (~> 3.12.0)
-      rspec-expectations (~> 3.12.0)
-      rspec-mocks (~> 3.12.0)
-    rspec-core (3.12.0)
-      rspec-support (~> 3.12.0)
-    rspec-expectations (3.12.2)
+    rexml (3.2.8)
+      strscan (>= 3.0.9)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-mocks (3.12.3)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.12.0)
-    rspec-support (3.12.0)
-    rubocop (1.44.1)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    rubocop (1.63.5)
       json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
-      parser (>= 3.2.0.0)
+      parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.24.1, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.24.1)
-      parser (>= 3.1.1.0)
-    rubocop-capybara (2.17.0)
+    rubocop-ast (1.31.3)
+      parser (>= 3.3.1.0)
+    rubocop-capybara (2.20.0)
       rubocop (~> 1.41)
-    rubocop-rspec (2.18.1)
-      rubocop (~> 1.33)
+    rubocop-factory_bot (2.25.1)
+      rubocop (~> 1.41)
+    rubocop-rspec (2.29.2)
+      rubocop (~> 1.40)
       rubocop-capybara (~> 2.17)
-    ruby-progressbar (1.11.0)
+      rubocop-factory_bot (~> 2.22)
+      rubocop-rspec_rails (~> 2.28)
+    rubocop-rspec_rails (2.28.3)
+      rubocop (~> 1.40)
+    ruby-progressbar (1.13.0)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    unicode-display_width (2.4.2)
+    stringio (3.1.0)
+    strscan (3.1.0)
+    unicode-display_width (2.5.0)
 
 PLATFORMS
+  ruby
   x86_64-linux
 
 DEPENDENCIES
@@ -77,4 +98,4 @@ DEPENDENCIES
   sumaki!
 
 BUNDLED WITH
-   2.4.5
+   2.5.9

data/README.md

@@ -2,6 +2,8 @@
 
 ---
 
+[![Gem Version](https://badge.fury.io/rb/sumaki.svg)](https://badge.fury.io/rb/sumaki)
+![example workflow](https://github.com/nowlinuxing/sumaki/actions/workflows/main.yml/badge.svg?branch=main)
 [![Maintainability](https://api.codeclimate.com/v1/badges/dd92d4092d6858cbcfb2/maintainability)](https://codeclimate.com/github/nowlinuxing/sumaki/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/dd92d4092d6858cbcfb2/test_coverage)](https://codeclimate.com/github/nowlinuxing/sumaki/test_coverage)
 
@@ -91,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
@@ -112,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.
 
@@ -170,7 +190,9 @@ class Company
     field :name
   end
 end
+```
 
+```ruby
 data = {
   name: 'The Ronaldo Vampire Hunter Agency',
   member: [
@@ -180,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
@@ -223,16 +253,27 @@ By declaring `enum`, You can map a field to the specified value.
 class Character
   include Sumaki::Model
   field :name
-  enum :type, vampire: 1, vampire_hunter: 2, familier: 3, editor: 4
+  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
 ```
 
 
@@ -244,7 +285,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sumaki.
+Bug reports and pull requests are welcome on GitHub at https://github.com/nowlinuxing/sumaki.
 
 ## License
 

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

@@ -1,33 +1,25 @@
 # frozen_string_literal: true
 
+require 'minenum'
+
 module Sumaki
   module Model
     # = Sumaki::Model::Enum
     module Enum
       def self.included(base)
+        base.include Minenum::Model
         base.extend ClassMethods
       end
 
-      class EnumValue < Hash # :nodoc:
-        code = <<-RUBY
-          case value
-          when Symbol then super(value) || super(value.to_s)
-          when String then super(value) || super(value.to_sym)
-          else super(value)
-          end
-        RUBY
-
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
-          def key?(value); #{code}; end
-        RUBY
-
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
-          def key(value); #{code}; end
-        RUBY
+      module EnumAttrAccessor # :nodoc:
+        def get(model, name)
+          model.get(name)
+        end
 
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
-          def value?(value); #{code}; end
-        RUBY
+        def set(model, name, value)
+          model.set(name, value)
+        end
+        module_function :get, :set
       end
 
       module ClassMethods # :nodoc:
@@ -36,7 +28,7 @@ module Sumaki
         #   class Character
         #     include Sumaki::Model
         #     field :name
-        #     enum :type, vampire: 1, vampire_hunter: 2, familier: 3, editor: 4
+        #     enum :type, { vampire: 1, vampire_hunter: 2, familier: 3, editor: 4 }
         #   end
         #
         #   data = {
@@ -45,19 +37,17 @@ module Sumaki
         #   }
         #
         #   character = Character.new(data)
-        #   character.type #=> :familier
-        def enum(name, **values)
-          values = EnumValue[values]
-
-          enum_methods_module.define_method(name) do
-            value = get(name)
-
-            if values.key?(value)
-              value
-            elsif values.value?(value)
-              values.key(value)
-            end
-          end
+        #   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
 
         private

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.1.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sumaki
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Loose Coupling
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-19 00:00:00.000000000 Z
-dependencies: []
+date: 2024-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minenum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Sumaki is a wrapper for structured data like JSON.
   Since Sumaki wraps the target data as it is, rather than parsing it using a schema, the original data can be referenced at any time.
@@ -34,12 +48,14 @@ 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
 - sig/sumaki.rbs
-- sumaki.gemspec
 homepage: https://github.com/nowlinuxing/sumaki/
 licenses:
 - MIT
@@ -57,14 +73,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Sumaki is a wrapper for structured data like JSON.

data/lib/sumaki/model/association.rb

@@ -1,118 +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:
-        private
-
-        def get(name)
-          self.class.adapter.get(object, name)
-        end
-      end
-    end
-  end
-end

data/sumaki.gemspec

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/sumaki/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'sumaki'
-  spec.version = Sumaki::VERSION
-  spec.authors = ['Loose Coupling']
-  spec.email = ['loosecpl@gmail.com']
-
-  spec.summary = 'Sumaki is a wrapper for structured data like JSON.'
-  spec.description = <<~DESC
-    Sumaki is a wrapper for structured data like JSON.
-    Since Sumaki wraps the target data as it is, rather than parsing it using a schema, the original data can be referenced at any time.
-    This makes it easy to add or modify definitions as needed while checking the target data.
-    This feature may be useful when there is no document defining the structure of the data, or when the specification is complex and difficult to grasp, and the definition is written little by little starting from the obvious places.
-  DESC
-  spec.homepage = 'https://github.com/nowlinuxing/sumaki/'
-  spec.license = 'MIT'
-  spec.required_ruby_version = '>= 2.6.0'
-
-  spec.metadata['allowed_push_host'] = 'https://rubygems.org/'
-
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = spec.homepage
-  spec.metadata['changelog_uri'] = spec.homepage
-  spec.metadata['rubygems_mfa_required'] = 'true'
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
-    end
-  end
-  spec.bindir = 'exe'
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
-end