acts_has_many 0.1.5 → 0.2.0

data/README.md

@@ -33,9 +33,9 @@ end
 # OR
 
 class Company < ActiveRecord::Base
-  acts_has_many :users # list necessary relations
-  
   has_many :users
+
+  acts_has_many :users # list necessary relations
 end
 
 # acts_has_many options:
@@ -60,13 +60,12 @@ company.actuale? :users # => false ( exclude 1 record of current relation)
 
 company   # => <Company id: 1, title: "Microsoft"> 
 
-update_id, delete_id  = company.has_many_update({ title: 'Google'}, :users)
+update_record, delete_record  = company.has_many_update({ title: 'Google'}, :users)
 # or
-#   update_id, delete_id  = company.update_with_users({ title: 'Google'})
+#   update_record, delete_record  = company.update_with_users({ title: 'Google'})
 
-update_id # => 1
-delete_id # => nil
-company   # => <Company id: 1, title: "Google"> 
+update_record # => <Company id: 1, title: "Google"> 
+delete_record # => nil
 
 user2 = User.create do |user|
 	user.company = company
@@ -80,11 +79,11 @@ company.actuale? :users # => true
 #   user2.destroy # => user will be destroyed, company will rollback (because company is used by other user)
 
 company   # => <Company id: 1, title: "Google"> 
-update_id, delete_id  = company.has_many_update({ title: 'Apple'}, :users)
-update_id # => 2
-delete_id # => nil
+update_record, delete_id  = company.has_many_update({ title: 'Apple'}, :users)
+update_record # => <Company id: 2, title: "Apple"> 
+delete_record # => nil
 
-user2.company = Company.find(update_id)
+user2.company = update_record
 user2.save
 
 # if you want to destroy user now
@@ -95,65 +94,17 @@ Company.all # [#<Company id: 1, title: "Google">, #<Company id: 2, title: "Apple
 company.destroy # => false (because company is used)
 
 companu 	# => <Company id: 1, title: "Google">
-update_id, delete_id  = company.has_many_update({ title: 'Apple'}, :users)
-update_id 	# => 2
-delete_id 	# => 1
+update_record, delete_record  = company.has_many_update({ title: 'Apple'}, :users)
+update_record 	# => <Company id: 2, title: "Apple"> 
+delete_record 	# => <Company id: 1, title: "Google">
 
-user2.company = Company.find(update_id)
+user2.company = update_record
 user2.save
 
 company.destroy # => true
 
-# this situation with delete_id best way is "company.delete" because you miss unnecessary check actuality
-
-# if you need update element and you don't care where it uses you can skip relation
-Company.first.has_many_update({title: "IBM"}) 
-# in this case check all relation but if you use this gem you don't have unused record
-# that why this exampl is equal Company.first_or_create({title: "IBM"})
-
+# this situation with delete_record best way is "company.delete" because you miss unnecessary check actuality
 
-```
-### Also you can use has_many_update!
-```ruby
-
-user = User.first
-user.company.has_many_update!({title: "Google"}, user)
-
-user.reload # becaus variable user have old data
-user.company # <Company id: 3, title: "Google">
-# you don't need update user
-```
-### Use acts_has_many_for with acts_has_many
-When use acts_has_many_for you don't need set relation and give parent record in case with has_many_update!
-```ruby
-
-class User < ActiveRecord::Base
-  belongs_to :company, dependent: :destroy
-  acts_has_many_for :company
-end
-
-class Company < ActiveRecord::Base
-  has_many :users
-
-  acts_has_many # after necessary relation
-end
-
-# in this case 
-
-user = User.first
-company = user.company
-company.has_many_update!({title: "Google"}) # don't give record user
-
-user.reload # becaus variable user have old data
-user.company # <Company id: 3, title: "Google">
-
-new_id, del_id = user.company.has_many_update({title: "Google"}) # don't give relation
-
-# in this case has_many_update doesn't know about relation and the same as if you skip relation(see above)
-new_id, del_id = Company.first.has_many_update({title: "something else"}) 
-
-# not work becous has_many_update! doesn't know about parent record
-Company.first.has_many_update!({title: "something else"}) 
 ```
 
 ### has_many_update_through used with has_many :through and get array parameters
@@ -169,9 +120,9 @@ class UserCompany < ActiveRecord::Base
 
 class Company < ActiveRecord::Base
   has_many :users, :through => :user_company
-  acts_has_many :through => true
-  
   has_many :user_company
+
+  acts_has_many :users, :through => true
 end
 
 class User < ActiveRecord::Base
@@ -186,6 +137,35 @@ user.companies = new_rows # update user companies
 Company.delete(delete_ids) # for delete_ids from has_many_update_through best way is to use "delete" and miss unnecessary check
 ```
 
