active_delegate 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d157fcd42a41e6a9106addbf103a551543d9443
-  data.tar.gz: 181bc82d7f83e017d77438bee17a3fd1ff4225f5
+  metadata.gz: 35e32e13c8c9845a3a17e841ddb1eaa2d5f9121a
+  data.tar.gz: 0ed1a3d1c8ca242f17e4380b71580a67b5ee37c9
 SHA512:
-  metadata.gz: 19ab087839bd3766cb65f23caa4e9fc33d5bc7043b6488ccab65b67b2b5f222fd480a95f5c31474d1af6b06f8ddc473bbde2851d997530565816052cda366b16
-  data.tar.gz: 4c89f450c882dc11f0b0200c5631c82dabfbde717c319e2e107ed9a4fc8f559673595c65967a7294b0803061a097675de148565d3eb0cee8c819941a3b43321a
+  metadata.gz: 5cab38ba25465170241da07c01579281f56f7ad72e423fad6c42a22b3f1769d13963533b67347835fc2a93d1eccab2bbdd1157bae6c59ea9585829136629864a
+  data.tar.gz: '0782f2d0cc0d8f9585921d3fcf4dbedd32ecfcc5768fd45a90019be9343850b4c67733e9d82e1a6bf3cf7fb66558196a00c679e9ff574e1c0ee6b78c569ea2c0'

data/lib/active_delegate/attributes.rb

@@ -101,6 +101,11 @@ module ActiveDelegate
         prefix.is_a?(TrueClass) ? @options[:to] : prefix
       end
 
+      # Get unprefixed attribute
+      def unprefix_attribute(attribute)
+        attribute.to_s.sub("#{attribute_prefix}_", '')
+      end
+
       # Get prefixed attributes
       def prefix_attributes(attributes)
         if @options[:prefix].present?
@@ -110,13 +115,33 @@ module ActiveDelegate
         end
       end
 
+      # Get attribute default
+      def attribute_default(attribute)
+        @options[:default] || association_class.column_defaults["#{attribute}"]
+      end
+
+      # Get attribute cast type
+      def attribute_cast_type(attribute)
+        @options[:cast_type] || association_class.attribute_types["#{attribute}"]
+      end
+
+      # Check if should define attribute finders
+      def define_finders?(attribute)
+        @options[:finder] || Array(@options[:finder]).include?(attribute)
+      end
+
+      # Check if should define attribute scopes
+      def define_scopes?(attribute)
+        @options[:scope] || Array(@options[:scope]).include?(attribute)
+      end
+
       # Save delagated attributes in model class
       def save_delegated_attributes
         dl_atable = association_reflection.klass.table_name
         dl_method = :"#{dl_atable}_attribute_names"
 
         delegated = prefix_attributes(delegatable_attributes)
-        define_attribute_names_and_types(delegated)
+        define_attribute_defaults_and_methods(delegated)
 
         delegated = @model.try(dl_method).to_a.concat(delegated)
         @model.send(:define_singleton_method, dl_method) { delegated }
@@ -129,54 +154,65 @@ module ActiveDelegate
         end
       end
 
-      # Define attribute names and types
-      def define_attribute_names_and_types(attributes)
+      # 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    = attrib.to_s.sub("#{attribute_prefix}_", '')
-          cast_type    = @options[:cast_type] || association_class.attribute_types["#{attr_name}"]
-          attr_alias   = @options[:alias]
-          attr_default = @options[:default] || association_class.column_defaults["#{attr_name}"]
-          attr_finder  = @options[:finder] || Array(@options[:finder]).include?(attr_name)
-          attr_scope   = @options[:scope] || Array(@options[:scope]).include?(attr_name)
-
-          @model.attribute(attrib, cast_type)
-
-          define_attribute_default_value(attrib, attr_name, attr_default) unless attr_default.nil?
-          define_attribute_alias_method(attrib, attr_alias, cast_type) unless attr_alias.nil?
-          define_attribute_finder_methods(attr_alias || attrib, attr_name) if attr_finder == true
-          define_attribute_scope_methods(attr_alias || attrib, attr_name) if attr_scope == true
+          attr_name = unprefix_attribute(attrib)
+
+          define_attribute_default_value(attrib, attr_name)
+          define_attribute_and_alias(attrib, attr_name)
+          define_attribute_finders_and_scopes(attrib, attr_name)
         end
       end
 
       # Define delegated attribute default
-      def define_attribute_default_value(attrib, attr_name, attr_default)
-        attr_assoc = @options[:to]
-        attr_cattr = :"_attribute_#{attrib}_default"
+      def define_attribute_default_value(attrib, attr_name)
+        attr_default = attribute_default(attr_name)
 
-        @model.send(:define_singleton_method, attr_cattr) { attr_default }
+        unless attr_default.nil?
+          attr_assoc = @options[:to]
+          attr_cattr = :"_attribute_#{attrib}_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
+          @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
       end
 
       # Define delegated attribute alias
-      def define_attribute_alias_method(attrib, attr_alias, cast_type)
-        @model.attribute(attr_alias, cast_type)
-        @model.alias_attribute(attr_alias, attrib)
+      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
+      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)
       end
 
       # Define attribute finder methods
-      def define_attribute_finder_methods(attrib, attr_name)
-        attr_assoc  = @options[:to]
-        attr_table  = association_reflection.klass.table_name
+      def define_attribute_finder_methods(attrib, attr_name, attr_assoc, attr_table)
         attr_method = :"find_by_#{attrib}"
 
         @model.send(:define_singleton_method, attr_method) do |value|
@@ -191,32 +227,15 @@ module ActiveDelegate
       end
 
       # Define attribute scope methods
-      def define_attribute_scope_methods(attrib, attr_name)
-        attr_assoc = @options[:to]
-        attr_table = association_reflection.klass.table_name
-        attr_blank = { attr_table => { attr_name => nil } }
-
+      def define_attribute_scope_methods(attrib, attr_name, attr_assoc, attr_table)
         @model.scope :"with_#{attrib}", -> (*names) do
-          if names.empty?
-            left_outer_joins(attr_assoc).where.not(attr_blank)
-          else
-            names = names.map { |n| type_caster.type_cast_for_database(attr_name, n) }
-            named = { attr_table => { attr_name => names } }
-
-            left_outer_joins(attr_assoc).where(named)
-          end
+          names = names.map { |n| type_caster.type_cast_for_database(attr_name, n) }
+          joins(attr_assoc).where(attr_table => { attr_name => names })
         end
 
         @model.scope :"without_#{attrib}", -> (*names) do
-          if names.empty?
-            left_outer_joins(attr_assoc).where(attr_blank)
-          else
-            names = names.map { |n| type_caster.type_cast_for_database(attr_name, n) }
-            named = { attr_table => { attr_name => names } }
-
-            left_outer_joins(attr_assoc).where(attr_blank)
-            .or(left_outer_joins(attr_assoc).where.not(named))
-          end
+          names = names.map { |n| type_caster.type_cast_for_database(attr_name, n) }
+          joins(attr_assoc).where.not(attr_table => { attr_name => names })
         end
       end
   end

data/lib/active_delegate/version.rb

@@ -1,3 +1,3 @@
 module ActiveDelegate
-  VERSION = '0.1.9'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_delegate
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - Jonian Guveli
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-16 00:00:00.000000000 Z
+date: 2017-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord