active_delegate 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c99873f9805b6f84c6d036a649e76ec69608b8b5c99d850ea0161e38fb96b542
-  data.tar.gz: bd53c53b31fec9193cbfb1256e3d30e238dfcd381b4831dade2cc892d2010f3d
+  metadata.gz: a0ff0702750360bd4c01ebc4075853ce241921ec038c864e6c3536934adfbcba
+  data.tar.gz: 3e18f2b5f05f886b1d5a25e7e2b46cc5fb511ccd90edbff242b543891512359c
 SHA512:
-  metadata.gz: 44d3ec0a17ff617a897fa7b0f5a756b34d769700abc0f1cc51f2db7369bd67f2233284f4499f6f2817693ce14da4ea67382f50b2e6b93a99b2ad71618f62ced2
-  data.tar.gz: 43b4cdae60e193e306ad1054aae8b2d451aaa0916bb1541e1d0c207121d094171d571a2ec653a5e1c11b345bed9318fe0c9bd52f5edd04d4565882bfb45470d3
+  metadata.gz: 81f7b9b0b20bca2831c30c1e90ed4789cfcac4501b37816eb4ff6879a78da79875d67f7a9fd90a71c4d5a977a6eec4cfe376424c10e7c04cd4d4b283dca2ddaa
+  data.tar.gz: b6bef5e43efab6fa63b8f3f95952fc2e1f3df0cdd2f4af7cefdad6e73e18edddb2b8ebd13d78130bce3b3dfb443e086f23445b48a72fb9c4eb71c9d56e2734dc

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in active_delegate.gemspec

data/Gemfile.lock

@@ -1,31 +1,31 @@
 PATH
   remote: .
   specs:
-    active_delegate (0.1.1)
+    active_delegate (1.0.1)
       activerecord (~> 5.0)