+### Use acts_has_many_for with acts_has_many
+When use acts_has_many_for you can user attributes
+```ruby
+
+user = User.create name: 'Bill', company_attributes: { title: 'Microsoft' }
+
+or
+
+user.company_attributes = { title: 'Google' }
+
+or 
+
+user.company_attributes = Company.first
+user.save
+
+# if you use has_many_through you can use collection
+
+user = User.create name: 'Bob', companies_collection: [{title: 'MS'}, {title: 'Google'}]
+
+or
+
+user.companies_collection = [{title: 'MS'}, {title: 'Google'}]
+
+or
+
+user.companies_collection = Company.all
+user.save
+
+```
 
 Contributing
 ------------
@@ -193,7 +173,6 @@ You can help improve this project.
 
 Here are some ways *you* can contribute:
 
-* by using alpha, beta, and prerelease versions
 * by reporting bugs
 * by suggesting new features
 * by writing or editing documentation

data/lib/acts_has_many/active_record/acts_has_many/child.rb

@@ -0,0 +1,143 @@
+module ActiveRecord
+  module ActsHasMany
+
+    # Added:
+    #   class methods:
+    #     +has_many_through_update+
+    #
+    #   instance methods:
+    #     +has_many_update+
+    #     +update_with_<relation>+
+    #     +actuale?+
+
+    module Child
+
+      def self.included base
+
+        # Generate methods:
+        #   update_with_<relation>(data)
+
+        base.dependent_relations.each do |relation|
+          define_method("update_with_#{relation}") do |data|
+            has_many_update data, relation
+          end
+        end
+      end
+
+      #
+      # +has_many_update+ (return: array) - [new_record, delete_record]
+      # options: (Hash is deprecated, list parameters)
+      #   data (type: hash) - data for updte
+      #   relation (type: str, symbol) - current relation for check
+      #
+
+      def has_many_update data, relation
+        data = { model.compare => ''}.merge data
+
+        if relation.blank?
+          warn "[ARRGUMENT MISSING]: 'has_many_update' don't know about current relation, and check all relations"
+        end
+
+        has_many_cleaner data.symbolize_keys, relation
+      end
+
+      #
+      # +actuale?+ - check the acutuality of element in has_many table
+      # options:
+      #   relation (String, Symbol) - for exclude one record from current relation
+      #
+
+      def actuale? opt = ""
+        relation = opt.to_s.tableize
+
+        actuale = false
+        model.dependent_relations.each do |dependent_relation|
+          tmp = self.send dependent_relation
+          if relation == dependent_relation
+            actuale ||= tmp.all.size > 1
+          else
+            actuale ||= tmp.exists?
+          end
+        end
+        actuale
+      end
+    end
+
+  private
+
+    #
+    # +destroy_filter+ - use with before_filter, and protect actuale records
+    #
+
+    def destroy_filter
+      not actuale?
+    end
+
+    #
+    # +has_many_cleaner+ - base mothod
+    #
+
+    def has_many_cleaner data, relation
+      compare = { model.compare => data[model.compare] }
+
+      new_record = self
+      del_record = nil
+
+      if actuale? relation
+        new_record = model.where(compare).first_or_create data
+      else
+        object_tmp = model.where(compare).first
+        unless object_tmp.nil?
+          del_record = (new_record.id == object_tmp.id) ? nil : new_record
+          new_record = object_tmp
+        else
+          if new_record.id.nil?
+            new_record = model.where(compare).first_or_create data
+          else
+            if data[model.compare].blank?
+              del_record, new_record = new_record, nil
+            else
+              update_attributes data
+            end
+          end
+        end
+      end
+      [new_record, del_record]
+    end
+
+
+    module ChildThrough
+
+      #
+      # +has_many_through_update+ (return array) [ 1 - array new records, 2 - array delete records ]
+      # options
+      #   :update (array) - data for update (id and data)
+      #   :new (array) - data for create record (data)
+      #
+      # +for delete records need use method destroy !!!+
+      #
+
+      def has_many_through_update(options)
+        record_add = []
+        record_del = []
+
+        options[:update].each do |id, data|
+          add, del = find(id).has_many_update data, options[:relation]
+          record_add << add unless add.nil?
+          record_del << del unless del.nil?
+        end unless options[:update].nil?
+
+        unless options[:new].nil?
+          options[:new].uniq!
+          options[:new].each do |data|
+            data = data.symbolize_keys
+            record_add << where(compare => data[compare]).first_or_create(data)
+            record_del.delete record_add.last
+          end
+        end
+
+        [record_add, record_del]
+      end
+    end
+  end
+end

data/lib/acts_has_many/active_record/acts_has_many/parent.rb

@@ -0,0 +1,106 @@
+module ActiveRecord
+  module ActsHasMany
+
+    #
+    # Add class methods:
+    #   +<relation>_attributes=+
+    #   or
+    #   +<relation>_collection=+
+    #
+
+    module Parent
+
+      def self.included base
+
+        #
+        # Generate class methods
+        #   +<relation>_attributes=+ - set one element (use with belogns_to)
+        #   options:
+        #     data (type: Hash, existing recod, NilClass)
+        #
+        #   Create or update child record and set to parent when `data` is Hash
+        #   Change data with delating or leaving child record when `data` is exists record, or NilClass
+        #
+        # =>------------------------------------------------------------------
+        #
+        #   +<relation>_collection=+ - set many elements (use with has_many :through)
+        #   options:
+        #     data (type: Array with (exist records or Hash)
+        #
+        #   Create or select exists records and set to parent, unused record try destory
+        #
+
+        base.dependent_relations.each do |relation|
+          unless base.reflect_on_association relation.to_sym
+            raise ArgumentError, "No association found for name `#{relation}`. Has it been defined yet?"
+          end
+
+          relation = relation.to_s
+          unless base.reflect_on_association(relation.to_sym).collection?
+            base.class_eval <<-EOV, __FILE__ , __LINE__
+            def #{relation}_attributes= data
+              self.tmp_garbage ||= {}
+              current = self.#{relation}
+
+              if data.is_a? Hash
+                if current
+                  new, del = current.has_many_update data, '#{base.name.tableize}'
+                else
+                  new, del = #{relation.classify}.new.has_many_update data, '#{base.name.tableize}'
+                end
+
+                self.#{relation} = new
+                self.tmp_garbage.merge!({ #{relation}: del }) if del
+              else
+                self.#{relation} = data
+                self.tmp_garbage.merge!({ #{relation}: current }) if current
+              end
+            end
+            EOV
+          else
+            base.class_eval <<-EOV, __FILE__ , __LINE__
+            def #{relation}_collection= data
+              self.tmp_garbage ||= {}
+
+              if data.is_a? Array
+                if data.first.is_a? Hash
+                  new, del = #{relation.classify}.has_many_through_update new: data, relation: '#{base.name.tableize}'
+                elsif data.first.is_a? #{relation.classify}
+                  new, del = data, []
+                elsif data.empty?
+                  new, del = [],[]
+                else
+                  raise ArgumentError, "Array with (Hash or " + #{relation.classify}.inspect + ") expected, got Array with " + data.first.inspect
+                end
+
+                #{relation}.each{ |t| del << t if not new.include? t }
+                self.#{relation} = new
+                self.tmp_garbage.merge!({ #{relation}: del }) if del.present?
+              else
+                raise ArgumentError, "Array expected, got " + data.inspect
+              end
+            end
+            EOV
+          end
+        end
+      end
+
+    private
+
+      #
+      #  +clear_garbage+ work with after_save and try destroied records from tmp_garbage
+      #
+
+      def clear_garbage
+        self.tmp_garbage.each do |relation, record|
+          if record.is_a? Array
+            record.each { |r| r.destroy }
+          else
+            record.destroy
+          end
+        end if self.tmp_garbage.present?
+        self.tmp_garbage = {}
+      end
+    end
+  end
+end

data/lib/acts_has_many/active_record/acts_has_many.rb

@@ -0,0 +1,100 @@
+module ActiveRecord
+  module ActsHasMany
+
+    #
+    # Add class methods: (for use in your model)
+    #   +acts_has_many_for+
+    #   +acts_has_many+
+    #
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Add class methods:
+      #   +dependent_relations+
+      #   +compare+
+      #   +model+
+      #   +has_many_through_update+
+      #
+      # Add instance mothods:
+      #   +actuale?+
+      #   +has_many_update+
+      #   +update_with_<relation>+
+      #
+      # Set:
+      #   validates for <compare_element> (uniqueness: true, presence: true)
+      #   before destroy filter
+      #
+
+      def acts_has_many *opt
+        options = { compare: :title, through: false }
+        options.update opt.extract_options!
+        options.assert_valid_keys :compare, :through
+        options[:relations] = opt
+
+        options[:relations] = self.reflect_on_all_associations(:has_many)
+          .map(&:name) if options[:relations].blank?
+
+        dependent_relations = []
+        options[:relations].each do |relation|
+          if reflect_on_association relation.to_sym
+            dependent_relations << relation.to_s.tableize
+          else
+            raise ArgumentError, "No association found for name `#{relation}'. Has it been defined yet?"
+          end
+        end
+
+        class_eval <<-EOV, __FILE__ , __LINE__
+          def self.dependent_relations
+            #{dependent_relations}
+          end
+
+          def self.compare
+            '#{options[:compare]}'.to_sym
+          end
+
+          include ActiveRecord::ActsHasMany::Child
+          #{'extend  ActiveRecord::ActsHasMany::ChildThrough' if options[:through]}
+
+          def model
+            #{self}
+          end
+
+          validates :#{options[:compare]}, uniqueness: true, presence: true
+          before_destroy :destroy_filter
+        EOV
+      end
+
+      #
+      # Add class methods:
+      #   +dependent_relations+
+      #
+      #   +<relation>_attributes=+
+      #   or
+      #   +<relation>_collection=+
+      #
+      # Set:
+      #   after save filter
+      #   attribut accessor tmp_garbage
+      #
+
+      def acts_has_many_for *relations
+        class_eval <<-EOV, __FILE__ , __LINE__
+          def self.dependent_relations 
+            #{relations}
+          end
+
+          attr_accessor :tmp_garbage
+
+          include ActiveRecord::ActsHasMany::Parent
+
+          after_save :clear_garbage
+        EOV
+      end
+
+    end
+  end
+end

data/lib/acts_has_many/version.rb

@@ -1,3 +1,3 @@
 module ActsHasMany
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/lib/acts_has_many.rb

@@ -1,2 +1,5 @@
-require 'acts_has_many/active_record/acts/has_many'
-ActiveRecord::Base.class_eval { include ActiveRecord::Acts::HasMany}
+require 'acts_has_many/active_record/acts_has_many'
+require 'acts_has_many/active_record/acts_has_many/child'
+require 'acts_has_many/active_record/acts_has_many/parent'
+
+ActiveRecord::Base.class_eval { include ActiveRecord::ActsHasMany}