sumaki 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cc5d96c3a979b46ace35c6bcae70136875b415af2dbe971f45731ff69aa61ff
-  data.tar.gz: dbae61d4d18b0c6e3034620ea3dbe77467b4133da5df1eb45b9d89c927d98504
+  metadata.gz: dc2e15ea308cacd7c524ba33698734f08020c2c9d6fb9b39accb4c79bc108a67
+  data.tar.gz: 1090e186dd028117e5f6cb7df816004dcc9508313757e6af8b802d6eeef74a2d
 SHA512:
-  metadata.gz: 9a7ecf9d761bf8b6f8ff2b5236090f83105795dcb78e45d27c109a7377ead5ed323a38e51a6b3be5996bedd95917e7676e13894dd16517bac180de6ea589be6f
-  data.tar.gz: 1c3624fdf113f3d260e58e00f68c96f51abcdac1fe1f55e7f30ec93a3b62159b3a051618a3bfe4b9c791f66499d6160429083c73eb90d2661d97e027c74c0f16
+  metadata.gz: 720e0a53bf096093e5e25c5b2dbd2d562666e696d274147d1b3634e49a350309be22b1ada5e069c43f23025e4fdeafbde25c7a9f0b8a4f2d05ffc47fcc7a25d6
+  data.tar.gz: e00e0ef3b7f0af18c438e680e4bfdc40aa83b3409853c5cc587c529b43c9c2f73cd9ad72d0e383d738fbe8879247a8f25beb829001daa3d397e836f1486850a6

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    sumaki (0.3.0)
-      minenum
+    sumaki (0.5.0)
+      minenum (>= 0.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -19,7 +19,7 @@ GEM
       reline (>= 0.4.2)
     json (2.7.2)
     language_server-protocol (3.17.0.3)
-    minenum (0.1.0)
+    minenum (0.2.0)
     parallel (1.24.0)
     parser (3.3.1.0)
       ast (~> 2.4.1)

data/README.md

@@ -111,6 +111,30 @@ 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.
@@ -274,6 +298,12 @@ character.type.familier? #=> true
 character = Character.new({})
 character.type = 1
 character.type.name #=> :vampire
+
+character.type = :vampire_hunter
+character.type.name #=> :vampire_hunter
+
+character.type.familier!
+character.type.name #=> :familier
 ```
 
 

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

@@ -18,8 +18,8 @@ module Sumaki
           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)
+              klass = if @owner_class.const_defined?(basename, false)
+                        @owner_class.const_get(basename, false)
                       else
                         @owner_class.const_set(basename, Class.new { include Model })
                       end

data/lib/sumaki/model/enum.rb

@@ -11,15 +11,14 @@ module Sumaki
         base.extend ClassMethods
       end
 
-      module EnumAttrAccessor # :nodoc:
-        def get(model, name)
-          model.get(name)
+      class EnumAttrAccessor < Minenum::Enum::Adapter::Base # :nodoc:
+        def get
+          @enum_object.get(@name)
         end
 
-        def set(model, name, value)
-          model.set(name, value)
+        def set(value)
+          @enum_object.set(@name, value)
         end
-        module_function :get, :set
       end
 
       module ClassMethods # :nodoc:
@@ -47,7 +46,7 @@ module Sumaki
         #   character.type = 1
         #   character.type.name #=> :vampire
         def enum(name, values)
-          super(name, values, adapter: EnumAttrAccessor)
+          super(name, values, adapter_builder: EnumAttrAccessor)
         end
 
         private

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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+require 'date'
+
+module Sumaki
+  module Model
+    module Fields
+      module Type
+        class DateError < Error; end
+
+        class Date < Value # :nodoc:
+          def self.serialize(value)
+            value.nil? ? nil : cast(value)
+          rescue ::Date::Error
+            raise DateError
+          end
+
+          def self.deserialize(value)
+            value.nil? ? nil : cast(value)
+          rescue ::Date::Error
+            nil
+          end
+
+          def self.cast(value)
+            return value.to_date if value.respond_to?(:to_date)
+
+            ::Date.parse(value.to_s)
+          end
+          private_class_method :cast
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+require 'date'
+
+module Sumaki
+  module Model
+    module Fields
+      module Type
+        class DateError < Error; end
+
+        class DateTime < Value # :nodoc:
+          def self.serialize(value)
+            value.nil? ? nil : cast(value)
+          rescue ::Date::Error
+            raise DateError
+          end
+
+          def self.deserialize(value)
+            value.nil? ? nil : cast(value)
+          rescue ::Date::Error
+            nil
+          end
+
+          def self.cast(value)
+            return value.to_datetime if value.respond_to?(:to_datetime)
+
+            ::DateTime.parse(value.to_s)
+          end
+          private_class_method :cast
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+
+module Sumaki
+  module Model
+    module Fields
+      module Type
+        class Float < Value # :nodoc:
+          def self.serialize(value)
+            try_casting do
+              value.nil? ? nil : Float(value)
+            end
+          end
+
+          def self.deserialize(value)
+            value.nil? ? nil : Float(value, exception: false)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+
+module Sumaki
+  module Model
+    module Fields
+      module Type
+        class Integer < Value # :nodoc:
+          def self.serialize(value)
+            try_casting do
+              value.nil? ? nil : Integer(value)
+            end
+          end
+
+          def self.deserialize(value)
+            value.nil? ? nil : Integer(value, exception: false)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+
+module Sumaki
+  module Model
+    module Fields
+      module Type
+        class String < Value # :nodoc:
+          def self.serialize(value)
+            try_casting do
+              value.nil? ? nil : String(value)
+            end
+          end
+
+          def self.deserialize(value)
+            value.nil? ? nil : String(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sumaki
+  module Model
+    module Fields
+      module Type
+        class Error < StandardError; end
+        class ArgumentError < Error; end
+        class TypeError < Error; end
+
+        class Value # :nodoc:
+          def self.serialize(value)
+            value
+          end
+
+          def self.deserialize(value)
+            value
+          end
+
+          def self.try_casting
+            yield
+          rescue ::ArgumentError
+            raise Type::ArgumentError
+          rescue ::TypeError
+            raise Type::TypeError
+          end
+          private_class_method :try_casting
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'type/value'
+require_relative 'type/integer'
+require_relative 'type/float'
+require_relative 'type/string'
+require_relative 'type/boolean'
+require_relative 'type/date'
+require_relative 'type/date_time'
+
+module Sumaki
+  module Model
+    module Fields
+      module Type # :nodoc:
+        class Types # :nodoc:
+          def initialize
+            @types = {}
+          end
+
+          def register(name, type_class)
+            @types[name] = type_class
+          end
+
+          def lookup(type_name)
+            @types.fetch(type_name)
+          end
+        end
+
+        @types = Types.new
+
+        def register(...)
+          @types.register(...)
+        end
+
+        def lookup(...)
+          @types.lookup(...)
+        end
+
+        module_function :register, :lookup
+
+        register(:int, Integer)
+        register(:float, Float)
+        register(:string, String)
+        register(:bool, Boolean)
+        register(:date, Date)
+        register(:datetime, DateTime)
+      end
+    end
+  end
+end

data/lib/sumaki/model/fields.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative 'fields/reflection'
+
+module Sumaki
+  module Model
+    # = Sumaki::Model::Fields
+    module Fields
+      def self.included(base)
+        base.extend ClassMethods
+        base.include InstanceMethods
+      end
+
+      class FieldAccessor # :nodoc:
+        def initialize(model)
+          @model = model
+        end
+
+        def get(field_name)
+          reflection = @model.class.field_reflections[field_name]
+
+          value = @model.get(reflection.name)
+          reflection.type_class.deserialize(value)
+        end
+
+        def set(field_name, value)
+          reflection = @model.class.field_reflections[field_name]
+
+          serialized = reflection.type_class.serialize(value)
+          @model.set(reflection.name, serialized)
+        end
+      end
+
+      module AccessorAdder # :nodoc:
+        def add(model_class, methods_module, reflection)
+          add_getter(methods_module, reflection.name)
+          add_setter(methods_module, reflection.name)
+
+          model_class.field_reflections[reflection.name] = reflection
+        end
+
+        def add_getter(methods_module, field_name)
+          methods_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{field_name}                      # def title
+              field_accessor.get(:'#{field_name}') #   field_accessor.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)
+              field_accessor.set(:'#{field_name}', value) #   field_accessor.set(:'title', value)
+            end                                           # end
+          RUBY
+        end
+        module_function :add, :add_getter, :add_setter
+      end
+
+      module ClassMethods # :nodoc:
+        # Access to the field.
+        #
+        #   class Anime
+        #     include Sumaki::Model
+        #     field :title
+        #     field :url
+        #   end
+        #
+        #   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'
+        #
+        # == Type casting
+        #
+        # When a type is specified, it will be typecast.
+        #
+        #   class Character
+        #     include Sumaki::Model
+        #
+        #     field :age, :int
+        #   end
+        #
+        #   character = Character.new({ age: '208' })
+        #   character.age #=> 208
+        #
+        # Types are:
+        #
+        # * <tt>:int</tt>
+        # * <tt>:float</tt>
+        # * <tt>:string</tt>
+        # * <tt>:bool</tt>
+        # * <tt>:date</tt>
+        # * <tt>:datetime</tt>
+        def field(name, type = nil)
+          reflection = Reflection.new(name, type)
+          AccessorAdder.add(self, attribute_methods_module, reflection)
+        end
+
+        def field_names
+          field_reflections.keys
+        end
+
+        def field_reflections
+          @field_reflections ||= {}
+        end
+
+        private
+
+        def attribute_methods_module
+          @attribute_methods_module ||= begin
+            mod = Module.new
+            include mod
+            mod
+          end
+        end
+      end
+
+      module InstanceMethods # :nodoc:
+        def fields
+          self.class.field_names.map.with_object({}) { |e, r| r[e] = public_send(e) }
+        end
+
+        private
+
+        def field_accessor
+          @field_accessor ||= FieldAccessor.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/sumaki/model.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'model/attribute'
+require_relative 'model/fields'
 require_relative 'model/associations'
 require_relative 'model/enum'
 
@@ -163,7 +163,7 @@ module Sumaki
       base.extend ClassMethods
       base.include InstanceMethods
 
-      base.include Attribute
+      base.include Fields
       base.include Associations
       base.include Enum
     end
@@ -237,12 +237,14 @@ module Sumaki
         "#<#{self.class.name} #{inspection}>"
       end
 
-      def pretty_print(pp)
+      def pretty_print(pp) # rubocop:disable Metrics/MethodLength
         pp.object_address_group(self) do
-          pp.seplist(fields) do |field, value|
+          pp.seplist(fields, -> { pp.text ',' }) do |field, value|
             pp.breakable
             pp.group(1) do
-              pp.text "#{field}: "
+              pp.text field.to_s
+              pp.text ':'
+              pp.breakable
               pp.pp value
             end
           end

data/lib/sumaki/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sumaki
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Loose Coupling
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-17 00:00:00.000000000 Z
+date: 2024-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minenum
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.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.
@@ -52,8 +52,17 @@ files:
 - 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/model/fields.rb
+- lib/sumaki/model/fields/reflection.rb
+- lib/sumaki/model/fields/type.rb
+- lib/sumaki/model/fields/type/boolean.rb
+- lib/sumaki/model/fields/type/date.rb
+- lib/sumaki/model/fields/type/date_time.rb
+- lib/sumaki/model/fields/type/float.rb
+- lib/sumaki/model/fields/type/integer.rb
+- lib/sumaki/model/fields/type/string.rb
+- lib/sumaki/model/fields/type/value.rb
 - lib/sumaki/version.rb
 - sig/sumaki.rbs
 homepage: https://github.com/nowlinuxing/sumaki/

data/lib/sumaki/model/attribute.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Sumaki
-  module Model
-    # = Sumaki::Model::Attribute
-    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:
-        # Access to the field.
-        #
-        #   class Anime
-        #     include Sumaki::Model
-        #     field :title
-        #     field :url
-        #   end
-        #
-        #   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)
-          field_names << name.to_sym
-          AccessorAdder.add(attribute_methods_module, name)
-        end
-
-        def field_names
-          @field_names ||= []
-        end
-
-        private
-
-        def attribute_methods_module
-          @attribute_methods_module ||= begin
-            mod = Module.new
-            include mod
-            mod
-          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