enumy 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce0707d044a3a8c05c9d9989c190177ff349fca9440a2ac74e49522caa924948
-  data.tar.gz: 2a4058a520e603d800936498db7a6c586a9cdd1da8ab1c550c7ef9cd7864215b
+  metadata.gz: c5a41d5b566db44a73694cda348ebdafd92ba493df67811989767da5ded37a32
+  data.tar.gz: 650fea0c0613b094a3323122fc6e95b7b0df42e6ee16a748b8f062ab2fb3f712
 SHA512:
-  metadata.gz: 76fa6acec0c8dd849adf0924783ee2eab517c8b27673f681a32710e788089e2522a834c48e3aa013f7e42f5004028dfeb150a2af31c2c9e2ad6ddcf10caa4d06
-  data.tar.gz: c223050367c30eba0b51ea73900ad9c903cfe2edd0e3c79d99e5094a5a435209601dba6906e481f2734d2baecae499de2fb23ccddef346c949b83be7a9be2cc3
+  metadata.gz: 0c0bafe3cd2eec7e47741617d0455b208d168559d3a972ca9b800efa1a8edbd1e4a7b451b95ee949d218411696a2deef5a31bcd24029e0e08d138a4faa8c8ce0
+  data.tar.gz: 98f2c6f8d26fcfb6f2067c97ae205807e8cab6835b5fb992fa3ec7f8e0d3f3e63b04eb8417b7ebe5b12be52cf143852007304d0b8ed9c77edff3ff8363284116

data/lib/enumy/enum.rb

@@ -0,0 +1,65 @@
+require 'enumy/errors'
+
+module Enumy
+  class Enum
+
+    attr_reader :key
+
+    def initialize(key)
+      raise Errors::KeyMissingError.new(self) if key.nil?
+      @key = key.to_sym
+    end
+
+    def to_s
+      key.to_s
+    end
+
+    def inspect
+      attributes = instance_variables.map do |name|
+        value = instance_variable_get(name)
+        "#{name}: #{value.inspect}"
+      end
+
+      "#<#{self.class.name} #{attributes.join(', ')}>"
+    end
+
+    class << self
+
+      def define(enum)
+        raise ArgumentError, "Expected an object of type `Enumy::Enum`, got #{enum.class.name}" unless enum.is_a?(Enumy::Enum)
+
+        if instances[enum.key]
+          raise Errors::DuplicateEnumInstanceError, "Enum `#{enum.key.to_s.upcase}` is using a duplicate key `#{enum.key}` for Enum '#{enum.class.name}'."
+        else
+          instances[enum.key] = enum
+        end
+      end
+
+      def all
+        instances.values
+      end
+
+      def find(key)
+        find_by(key: key.to_sym) || raise(Errors::EnumNotFoundError.new("Could not find a `#{self.name}` enum with a `key` of #{key}"))
+      end
+
+      def find_by(**args)
+        raise ArgumentError, "`find_by` requires at least one key-value pair" if args.empty?
+
+        instances.values.find do |instance|
+          args.all? do |attr, value|
+            instance.send(attr) == value
+          end
+        end
+      end
+
+      private
+
+      def instances
+        @instances ||= {}
+      end
+
+    end
+
+  end
+end

data/lib/enumy/errors.rb

@@ -5,5 +5,11 @@ module Enumy
     class InvalidEnumClassError < NameError; end
     class DuplicateEnumInstanceError < ArgumentError; end
 
+    class KeyMissingError < ArgumentError
+      def initialize(enum)
+        super("#{enum.class.name.upcase} enum requires a `key`")
+      end
+    end
+
   end
 end

data/lib/enumy/model.rb

@@ -1,32 +1,47 @@
-require_relative 'base'
-require_relative 'errors'
+require 'enumy/enum'
+require 'enumy/errors'
 
 module Enumy
   module Model
-    def has_enum(name, class_name: name, **options)
-      enum_class = class_name.to_s.classify.safe_constantize
 
-      assert_valid_enum_type!(enum_class, class_name)
-      define_enum_attributes(name, enum_class, default: options[:default])
-      define_enum_validations(name, enum_class) unless options[:optional]
+    def has_enum(name, enum_class:, **options)
+      assert_valid_enum_type!(enum_class)
+      define_enum_methods(name, enum_class, default: options[:default])
+    end
+
+    def assert_valid_enum_value_type!(enum_class, enum)
+      return if enum.nil?
+      raise Errors::InvalidEnumClassError, "Expected instance of `#{enum_class}`, got instance of `#{enum.class}`" unless enum.is_a?(enum_class)
     end
 
     private
 
-    def define_enum_attributes(name, enum_class, **options)
-      attribute name, ActiveModel::Type::Enum.new(enum_class), default: -> { options[:default] }
-    end
+    def define_enum_methods(name, enum_class, default: nil)
+      assert_valid_enum_value_type!(enum_class, default)
 
-    def define_enum_validations(name, enum_class)
-      validates name, presence: true, inclusion: { in: enum_class.all }
-    end
+      define_method(name) do
+        instance_variable_set("@#{name}", default) unless instance_variable_defined?("@#{name}")
+        instance_variable_get("@#{name}")
+      end
 
-    def assert_valid_enum_type!(enum_class, class_name)
-      if enum_class.nil?
-        raise Errors::InvalidEnumClassError, "Could not resolve class `#{class_name.to_s.classify}`"
-      elsif !enum_class.ancestors.include?(Enumy::Base)
-        raise Errors::InvalidEnumClassError, "`#{enum_class.name}` does not inherit from `#{Enumy::Base.name}`"
+      define_method("#{name}=") do |value|
+        case value
+        when Enumy::Enum, NilClass
+          self.class.assert_valid_enum_value_type!(enum_class, value)
+          instance_variable_set("@#{name}", value)
+        when String, Symbol
+          enum = enum_class.find(value)
+          instance_variable_set("@#{name}", enum)
+        else
+          raise ArgumentError
+        end
       end
     end
+
+    def assert_valid_enum_type!(enum_class)
+      raise Errors::InvalidEnumClassError, "`#{enum_class}` is not a constant" unless enum_class.is_a?(Module)
+      raise Errors::InvalidEnumClassError, "`#{enum_class.name}` does not inherit from `#{Enumy::Enum.name}`" unless enum_class.ancestors.include?(Enumy::Enum)
+    end
+
   end
-end
+end

data/lib/enumy/rails/active_job/serializers/enum_serializer.rb

@@ -0,0 +1,30 @@
+require 'enumy/enum.rb'
+
+module Enumy
+  module Rails
+    module ActiveJob
+      module Serializers
+        class EnumSerializer < ::ActiveJob::Serializers::ObjectSerializer
+
+          def serialize(enum)
+            super({ class: enum.class.name, key: enum.key.to_s })
+          end
+
+          def deserialize(hash)
+            hash[:class].safe_constantize&.find_by(key: hash[:key].to_sym)
+          end
+
+          def serialize?(value)
+            value.is_a?(klass)
+          end
+
+          private
+
+          def klass
+            Enumy::Enum
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enumy/rails/active_model/type/enum.rb

@@ -0,0 +1,34 @@
+module Enumy
+  module Rails
+    module ActiveModel
+      module Type
+        class Enum < ::ActiveModel::Type::Value
+          def initialize(enum_class)
+            @enum_class = enum_class
+            super()
+          end
+
+          def cast(value)
+            value.is_a?(@enum_class) ? value : @enum_class.find_by(key: value&.to_sym)
+          end
+
+          def serialize(value)
+            if value.is_a?(@enum_class)
+              value.key.to_s
+            else
+              @enum_class.find_by(key: value&.to_sym) ? value&.to_s : nil
+            end
+          end
+
+          def deserialize(value)
+            value.is_a?(@enum_class) ? value : @enum_class.find_by(key: value&.to_sym)
+          end
+
+          def type
+            :enum
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enumy/rails/enum.rb

@@ -0,0 +1,47 @@
+require 'enumy/rails/initializer_interceptor'
+
+module Enumy
+  module Rails
+    class Enum < Enumy::Enum
+      include Enumy::Rails::InitializerInterceptor
+      include ::ActiveModel::Model
+      include ::ActiveModel::Attributes
+
+      attribute :key
+
+      def initialize(key, **attrs)
+        raise Errors::KeyMissingError.new(self) if key.nil?
+        super(key: key.to_sym, **attrs)
+      end
+
+      def titleize
+        key.to_s.titleize
+      end
+
+      def human_attribute_name(attribute)
+        I18n.t("#{self.class.i18n_scope}.attributes.models.#{self.class.model_name.i18n_key}/#{self.key}.#{attribute}")
+      end
+
+      def name
+        human_attribute_name(:key)
+      end
+
+      def inspect
+        "#<#{self.class.name} #{attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')}>"
+      end
+
+      class << self
+
+        def model_name
+          @model_name ||= ::ActiveModel::Name.new(self, nil, self.name.to_s)
+        end
+
+        def i18n_scope
+          :enum
+        end
+
+      end
+
+    end
+  end
+end

data/lib/enumy/rails/generators/enumy/install/install_generator.rb

@@ -0,0 +1,13 @@
+require "rails/generators"
+
+module Enumy
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_application_enum
+        template "app/enums/application_enum.rb", "app/enums/application_enum.rb"
+      end
+    end
+  end
+end

data/lib/enumy/rails/generators/enumy/install/templates/app/enums/application_enum.rb

@@ -0,0 +1,3 @@
+class ApplicationEnum < Enumy::Rails::Enum
+
+end

data/lib/enumy/rails/initializer_interceptor.rb

@@ -0,0 +1,12 @@
+module Enumy
+  module Rails
+    module InitializerInterceptor
+      def initialize
+        # Intentionally left blank to intercept the original initialize method
+        # We do this because we want to use ActiveModel::Attributes for attribute handling
+        # but ActiveModel::Attributes calls super without arguments,
+        # which would call the original initialize method without arguments and raise an error.
+      end
+    end
+  end
+end

data/lib/enumy/rails/model.rb

@@ -0,0 +1,34 @@
+require 'enumy/enum'
+require 'enumy/errors'
+
+module Enumy
+  module Rails
+    module Model
+      def has_enum(name, class_name: name, **options)
+        enum_class = class_name.to_s.classify.safe_constantize
+
+        assert_valid_enum_type!(enum_class, class_name)
+        define_enum_attributes(name, enum_class, default: options[:default])
+        define_enum_validations(name, enum_class) unless options[:optional]
+      end
+
+      private
+
+      def define_enum_attributes(name, enum_class, **options)
+        attribute name, ActiveModel::Type::Enum.new(enum_class), default: -> { options[:default] }
+      end
+
+      def define_enum_validations(name, enum_class)
+        validates name, presence: true, inclusion: { in: enum_class.all }
+      end
+
+      def assert_valid_enum_type!(enum_class, class_name)
+        if enum_class.nil?
+          raise Errors::InvalidEnumClassError, "Could not resolve class `#{class_name.to_s.classify}`"
+        elsif !enum_class.ancestors.include?(Enumy::Enum)
+          raise Errors::InvalidEnumClassError, "`#{enum_class.name}` does not inherit from `#{Enumy::Enum.name}`"
+        end
+      end
+    end
+  end
+end

data/lib/enumy/rails/railtie.rb

@@ -1,9 +1,9 @@
 module Enumy
-  class Railtie < Rails::Railtie
+  class Railtie < ::Rails::Railtie
     initializer "enumy.register_active_job_serializer" do |app|
-      if Rails::VERSION::MAJOR >= 6
-        require 'enumy/active_job/serializers/enum_serializer'
-        app.config.active_job.custom_serializers << Enumy::ActiveJob::Serializers::EnumSerializer
+      if ::Rails::VERSION::MAJOR >= 6
+        require 'enumy/rails/active_job/serializers/enum_serializer'
+        app.config.active_job.custom_serializers << Enumy::Rails::ActiveJob::Serializers::EnumSerializer
       end
     end
   end

data/lib/enumy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Enumy
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 end

data/lib/enumy.rb

@@ -1,15 +1,11 @@
 require 'enumy/version'
-
-if defined?(ActiveModel)
-  require 'enumy/base'
-end
+require 'enumy/enum'
+require 'enumy/model'
 
 if defined?(Rails)
-  require 'enumy/generators/enumy/install/install_generator'
-  require 'enumy/active_model/type/enum'
-  require 'enumy/model'
-
-  if defined?(Rails::Railtie)
-    require 'enumy/rails/railtie'
-  end
+  require 'enumy/rails/enum'
+  require 'enumy/rails/model'
+  require 'enumy/rails/generators/enumy/install/install_generator'
+  require 'enumy/rails/active_model/type/enum'
+  require 'enumy/rails/railtie'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: enumy
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Bevan Holborn
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -53,28 +52,28 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '7.0'
 description: Use Enumeration objects as ActiveRecord like associations
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/enumy.rb
-- lib/enumy/active_job/serializers/enum_serializer.rb
-- lib/enumy/active_model/type/enum.rb
-- lib/enumy/base.rb
+- lib/enumy/enum.rb
 - lib/enumy/errors.rb
-- lib/enumy/generators/enumy/install/install_generator.rb
-- lib/enumy/generators/enumy/install/templates/app/enums/application_enum.rb
 - lib/enumy/model.rb
+- lib/enumy/rails/active_job/serializers/enum_serializer.rb
+- lib/enumy/rails/active_model/type/enum.rb
+- lib/enumy/rails/enum.rb
+- lib/enumy/rails/generators/enumy/install/install_generator.rb
+- lib/enumy/rails/generators/enumy/install/templates/app/enums/application_enum.rb
+- lib/enumy/rails/initializer_interceptor.rb
+- lib/enumy/rails/model.rb
 - lib/enumy/rails/railtie.rb
-- lib/enumy/test_helpers.rb
 - lib/enumy/version.rb
 homepage: https://rubygems.org/gems/enumy
 licenses:
 - MIT
 metadata:
   source_code_uri: https://gitlab.com/BevanHolborn/enumy
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -89,8 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: ActiveRecord like enum associations
 test_files: []

data/lib/enumy/active_job/serializers/enum_serializer.rb

@@ -1,28 +0,0 @@
-require 'enumy/base.rb'
-
-module Enumy
-  module ActiveJob
-    module Serializers
-      class EnumSerializer < ::ActiveJob::Serializers::ObjectSerializer
-
-        def serialize(enum)
-          super({ class: enum.class.name, key: enum.key.to_s })
-        end
-
-        def deserialize(hash)
-          hash[:class].constantize.find_by_key(hash[:key])
-        end
-
-        def serialize?(value)
-          value.is_a?(klass)
-        end
-
-        private
-
-        def klass
-          Enumy::Base
-        end
-      end
-    end
-  end
-end

data/lib/enumy/active_model/type/enum.rb

@@ -1,32 +0,0 @@
-module Enumy
-  module ActiveModel
-    module Type
-      class Enum < ::ActiveModel::Type::Value
-        def initialize(enum_class)
-          @enum_class = enum_class
-          super()
-        end
-
-        def cast(value)
-          value.is_a?(@enum_class) ? value : @enum_class.find_by_key(value&.to_sym)
-        end
-
-        def serialize(value)
-          if value.is_a?(@enum_class)
-            value.key.to_s
-          else
-            @enum_class.find_by_key(value&.to_sym) ? value&.to_s : nil
-          end
-        end
-
-        def deserialize(value)
-          value.is_a?(@enum_class) ? value : @enum_class.find_by_key(value&.to_sym)
-        end
-
-        def type
-          :enum
-        end
-      end
-    end
-  end
-end

data/lib/enumy/base.rb

@@ -1,87 +0,0 @@
-require_relative 'errors'
-
-module Enumy
-  class Base
-    include ::ActiveModel::Model
-    include ::ActiveModel::Attributes
-
-    attribute :key
-
-    def initialize(key, **attrs)
-      raise ArgumentError, "#{self.class.name.upcase} enum requires a `key`" if key.nil?
-      key = key.to_sym
-
-      super(key: key, **attrs)
-    end
-
-    def human_attribute_name(attribute)
-      I18n.t("#{self.class.i18n_scope}.attributes.models.#{self.class.model_name.i18n_key}/#{self.key}.#{attribute}")
-    end
-
-    def name
-      human_attribute_name(:key)
-    end
-
-    def titleize
-      key.to_s.titleize
-    end
-
-    def to_s
-      key.to_s
-    end
-
-    def inspect
-      "#<#{self.class.name} #{attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')}>"
-    end
-
-    class << self
-
-      def define(enum)
-        raise ArgumentError, "Expected an object of type `Enumy::Base`, got #{enum.class.name}" unless enum.is_a?(Enumy::Base)
-
-        if instances[enum.key]
-          raise Errors::DuplicateEnumInstanceError, "Enum `#{enum.key.to_s.upcase}` is using a duplicate key `#{enum.key}` for Enum '#{enum.class.name}'."
-        else
-          instances[enum.key] = enum
-        end
-      end
-
-      def all
-        instances.values
-      end
-
-      def find(key)
-        find_by_key(key) || raise(Errors::EnumNotFoundError.new("Could not find a `#{self.name}` enum with a `key` of #{key}"))
-      end
-
-      def find_by_key(key)
-        key = key.to_sym if key.is_a?(String)
-        instances[key]
-      end
-
-      def find_by(**args)
-        raise ArgumentError, "`find_by` requires at least one key-value pair" if args.empty?
-
-        instances.values.find do |instance|
-          args.all? { |attr, value| instance.send(attr) == value }
-        end
-      end
-
-      def model_name
-        @model_name ||= ::ActiveModel::Name.new(self, nil, self.name.to_s)
-      end
-
-      def i18n_scope
-        :enum
-      end
-
-      private
-
-      def instances
-        @instances ||= {}
-      end
-
-    end
-
-  end
-end

data/lib/enumy/generators/enumy/install/install_generator.rb

@@ -1,22 +0,0 @@
-require "rails/generators"
-
-module Enumy
-  module Generators
-    class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path("templates", __dir__)
-
-      def copy_application_enum
-        template "app/enums/application_enum.rb", "app/enums/application_enum.rb"
-      end
-
-      def add_application_record_concern
-        inject_into_file "app/models/application_record.rb", after: /^.*primary_abstract_class.*$/ do
-          <<~CODE
-      
-            \textend Enumy::Model\n
-          CODE
-        end
-      end
-    end
-  end
-end

data/lib/enumy/generators/enumy/install/templates/app/enums/application_enum.rb

@@ -1,3 +0,0 @@
-class ApplicationEnum < Enumy::Base
-
-end

data/lib/enumy/test_helpers.rb

@@ -1,28 +0,0 @@
-module Enumy
-  module TestHelpers
-    def with_enum_defined(enum_class, enum_instance)
-      enum_class.define(enum_instance)
-
-      yield
-
-      enum_class.send(:instances).delete(enum_instance.key)
-      enum_const_name = enum_class.constants.find { |const_name| enum_class.const_get(const_name) == enum_instance }
-      remove_const(enum_const_name) if enum_const_name
-    end
-
-    def enum_model_class(&block)
-      base_class = Class.new(ApplicationRecord) do
-        extend Enumy::Model
-
-        class << self
-          def name
-            "TempModel"
-          end
-        end
-      end
-
-      base_class.class_exec(&block) if block
-      base_class
-    end
-  end
-end