acts_has_many 0.1.3 → 0.1.4

data/README.md

@@ -1,5 +1,9 @@
 # acts_has_many
 
+Acts_has_many gem gives functional for clean update elements *has_many* relation
+(additional is has_many :trhough). The aim is work with has_many relation without gerbage,
+every record must be used, othervise there will be no record.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -41,6 +45,8 @@ end
 
 
 company = Company.create(:title => 'Microsoft')
+Company.dependent_relations # => ["users"]
+Company.compare             # => :title
 
 company.actuale? # => false
 
@@ -49,20 +55,20 @@ user = User.create do |user|
 	# ...
 end
 
-company.actuale? # => true
-company.actuale? relations: :users # => false ( exclude 1 record of current relation)
+company.actuale?        # => true
+company.actuale? :users # => false ( exclude 1 record of current relation)
 
-company.depend_relations # => ["users"]
-company.model 	# => Company
-company.compare # => :title
+company   # => <Company id: 1, title: "Microsoft"> 
 
-company.id 	# => 1
 update_id, delete_id  = company.has_many_update(data: { title: 'Google'}, relation: :users)
-update_id 	# => 1
-delete_id 	# => nil
-company.title # => 'Google'
+# or
+#   update_id, delete_id  = company.has_many_update({ title: 'Google'}, :users)
+# or
+#   update_id, delete_id  = company.update_with_users({ title: 'Google'})
 
-# ... update user with new company and other code
+update_id # => 1
+delete_id # => nil
+company   # => <Company id: 1, title: "Google"> 
 
 user2 = User.create do |user|
 	user.company = company
@@ -70,36 +76,86 @@ user2 = User.create do |user|
 end
 
 company.actuale? # => true
-company.actuale? relations: :users # => true
+company.actuale? :users # => true
 
-# Suggestion: if you want to destroy user
-user2.destroy # user will be destroyed, company will rollback (because company is used by other user)
+# if you want to destroy user
+#   user2.destroy # => user will be destroyed, company will rollback (because company is used by other user)
 
-company.id 	# => 1
-update_id, delete_id  = company.has_many_update(data: { title: 'Apple'}, relation: :users)
-update_id 	# => 2
-delete_id 	# => nil
+company   # => <Company id: 1, title: "Google"> 
+update_id, delete_id  = company.has_many_update({ title: 'Apple'}, :users)
+update_id # => 2
+delete_id # => nil
 
 user2.company = Company.find(update_id)
 user2.save
 
-# Suggestion: if you want to destroy user now
-user2.destroy # user and company will be destroyed (because company is used only by user2)
+# if you want to destroy user now
+#   user2.destroy # => user and company will be destroyed (because company is used only by user2)
 
 Company.all # [#<Company id: 1, title: "Google">, #<Company id: 2, title: "Apple"]
 
-company.destroy # => false
+company.destroy # => false (because company is used)
 
-companu.id 	# => 1
-update_id, delete_id  = company.has_many_update(data: { title: 'Apple'}, relation: :users)
+companu 	# => <Company id: 1, title: "Google">
+update_id, delete_id  = company.has_many_update({ title: 'Apple'}, :users)
 update_id 	# => 2
 delete_id 	# => 1
 
