refactor: use lambda based validators (#11)

Improves the abstraction of limit validations by building lambdas to
pass to the validate method

Author: benmelz

.rubocop.yml

@@ -9,3 +9,10 @@ AllCops:
     - gemfiles/**/*
   NewCops: enable
   TargetRubyVersion: 3.0
+
+Metrics/AbcSize:
+  CountRepeatedAttributes: false
+  Max: 20
+
+Metrics/MethodLength:
+  Max: 12

lib/limitable.rb

@@ -14,7 +14,7 @@ module Limitable
   class << self
     def included(klass)
       safe_column_names(klass).each do |column_name|
-        add_limit_validation klass, column_name
+        attach_limit_validator_if_needed klass, column_name
       end
     end
 
@@ -26,50 +26,47 @@ def safe_column_names(klass)
       []
     end
 
-    def add_limit_validation(klass, column_name)
+    def attach_limit_validator_if_needed(klass, column_name)
       column = klass.column_for_attribute column_name
       limit = column.sql_type_metadata.limit
       return if limit.blank?
 
       case column.type
       when :integer
-        add_integer_limit_validation klass, column_name, limit
+        klass.validate(&build_integer_limit_validator(column_name, limit))
       when :string, :text
-        add_string_limit_validation klass, column_name, limit
+        klass.validate(&build_string_limit_validator(column_name, limit))
       end
     end
 
-    def add_integer_limit_validation(klass, column_name, limit)
+    def build_integer_limit_validator(column_name, limit)
       min, max = integer_limit_range limit
-      integer_type_normalizer = method :integer_type_normalizer
-      klass.validate do
-        value = integer_type_normalizer.call klass, column_name, self[column_name]
-        next unless value.is_a?(Integer)
+      lambda do
+        value = begin
+          self.class.type_for_attribute(column_name).serialize self[column_name]
+        rescue ActiveModel::RangeError => e
+          e.message.match(/(?<number>\d+) is out of range/)[:number].to_i
+        end
+        next unless value.is_a? Integer
 
         errors.add column_name, I18n.t('errors.messages.greater_than_or_equal_to', count: min) if value < min
         errors.add column_name, I18n.t('errors.messages.less_than_or_equal_to', count: max) if value > max
       end
     end
 
-    def integer_limit_range(limit)
-      max = (1 << ((limit * 8) - 1)) - 1
-      min = -max
-      [min, max]
-    end
-
-    def integer_type_normalizer(klass, column_name, value)
-      klass.type_for_attribute(column_name).serialize value
-    rescue ActiveModel::RangeError => e
-      e.message.match(/(?<number>\d+) is out of range/)[:number].to_i
-    end
-
-    def add_string_limit_validation(klass, column_name, limit)
-      klass.validate do
-        value = klass.type_for_attribute(column_name).serialize self[column_name]
+    def build_string_limit_validator(column_name, limit)
+      lambda do
+        value = self.class.type_for_attribute(column_name).serialize self[column_name]
         next unless value.is_a?(String) && value.bytesize > limit
 
         errors.add column_name, I18n.t('errors.messages.too_long.other', count: limit)
       end
     end
+
+    def integer_limit_range(limit)
+      max = (1 << ((limit * 8) - 1)) - 1
+      min = -max
+      [min, max]
+    end
   end
 end