sumaki 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b7187ea951d6b5b682b054303d696ce2c65e205519c151aed52a7e6a542cdf7
-  data.tar.gz: 70631c497947954364961b3fde444bcc56be61b534687826872cab5efa139e86
+  metadata.gz: 23a3806fcf2a27686f82307a043ef96e36efc90fe73fa2f0da6bba0b1c4506dc
+  data.tar.gz: 3602002eaab7328a7b331add996774487687aa310aa06bdea99e84746544fca1
 SHA512:
-  metadata.gz: a913803fdde6db3a69bce4ad967048673c6d3b089d05265029d21e09074b817d45cb7b3c2f1570cc50e3ec034bdb85420eb7f38a0b6625803d2054bbb4fad733
-  data.tar.gz: 355746b7f56600a79023a056aaaee86a599f9b5951b371b8b6a600086428cf392528f8447bc03f71f3173a91cd939b661d1134cb80cae4d99c993053e9973987
+  metadata.gz: 9c5104b11ef1d3029c8f3e0e5795279a9ae82061c61d2e6b15f4f9fb62629c4a99fb362ec4818959827da4a10034b4024442092c0f0aa0fb056cdae1c1333197
+  data.tar.gz: f3e582ba5ccafc8a44f1ef66a48df31c2ea1b5e95ef434b958b42647218f5a593dfb13c9aa0cb899e63356313e7a42118ced4445a2a426d70438db3f5da0b70a

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.4.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,14 +93,48 @@ 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.
 
+#### Type casting
+
+When a type is specified, it will be typecast.
+
+```ruby
+class Character
+  include Sumaki::Model
+
+  field :age, :int
+end
+
+character = Character.new({ age: '208' })
+character.age #=> 208
+```
+
+Types are:
+
+* `:int`
+* `:float`
+* `:string`
+* `:bool`
+* `:date`
+* `:datetime`
+
 ### Access to the sub object
 
 By declaring `singular`, you can access the sub object.
@@ -114,23 +148,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'
 ```
 
-sub object is wrapped with the class inferred from the field name under the original class.
+```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.
 
 This can be changed by specifying the class to wrap.
 
@@ -172,7 +214,9 @@ class Company
     field :name
   end
 end
+```
 
+```ruby
 data = {
   name: 'The Ronaldo Vampire Hunter Agency',
   member: [
@@ -182,11 +226,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 +279,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/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/fields/reflection.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'type'
+
+module Sumaki
+  module Model
+    module Fields
+      class Reflection # :nodoc:
+        def initialize(name, type = nil)
+          @name = name
+          @type = type
+        end
+
+        def name
+          @name.to_sym
+        end
+
+        def type_class
+          @type_class ||= @type.nil? ? Type::Value : Type.lookup(@type)
+        end
+      end
+    end
+  end
+end

data/lib/sumaki/model/fields/type/boolean.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+
+module Sumaki
+  module Model
+    module Fields
+      module Type
+        class Boolean < Value # :nodoc:
+          def self.serialize(value)
+            return if value.nil?
+
+            case value
+            when true  then true
+            when false then false
+            else
+              raise ArgumentError
+            end
+          end
+
+          def self.deserialize(value)
+            case value
+            when true  then true
+            when false then false
+            end
+          end
+        end
+      end
+    end
+  end
+end