-      i18n (~> 0.8)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.1.1)
-      activesupport (= 5.1.1)
-    activerecord (5.1.1)
-      activemodel (= 5.1.1)
-      activesupport (= 5.1.1)
-      arel (~> 8.0)
-    activesupport (5.1.1)
+    activemodel (5.2.1)
+      activesupport (= 5.2.1)
+    activerecord (5.2.1)
+      activemodel (= 5.2.1)
+      activesupport (= 5.2.1)
+      arel (>= 9.0)
+    activesupport (5.2.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
+      i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (8.0.0)
+    arel (9.0.0)
     concurrent-ruby (1.0.5)
-    i18n (0.8.4)
-    minitest (5.10.2)
+    i18n (1.1.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.10.3)
     rake (10.5.0)
     thread_safe (0.3.6)
-    tzinfo (1.2.3)
+    tzinfo (1.2.5)
       thread_safe (~> 0.1)
 
 PLATFORMS
@@ -38,4 +38,4 @@ DEPENDENCIES
   rake (~> 10.0)
 
 BUNDLED WITH
-   1.14.6
+   1.16.6

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 

data/lib/active_delegate.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require 'active_delegate/version'
 
+# Defines delegation methods and loads modules
 module ActiveDelegate
   extend ActiveSupport::Concern
 
-  # Autoload modules
   autoload :Associations, 'active_delegate/associations'
   autoload :Attributes,   'active_delegate/attributes'
 
   class_methods do
-    # Delegate associations
     def delegate_associations(*args)
       options = args.extract_options!
       options = options.reverse_merge(only: args)
@@ -17,13 +18,11 @@ module ActiveDelegate
       Associations.new(self, options).call
     end
 
-    # Delegate association
     def delegate_association(association, options = {})
       options = options.merge(only: association)
       Associations.new(self, options).call
     end
 
-    # Delegate attributes
     def delegate_attributes(*args)
       options = args.extract_options!
       options = options.reverse_merge(only: args).except(:cast_type, :alias)
@@ -31,7 +30,6 @@ module ActiveDelegate
       Attributes.new(self, options).call
     end
 
-    # Delegate attribute
     def delegate_attribute(attribute, cast_type, options = {})
       options = options.except(:only, :except)
       options = options.merge(only: attribute, cast_type: cast_type)

data/lib/active_delegate/association/methods.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module ActiveDelegate
   module Association
+    # Generates association method names
     class Methods
       attr_reader :association_name, :association_class
 
-      # Initialize association methods
       def initialize(association_name, association_class)
         @association_name  = association_name
         @association_class = association_class
       end
 
-      # Get delegatable methods
       def delegatable
         delegatable = suffixed + prefixed
         delegatable & association_class.instance_methods
@@ -17,22 +18,18 @@ module ActiveDelegate
 
       private
 
-      # Get method prefixes
       def prefixes
         ['build_']
       end
 
-      # Get method suffixes
       def suffixes
         ['', '=', '_attributes', '_attributes=']
       end
 
-      # Get prefixed methods
       def prefixed
         prefixes.map { |s| :"#{s}#{attribute}" }
       end
 
-      # Get suffixed methods
       def suffixed
         suffixes.map { |s| :"#{attribute}#{s}" }
       end

data/lib/active_delegate/associations.rb

@@ -1,24 +1,23 @@
+# frozen_string_literal: true
+
 require 'active_delegate/delegator'
 require 'active_delegate/association/methods'
 
 module ActiveDelegate
+  # Delegates associations to an associated model
   class Associations < Delegator
-    # Get all associations
     def association_reflections
       association_class.reflect_on_all_associations
     end
 
-    # Get singular model association names
     def association_names
       association_reflections.map(&:name)
     end
 
-    # Get delegatable associations
     def delegatable_associations
       delegation_args(association_names)
     end
 
-    # Delegate associations
     def call
       delegatable_associations.each do |association|
         methods = Association::Methods.new(association, association_class)

data/lib/active_delegate/attribute/accessor.rb

@@ -1,87 +1,74 @@
+# frozen_string_literal: true
+
 module ActiveDelegate
   module Attribute
+    # Reads, writes and type casts attribute value
     class Accessor
       attr_reader :record, :options
 
-      # Initialize attribute
       def initialize(record, options = {})
         @record  = record
         @options = options
       end
 
-      # Get default value
       def default_value
         options[:default]
       end
 
-      # Get association name
       def association_name
         options[:association].to_sym
       end
 
-      # Get association attribute name
       def attribute_name
         options[:attribute].to_sym
       end
 
-      # Get record attribute type
       def read_type
         options[:read_type]
       end
 
-      # Get association attribute type
       def write_type
         options[:write_type]
       end
 
-      # Check if should cast value
       def type_cast?
-        read_type != write_type
+        read_type_caster.type != write_type_caster.type
       end
 
-      # Get associated value
       def association_record
         record.send(association_name)
       end
 
-      # Get association attribute value
       def attribute_value(*args)
         association_record.try(attribute_name, *args)
       end
 
-      # Get record attribute type caster
       def read_type_caster
         lookup_type_caster(read_type)
       end
 
-      # Get association attribute type caster
       def write_type_caster
         lookup_type_caster(write_type)
       end
 
-      # Cast value for reading
       def cast_read_value(value)
         read_type_caster.cast(value)
       end
 
-      # Cast value for writing
       def cast_write_value(value)
         write_type_caster.cast(value)
       end
 
-      # Prepare association attribute value for writing
       def normalize_value(value)
         value = cast_read_value(value)
         cast_write_value(value)
       end
 
-      # Read and cast value
       def read(*args)
         value = attribute_value(*args) || default_value
         type_cast? ? cast_read_value(value) : value
       end
 
-      # Cast and write value
       def write(value)
         value = normalize_value(value) if type_cast?
         association_record.send(:"#{attribute_name}=", value)
@@ -89,7 +76,6 @@ module ActiveDelegate
 
       private
 
-      # Get type caster class
       def lookup_type_caster(type_caster)
         if type_caster.is_a?(Symbol)
           ActiveRecord::Type.lookup(type_caster)

data/lib/active_delegate/attribute/localize.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module ActiveDelegate
   module Attribute
+    # Generates localized attributes names
     class Localize
       attr_reader :attribute_name, :association_instance
 
-      # Initialize attribute methods
       def initialize(attribute_name, association_class)
         @attribute_name       = attribute_name
         @association_instance = association_class.new
       end
 
-      # Get localized attributes
       def attributes
         localized = suffixes.map { |s| :"#{attribute_name}#{s}" }
         localized & association_instance.methods
@@ -17,14 +18,12 @@ module ActiveDelegate
 
       private
 
-      # Get localized method suffixes
       def suffixes
         @suffixes ||= I18n.available_locales.map do |locale|
           "_#{normalize_locale(locale)}"
         end
       end
 
-      # Normalize locale
       def normalize_locale(locale)
         locale.to_s.downcase.sub('-', '_').to_s
       end

data/lib/active_delegate/attribute/methods.rb

@@ -1,44 +1,47 @@
+# frozen_string_literal: true
+
 module ActiveDelegate
   module Attribute
+    # Generates attribute method names
     class Methods
       attr_reader :attribute_name, :association_instance
 
-      # Initialize attribute methods
       def initialize(attribute_name, association_class)
         @attribute_name       = attribute_name
         @association_instance = association_class.new
       end
 
-      # Get accessor methods
       def accessors
         suffix_attribute(accessor_suffixes)
       end
 
-      # Get dirty methods for attributes
       def dirty
         suffix_attribute(dirty_suffixes)
       end
 
-      # Get delegatable methods
       def delegatable
         accessors + dirty
       end
 
       private
 
-      # Get accessor method suffixes
       def accessor_suffixes
         ['', '=', '?']
       end
 
-      # Get dirty method suffixes
-      def dirty_suffixes
-        @dirty_suffixes ||= Class.new do
+      def dirty_module
+        @dirty_module ||= Class.new do
           include ::ActiveModel::Dirty
-        end.attribute_method_matchers.map(&:suffix).select { |m| m =~ /\A_/ }
+        end
+      end
+
+      def dirty_suffixes
+        @dirty_suffixes ||= begin
+          suffixes = dirty_module.attribute_method_matchers.map(&:suffix)
+          suffixes.select { |m| m.starts_with?('_') }
+        end
       end
 
-      # Generate suffixed array of symbols
       def suffix_attribute(suffixes)
         delegatable = suffixes.map { |s| :"#{attribute_name}#{s}" }
         delegatable & association_instance.methods

data/lib/active_delegate/attribute/object.rb

@@ -1,105 +1,89 @@
+# frozen_string_literal: true
+
 require 'active_delegate/attribute/methods'
 require 'active_delegate/attribute/localize'
 
 module ActiveDelegate
   module Attribute
+    # Calculates attribute methods, aliases and options
     class Object
       attr_reader :attribute_name, :association_class, :options
 
-      # Initialize attribute methods
       def initialize(attribute_name, association_class, options = {})
         @attribute_name    = attribute_name
         @association_class = association_class
         @options           = options
       end
 
-      # Check if should define attribute
       def define?
         options[:define] || in_option?(:define)
       end
 
-      # Check if should localize attribute
       def localize?
         options[:localized] || in_option?(:localized)
       end
 
-      # Check if should define attribute finders
       def finder?
         options[:finder] || in_option?(:finder)
       end
 
-      # Check if should define attribute scopes
       def scope?
         options[:scope] || in_option?(:scope)
       end
 
-      # Get attribute prefix
       def prefix
         options[:prefix]
       end
 
-      # Get attribute default
       def default
         options.fetch :default, association_class.column_defaults[unprefixed.to_s]
       end
 
-      # Get read type or fallback to write type
       def read_type
         options.fetch :cast_type, write_type
       end
 
-      # Get write type from associated model
       def write_type
         association_class.type_for_attribute(unprefixed.to_s)
       end
 
-      # Get unprefixed attribute
       def unprefixed
         remove_prefix(attribute_name)
       end
 
-      # Get prefixed attribute
       def prefixed
         add_prefix(attribute_name)
       end
 
-      # Check if attribute is prefixed
       def prefixed?
         unprefixed != prefixed
       end
 
-      # Get aliased attribute
       def aliased
         options[:alias] || prefixed
       end
 
-      # Check if attribute is aliased
       def aliased?
         prefixed != aliased
       end
 
-      # Get method aliases
       def aliases
         return {} unless aliased?
         Hash[delegatable_methods.map { |m| generate_alias(m) }]
       end
 
-      # Get localized attributes
       def localized
         @localized ||= Localize.new(unprefixed, association_class).attributes
       end
 
-      # Check if attributes has localized methods
       def localized?
         localized.any?
       end
 
-      # Get delegatable attributes
       def delegatable_attributes
         @delegatable_attributes ||= [unprefixed, *localized].map { |a| add_prefix(a) }
       end
 
-      # Get delegatable attribute methods
       def delegatable_methods
         @delegatable_methods ||= [unprefixed, *localized].flat_map do |method_name|
           Methods.new(method_name, association_class).delegatable
@@ -108,17 +92,14 @@ module ActiveDelegate
 
       private
 
-      # Prefix attribute
       def add_prefix(attr_name)
         prefix.present? ? :"#{prefix}_#{attr_name}" : attr_name
       end
 
-      # Unprefix attribute
       def remove_prefix(attr_name)
         attr_name.to_s.sub("#{prefix}_", '').to_sym
       end
 
-      # Generate alias method
       def generate_alias(method_name)
         old_name = method_name.to_s.sub(unprefixed.to_s, prefixed.to_s)
         new_name = method_name.to_s.sub(unprefixed.to_s, aliased.to_s)
@@ -126,7 +107,6 @@ module ActiveDelegate
         [new_name.to_sym, old_name.to_sym]
       end
 
-      # Check if attribute is in option
       def in_option?(key)
         attribute_name.in? Array(options[key])
       end

data/lib/active_delegate/attributes.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'active_delegate/delegator'
 require 'active_delegate/attribute/object'
 require 'active_delegate/attribute/accessor'
 
 module ActiveDelegate
+  # Delegates attributes to an associated model
   class Attributes < Delegator
-    # Get default options
     def default_options
       {
         except:    [],
@@ -19,18 +21,15 @@ module ActiveDelegate
       }
     end
 
-    # Get attribute options
     def attribute_options
       keys = %i[cast_type default define alias localized finder scope]
       options.select { |k, _v| k.in? keys }.merge(prefix: delegation_prefix)
     end
 
-    # Get association table
     def association_table
       association_class.table_name
     end
 
-    # Default excluded attributes
     def excluded_attributes
       excluded  = %i[id created_at updated_at]
 
@@ -43,7 +42,6 @@ module ActiveDelegate
       excluded
     end
 
-    # Get delegatable attributes
     def delegatable_attributes
       attributes  = delegation_args(association_class.attribute_names)
       attributes -= excluded_attributes
@@ -57,7 +55,6 @@ module ActiveDelegate
       attributes.reject { |a| model.has_attribute?(a.prefixed) }
     end
 
-    # Delegate attributes
     def call
       redefine_build_association(association_name)
 
@@ -72,18 +69,16 @@ module ActiveDelegate
 
     private
 
-    # Redefine build association method
     def redefine_build_association(assoc_name)
       model.class_eval do
-        class_eval <<-EOM, __FILE__, __LINE__ + 1
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{assoc_name}
             super || send(:build_#{assoc_name})
           end
-        EOM
+        RUBY
       end
     end
 
-    # Redefine attribute accessor methods
     def redefine_attribute_accessors(method_name, attribute)
       attr_options = {
         association: association_name,
@@ -102,18 +97,15 @@ module ActiveDelegate
       end
     end
 
-    # Delegate attribute methods
     def delegate_methods(methods)
       model.delegate(*methods, delegation_options)
     end
 
-    # Define model method keeping old values
     def define_model_method(method, *attributes)
       attributes = model.try(method).to_a.concat(attributes).uniq
       model.send(:define_singleton_method, method) { attributes }
     end
 
-    # Store attribute names in model class methods
     def define_model_class_methods(attribute)
       method_name = :"#{association_table}_attribute_names"
       define_model_method(method_name, attribute.prefixed)
@@ -122,11 +114,8 @@ module ActiveDelegate
       define_model_method(method_name, attribute.prefixed) if attribute.localized?
     end
 
-    # Define delegated attribute methods
     def define_attribute_methods(attribute)
-      if attribute.define?
-        model.attribute(attribute.aliased, attribute.read_type)
-      end
+      model.attribute(attribute.aliased, attribute.read_type) if attribute.define?
 
       attribute.delegatable_attributes.each do |method_name|
         redefine_attribute_accessors(method_name, attribute)
@@ -137,7 +126,6 @@ module ActiveDelegate
       end
     end
 
-    # Define attribute finder methods
     def define_attribute_finders(attr_method:, attr_column:, assoc_name:, table_name:)
       model.send(:define_singleton_method, :"find_by_#{attr_method}") do |value|
         joins(assoc_name).find_by(table_name => { attr_column => value })
@@ -148,7 +136,6 @@ module ActiveDelegate
       end
     end
 
-    # Define attribute scope methods
     def define_attribute_scopes(attr_method:, attr_column:, assoc_name:, table_name:)
       model.send(:define_singleton_method, :"with_#{attr_method}") do |*args|
         joins(assoc_name).where(table_name => { attr_column => args })
@@ -159,7 +146,6 @@ module ActiveDelegate
       end
     end
 
-    # Define attribute finders and scopes
     def define_attribute_queries(attribute)
       attr_options = {
         assoc_name:  association_name,

data/lib/active_delegate/delegator.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 module ActiveDelegate
+  # Validates delegation target and sets basic options
   class Delegator
     attr_reader :model, :options
 
-    # Initialize delegator
     def initialize(model, options)
       @model   = model
       @options = default_options.merge(options.symbolize_keys)
     end
 
-    # Get default options
     def default_options
       {
         except:    [],
@@ -18,12 +19,10 @@ module ActiveDelegate
       }
     end
 
-    # Get delegation options
     def delegation_options
       options.select { |k, _v| k.in? %i[to allow_nil prefix] }
     end
 
-    # Get delegation arguments
     def delegation_args(available = [])
       included   = Array(options[:only]).map(&:to_sym)
       excluded   = Array(options[:except]).map(&:to_sym)
@@ -34,25 +33,21 @@ module ActiveDelegate
       available
     end
 
-    # Get delegation prefix
     def delegation_prefix
       prefix = options[:prefix]
       prefix == true ? association_name : prefix
     end
 
-    # Get association name
     def association_name
       @options[:to]
     end
 
-    # Get association reflection
     def association_reflection
-      reflection = @model.reflect_on_association(association_name)
+      reflection = model.reflect_on_association(association_name)
       return reflection unless reflection.nil?
-      raise "#{@model.name} don't have the association #{association_name}"
+      raise "#{model.name} don't have the association #{association_name}"
     end
 
-    # Get model association class
     def association_class
       association_reflection.klass
     end

data/lib/active_delegate/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveDelegate
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_delegate
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Jonian Guveli
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-03 00:00:00.000000000 Z
+date: 2018-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord