active_delegate 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: db4ce7e906bb62440ecead0e66d21d611b9354ac
-  data.tar.gz: e6e9e1b63faaf10d0f7522f7c19cc22563976554
+SHA256:
+  metadata.gz: 7ef4539c2b70f925e9e83e293bd7fec0a560586526efa6c6b486f36b1675fa65
+  data.tar.gz: ff272b205a8757d99b95cc45642b0f7c10cbb4171e63b3dd9149ab82389b03bd
 SHA512:
-  metadata.gz: 11d848253fb51ced3c37e97806dcd15ef71634a501ae6003a65e18a074347406d1b1c12241904b74d58b5ebc37a386d97baf119250fe83fcd0d16ad26686265d
-  data.tar.gz: 51202fe31b97ac2fa6bf6dfa0966681d9b75fc87ef3845b9959674f59403c6f9d7dce06a62682175c14fee417f7cdfdc000c51798557f53a8c1001925dd55df9
+  metadata.gz: 620de75b4495080c73c9059ff361d2550ad2b2c031c19f68745f53b375dc1df119e18c33ab5f22027ae08cd9bb0e7b919740e87f0955f084133e580ce64fc638
+  data.tar.gz: 1c4e5f6b8f3cc93212b027d47e3098c1bd96a5c9b34bca9d4f00204892f8ab8a72e7dae65e407dc4d186860a3ba88448b2c814b5308068949418df5047ce57a0

data/Gemfile.lock

@@ -1,28 +1,29 @@
 PATH
   remote: .
   specs:
-    active_delegate (0.1.1)
+    active_delegate (0.1.2)
       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)
+    activemodel (5.1.4)
+      activesupport (= 5.1.4)
+    activerecord (5.1.4)
+      activemodel (= 5.1.4)
+      activesupport (= 5.1.4)
       arel (~> 8.0)
-    activesupport (5.1.1)
+    activesupport (5.1.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (~> 0.7)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
     arel (8.0.0)
     concurrent-ruby (1.0.5)
-    i18n (0.8.4)
-    minitest (5.10.2)
+    i18n (0.9.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.10.3)
     rake (10.5.0)
     thread_safe (0.3.6)
     tzinfo (1.2.3)
@@ -38,4 +39,4 @@ DEPENDENCIES
   rake (~> 10.0)
 
 BUNDLED WITH
-   1.14.6
+   1.15.4

data/Rakefile

@@ -7,4 +7,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+task default: :test

data/lib/active_delegate.rb

@@ -12,23 +12,31 @@ module ActiveDelegate
     # Delegate associations
     def delegate_associations(*args)
       options = args.extract_options!
-      Associations.new(self, options)
+      options = options.reverse_merge(only: args)
+
+      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.except(:single, :cast_type, :alias)
+      options = options.reverse_merge(only: args).except(:cast_type, :alias)
 
-      Attributes.new(self, options)
+      Attributes.new(self, options).call
     end
 
     # Delegate attribute
-    def delegate_attribute(attribute, cast_type, options={})
+    def delegate_attribute(attribute, cast_type, options = {})
       options = options.except(:only, :except)
-      options = options.merge(only: [attribute], single: true, cast_type: cast_type)
+      options = options.merge(only: attribute, cast_type: cast_type)
 
-      Attributes.new(self, options)
+      Attributes.new(self, options).call
     end
   end
 end

data/lib/active_delegate/association/methods.rb

@@ -0,0 +1,41 @@
+module ActiveDelegate
+  module Association
+    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
+      end
+
+      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
+    end
+  end
+end

data/lib/active_delegate/associations.rb

@@ -1,70 +1,29 @@
-module ActiveDelegate
-  class Associations
-    # Initialize assoctiations
-    def initialize(model, options)
-      @model   = model
-      @options = default_options.merge(options)
+require 'active_delegate/delegator'
+require 'active_delegate/association/methods'
 
-      delegate_associations
+module ActiveDelegate
+  class Associations < Delegator
+    # Get all associations
+    def association_reflections
+      association_class.reflect_on_all_associations
     end
 
-    private
-
-      # Get default options
-      def default_options
-        { except: [], only: [], allow_nil: false, to: [] }
-      end
-
-      # Get association reflection
-      def association_reflection
-        assoc_name = @options.fetch(:to)
-        reflection = @model.reflect_on_association(assoc_name)
-
-        return reflection unless reflection.nil?
-        raise "#{@model.name} don't have the association #{assoc_name}"
-      end
-
-      # Get model association class
-      def association_class
-        association_reflection.klass
-      end
-
-      # 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
-        associations = association_names.map(&:to_sym)
-        associations = associations & @options[:only].to_a   if @options[:only].present?
-        associations = associations - @options[:except].to_a if @options[:except].present?
-
-        associations.map(&:to_sym)
-      end
-
-      # Check if association is collection
-      def collection_association?(association)
-        collections = association_reflections.select(&:collection?).map(&:name)
-        association.in? collections
-      end
-
-      # Delegate associations
-      def delegate_associations
-        options = { to: @options[:to], allow_nil: @options[:allow_nil] }
+    # Get singular model association names
+    def association_names
+      association_reflections.map(&:name)
+    end
 
-        delegatable_associations.each do |association|
-          @model.delegate "#{association}",  options
-          @model.delegate "#{association}=", options
+    # Get delegatable associations
+    def delegatable_associations
+      delegation_args(association_names)
+    end
 
-          @model.delegate "#{association}_attributes=", options rescue true
-          @model.delegate "build_#{association}", options unless collection_association?(association)
-        end
+    # Delegate associations
+    def call
+      delegatable_associations.each do |association|
+        methods = Association::Methods.new(association, association_class)
+        model.delegate(*methods.delegatable, delegation_options)
       end
+    end
   end
 end

data/lib/active_delegate/attribute/accessor.rb

@@ -0,0 +1,102 @@
+module ActiveDelegate
+  module Attribute
+    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
+      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)
+      end
+
+      private
+
+      # Get type caster class
+      def lookup_type_caster(type_caster)
+        if type_caster.is_a?(Symbol)
+          ActiveRecord::Type.lookup(type_caster)
+        else
+          type_caster
+        end
+      end
+    end
+  end
+end

data/lib/active_delegate/attribute/localize.rb

@@ -0,0 +1,33 @@
+module ActiveDelegate
+  module Attribute
+    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
+      end
+
+      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
+    end
+  end
+end

data/lib/active_delegate/attribute/methods.rb

@@ -0,0 +1,48 @@
+module ActiveDelegate
+  module Attribute
+    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
+          include ::ActiveModel::Dirty
+        end.attribute_method_matchers.map(&:suffix).select { |m| m =~ /\A_/ }
+      end
+
+      # Generate suffixed array of symbols
+      def suffix_attribute(suffixes)
+        delegatable = suffixes.map { |s| :"#{attribute_name}#{s}" }
+        delegatable & association_instance.methods
+      end
+    end
+  end
+end

data/lib/active_delegate/attribute/object.rb

@@ -0,0 +1,135 @@
+require 'active_delegate/attribute/methods'
+require 'active_delegate/attribute/localize'
+
+module ActiveDelegate
+  module Attribute
+    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
+        end
+      end
+
+      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)
+
+        [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
+    end
+  end
+end

data/lib/active_delegate/attributes.rb

@@ -1,274 +1,175 @@
-module ActiveDelegate
-  autoload :ReadWrite, 'active_delegate/read_write'
-  autoload :Dirty,     'active_delegate/dirty'
-  autoload :Localized, 'active_delegate/localized'
-
-  class Attributes
-    # Initialize attributes
-    def initialize(model, options)
-      @model   = model
-      @options = default_options.merge(options)
+require 'active_delegate/delegator'
+require 'active_delegate/attribute/object'
+require 'active_delegate/attribute/accessor'
 
-      delegate_attributes
-      save_delegated_attributes
-      redefine_build_association
+module ActiveDelegate
+  class Attributes < Delegator
+    # Get default options
+    def default_options
+      {
+        except:    [],
+        only:      [],
+        localized: false,
+        define:    true,
+        finder:    false,
+        scope:     false,
+        to:        nil,
+        prefix:    nil,
+        allow_nil: false
+      }
     end
 
-    private
-
-      # Get default options
-      def default_options
-        {
-          except: [], only: [], allow_nil: false, to: [],
-          prefix: nil, localized: false, finder: false,
-          scope: false, cast: false
-        }
-      end
-
-      # Get association reflection
-      def association_reflection
-        assoc_name = @options.fetch(:to)
-        reflection = @model.reflect_on_association(assoc_name)
-
-        return reflection unless reflection.nil?
-        raise "#{@model.name} don't have the association #{assoc_name}"
-      end
-
-      # Get model association class
-      def association_class
-        association_reflection.klass
-      end
-
-      # Get association attribute names
-      def association_attribute_names
-        association_class.attribute_names
-      end
-
-      # Default excluded attributes
-      def default_excluded_attributes
-        assoc_as  = association_reflection.options[:as]
-        poly_attr = [:"#{assoc_as}_type", :"#{assoc_as}_id"] if assoc_as.present?
-
-        [:id, :created_at, :updated_at] + poly_attr.to_a
-      end
-
-      # Get delegatable attributes
-      def delegatable_attributes
-        attributes = association_attribute_names.map(&:to_sym)
-        attributes = attributes & @options[:only].to_a   if @options[:only].present?
-        attributes = attributes - @options[:except].to_a if @options[:except].present?
-        attributes = attributes - default_excluded_attributes
-
-        attributes.map(&:to_sym)
-      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 localized delegatable attributes
-      def localized_attributes
-        attributes = delegatable_attributes
-        localized  = Localized.localized_methods(attributes) if @options[:localized].present?
+    # Get association table
+    def association_table
+      association_class.table_name
+    end
 
-        localized.to_a.map(&:to_sym)
-      end
+    # Default excluded attributes
+    def excluded_attributes
+      excluded  = %i[id created_at updated_at]
 
-      # Get delegatable methods
-      def delegatable_methods
-        attributes = delegatable_attributes + localized_attributes
-        readwrite  = ReadWrite.readwrite_methods(attributes)
-        dirty      = Dirty.dirty_methods(attributes)
-        methods    = readwrite + dirty
+      sti_col   = association_class.inheritance_column
+      excluded << sti_col.to_sym if sti_col.present?
 
-        methods.map(&:to_sym)
-      end
+      assoc_as  = association_reflection.options[:as]
+      excluded += [:"#{assoc_as}_type", :"#{assoc_as}_id"] if assoc_as.present?
 
-      # Delegate attributes
-      def delegate_attributes
-        options = { to: @options[:to], allow_nil: @options[:allow_nil], prefix: @options[:prefix] }
-        @model.delegate(*delegatable_methods, options)
-      end
+      excluded
+    end
 
-      # Redefine build association method
-      def redefine_build_association
-        assoc_name = @options[:to]
+    # Get delegatable attributes
+    def delegatable_attributes
+      attributes  = delegation_args(association_class.attribute_names)
+      attributes -= excluded_attributes
 
-        @model.class_eval do
-          class_eval <<-EOM, __FILE__, __LINE__ + 1
-            def #{assoc_name}
-              super || send(:build_#{assoc_name})
-            end
-          EOM
-        end
+      attributes.map! do |attribute_name|
+        ActiveDelegate::Attribute::Object.new(
+          attribute_name, association_class, attribute_options
+        )
       end
 
-      # Get attribute prefix
-      def attribute_prefix
-        prefix = @options[:prefix]
-        prefix.is_a?(TrueClass) ? @options[:to] : prefix
-      end
+      attributes.reject { |a| model.has_attribute?(a.prefixed) }
+    end
 
-      # Get unprefixed attribute
-      def unprefix_attribute(attribute)
-        attribute.to_s.sub("#{attribute_prefix}_", '')
-      end
+    # Delegate attributes
+    def call
+      redefine_build_association(association_name)
 
-      # Get prefixed attributes
-      def prefix_attributes(attributes)
-        if @options[:prefix].present?
-          attributes.map { |a| :"#{attribute_prefix}_#{a}" }
-        else
-          attributes
-        end
-      end
+      delegatable_attributes.each do |attribute|
+        delegate_methods(attribute.delegatable_methods)
+        define_model_class_methods(attribute)
 
-      # Get attribute default
-      def attribute_default(attribute)
-        @options.fetch :default, association_class.column_defaults["#{attribute}"]
+        define_attribute_methods(attribute)
+        define_attribute_queries(attribute)
       end
+    end
 
-      # Get attribute cast type
-      def attribute_cast_type(attribute)
-        @options.fetch :cast_type, association_class.type_for_attribute("#{attribute}")
-      end
+    private
 
-      # Check if attribute types are not the same
-      def cast_types_mismatch?(attribute)
-        attribute_cast_type(attribute) != association_class.type_for_attribute("#{attribute}")
+    # Redefine build association method
+    def redefine_build_association(assoc_name)
+      model.class_eval do
+        class_eval <<-EOM, __FILE__, __LINE__ + 1
+          def #{assoc_name}
+            super || send(:build_#{assoc_name})
+          end
+        EOM
       end
+    end
 
-      # Check if attribute needs type cast
-      def needs_type_cast?(attribute)
-        @options[:cast] != false && cast_types_mismatch?(attribute)
-      end
+    # Redefine attribute accessor methods
+    def redefine_attribute_accessors(method_name, attribute)
+      attr_options = {
+        association: association_name,
+        attribute:   attribute.unprefixed,
+        read_type:   attribute.read_type,
+        write_type:  attribute.write_type,
+        default:     attribute.default
+      }
 
-      # Check if should define attribute finders
-      def define_finders?(attribute)
-        @options[:finder] || Array(@options[:finder]).include?(attribute)
+      model.send(:redefine_method, method_name) do |*args|
+        ActiveDelegate::Attribute::Accessor.new(self, attr_options).read(*args)
       end
 
-      # Check if should define attribute scopes
-      def define_scopes?(attribute)
-        @options[:scope] || Array(@options[:scope]).include?(attribute)
+      model.send(:redefine_method, :"#{method_name}=") do |value|
+        ActiveDelegate::Attribute::Accessor.new(self, attr_options).write(value)
       end
+    end
 
-      # Save delagated attributes in model class
-      def save_delegated_attributes
-        dl_atable = association_reflection.klass.table_name
-        dl_method = :"#{dl_atable}_attribute_names"
+    # Delegate attribute methods
+    def delegate_methods(methods)
+      model.delegate(*methods, delegation_options)
+    end
 
-        delegated = prefix_attributes(delegatable_attributes)
-        define_attribute_defaults_and_methods(delegated)
+    # 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
 
-        delegated = @model.try(dl_method).to_a.concat(delegated)
-        @model.send(:define_singleton_method, dl_method) { delegated }
+    # 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)
 
-        if @options[:localized].present?
-          localized = prefix_attributes(localized_attributes)
-          lc_method = :"#{dl_atable}_localized_attribute_names"
+      method_name = :"#{association_table}_localized_attribute_names"
+      define_model_method(method_name, attribute.prefixed) if attribute.localized?
+    end
 
-          @model.send(:define_singleton_method, lc_method) { localized }
-        end
+    # Define delegated attribute methods
+    def define_attribute_methods(attribute)
+      if attribute.define?
+        model.attribute(attribute.aliased, attribute.read_type)
       end
 
-      # Define attribute default values, methods and scopes
-      def define_attribute_defaults_and_methods(attributes)
-        existing  = @model.attribute_names.map(&:to_sym)
-        undefined = attributes.reject { |a| a.in? existing }
-
-        undefined.each do |attrib|
-          attr_name = unprefix_attribute(attrib)
-
-          define_attribute_default_value(attrib, attr_name)
-          define_attribute_type_cast(attrib, attr_name)
-          define_attribute_and_alias(attrib, attr_name)
-          define_attribute_finders_and_scopes(attrib, attr_name)
-        end
+      attribute.delegatable_attributes.each do |method_name|
+        redefine_attribute_accessors(method_name, attribute)
       end
 
-      # Define delegated attribute default
-      def define_attribute_default_value(attrib, attr_name)
-        attr_default = attribute_default(attr_name)
-
-        unless attr_default.nil?
-          attr_assoc = @options[:to]
-          attr_cattr = :"_attribute_#{attrib}_default"
-
-          @model.send(:define_singleton_method, attr_cattr) { attr_default }
-
-          @model.class_eval do
-            class_eval <<-EOM, __FILE__, __LINE__ + 1
-              def #{attrib}
-                send(:#{attr_assoc}).try(:#{attr_name}) || self.class.send(:#{attr_cattr})
-              end
-            EOM
-          end
-        end
+      attribute.aliases.each do |alias_name, method_name|
+        model.alias_method(alias_name, method_name)
       end
+    end
 
-      # Define attribute type casting
-      def define_attribute_type_cast(attrib, attr_name)
-        attr_assoc = @options[:to]
-        attr_cattr = :"_attribute_#{attrib}_default"
-
-        if needs_type_cast?(attr_name)
-          @model.class_eval do
-            class_eval <<-EOM, __FILE__, __LINE__ + 1
-              def #{attrib}
-                assoc_value = send(:#{attr_assoc}).try(:#{attr_name})
-                self.class.type_for_attribute('#{attrib}').cast(assoc_value) ||
-                self.class.try(:#{attr_cattr})
-              end
-
-              def #{attrib}=(value)
-                assoc_value = self.class.type_for_attribute('#{attrib}').cast(value)
-                send(:#{attr_assoc}).send(:#{attr_name}=, assoc_value)
-              end
-            EOM
-          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 })
       end
 
-      # Define delegated attribute alias
-      def define_attribute_and_alias(attrib, attr_name)
-        cast_type  = attribute_cast_type(attr_name)
-        attr_alias = @options[:alias]
-
-        @model.attribute(attrib, cast_type)
-
-        unless attr_alias.nil?
-          @model.attribute(attr_alias, cast_type)
-          @model.alias_attribute(attr_alias, attrib)
-        end
+      model.send(:define_singleton_method, :"find_by_#{attr_method}!") do |value|
+        joins(assoc_name).find_by!(table_name => { attr_column => value })
       end
+    end
 
-      # Define attribute finders and scopes
-      def define_attribute_finders_and_scopes(attrib, attr_name)
-        attr_assoc = @options[:to]
-        attr_table = association_reflection.klass.table_name
-        attr_args  = [@options[:alias] || attrib, attr_name, attr_assoc, attr_table]
-
-        define_attribute_finder_methods(*attr_args) if define_finders?(attr_name)
-        define_attribute_scope_methods(*attr_args) if define_scopes?(attr_name)
+    # 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 })
       end
 
-      # Define attribute finder methods
-      def define_attribute_finder_methods(attrib, attr_name, attr_assoc, attr_table)
-        @model.send(:define_singleton_method, :"find_by_#{attrib}") do |value|
-          joins(attr_assoc).find_by(attr_table => { attr_name => value })
-        end
-
-        @model.send(:define_singleton_method, :"find_by_#{attrib}!") do |value|
-          joins(attr_assoc).find_by!(attr_table => { attr_name => value })
-        end
+      model.send(:define_singleton_method, :"without_#{attr_method}") do |*args|
+        joins(assoc_name).where.not(table_name => { attr_column => args })
       end
+    end
 
-      # Define attribute scope methods
-      def define_attribute_scope_methods(attrib, attr_name, attr_assoc, attr_table)
-        @model.scope :"with_#{attrib}", -> (*names) do
-          joins(attr_assoc).where(attr_table => { attr_name => names })
-        end
-
-        @model.scope :"without_#{attrib}", -> (*names) do
-          joins(attr_assoc).where.not(attr_table => { attr_name => names })
-        end
-      end
+    # Define attribute finders and scopes
+    def define_attribute_queries(attribute)
+      attr_options = {
+        assoc_name:  association_name,
+        table_name:  association_table,
+        attr_method: attribute.aliased,
+        attr_column: attribute.unprefixed
+      }
+
+      define_attribute_finders(attr_options) if attribute.finder?
+      define_attribute_scopes(attr_options)  if attribute.scope?
+    end
   end
 end

data/lib/active_delegate/delegator.rb

@@ -0,0 +1,60 @@
+module ActiveDelegate
+  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:    [],
+        only:      [],
+        to:        nil,
+        allow_nil: false
+      }
+    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)
+      available  = Array(available).map(&:to_sym)
+      available &= included if included.any?
+      available -= excluded if excluded.any?
+
+      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)
+      return reflection unless reflection.nil?
+      raise "#{@model.name} don't have the association #{association_name}"
+    end
+
+    # Get model association class
+    def association_class
+      association_reflection.klass
+    end
+  end
+end

data/lib/active_delegate/version.rb

@@ -1,3 +1,3 @@
 module ActiveDelegate
-  VERSION = '0.2.1'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_delegate
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Jonian Guveli
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-11 00:00:00.000000000 Z
+date: 2018-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -53,33 +53,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.14'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '10.0'
 description: Stores and retrieves delegatable data through attributes on an ActiveRecord
   class, with support for translatable attributes.
 email:
@@ -94,11 +94,14 @@ files:
 - README.md
 - Rakefile
 - lib/active_delegate.rb
+- lib/active_delegate/association/methods.rb
 - lib/active_delegate/associations.rb
+- lib/active_delegate/attribute/accessor.rb
+- lib/active_delegate/attribute/localize.rb
+- lib/active_delegate/attribute/methods.rb
+- lib/active_delegate/attribute/object.rb
 - lib/active_delegate/attributes.rb
-- lib/active_delegate/dirty.rb
-- lib/active_delegate/localized.rb
-- lib/active_delegate/read_write.rb
+- lib/active_delegate/delegator.rb
 - lib/active_delegate/version.rb
 homepage: https://github.com/hardpixel/active-delegate
 licenses:
@@ -120,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Delegate ActiveRecord model attributes and associations

data/lib/active_delegate/dirty.rb

@@ -1,19 +0,0 @@
-module ActiveDelegate
-  module Dirty
-    class << self
-      # Get dirty methods for attributes
-      def dirty_methods(attributes)
-        @dirty_methods = attributes.to_a.flat_map do |attribute|
-          method_suffixes.map { |suffix| "#{attribute}#{suffix}" }
-        end
-      end
-
-      # Get method suffixes
-      def method_suffixes
-        @method_suffixes ||= Class.new do
-          include ::ActiveModel::Dirty
-        end.attribute_method_matchers.map(&:suffix).select { |m| m =~ /\A_/ }
-      end
-    end
-  end
-end

data/lib/active_delegate/localized.rb

@@ -1,26 +0,0 @@
-require 'i18n'
-
-module ActiveDelegate
-  module Localized
-    class << self
-      # Get localized methods for attributes
-      def localized_methods(attributes)
-        @localized_methods = attributes.to_a.flat_map do |attribute|
-          method_suffixes.map { |suffix| "#{attribute}#{suffix}" }
-        end
-      end
-
-      # Get method suffixes
-      def method_suffixes
-        @method_suffixes ||= I18n.available_locales.map do |locale|
-          "_#{normalize_locale(locale)}"
-        end
-      end
-
-      # Normalize locale
-      def normalize_locale(locale)
-        "#{locale.to_s.downcase.sub("-", "_")}".freeze
-      end
-    end
-  end
-end

data/lib/active_delegate/read_write.rb

@@ -1,17 +0,0 @@
-module ActiveDelegate
-  module ReadWrite
-    class << self
-      # Get readwrite methods for attributes
-      def readwrite_methods(attributes)
-        @readwrite_methods = attributes.to_a.flat_map do |attribute|
-          method_suffixes.map { |suffix| "#{attribute}#{suffix}" }
-        end
-      end
-
-      # Get method suffixes
-      def method_suffixes
-        ['', '=', '?']
-      end
-    end
-  end
-end