anchormodel 0.1.3 → 0.1.4

data/lib/anchormodel/model_mixin.rb

@@ -9,88 +9,10 @@ module Anchormodel::ModelMixin
 
   class_methods do
     # Creates an attribute linking to an Anchormodel. The attribute should be
-    # present in the DB and the column should be named the same as `attribute_name.`
-    # @param attribute_name [String,Symbol] The name and database column of the attribute
-    # @param anchormodel_class [Class] Class of the Anchormodel (omit if attribute `:foo_bar` holds a `FooBar`)
-    # @param optional [Boolean] If true, a presence validation is added to the model.
-    # @param model_readers [Boolean] If true, the model is given an ActiveRecord::Enum style method `my_model.my_key?` reader for each key in the anchormodel
-    # @param model_writers [Boolean] If true, the model is given an ActiveRecord::Enum style method `my_model.my_key!` writer for each key in the anchormodel
-    # @param model_scopes [Boolean] If true, the model is given an ActiveRecord::Enum style scope `MyModel.mykey` for each key in the anchormodel
-    # @param model_methods [Boolean, NilClass] If non-nil, this mass-assigns and overrides `model_readers`, `model_writers` and `model_scopes`
-    def belongs_to_anchormodel(attribute_name, anchormodel_class = nil, optional: false, model_readers: true,
-                               model_writers: true, model_scopes: true, model_methods: nil)
-      anchormodel_class ||= attribute_name.to_s.classify.constantize
-      attribute_name = attribute_name.to_sym
-      attribute = Anchormodel::Attribute.new(self, attribute_name, anchormodel_class, optional)
-
-      # Mass configurations if model_methods was specfied
-      unless model_methods.nil?
-        model_readers = model_methods
-        model_writers = model_methods
-        model_scopes = model_methods
-      end
-
-      # Register attribute
-      self.anchormodel_attributes = anchormodel_attributes.merge({ attribute_name => attribute }).freeze
-
-      # Add presence validation if required
-      unless optional
-        validates attribute_name, presence: true
-      end
-
-      # Make casting work
-      # Define serializer/deserializer
-      active_model_type_value = Anchormodel::ActiveModelTypeValue.new(attribute)
-
-      # Overwrite reader to force building anchors at every retrieval
-      define_method(attribute_name.to_s) do
-        active_model_type_value.deserialize(read_attribute(attribute_name))
-      end
-
-      # Override writer to fail early when an invalid target value is specified
-      define_method("#{attribute_name}=") do |new_value|
-        write_attribute(attribute_name, active_model_type_value.serialize(new_value))
-      end
-
-      # Supply serializer and deserializer
-      attribute attribute_name, active_model_type_value
-
-      # Create ActiveRecord::Enum style reader directly in the model if asked to do so
-      # For a model User with anchormodel Role with keys :admin and :guest, this creates user.admin? and user.guest? (returning true iff role is admin/guest)
-      if model_readers
-        anchormodel_class.all.each do |entry|
-          if respond_to?(:"#{entry.key}?")
-            fail("Anchormodel reader #{entry.key}? already defined for #{self}, add `model_readers: false` to `belongs_to_anchormodel :#{attribute_name}`.")
-          end
-          define_method(:"#{entry.key}?") do
-            public_send(attribute_name.to_s) == entry
-          end
-        end
-      end
-
-      # Create ActiveRecord::Enum style writer directly in the model if asked to do so
-      # For a model User with anchormodel Role with keys :admin and :guest, this creates user.admin! and user.guest! (setting the role to admin/guest)
-      if model_writers
-        anchormodel_class.all.each do |entry|
-          if respond_to?(:"#{entry.key}!")
-            fail("Anchormodel writer #{entry.key}! already defined for #{self}, add `model_writers: false` to `belongs_to_anchormodel :#{attribute_name}`.")
-          end
-          define_method(:"#{entry.key}!") do
-            public_send(:"#{attribute_name}=", entry)
-          end
-        end
-      end
-
-      # Create ActiveRecord::Enum style scope directly in the model class if asked to do so
-      # For a model User with anchormodel Role with keys :admin and :guest, this creates user.admin! and user.guest! (setting the role to admin/guest)
-      if model_scopes
-        anchormodel_class.all.each do |entry|
-          if respond_to?(entry.key)
-            fail("Anchormodel scope #{entry.key} already defined for #{self}, add `model_scopes: false` to `belongs_to_anchormodel :#{attribute_name}`.")
-          end
-          scope(entry.key, -> { where(attribute_name => entry.key) })
-        end
-      end
+    # present in the DB and the column should be of type String and named the same as `attribute_name`.
+    # @see Anchormodel::Util#install_methods_in_model Parameters
+    def belongs_to_anchormodel(*args, **kwargs)
+      Anchormodel::Util.install_methods_in_model(self, *args, **kwargs)
     end
   end
 end

data/lib/anchormodel/util.rb

@@ -0,0 +1,93 @@
+# @api description
+# A swiss army knife for common functionality
+module Anchormodel::Util
+  # Installs an anchormodel attribute in a model class
+  # @param model_class [ActiveRecord::Base] Internal only. The model class that the attribute should be installed to.
+  # @param attribute_name [String,Symbol] The name and database column of the attribute
+  # @param anchormodel_class [Class] Class of the Anchormodel (omit if attribute `:foo_bar` holds a `FooBar`)
+  # @param optional [Boolean] If false, a presence validation is added to the model.
+  # @param model_readers [Boolean] If true, the model is given an ActiveRecord::Enum style method `my_model.my_key?` reader for each key in the anchormodel
+  # @param model_writers [Boolean] If true, the model is given an ActiveRecord::Enum style method `my_model.my_key!` writer for each key in the anchormodel
+  # @param model_scopes [Boolean] If true, the model is given an ActiveRecord::Enum style scope `MyModel.mykey` for each key in the anchormodel
+  # @param model_methods [Boolean, NilClass] If non-nil, this mass-assigns and overrides `model_readers`, `model_writers` and `model_scopes`
+  def self.install_methods_in_model(model_class, attribute_name, anchormodel_class = nil,
+                                    optional: false,
+                                    model_readers: true,
+                                    model_writers: true,
+                                    model_scopes: true,
+                                    model_methods: nil)
+
+    anchormodel_class ||= attribute_name.to_s.classify.constantize
+    attribute_name = attribute_name.to_sym
+    attribute = Anchormodel::Attribute.new(self, attribute_name, anchormodel_class, optional)
+
+    # Mass configurations if model_methods was specfied
+    unless model_methods.nil?
+      model_readers = model_methods
+      model_writers = model_methods
+      model_scopes = model_methods
+    end
+
+    # Register attribute
+    model_class.anchormodel_attributes = model_class.anchormodel_attributes.merge({ attribute_name => attribute }).freeze
+
+    # Add presence validation if required
+    unless optional
+      model_class.validates attribute_name, presence: true
+    end
+
+    # Make casting work
+    # Define serializer/deserializer
+    active_model_type_value = Anchormodel::ActiveModelTypeValueSingle.new(attribute)
+
+    # Overwrite reader to force building anchors at every retrieval
+    model_class.define_method(attribute_name.to_s) do
+      active_model_type_value.deserialize(read_attribute_before_type_cast(attribute_name))
+    end
+
+    # Override writer to fail early when an invalid target value is specified
+    model_class.define_method("#{attribute_name}=") do |new_value|
+      write_attribute(attribute_name, active_model_type_value.serialize(new_value))
+    end
+
+    # Supply serializer and deserializer
+    model_class.attribute attribute_name, active_model_type_value
+
+    # Create ActiveRecord::Enum style reader directly in the model if asked to do so
+    # For a model User with anchormodel Role with keys :admin and :guest, this creates user.admin? and user.guest? (returning true iff role is admin/guest)
+    if model_readers
+      anchormodel_class.all.each do |entry|
+        if model_class.respond_to?(:"#{entry.key}?")
+          fail("Anchormodel reader #{entry.key}? already defined for #{self}, add `model_readers: false` to `belongs_to_anchormodel :#{attribute_name}`.")
+        end
+        model_class.define_method(:"#{entry.key}?") do
+          public_send(attribute_name.to_s) == entry
+        end
+      end
+    end
+
+    # Create ActiveRecord::Enum style writer directly in the model if asked to do so
+    # For a model User with anchormodel Role with keys :admin and :guest, this creates user.admin! and user.guest! (setting the role to admin/guest)
+    if model_writers
+      anchormodel_class.all.each do |entry|
+        if model_class.respond_to?(:"#{entry.key}!")
+          fail("Anchormodel writer #{entry.key}! already defined for #{self}, add `model_writers: false` to `belongs_to_anchormodel :#{attribute_name}`.")
+        end
+        model_class.define_method(:"#{entry.key}!") do
+          public_send(:"#{attribute_name}=", entry)
+        end
+      end
+    end
+
+    # Create ActiveRecord::Enum style scope directly in the model class if asked to do so
+    # For a model User with anchormodel Role with keys :admin and :guest, this creates user.admin! and user.guest! (setting the role to admin/guest)
+    if model_scopes
+      anchormodel_class.all.each do |entry|
+        if model_class.respond_to?(entry.key)
+          fail("Anchormodel scope #{entry.key} already defined for #{self}, add `model_scopes: false` to `belongs_to_anchormodel :#{attribute_name}`.")
+        end
+        model_class.scope(entry.key, -> { where(attribute_name => entry.key) })
+      end
+    end
+  end
+end

data/lib/anchormodel/version.rb

@@ -1,11 +1,5 @@
 class Anchormodel
   module Version
-    MAJOR = 0
-    MINOR = 1
-    PATCH = 3
-
-    EDGE = false
-
-    LABEL = [MAJOR, MINOR, PATCH, EDGE ? 'edge' : nil].compact.join('.')
+    LABEL = (Pathname.new(__FILE__).dirname.dirname.dirname / 'VERSION').read
   end
 end

data/lib/anchormodel.rb

@@ -77,7 +77,8 @@ class Anchormodel
   end
 end
 
-require 'anchormodel/active_model_type_value'
+require 'anchormodel/util'
+require 'anchormodel/active_model_type_value_single'
 require 'anchormodel/attribute'
 require 'anchormodel/model_mixin'
 require 'anchormodel/version'

data/test/active_record_model/user_test.rb

@@ -118,4 +118,23 @@ class UserTest < Minitest::Test
     u.secondary_role = ''
     assert_nil u.secondary_role
   end
+
+  # Attempting to create a model with an invalid constant name should fail
+  def test_invalid_key_update
+    assert_raises(RuntimeError) { User.create!(role: :admin, locale: :de, preferred_locale: :invalid) }
+  end
+
+  # Attempting to assign an invalid constant name to a model should fail
+  def test_invalid_key_assignment
+    assert_raises(RuntimeError) { User.new(role: :invalid) }
+  end
+
+  # An invalid constant name into the DB should raise when reading
+  def test_invalid_db_read
+    sql = <<~SQL.squish
+      INSERT INTO users (role, locale, preferred_locale, created_at, updated_at) VALUES ('invalid', 'de', 'de', 'now', 'now')
+    SQL
+    ActiveRecord::Base.connection.execute(sql)
+    assert_raises(RuntimeError) { User.first.role }
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anchormodel
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Sandro Kalbermatter
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-19 00:00:00.000000000 Z
+date: 2024-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -150,8 +150,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.6.0
-description: 
-email: 
+description:
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -165,6 +165,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- VERSION
 - anchormodel.gemspec
 - bin/rails
 - doc/Anchormodel.html
@@ -187,14 +188,16 @@ files:
 - doc/method_list.html
 - doc/top-level-namespace.html
 - lib/anchormodel.rb
-- lib/anchormodel/active_model_type_value.rb
+- lib/anchormodel/active_model_type_value_single.rb
 - lib/anchormodel/attribute.rb
 - lib/anchormodel/model_mixin.rb
+- lib/anchormodel/util.rb
 - lib/anchormodel/version.rb
 - lib/generators/anchormodel/USAGE
 - lib/generators/anchormodel/anchormodel_generator.rb
 - lib/generators/anchormodel/templates/anchormodel.rb.erb
 - logo.svg
+- pkg/anchormodel-0.1.3.gem
 - test/active_record_model/user_test.rb
 - test/dummy/.gitignore
 - test/dummy/Rakefile
@@ -233,7 +236,7 @@ homepage: https://github.com/kalsan/anchormodel
 licenses:
 - LGPL-3.0-or-later
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -248,8 +251,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
-signing_key: 
+rubygems_version: 3.5.6
+signing_key:
 specification_version: 4
 summary: Bringing object-oriented programming to Rails enums
 test_files: []