-# ... update user with company
+user2.company = Company.find(update_id)
+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"})
+
+
+```
+### 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
@@ -130,4 +186,31 @@ new_rows, delete_ids = Company.has_many_update_through( update: data, new: date,
 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
-```
+```
+
+
+Contributing
+------------
+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
+* by writing specifications
+* by writing code (**no patch is too small**: fix typos, add comments, clean up inconsistent whitespace)
+* by refactoring code
+* by closing [issues](https://github.com/igor04/acts_has_many/issues)
+* by reviewing patches
+
+
+Submitting an Issue
+-------------------
+We use the [GitHub issue tracker](https://github.com/igor04/acts_has_many/issues) to track bugs and
+features. Before submitting a bug report or feature request, check to make sure it hasn't already
+been submitted. You can indicate support for an existing issuse by voting it up. When submitting a
+bug report, please include a [Gist](http://gist.github.com/) that includes a stack trace and any
+details that may be necessary to reproduce the bug, including your gem version, Ruby version, and
+operating system. Ideally, a bug report should include a pull request with failing specs.

data/lib/acts_has_many/active_record/acts/has_many.rb

@@ -1,32 +1,112 @@
 module ActiveRecord
   module Acts #:nodoc:
     module HasMany
+      
+      # class methods for use in model
+      #   +acts_has_many_for+
+      #   +acts_has_many+ 
+      #
+      #   the last method added:
+      #
+      #   class method:
+      #     +has_many_through_update+
+      #     +dependent_relations+
+      #     +compare+
+      #   
+      #   Instance methods:
+      #     +model+
+      #     +has_many_update+
+      #     +has_many_update!+
+      #     +update_with_<relation>+
+      #     +actuale?+
+      #
+      #   set +before_destroy+ callback;
+
       def self.included(base)
         base.extend(ClassMethods)
       end
-
+      
+      #
+      # Acts Has Many gem is for added functional to work 
+      # with +has_many+ relation (additional is has_many :trhough)
+      # 
+      # +acts_has_many+ and +acts_has_many_for+ are class methods for all model,
+      # and you can use them for connection acts_has_many functional to necessary model
+      # acts_has_many set in model where is has_many relation and 
+      # acts_has_many_for in model where use model with acts_has_many
+      #
+      #   class Education < ActiveRecord::Base
+      #     belongs_to :location
+      #     ...
+      #     acts_has_many_for :location
+      #   end
+      #   
+      #   class Location < ActiveRecord::Base
+      #     has_many :educaitons
+      #     acts_has_many
+      #   end
+      #        
+      # You can use +acts_has_many+ methods without +acts_has_many_for+
+      #
+      #   class Education < ActiveRecord::Base
+      #     belongs_to :location
+      #     ...
+      #   end
+      #   
+      #   class Location < ActiveRecord::Base
+      #     has_many :education
+      #     acts_has_many
+      #   end
+      #         
+      # in this case you can use nex function:
+      #   
+      #   education = Education.first
+      #   location = education.location # get location from education
       #
-      # class methods +acts_has_many+ added:
+      #   new_id, del_id = location.has_many_update(data: {title:"Kyiv"}, relation: :educations)
+      #   # or simple
+      #   new_id, del_id = location.has_many_update({title:"Kyiv"}, :educations)
+      #   # or with dinamic methods helper
+      #   new_id, del_id = location.update_with_educations {title:"Kyiv"}
+      # 
+      #   # you can also use has_many_update! which updated relation with parent row without you
+      #   location.has_many_update!({title: "Kyiv"}, education)
       #
-      # class method:
-      #   +has_many_through_update+
+      # with usage +acts_has_many_for+ you don't need set relation and give parent row in case with has_many_update!
+      # but you need get row for update get per ralation from parent row (see above with location row) in other case
+      # you can't use it becaus methods will not know about relation and paren row for update it.
       #
-      # instance methods:
-      #   +depend_relations+
-      #   +model+
-      #   +compare+
-      #   +has_many_update+
-      #   +actuale?+
+      #   new_id, del_id = location.has_many_update {title:"Kyiv"}
+      #   # and
+      #   location.has_many_update! {title:"Kyiv"}
       #
-      # set +before_destroy+ callback;
-      #      
       
       module ClassMethods
-        
+
+        #
+        # +acts_has_many_for+: use with +acts_has_many+
+        #   use for set link between parent row and child
+        # options: list relations (symbol)
+        #
+                
+        def acts_has_many_for(*relations)
+          relations.each do |relation|
+            relation = relation.to_s
+            class_eval <<-EOV
+              def #{relation}
+                row = #{relation.classify}.find #{relation.foreign_key}
+                row.tmp_parrent_id = id
+                row.tmp_current_relation = '#{self.name.tableize}'
+                row
+              end
+            EOV
+          end
+        end
+
         #
         # +acts_has_many+ - available method in all model and switch on 
         #   extension functional in concrete model (need located this method
-        #   after all relation or after relation which include in dependence)
+        #   after relation which include in dependence, or anywhere but set depend relation)
         # options
         #   :compare( symbol, string)- name column for compare with other element in table
         #   :relations( array) - concrete name of depended relation
@@ -34,19 +114,18 @@ module ActiveRecord
         #
         
         def acts_has_many(options = {})
-          depend_relations = []
+          dependent_relations = []
           options_default = { compare: :title, through: false }
 
           options = options_default.merge options
               
-          options[:relations] = self.reflections
-            .select{ |k, v| v.macro == :has_many }
-            .map{|k, v| k} if options[:relations].nil?
+          options[:relations] = self.reflect_on_all_associations(:has_many)
+            .map{|o| o.name} if options[:relations].nil?
            
           options[:relations].each do |relation|
-            depend_relations << relation.to_s.tableize
+            dependent_relations << relation.to_s.tableize
           end
-            
+         
           #
           # +has_many_through_update+ (return array) [ 1 - array objects records, 2 - array delete ids ] 
           # options 
@@ -88,104 +167,178 @@ module ActiveRecord
               end """
           end
           
+          # add dinamic methods for example
+          # update_with_<relation>(data) equal has_many_update(data, relation)
+          extend_methods = ''
+          dependent_relations.each do |relation|
+            extend_methods += """
+              def update_with_#{relation}(data)
+                has_many_update data: data, relation: :#{relation}
+              end
+            """
+          end
+          
           class_eval <<-EOV
             include ActiveRecord::Acts::HasMany::InstanceMethods
-            def depend_relations
-              #{depend_relations}
-            end
-            def compare
-              '#{options[:compare]}'.to_sym
+            class << self
+              def dependent_relations
+                #{dependent_relations}
+              end
+              def compare
+                '#{options[:compare]}'.to_sym
+              end
             end
+
             def model
               #{self}
-            end 
+            end             
             
+            #{extend_methods}
             #{has_many_through}
             
+            attr_accessor :tmp_current_relation, :tmp_parrent_id
             before_destroy :destroy_filter
           EOV
         end
       end
       
       module InstanceMethods
+        
+        #
+        # +has_many_update!+ identicaly to has_many_update but 
+        #   You can use this method when you use +acts_has_many_for+
+        #   and get object for update with help of +relation+ or give parent row
+        # option
+        #   data for update
+        #   parrent row (maybe miss)
+        #
+
+        def has_many_update!(*data)
+          if data.size == 2
+            self.tmp_current_relation = data[1].class.name.tableize
+            self.tmp_parrent_id = data[1].id
+          end
+          
+          if tmp_current_relation.nil? or tmp_parrent_id.nil?
+            p "ArgumentError: 'has_many_update!' don't have data about parent object"
+            p "* maybe you use 'acts_has_many_for' incorrectly"
+            p "* if you don't use 'acts_has_many_for' in parent model you can give parent object"
+            return nil
+          end
 
+          new_id, del_id = has_many_update data[0]
+          parrent = eval(tmp_current_relation.classify).find(tmp_parrent_id)
+          parrent.update_attributes("#{model.name.foreign_key}" => new_id)
+          parrent.save!
+
+          destroy unless del_id.nil?
+          model.find new_id
+        end
+        
         #
         # +has_many_update+ ( return array) [new_id, del_id]
-        # options
+        # options maybe Hash, or list parameters
         #   :data( type: hash) - data for updte
-        #   :relation( type: str, symbol) - modifi with tableize
-        #
-        
-        def has_many_update(options)
-          options_default = { 
-            :data => { title: "" }
-          }
+        #   :relation( type: str, symbol) - modifi with tableize (maybe miss)
+        # 
 
-          options = options_default.merge options
-          options[:data] = options[:data].symbolize_keys
-          full_compare = { compare => options[:data][compare] }
-
-          object_id = id
-          delete_id = nil
-          
-          if actuale? relation: options[:relation]
-            # create new object and finish
-            object = model.where(full_compare).first_or_create(options[:data])
-            object_id = object.id
+        def has_many_update(*options)
+          if options.size == 1 && options[0].include?(:data) && options[0].include?(:relation) 
+            data = options[0][:data]
+            relation = options[0][:relation]
+          elsif options.size == 2
+            data = options[0]
+            relation = options[1]
           else
-            object_tmp = model.where(full_compare)[0]
-            unless object_tmp.nil?
-              # set new object and delete old
-              delete_id = (object_id == object_tmp.id) ? nil : object_id
-              object_id = object_tmp.id
-            else
-              # update old object
-              if object_id.nil?
-                object = model.where(full_compare).first_or_create(options[:data])
-                object_id = object.id
-              else
-                if options[:data][compare].empty?
-                  delete_id = object_id
-                  object_id = nil
-                else
-                  update_attributes(options[:data])
-                end
-              end
-            end
+            relation = tmp_current_relation
+            data = options[0]
           end
-          [object_id, delete_id]
+          
+          data_default = {}
+          data_default[model.compare] = ""
+          data = data_default.merge data
+
+          if relation.blank?
+            p "Notice: '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) - exclude current relation 
+        # options maybe Hash, or simple parameter
+        #   :relation( string, symbol) - exclude current relation (maybe miss)
         #
         
-        def actuale? (options = { relation: "" })
+        def actuale? (options={relation: ""})
+          if options.is_a? Hash and options.include? :relation 
+            relation = options[:relation].to_s.tableize
+          else
+            relation = options.to_s.tableize 
+          end
+
           actuale = false
-          
-          depend_relations.each do |relation|
-            tmp = self.send(relation)
-            if options[:relation].to_s.tableize == relation
+          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+ - method for before_destroy, check actuale record and
       # return true for delete or false for leave
       #
-      
+
       def destroy_filter
         not actuale?
       end
+
+      # 
+      # base operations in this gem
+      #
+
+      def has_many_cleaner(data, relation)
+        compare = { model.compare => data[model.compare] }
+          
+        object_id = id
+        delete_id = nil
+        
+        if actuale? relation
+          # create new object and finish
+          object = model.where(compare).first_or_create(data)
+          object_id = object.id
+        else
+          object_tmp = model.where(compare)[0]
+          unless object_tmp.nil?
+            # set new object and delete old
+            delete_id = (object_id == object_tmp.id) ? nil : object_id
+            object_id = object_tmp.id
+          else
+            # update old object
+            if object_id.nil?
+              object = model.where(compare).first_or_create(data)
+              object_id = object.id
+            else
+              if data[model.compare].blank?
+                delete_id = object_id
+                object_id = nil
+              else
+                update_attributes(data)
+              end
+            end
+          end
+        end
+        [object_id, delete_id]
+      end
     end
   end
 end

data/lib/acts_has_many/version.rb

@@ -1,3 +1,3 @@
 module ActsHasMany
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/spec/has_many_spec.rb

@@ -33,39 +33,115 @@ require 'helper'
 
   describe "Initialization tipe #{c}" do
     describe 'acts_has_many' do
-      it 'update' do
-        Location.delete_all
-        Experience.delete_all
+      context 'update method' do
+        let(:location){Location.create :title => "italy"}
+        let(:experience){Experience.create :location => location, :title => "test experience1"}
+        before :each do
+          Location.delete_all
+          Experience.delete_all
+        end
 
-        location = Location.create :title => "italy"
-        experience = Experience.create :location => location, :title => "test experience1"
-                
-        add_loc, del_loc = experience.location.has_many_update(
-            :data => {"title" => "ukraine"}, :relation => "experiences")
-        
-        Location.all.size.should == 1
-        location.id.should == add_loc
-        del_loc.should == nil
-        experience.location.title.should == "ukraine"
-        
-        Experience.create :location => location, :title => "test experience2" 
-            
-        add_loc, del_loc = experience.location.has_many_update(
-            :data => {"title" => "italy"}, :relation => "experiences")
-        
-        Location.all.size.should == 2
-        location.id.should_not == add_loc
-        del_loc.should == nil
-        experience.location = Location.find(add_loc)
-        experience.location.title.should == "italy"
-        
-        add_loc, del_loc = experience.location.has_many_update(
-            :data => {"title" => "ukraine"}, :relation => "experiences")
-        
-        location.id.should == add_loc
-        experience.location.id.should == del_loc
-      end
+        it 'has_many_update(data: data, relation: relation)' do
+          add_loc, del_loc = experience.location.has_many_update(
+              :data => {"title" => "ukraine"}, :relation => "experiences")
+          
+          Location.all.size.should == 1
+          location.id.should == add_loc
+          del_loc.should == nil
+          experience.location.title.should == "ukraine"
+          
+          Experience.create :location => location, :title => "test experience2" 
+              
+          add_loc, del_loc = experience.location.has_many_update({"title" => "italy"}, "experiences")
+          
+          Location.all.size.should == 2
+          location.id.should_not == add_loc
+          del_loc.should == nil
+          experience.location = Location.find(add_loc)
+          experience.location.title.should == "italy"
+          
+          add_loc, del_loc = experience.location.has_many_update({"title" => "ukraine"})
+          
+          location.id.should == add_loc
+          experience.location.id.should == del_loc
+        end
       
+        it 'has_many_update!(data)' do
+          # update independent Location
+          new_row = experience.location.has_many_update!({"title" => "ukraine"})
+          
+          Location.all.size.should == 1
+          location.id.should == new_row.id
+          experience.location.title.should == "ukraine"
+          
+          Experience.create :location => location, :title => "test experience2" 
+
+          # don't update and create new Location
+          new_row = experience.location.has_many_update!({"title" => "italy"})
+
+          experience.reload
+          Location.all.size.should == 2
+          location.id.should_not == new_row.id
+          experience.location.title.should == "italy"
+          
+          # delete unnecessary Location
+          new_row = experience.location.has_many_update!({"title" => "ukraine"})
+
+          location.id.should == new_row.id
+          Location.all.size.should == 1
+        end
+      
+        it 'has_many_update!(data, parent_row)' do
+          # update independent Location
+          new_row = location.has_many_update!({"title" => "ukraine"}, experience)
+          
+          Location.all.size.should == 1
+          location.id.should == new_row.id
+          experience.location.title.should == "ukraine"
+          
+          Experience.create :location => location, :title => "test experience2" 
+
+          # don't update and create new Location
+          new_row = location.has_many_update!({"title" => "italy"}, experience)
+
+          experience.reload
+          Location.all.size.should == 2
+          location.id.should_not == new_row.id
+          experience.location.title.should == "italy"
+          
+          # delete unnecessary Location
+          new_row = location.has_many_update!({"title" => "italy"}, Experience.where(location_id: location).first) #becaus experience wos reload
+
+          location.id.should_not == new_row.id
+          location.frozen?.should == true
+          Location.all.size.should == 1
+        end
+
+        it 'update_with_<relation>(data)' do
+          add_loc, del_loc = experience.location.update_with_experiences({"title" => "ukraine"})
+          
+          Location.all.size.should == 1
+          location.id.should == add_loc
+          del_loc.should == nil
+          experience.location.title.should == "ukraine"
+          
+          Experience.create :location => location, :title => "test experience2" 
+              
+          add_loc, del_loc = experience.location.update_with_experiences({"title" => "italy"})
+          
+          Location.all.size.should == 2
+          location.id.should_not == add_loc
+          del_loc.should == nil
+          experience.location = Location.find(add_loc)
+          experience.location.title.should == "italy"
+          
+          add_loc, del_loc = experience.location.update_with_experiences({"title" => "ukraine"})
+          
+          location.id.should == add_loc
+          experience.location.id.should == del_loc
+        end
+      end
+
       it 'destroy' do
         Location.delete_all
         Experience.delete_all
@@ -96,16 +172,17 @@ require 'helper'
         location.actuale?(:relation => "experiences").should == false
         location.actuale?(:relation => :experiences).should == false
         location.actuale?(:relation => "Experience").should == false
+        location.actuale?("Experience").should == false
 
         Experience.create( :title => 'test', :location => location )
         
         location.actuale?.should == true
         location.actuale?(:relation => "experiences").should == true
+        location.actuale?(:experiences).should == true
       end 
 
       it 'compare' do
-        location = Location.create(:title => "ukraine")
-        location.compare.should == :title
+        Location.compare.should == :title
       end
 
       it 'model' do
@@ -113,9 +190,8 @@ require 'helper'
         location.model.should == Location
       end
 
-      it 'depend_relations' do
-        location = Location.create(:title => "ukraine")
-        location.depend_relations.should == ['experiences']
+      it 'dependent_relations' do
+        Location.dependent_relations.should == ['experiences']
       end
     end
   end

data/spec/helper.rb

@@ -39,6 +39,8 @@ end
 class Experience < ActiveRecord::Base
   self.table_name = 'experiences'
   belongs_to :location, :dependent => :destroy
+
+  acts_has_many_for :location
 end
 
 class CompanyLocal < ActiveRecord::Base

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_has_many
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-10 00:00:00.000000000 Z
+date: 2012-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.19
 signing_key: 
 specification_version: 3
 summary: All records must be used, otherwise they will be deleted. Clear logic with