active_tools 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acfe4b265f95ccad971ff61c48084979dd50b044
-  data.tar.gz: 9d6eecba7d6887738b49cc1df2227e4366f08bf2
+  metadata.gz: 6884fd00e3b38429d219a9d533116fa46c824de0
+  data.tar.gz: 5fa48a6d56370b0e68729b71ac24977f6c327bfd
 SHA512:
-  metadata.gz: 8c3567fda0e3798d24c27483bc433d4cb72283ad9bccd366c48b7ef3f29f569af4b82b997755b35312dfcf5f92aa13020f401510ee4cf524d11a23201ce4bb93
-  data.tar.gz: 8242b93fed275505b7cfaf7be8a3eb77c08f0440234ad4c8bac53d442830d7f15635f3831d9f611d5a23a5b6860eb845b38e390d8975fd58204a23e3ce453cc2
+  metadata.gz: 478603a760745f50193cbe24358e39fefef37792a766b0d31bad36f686b127812deb76f80e9d8d11cdc963a20d3d773287350855d1af7a8db1cb93c44fddf342
+  data.tar.gz: c8f2fbae68a570892e9f212a0bc9c1c611867d064e0212eb8668fe4ed3515aa096482dae36dd95ea30ef872a59a5a8dccb10a6bb4767676c0fabfdbc6d7281ce

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea

data/.ruby-gemset

@@ -0,0 +1 @@
+delegate_attributes

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0-p247

data/README.md

@@ -1,3 +1,58 @@
+# DOCS ARE UNDER CONSTRUCTION
+
+### For now, the most usable feature of active tools is 'custom counters' - my implementation of <t>counter through</t> solution
+
+#### Look here! Typical data structure
+
+Country
+
+    class Country # has 'products_count' column
+      ...
+    end
+
+Made in ...
+
+    class MadeIn # has 'products_count' column
+      belongs_to :country
+      
+      custom_counter_cache_for :country => {:made_ins_count => 1, :products_count => :products_count}
+      
+      # So, when MadeIn created/deleted, Country's 'made_ins_count' incremented/decremented by 1 and 'products_count' by MadeIn's 'products_count' value
+      ...
+    end
+
+Category (has parent)
+
+    class Category # has 'products_count' column
+      acts_as_nested_set # has parent and children (!)
+
+      custom_counter_cache_for "parent*" => {:children_count => 1, :products_count => :products_count}
+
+      # So, when Category created/deleted, parent's 'children_count' incremented/decremented by 1 and 'products_count' by Category's 'products_count' value
+
+    end
+
+Brand name
+
+    class Brand # has 'products_count' column
+      ...
+    end
+
+Product itself
+
+    class Product < ActiveRecord::Base
+      belongs_to :category
+      belongs_to :brand
+      belongs_to :made_in
+      
+      custom_counter_cache_for :made_in => {:products_count => 1, :country => {:products_count => 1}}, :category => {:products_count => 1, "parent*" => {:products_count => 1}}, :brand => {:products_count => 1}
+  
+      # You can use nested options... it is very very useful :)
+  
+    end
+
+Thanks
+
 # ActiveTools
 
 TODO: Write a gem description

data/active_tools.gemspec

@@ -15,6 +15,7 @@ Gem::Specification.new do |gem|
   gem.rubyforge_project = "active_tools"
 
   gem.add_dependency "rails"
+  gem.add_development_dependency "rspec"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/copy

@@ -0,0 +1,2 @@
+#/bin/sh
+rm -rfv /Volumes/library/"All for Ruby"/"Rails Projects"/active_tools && cp -Rv ~/active_tools /Volumes/library/"All for Ruby"/"Rails Projects"/

data/lib/active_tools/action_pack/action_dispatch/flash_stack.rb

@@ -2,6 +2,8 @@ module ActiveTools
   module ActionPack
     module ActionDispatch
       module FlashStack
+        # Doesn't work with Rails 4.0>
+  
         extend ActiveSupport::Concern
 
         included do

data/lib/active_tools/action_pack/action_view/perform_as_tree.rb

@@ -0,0 +1,38 @@
+module ActiveTools
+  module ActionPack
+    module ActionView
+      module PerformAsTree
+        def self.line(item, children_method, depth = 0, &block)
+          yield item, depth
+          item.send(children_method).each do |child|
+            line(child, children_method, depth+1, &block)
+          end
+        end
+      end
+    end
+  end
+  
+  module OnLoadActionView
+    
+    def perform_as_tree(scope, options = {}, &block)
+      options = options.with_indifferent_access
+      children_method = options[:children_method]||:children
+      parent_method = options[:parent_method]||:parent
+      id_key = options[:id]||nil
+      scope = case scope
+      when ::ActiveRecord::Relation then
+        parent_key = scope.klass.reflections[children_method].foreign_key
+        scope.where(parent_key => id_key)
+      when ::Array, ::Set then
+        scope.select {|item| item.send(parent_method) == id_key}
+      else
+        raise(TypeError, "ActiveRecord::Relation, Array or Set expected, #{scope.class.name} passed!")
+      end
+      scope.each do |item|
+        ActionPack::ActionView::PerformAsTree.line(item, children_method, 0, &block)
+      end
+    end
+    
+  end
+  
+end

data/lib/active_tools/action_pack/action_view.rb

@@ -1,4 +1,5 @@
 require 'active_tools/action_pack/action_view/tag_attributes'
+require 'active_tools/action_pack/action_view/perform_as_tree'
 
 module ActiveTools
   module ActionPack

data/lib/active_tools/active_model/delegate_attributes.rb

@@ -3,57 +3,33 @@ module ActiveTools
     module DelegateAttributes
       extend ::ActiveSupport::Concern
       
-      included do
-        class FakeErrors < ::ActiveModel::Errors
-          private
-          def normalize_message(attribute, message, options)
-            message ||= :invalid
-          end
-        end
-        
-      end
-      
       module ClassMethods
         def delegate_attributes(*args)
           options = args.extract_options!
           errors_option = options.delete(:errors)
           writer_option = options.delete(:writer)
+          prefix_option = options.delete(:prefix)
 
           writer_regexp = /=\z/
           readers = args.select {|a| a.to_s !=~ writer_regexp}
           writers = args.select {|a| a.to_s =~ writer_regexp}
           if writer_option == true
-            writers += readers.map {|a| "#{a}="}
+            writers |= readers.map {|a| "#{a}="}
           end
 
           class_eval do
             delegate *(readers + writers), options.dup
+            unless errors_option == false
+              valid_with options[:to], :attributes => Hash[readers.map {|a| [a, a]}], :fit => errors_option.to_s == "fit", :prefix => prefix_option
+            end
           end          
-
-          unless errors_option == false
-            class_eval <<-EOV
-              validate do
-                object = #{options[:to]}
-                #{"object.instance_variable_set(:@errors, FakeErrors.new(object))" if errors_option.to_s == "fit"}
-                if !object.valid?
-                  object.errors.messages.each do |attribute, suberrors|
-                    if attribute.to_s.in? %w{#{readers.join(" ")}}
-                      suberrors.each do |suberror|
-                        errors.add(attribute, suberror)
-                      end
-                    end
-                  end
-                end
-              end
-            EOV
-          end
         end
       end
       
       
     end
 
-	  ::ActiveModel::Validations.send(:include, ActiveModel::DelegateAttributes)    
+    ::ActiveModel::Validations.send(:include, ActiveModel::DelegateAttributes)    
 
   end
   

data/lib/active_tools/active_model/valid_with/fake_errors.rb

@@ -0,0 +1,12 @@
+module ActiveTools
+  module ActiveModel
+    module ValidWith
+      class FakeErrors < ::ActiveModel::Errors
+        private
+        def normalize_message(attribute, message, options)
+          message ||= :invalid
+        end
+      end
+    end
+  end
+end

data/lib/active_tools/active_model/valid_with.rb

@@ -0,0 +1,53 @@
+require 'active_tools/active_model/valid_with/fake_errors'
+module ActiveTools
+  module ActiveModel
+    module ValidWith
+      extend ::ActiveSupport::Concern
+      
+      module ClassMethods
+        def valid_with(*args)
+          options = args.extract_options!
+          object_name = args.first
+          passed_attr_map = options.delete(:attributes)
+          prefix = options.delete(:prefix)
+          raise(TypeError, "Option :attributes must be a Hash. #{passed_attr_map.class} passed!") unless passed_attr_map.is_a?(Hash)
+          attr_map_name = :"_valid_with_#{object_name}"
+          unless respond_to?(attr_map_name)
+            class_attribute attr_map_name 
+            self.send("#{attr_map_name}=", passed_attr_map.with_indifferent_access)
+          else
+            self.send(attr_map_name).merge!(passed_attr_map)
+          end
+
+          if passed_attr_map.any?
+            class_eval <<-EOV
+              validate do
+                if object = #{object_name}
+                  #{"object.instance_variable_set(:@errors, ActiveTools::ActiveModel::ValidWith::FakeErrors.new(object))" if options[:fit] == true}
+                  if !object.valid?
+                    object.errors.messages.each do |attribute, suberrors|
+                      if local_attribute = self.#{attr_map_name}[attribute]
+                        suberrors.each do |suberror|
+                          errors.add(["#{prefix}", local_attribute].select(&:present?).join("_"), suberror)
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            EOV
+          end
+        end
+      end
+      
+      
+    end
+
+    ::ActiveModel::Validations.send(:include, ActiveModel::ValidWith)    
+
+  end
+  
+  module OnLoadActiveRecord
+  end
+  
+end

data/lib/active_tools/active_record/adaptive_belongs_to/adapter.rb

@@ -0,0 +1,195 @@
+module ActiveTools
+  module ActiveRecord
+    module AdaptiveBelongsTo
+      class Adapter
+        attr_reader :association, :options
+
+        delegate :target, :target_id, :klass, :owner, :reflection, :to => :association
+
+        def initialize(association, options = {})
+          @association = association
+          @options = options.with_indifferent_access
+          @foreign_key = reflection.foreign_key
+          @remote_attributes = @options[:remote_attributes]
+          @init_proc = @options[:init_proc]
+          @update_if = @options[:update_if]
+          @destroy_if = @options[:destroy_if]
+          @uniq_by = Array(@options[:uniq_by]).map(&:to_s)
+          @association.load_target
+        end
+
+        def read(name)
+          valid_attribute?(name)
+          target.send(name) if target
+        end
+
+        def write(name, value)
+          valid_attribute?(name)
+          if value != read(name)
+            store_backup!
+            create_template!
+            target.send("#{name}=", value)
+            if same_as_backup?
+              restore_backup!
+            end
+          end
+        end
+
+        def try_commit
+          try_commit_existed || try_update
+        end
+
+        def try_destroy
+          try_destroy_backup
+          try_destroy_target
+        end
+
+        def try_update
+          if updateable_backup?
+            begin
+              @backup.update(attributes(@template, *@remote_attributes))
+            rescue ::ActiveRecord::StaleObjectError
+              @backup.reload
+              try_update
+            end
+            self.target = @backup
+          end
+        end
+
+        def try_commit_existed
+          if @template.present? && @uniq_by.any? && existed = detect_existed
+            self.target = existed
+            try_destroy_updateable_backup
+            true
+          end 
+        end
+
+        def try_destroy_backup
+          if destroyable_backup?
+            begin
+              @backup.destroy
+            rescue ::ActiveRecord::StaleObjectError
+              @backup.reload
+              try_destroy_backup
+            end
+          end
+        end
+
+        def try_destroy_updateable_backup
+          if updateable_backup?
+            begin
+              @backup.destroy
+            rescue ::ActiveRecord::StaleObjectError
+              @backup.reload
+              try_destroy_updateable_backup
+            end
+          end
+        end
+
+        def try_destroy_target(force = false)
+          if destroyable_target?
+            begin
+              target.destroy
+            rescue ::ActiveRecord::StaleObjectError
+              target.reload
+              try_destroy_target
+            end
+          end
+        end
+
+        def clear!
+          @template = nil
+          @backup = nil
+        end
+
+        private
+
+        def detect_existed
+          outer_values = {}
+          where_values = {}
+          @uniq_by.each do |attribute|
+            relation_options_call = "#{attribute}_relation_options"
+            if klass.respond_to?(relation_options_call)
+              values = @template.send(relation_options_call)
+              outer_values.merge!(values[:outer_values])
+              where_values.merge!(values[:where_values])
+            else
+              where_values[attribute] = @template.send(attribute)
+            end
+          end
+          klass.includes(outer_values).where(where_values).limit(1).first
+        end
+
+        def updateable_backup?
+          @backup.present? && @update_if.try(:call, @backup)
+        end
+
+        def destroyable_backup?
+          @backup.present? && !@backup.destroyed? && @destroy_if.try(:call, @backup)
+        end
+
+        def destroyable_target?
+          target.try(:persisted?) && !target.destroyed? && @destroy_if.try(:call, target)
+        end
+        
+        def attributes(object, *attrs)
+          Hash[attrs.map {|a| [a, object.send(a)]}]
+        end
+
+        def create_template!
+          if target.nil? || @template.nil? 
+            self.target = template
+          end
+        end
+
+        def restore_backup!
+          if @backup
+            self.target = @backup
+            @backup = nil
+          end
+        end
+        
+        def store_backup!
+          if target.try(:persisted?)
+            @backup ||= target
+          end
+        end
+
+        def same_as_backup?
+          @backup.present? && eval(@remote_attributes.map {|a| "@backup.send(:#{a}) == target.send(:#{a})"}.join(" && "))
+        end
+
+        def valid_attribute?(name)
+          raise(NameError, "Undefined remote attribute :#{name}!") unless @remote_attributes.include?(name.to_s)
+        end
+
+        def target=(record)
+          if owner.persisted?
+            association.send(:replace_keys, record)
+            association.set_inverse_instance(record)
+            association.instance_variable_set(:@updated, true) if record != @backup
+            association.target = record
+          else
+            association.replace(record)
+          end
+        end
+
+        def template
+          @template ||=
+          if target.try(:persisted?)
+            klass.new(attributes(target, *@remote_attributes))
+          elsif target.nil?
+            klass.new
+          elsif target.try(:new_record?)
+            target.dup
+          end
+          @template.tap do |t|
+            @init_proc.try(:call, t)
+          end
+        end 
+      end
+
+    end
+  end
+  
+end

data/lib/active_tools/active_record/adaptive_belongs_to.rb

@@ -0,0 +1,120 @@
+require 'active_tools/active_record/adaptive_belongs_to/adapter'
+module ActiveTools
+  module ActiveRecord
+    module AdaptiveBelongsTo
+      extend ::ActiveSupport::Concern
+      
+      included do
+      end
+
+      module ClassMethods
+  
+        def relation_options_under(*args)
+          path = args.extract_options!
+          local_attribute = args.first
+          local_method = "#{local_attribute}_relation_options"
+
+          define_singleton_method local_method do |instance = nil|
+            outer_values = {}
+            where_values = {}
+            path.each do |assoc_name, remote_attributes|
+              reflection = reflections[assoc_name]
+              target = instance.try(reflection.name)
+              outer_values[reflection.name] = {}
+              Array(remote_attributes).each do |remote_attribute|
+                remote_method = "#{remote_attribute}_relation_options"
+                if reflection.klass.respond_to?(remote_method)
+                  deeper = reflection.klass.send(remote_method, target)
+                  outer_values[reflection.name].merge!(deeper[:outer_values])
+                  where_values.merge!(deeper[:where_values])
+                else
+                  where_values[reflection.table_name] ||= {}.with_indifferent_access
+                  where_values[reflection.table_name][remote_attribute] = target.try(remote_attribute)
+                end
+              end
+            end
+            {:outer_values => outer_values, :where_values => where_values}
+          end
+          
+          class_eval do
+            define_method local_method do
+              self.class.send(local_method, self)
+            end
+          end
+          
+        end
+        
+        def adaptive_belongs_to(*args)
+          options = args.extract_options!
+          assoc_name = args.first
+          unless reflection = reflections[assoc_name]
+            raise(ArgumentError, ":#{assoc_name} method doesn't look like an association accessor!")
+          end
+          adapter_name = "#{assoc_name}_"
+          config_name = "#{assoc_name}_adapter_options"
+          
+          raise(TypeError, "Option :attributes must be a Hash. #{options[:attributes].class} passed!") unless options[:attributes].is_a?(Hash)
+          attr_map = options.delete(:attributes).with_indifferent_access
+       
+          valid_with assoc_name, :attributes => attr_map
+        
+          class_attribute config_name
+          self.send("#{config_name}=", options.merge(:remote_attributes => attr_map.keys))
+          
+          class_eval <<-EOV
+            after_validation do
+              #{adapter_name}.try_commit
+            end
+
+            after_commit do
+              #{adapter_name}.try_destroy_backup
+              #{adapter_name}.clear!
+            end
+
+            after_destroy do
+              #{adapter_name}.try_destroy
+            end
+          
+            def #{adapter_name}
+              @#{adapter_name} ||= ActiveTools::ActiveRecord::AdaptiveBelongsTo::Adapter.new(association(:#{assoc_name}), #{config_name})
+            end
+          EOV
+
+          attr_map.each do |remote_attribute, local_attribute|
+            relation_options_under(local_attribute, assoc_name => remote_attribute)
+            class_eval do
+              define_method local_attribute do
+                send(adapter_name).read(remote_attribute)
+              end
+
+              define_method "#{local_attribute}=" do |value|
+                send(adapter_name).write(remote_attribute, value)
+              end
+            end
+          end
+
+          # attr_map.each do |remote_attribute, local_attribute|        
+          #   class_eval <<-EOV
+          #     def #{local_attribute}_adaptive
+          #       [{:#{assoc_name} => {}}, {:#{reflections[assoc_name].table_name} => {:#{remote_attribute} => #{local_attribute}}}]
+          #     end
+          # 
+          #     def #{local_attribute}
+          #       #{adapter_name}.read(:#{remote_attribute})
+          #     end
+          # 
+          #     def #{local_attribute}=(value)
+          #       #{adapter_name}.write(:#{remote_attribute}, value)
+          #     end           
+          #   EOV
+          # end
+        end    
+      end
+    end
+  end
+  
+  module OnLoadActiveRecord
+    include ActiveRecord::AdaptiveBelongsTo
+  end
+  
+end

data/lib/active_tools/active_record/custom_counter_cache/instance_methods.rb

@@ -0,0 +1,51 @@
+module ActiveTools
+  module ActiveRecord
+    module CustomCounterCache
+      module InstanceMethods
+        def custom_counter_cache_after_create(assoc_name, reflection, assoc_mapping)
+          if record = send(assoc_name)
+            ActiveRecord::CustomCounterCache.digger(self, record, assoc_mapping) do |parent, cache_column, value|
+              parent.class.update_counters(parent.id, cache_column => value)
+            end
+            @_after_create_custom_counter_called = true
+          end
+        end
+
+        def custom_counter_cache_before_destroy(assoc_name, reflection, assoc_mapping)
+          foreign_key = reflection.foreign_key.to_sym
+          unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
+            record = send(assoc_name)
+            if record && !self.destroyed?
+              ActiveRecord::CustomCounterCache.digger(self, record, assoc_mapping) do |parent, cache_column, value|
+                parent.class.update_counters(parent.id, cache_column => -value)
+              end
+            end
+          end
+        end
+
+        def custom_counter_cache_after_update(assoc_name, reflection, assoc_mapping)
+          foreign_key  = reflection.foreign_key
+          if (@_after_create_custom_counter_called ||= false)
+            @_after_create_custom_counter_called = false
+          elsif send(:attribute_changed?, foreign_key) && !new_record? && (Rails.version >= "4.1.0" ? association(assoc_name).constructable? : defined?(reflection.klass.to_s.camelize))
+            model           = reflection.klass
+            foreign_key_was = attribute_was foreign_key
+            foreign_key     = attribute foreign_key
+
+            if foreign_key && model.respond_to?(:increment_counter) && to_increment = model.find_by_id(foreign_key)
+              ActiveRecord::CustomCounterCache.digger(self, to_increment, assoc_mapping) do |parent, cache_column, value|
+                parent.class.update_counters(parent.id, cache_column => value)
+              end
+            end
+            if foreign_key_was && model.respond_to?(:decrement_counter) && to_decrement = model.find_by_id(foreign_key_was)
+              ActiveRecord::CustomCounterCache.digger(self, to_decrement, assoc_mapping) do |parent, cache_column, value|
+                parent.class.update_counters(parent.id, cache_column => -value)
+              end
+            end
+          end
+        end
+      end
+    
+    end
+  end
+end

data/lib/active_tools/active_record/custom_counter_cache.rb

@@ -0,0 +1,64 @@
+require 'active_tools/active_record/custom_counter_cache/instance_methods'
+
+module ActiveTools
+  module ActiveRecord
+    module CustomCounterCache
+      extend ::ActiveSupport::Concern
+      
+      included do
+      end
+      
+      module ClassMethods
+        def custom_counter_cache_for(*args)
+          mapping = args.extract_options!
+          mapping.each do |assoc_name, value|
+            assoc_name = assoc_name.to_s
+            if assoc_name.last == "*"
+              if value.is_a?(Hash)
+                assoc_mapping = value.merge(assoc_name => value)
+              end
+              assoc_name = assoc_name[0..-2]
+            else
+              assoc_mapping = value
+            end
+            reflection = reflections[assoc_name.to_sym]
+          
+            unless method_defined? :custom_counter_cache_after_create
+              include ActiveRecord::CustomCounterCache::InstanceMethods
+            end
+          
+            after_create lambda { |record|
+              record.custom_counter_cache_after_create(assoc_name, reflection, assoc_mapping)
+            }
+
+            before_destroy lambda { |record|
+              record.custom_counter_cache_before_destroy(assoc_name, reflection, assoc_mapping)
+            }
+
+            after_update lambda { |record|
+              record.custom_counter_cache_after_update(assoc_name, reflection, assoc_mapping)
+            }
+          end
+        end
+      end
+
+      def self.digger(owner, object, mapping)
+        object.method_digger(mapping) do |object, key, response, value|
+          if response && !response.is_a?(::ActiveRecord::Base)
+            count = case value
+            when String, Symbol then owner.send(value)
+            when Fixnum then value
+            end
+            yield object, key, count          
+          end
+        end
+      end
+      
+    end
+  end
+  
+  module OnLoadActiveRecord
+    include ActiveRecord::CustomCounterCache
+  end
+  
+end

data/lib/active_tools/active_record/record_id.rb

@@ -1,5 +1,5 @@
 module ActiveTools
-  module ActiveModel
+  module ActiveRecord
     module RecordId
       extend ::ActiveSupport::Concern
       
@@ -10,18 +10,18 @@ module ActiveTools
       end
       
       def record_id
-        "#{self.class.model_name.singular}_#{try(:id)||uniq_id}"
+        "#{self.class.model_name.singular}_#{try(self.class.primary_key)||uniq_id}"
       end
 
       def uniq_id
-        Base64.urlsafe_encode64(Time.now._dump)
+        Base64.urlsafe_encode64(Time.now.send(:_dump))
       end
       
     end
   end
   
   module OnLoadActiveRecord
-    include ActiveModel::RecordId
+    include ActiveRecord::RecordId
   end
   
 end

data/lib/active_tools/activemodel.rb

@@ -1,3 +1,4 @@
+require 'active_tools/active_model/valid_with'
 require 'active_tools/active_model/delegate_attributes'
 
 module ActiveTools

data/lib/active_tools/activerecord.rb

@@ -1,4 +1,6 @@
 require 'active_tools/active_record/record_id'
+require 'active_tools/active_record/adaptive_belongs_to'
+require 'active_tools/active_record/custom_counter_cache'
 
 module ActiveTools
   module ActiveRecord

data/lib/active_tools/core_extension/method_digger.rb

@@ -0,0 +1,42 @@
+module ActiveTools
+  module CoreExtension
+    
+    module MethodDigger
+      module ObjectExtension
+        def method_digger(tree, &block)
+          tree.stringify_keys!
+          tree.each do |method, value|
+            if method.last == "*"
+              method = method[0..-2]
+              cycle_call(method) do |nested|
+                yield self, method, nested, value
+                if value.is_a?(Hash) && !nested.nil?
+                  nested.method_digger(value, &block)
+                end
+              end
+            else
+              response = try(:send, method)
+              yield self, method, response, value
+              if value.is_a?(Hash) && !response.nil?
+                response.method_digger(value, &block)
+              end
+            end
+          end
+        end
+        
+        def cycle_call(method, &block)
+          object = self
+          export = []
+          while object = object.try(:send, method)
+            yield object if block_given?
+            export << object
+          end
+          export
+        end
+        
+      end
+
+      ::Object.send(:include, ObjectExtension)
+    end
+  end
+end

data/lib/active_tools/core_extension.rb

@@ -3,6 +3,7 @@ require 'active_tools/core_extension/deep_merge'
 require 'active_tools/core_extension/hashup'
 require 'active_tools/core_extension/merge_hashup'
 require 'active_tools/core_extension/kabuki'
+require 'active_tools/core_extension/method_digger'
 
 module ActiveTools
   module CoreExtension

data/lib/active_tools/version.rb

@@ -1,3 +1,3 @@
 module ActiveTools
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/active_tools/active_model/delegate_attributes_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe ActiveTools::ActiveModel::DelegateAttributes do
+  class Parent
+    include ActiveModel::Validations
+    include ActiveTools::ActiveModel::DelegateAttributes
+
+    attr_accessor :child
+
+    delegate_attributes :name, to: :child, writer: true
+    delegate_attributes :name, to: :child, prefix: :prefixed, writer: true
+  end
+
+  class Child
+    include ActiveModel::Validations
+    include ActiveTools::ActiveModel::DelegateAttributes
+
+    attr_accessor :name
+
+    validates_presence_of :name
+  end
+
+  let(:teh_object) { Parent.new.tap{|parent| parent.child = teh_child} }
+  let(:teh_child) { Child.new }
+
+  it "delegates the given attribute from parent to child" do
+    teh_object.name = "Foo"
+
+    expect(teh_child.name).to eq("Foo")
+    expect(teh_object.name).to eq("Foo")
+  end
+
+  it "delegates the given attribute with a prefix from parent to child" do
+    teh_object.prefixed_name = "Bar"
+
+    expect(teh_child.name).to eq("Bar")
+    expect(teh_object.prefixed_name).to eq("Bar")
+  end
+
+  it "forwards the errors from child to parent" do
+    expect(teh_object.valid?).to be_false
+    expect(teh_object.errors.messages[:name]).to eq(["can't be blank"])
+  end
+
+  it "forwards the errors from child to parent via prefix" do
+    expect(teh_object.valid?).to be_false
+    expect(teh_object.errors.messages[:prefixed_name]).to eq(["can't be blank"])
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'active_model'
+require 'rails'
+require 'active_tools'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_tools
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Valery Kvon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-23 00:00:00.000000000 Z
+date: 2013-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Missing tools for Rails developers
 email:
 - addagger@gmail.com
@@ -32,20 +46,30 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .ruby-gemset
+- .ruby-version
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - active_tools.gemspec
+- copy
 - lib/active_tools.rb
 - lib/active_tools/action_pack/action_controller.rb
 - lib/active_tools/action_pack/action_controller/path_helper.rb
 - lib/active_tools/action_pack/action_dispatch.rb
 - lib/active_tools/action_pack/action_dispatch/flash_stack.rb
 - lib/active_tools/action_pack/action_view.rb
+- lib/active_tools/action_pack/action_view/perform_as_tree.rb
 - lib/active_tools/action_pack/action_view/tag_attributes.rb
 - lib/active_tools/actionpack.rb
 - lib/active_tools/active_model/delegate_attributes.rb
+- lib/active_tools/active_model/valid_with.rb
+- lib/active_tools/active_model/valid_with/fake_errors.rb
+- lib/active_tools/active_record/adaptive_belongs_to.rb
+- lib/active_tools/active_record/adaptive_belongs_to/adapter.rb
+- lib/active_tools/active_record/custom_counter_cache.rb
+- lib/active_tools/active_record/custom_counter_cache/instance_methods.rb
 - lib/active_tools/active_record/record_id.rb
 - lib/active_tools/activemodel.rb
 - lib/active_tools/activerecord.rb
@@ -60,12 +84,15 @@ files:
 - lib/active_tools/core_extension/kabuki/dump.rb
 - lib/active_tools/core_extension/kabuki/zip.rb
 - lib/active_tools/core_extension/merge_hashup.rb
+- lib/active_tools/core_extension/method_digger.rb
 - lib/active_tools/engine.rb
 - lib/active_tools/misc.rb
 - lib/active_tools/misc/input_source.rb
 - lib/active_tools/misc/script_flow.rb
 - lib/active_tools/railtie.rb
 - lib/active_tools/version.rb
+- spec/active_tools/active_model/delegate_attributes_spec.rb
+- spec/spec_helper.rb
 homepage: http://vkvon.ru/projects/active_tools
 licenses: []
 metadata: {}
@@ -85,9 +112,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: active_tools
-rubygems_version: 2.0.0
+rubygems_version: 2.0.4
 signing_key: 
 specification_version: 4
 summary: ActionDispatch, ActionController, ActiveModel, ActiveRecord, ActiveSupport,
   ActionView and core extensions
-test_files: []
+test_files:
+- spec/active_tools/active_model/delegate_attributes_spec.rb
+- spec/spec_helper.rb