minenum 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62775a6aa94437fc897c0ced4c9f7209cd279ab4c51f55793c3dbd218a4cf492
-  data.tar.gz: 5fd974a1b3efb463a6b39aea2a5206c7acc013c729acdc80a590e0e6b1011e3c
+  metadata.gz: e30a7b63806d1b89941d7297d647ff2c023ec029f703e4522d4575f4bffa356e
+  data.tar.gz: 627051960b7b12cb639b4a11255bb570037dfa1c427ff2ea80ca4f5ef047a416
 SHA512:
-  metadata.gz: 8c75161d38a61f3e67c83f7ade775ea3c9de48fc9f1a90f991c77835f6469be11bd3bbbf947a3fe7cd5d375ada00d8a56be320565c6516eb4fd62bf31d25f912
-  data.tar.gz: 9706434cf641116c550cc341686059721495ec9dcb9528077562fccd90e5f08ea6f45fd7dc39caaa0990a74282b06accd63e48052fb03181b6f5f76a06cfd705
+  metadata.gz: 2b8856a071493ce14759178492992bf0578e75a71b6d10d992573caba2979b8d3027fd7b1a80f34639e598f575479ee776dfd39c5c28fefdd67003d6f94679a8
+  data.tar.gz: 6eddef5145f0b90c81d0a188a62dbad5fb171f9cb5b21adcc0ab854fba993e35306c498ffad9955f912d84cdace9fc55849a78076beb381377fbd2ebd8f5bff9

data/README.md

@@ -1,3 +1,6 @@
+[![Maintainability](https://api.codeclimate.com/v1/badges/04440479daa0ecea68de/maintainability)](https://codeclimate.com/github/nowlinuxing/minenum/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/04440479daa0ecea68de/test_coverage)](https://codeclimate.com/github/nowlinuxing/minenum/test_coverage)
+
 # Minenum
 
 Minenum is a gem that enhances Ruby objects by adding enum functionality and returning enum objects as return values. Enums simplify representing states or types within a specific range of values and can be returned directly from methods.
@@ -37,6 +40,10 @@ shirt.size.small? #=> true
 shirt.size = :medium
 shirt.size.name #=> :medium
 shirt.size.medium? #=> true
+
+# Call bang method to change the enum value
+shirt.size.small!
+shirt.size.small? #=> true
 ```
 
 ```ruby

data/Steepfile

@@ -6,4 +6,5 @@ target :lib do
   signature 'sig'
 
   check 'lib'
+  library 'forwardable'
 end

data/lib/minenum/enum/adapter/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Minenum
+  module Enum
+    module Adapter
+      class Base # :nodoc:
+        def self.build(enum_object, name)
+          new(enum_object, name)
+        end
+
+        def initialize(enum_object, name)
+          @enum_object = enum_object
+          @name = name
+        end
+
+        def get
+          raise NotImplementedError
+        end
+
+        def set(_value)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/minenum/enum/adapter/local_instance_variable_accessor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Minenum
+  module Enum
+    module Adapter
+      class LocalInstanceVariableAccessor < Base # :nodoc:
+        def initialize(enum_object = nil, name = nil)
+          super
+          @value = nil
+        end
+
+        def get
+          @value
+        end
+
+        def set(value)
+          @value = value
+        end
+      end
+    end
+  end
+end

data/lib/minenum/enum/base.rb

@@ -1,13 +1,42 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+require_relative 'adapter/local_instance_variable_accessor'
+
 module Minenum
   module Enum
     class Base # :nodoc:
-      attr_reader :value
+      extend Forwardable
+
+      singleton_class.attr_reader :_values
+
+      alias _inspect inspect
+      def_delegators :name, :to_s, :to_sym, :inspect, :pretty_print
+
+      def self.values
+        _values.values
+      end
+
+      def initialize(adapter = Adapter::LocalInstanceVariableAccessor.new)
+        @adapter = adapter
+      end
+
+      def name
+        self.class._values.key(_raw_value)
+      end
+
+      def value
+        self.class._values.value(_raw_value)
+      end
+
+      def value=(value)
+        @adapter.set(self.class._values.value(value))
+      end
+
+      private
 
-      def initialize(value)
-        @value = value
-        freeze
+      def _raw_value
+        @adapter.get
       end
     end
   end

data/lib/minenum/enum/class_builder.rb

@@ -17,34 +17,34 @@ module Minenum
       def build
         values = Values.new(@values)
 
-        klass = Class.new(Base)
-        add_values_method(klass, values)
-        add_name_method(klass, values)
-        add_predicate_methods(klass, values)
+        klass = Class.new(Base) do
+          @_values = values
+        end
+
+        values.each_key do |key|
+          add_predicate_method(klass, key)
+          add_bang_method(klass, key)
+        end
 
         klass
       end
 
       private
 
-      def add_values_method(klass, values)
-        klass.singleton_class.define_method(:values) do
-          values.values
-        end
-      end
-
-      def add_name_method(klass, values)
-        klass.define_method(:name) do
-          values.key(@value)
-        end
+      def add_predicate_method(klass, key)
+        klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{key}?                                   # def small?
+            self.class._values.match?(:'#{key}', value) #   self.class._values.match?(:'small', value)
+          end                                           # end
+        RUBY
       end
 
-      def add_predicate_methods(klass, values)
-        values.each_key do |key|
-          klass.define_method("#{key}?") do
-            values.match?(key, @value)
-          end
-        end
+      def add_bang_method(klass, key)
+        klass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{key}!              # def small!
+            self.value = :'#{key}' #   self.value = :'small'
+          end                      # end
+        RUBY
       end
     end
   end

data/lib/minenum/enum/values.rb

@@ -6,7 +6,7 @@ module Minenum
       attr_reader :values
 
       def initialize(values)
-        @values = values.transform_keys(&:to_sym).tap(&:freeze)
+        @values = values.transform_keys(&:to_sym).transform_values(&:freeze).tap(&:freeze)
         freeze
       end
 
@@ -15,37 +15,52 @@ module Minenum
       end
 
       def key(key_or_value)
-        if key_or_value.respond_to?(:to_sym) && (key_sym = key_or_value.to_sym) && @values.key?(key_sym)
-          key_sym
-        else
-          return @values.key(key_or_value) if @values.value?(key_or_value)
+        return key_or_value if @values.key?(key_or_value)
+        return @values.key(key_or_value) if @values.value?(key_or_value)
 
-          case key_or_value
-          when Symbol then @values.key(key_or_value.to_s)
-          when String then @values.key(key_or_value.to_sym)
-          end
-        end
+        return key_or_value.to_sym if match_as_key?(key_or_value)
+
+        find_by_key(key_or_value)
+      end
+
+      def value(key_or_value)
+        return @values.values.find { _1 == key_or_value } if @values.value?(key_or_value)
+        return @values[key_or_value] if @values.key?(key_or_value)
+
+        val = find_by_value(key_or_value)
+        return val if val
+
+        @values[key_or_value.to_sym] if match_as_key?(key_or_value)
       end
 
       def match?(key_name, key_or_value)
-        if key_or_value.respond_to?(:to_sym) && (key_sym = key_or_value.to_sym) && @values.key?(key_sym)
-          key_sym == key_name.to_sym
-        else
-          match_with_value?(key_name, key_or_value)
-        end
+        key(key_or_value) == key_name.to_sym
       end
 
       private
 
-      def match_with_value?(key_name, value)
-        registered_value = @values[key_name.to_sym]
-        return true if value == registered_value
+      def match_as_key?(key_or_value)
+        return false unless key_or_value.respond_to?(:to_sym)
+
+        @values.key?(key_or_value.to_sym)
+      end
+
+      def find_by_key(key_or_value)
+        case key_or_value
+        when Symbol then @values.key(key_or_value.to_s)
+        when String then @values.key(key_or_value.to_sym)
+        end
+      end
 
-        case value
-        when Symbol then value.to_s == registered_value
-        when String then value.to_sym == registered_value
-        else false
+      def find_by_value(key_or_value)
+        case key_or_value
+        when Symbol then value = key_or_value.to_s
+        when String then value = key_or_value.to_sym
+        else
+          return
         end
+
+        @values.values.find { _1 == value }
       end
     end
   end

data/lib/minenum/model/reflection.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../enum/class_builder'
+require_relative '../enum/adapter/local_instance_variable_accessor'
+
+module Minenum
+  module Model
+    class Reflection # :nodoc:
+      attr_reader :adapter_builder
+
+      def initialize(owner_class, name, values, adapter_builder: Enum::Adapter::LocalInstanceVariableAccessor)
+        @owner_class = owner_class
+        @name = name
+        @values = values
+
+        @adapter_builder = adapter_builder
+      end
+
+      def name
+        @name.to_sym
+      end
+
+      def enum_class
+        @enum_class ||= begin
+          basename = classify(@name.to_s)
+
+          if @owner_class.const_defined?(basename, false)
+            @owner_class.const_get(basename, false)
+          else
+            klass = Enum::ClassBuilder.build(@values)
+            @owner_class.const_set(basename, klass)
+          end
+        end
+      end
+
+      def build_enum(model)
+        adapter = @adapter_builder.build(model, @name)
+        enum_class.new(adapter)
+      end
+
+      private
+
+      def classify(key)
+        key.gsub(/([a-z\d]+)_?/) { ::Regexp.last_match(1)&.capitalize }
+      end
+    end
+  end
+end

data/lib/minenum/model.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'enum'
+require_relative 'enum/adapter/local_instance_variable_accessor'
+require_relative 'model/reflection'
 
 module Minenum
   # = Minenum
@@ -27,42 +29,56 @@ module Minenum
   #   Shirt.size.values #=> { small: 1, medium: 2, large: 3 }
   #
   module Model
-    module InstanceVariableAccessor # :nodoc:
-      def set(model, name, value)
-        enum = if model.instance_variable_defined?(:@_minenum_enum)
-                 model.instance_variable_get(:@_minenum_enum)
-               else
-                 model.instance_variable_set(:@_minenum_enum, {})
-               end
-        enum[name] = value
+    def self.included(base)
+      base.extend ClassMethods
+      base.include InstanceMethods
+    end
+
+    module AccessorAdder # :nodoc:
+      def add(model_class, methods_module, reflection)
+        add_singleton_method(model_class, reflection.name)
+
+        add_getter(methods_module, reflection.name)
+        add_setter(methods_module, reflection.name)
+
+        model_class._minenum_reflections[reflection.name] = reflection
       end
-      module_function :set
+      module_function :add
 
-      def get(model, name)
-        enum = model.instance_variable_get(:@_minenum_enum)
-        enum&.[](name)
+      def add_singleton_method(model_class, name)
+        model_class.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def self.#{name}                              # def self.size
+            _minenum_reflections[:'#{name}'].enum_class #   _minenum_reflections[:'size'].enum_class
+          end                                           # end
+        RUBY
       end
-      module_function :get
-    end
 
-    def self.included(base)
-      base.extend ClassMethods
+      def add_getter(methods_module, name)
+        methods_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{name}                 # def size
+            _minenum_enum(:'#{name}') #   _minenum_enum(:'size')
+          end                         # end
+        RUBY
+      end
+
+      def add_setter(methods_module, name)
+        methods_module.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{name}=(value)                       # def size=(value)
+            _minenum_enum(:'#{name}').value = value #   _minenum_enum(:'size').value = value
+          end                                       # end
+        RUBY
+      end
+      module_function :add_singleton_method, :add_getter, :add_setter
     end
 
     module ClassMethods # :nodoc:
-      def enum(name, values, adapter: InstanceVariableAccessor)
-        enum_class = Enum::ClassBuilder.build(values)
-
-        const_set(classify(name.to_s), enum_class)
-        singleton_class.define_method(name) { enum_class }
-
-        enum_methods_module.define_method("#{name}=") do |value|
-          adapter.set(self, name, value)
-        end
+      def enum(name, values, adapter_builder: Enum::Adapter::LocalInstanceVariableAccessor)
+        reflection = Reflection.new(self, name, values, adapter_builder: adapter_builder)
+        AccessorAdder.add(self, enum_methods_module, reflection)
+      end
 
-        enum_methods_module.define_method(name) do
-          enum_class.new(adapter.get(self, name))
-        end
+      def _minenum_reflections
+        @_minenum_reflections ||= {}
       end
 
       private
@@ -74,9 +90,14 @@ module Minenum
           mod
         end
       end
+    end
+
+    module InstanceMethods # :nodoc:
+      private
 
-      def classify(key)
-        key.gsub(/([a-z\d]+)_?/) { ::Regexp.last_match(1)&.capitalize }
+      def _minenum_enum(name)
+        @_minenum_enum ||= {}
+        @_minenum_enum[name.to_sym] ||= self.class._minenum_reflections[name.to_sym].build_enum(self)
       end
     end
   end

data/lib/minenum/version.rb

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

data/sig/minenum/enum/adapter/base.rbs

@@ -0,0 +1,24 @@
+module Minenum
+  module Enum
+    module Adapter
+      interface _AdapterBuilder
+        def build: (untyped, Symbol) -> Minenum::Enum::Adapter::Base
+      end
+
+      interface _Adapter
+        def get: -> untyped
+        def set: (untyped) -> untyped
+      end
+
+      class Base
+        extend _AdapterBuilder
+        include _Adapter
+
+        @enum_object: untyped
+        @name: String | Symbol
+
+        def initialize: (untyped, Symbol) -> void
+      end
+    end
+  end
+end

data/sig/minenum/enum/adapter/local_instance_variable_accessor.rbs

@@ -0,0 +1,13 @@
+module Minenum
+  module Enum
+    module Adapter
+      class LocalInstanceVariableAccessor
+        include Minenum::Enum::Adapter::_Adapter
+
+        @value: untyped
+
+        def initialize: (?untyped, ?Symbol) -> void
+      end
+    end
+  end
+end

data/sig/minenum/enum/base.rbs

@@ -1,9 +1,24 @@
 module Minenum
   module Enum
     class Base
-      attr_reader value: untyped
+      extend Forwardable
+
+      @adapter: Minenum::Enum::Adapter::_Adapter
+
+      attr_reader self._values: Minenum::Enum::Values
+
+      alias _inspect inspect
+
+      def self.values: -> Hash[Symbol, untyped]
 
       def initialize: (untyped) -> void
+      def name: -> Symbol?
+      def value: -> untyped
+      def value=: (untyped) -> untyped
+
+      private
+
+      def _raw_value: -> untyped
     end
   end
 end

data/sig/minenum/enum/class_builder.rbs

@@ -11,9 +11,8 @@ module Minenum
 
       private
 
-      def add_values_method: (untyped, Minenum::Enum::Values) -> void
-      def add_name_method: (untyped, Minenum::Enum::Values) -> void
-      def add_predicate_methods: (untyped, Minenum::Enum::Values) -> void
+      def add_predicate_method: (untyped, Symbol) -> void
+      def add_bang_method: (untyped, Symbol) -> void
     end
   end
 end

data/sig/minenum/enum/values.rbs

@@ -1,16 +1,21 @@
 module Minenum
   module Enum
     class Values
+      @values: Hash[Symbol, untyped]
+
       attr_reader values: Hash[Symbol, untyped]
 
       def initialize: (Hash[String | Symbol, untyped]) -> void
       def each_key: { (Symbol) -> untyped } -> Hash[String | Symbol, untyped]
       def key: (untyped) -> Symbol?
+      def value: (untyped) -> untyped
       def match?: (String | Symbol, untyped) -> bool
 
       private
 
-      def match_with_value?: (String | Symbol, untyped) -> bool
+      def match_as_key?: (untyped) -> bool
+      def find_by_key: (untyped) -> Symbol?
+      def find_by_value: (untyped) -> untyped
     end
   end
 end

data/sig/minenum/model/reflection.rbs

@@ -0,0 +1,22 @@
+module Minenum
+  module Model
+    class Reflection
+      @owner_class: untyped
+      @name: Symbol | String
+      @values: Hash[untyped, untyped]
+      @adapter: untyped
+      @enum_class: Minenum::Enum::Base
+
+      attr_reader adapter_builder: untyped
+
+      def initialize: (untyped, String | Symbol, Hash[untyped, untyped], ?adapter_builder: Minenum::Enum::Adapter::_AdapterBuilder) -> void
+      def name: -> Symbol
+      def enum_class: -> untyped
+      def build_enum: (untyped) -> untyped
+
+      private
+
+      def classify: (String) -> String
+    end
+  end
+end

data/sig/minenum/model.rbs

@@ -1,24 +1,29 @@
 module Minenum
   module Model
-    interface _Accessor
-      def set: (untyped model, String | Symbol name, untyped value) -> untyped
-      def get: (untyped model, String | Symbol name) -> untyped
-    end
-
-    module InstanceVariableAccessor
-      include _Accessor
+    module AccessorAdder
+      def self?.add: (untyped, untyped, Minenum::Model::Reflection) -> void
+      def self?.add_singleton_method: (untyped, Symbol) -> void
+      def self?.add_getter: (untyped, Symbol) -> void
+      def self?.add_setter: (untyped, Symbol) -> void
     end
 
     module ClassMethods
-      def enum: (String | Symbol name, Hash[String | Symbol, untyped], ?adapter: _Accessor) -> void
+      def enum: (String | Symbol name, Hash[String | Symbol, untyped], ?adapter_builder: Minenum::Enum::Adapter::_AdapterBuilder) -> void
+      def _minenum_reflections: -> Hash[Symbol, untyped]
 
       private
 
       def enum_methods_module: -> Module
-      def classify: (String) -> String
 
-      def const_set: [T] (String | Symbol, T) -> T
       def include: (Module) -> self
     end
+
+    module InstanceMethods
+      private
+
+      def _minenum_enum: (Symbol) -> untyped
+
+      def self._minenum_reflections: -> Hash[Symbol, untyped]
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minenum
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Loose Coupling
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-22 00:00:00.000000000 Z
+date: 2024-06-03 00:00:00.000000000 Z
 dependencies: []
 description: Enum for Ruby
 email:
@@ -26,17 +26,23 @@ files:
 - Steepfile
 - lib/minenum.rb
 - lib/minenum/enum.rb
+- lib/minenum/enum/adapter/base.rb
+- lib/minenum/enum/adapter/local_instance_variable_accessor.rb
 - lib/minenum/enum/base.rb
 - lib/minenum/enum/class_builder.rb
 - lib/minenum/enum/values.rb
 - lib/minenum/model.rb
+- lib/minenum/model/reflection.rb
 - lib/minenum/version.rb
 - minenum.gemspec
 - sig/minenum.rbs
+- sig/minenum/enum/adapter/base.rbs
+- sig/minenum/enum/adapter/local_instance_variable_accessor.rbs
 - sig/minenum/enum/base.rbs
 - sig/minenum/enum/class_builder.rbs
 - sig/minenum/enum/values.rbs
 - sig/minenum/model.rbs
+- sig/minenum/model/reflection.rbs
 homepage: https://github.com/nowlinuxing/minenum
 licenses:
 - MIT
@@ -60,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Enum for Ruby