acts_has_many 0.1.4 → 0.1.5

data/README.md

@@ -33,13 +33,13 @@ end
 # OR
 
 class Company < ActiveRecord::Base
-  acts_has_many relations: [:users] # array necessary relations
+  acts_has_many :users # list necessary relations
   
   has_many :users
 end
 
 # acts_has_many options:
-# 	:relations( array; default: has many relation which are written above) - necessary relations
+# 	list relations(it maybe missed if you use has many relation which are written above)
 # 	:compare( string or symbol; default: :title) - name column with unique elements in table
 # 	:through( boolean; default: false) - if you use has_many :through
 
@@ -60,9 +60,7 @@ company.actuale? :users # => false ( exclude 1 record of current relation)
 
 company   # => <Company id: 1, title: "Microsoft"> 
 
-update_id, delete_id  = company.has_many_update(data: { title: 'Google'}, relation: :users)
-# or
-#   update_id, delete_id  = company.has_many_update({ title: 'Google'}, :users)
+update_id, delete_id  = company.has_many_update({ title: 'Google'}, :users)
 # or
 #   update_id, delete_id  = company.update_with_users({ title: 'Google'})
 
@@ -213,4 +211,4 @@ features. Before submitting a bug report or feature request, check to make sure
 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.
+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,10 +1,10 @@
 module ActiveRecord
   module Acts #:nodoc:
     module HasMany
-      
+
       # class methods for use in model
       #   +acts_has_many_for+
-      #   +acts_has_many+ 
+      #   +acts_has_many+
       #
       #   the last method added:
       #
@@ -12,54 +12,54 @@ module ActiveRecord
       #     +has_many_through_update+
       #     +dependent_relations+
       #     +compare+
-      #   
+      #
       #   Instance methods:
       #     +model+
-      #     +has_many_update+
+      #     +has_many_update+ 
       #     +has_many_update!+
       #     +update_with_<relation>+
       #     +actuale?+
       #
       #   set +before_destroy+ callback;
 
-      def self.included(base)
-        base.extend(ClassMethods)
+      def self.included base
+        base.extend ClassMethods
       end
-      
+
       #
-      # Acts Has Many gem is for added functional to work 
+      # 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 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
       #
@@ -68,7 +68,7 @@ module ActiveRecord
       #   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)
       #
@@ -80,7 +80,7 @@ module ActiveRecord
       #   # and
       #   location.has_many_update! {title:"Kyiv"}
       #
-      
+
       module ClassMethods
 
         #
@@ -88,23 +88,29 @@ module ActiveRecord
         #   use for set link between parent row and child
         # options: list relations (symbol)
         #
-                
-        def acts_has_many_for(*relations)
+
+        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
+                if #{relation.foreign_key}
+                  row = #{relation.classify}.find #{relation.foreign_key}
+                  if row.is_a? #{relation.classify}
+                    row.tmp_parrent_id = id
+                    row.tmp_current_relation = '#{self.name.tableize}'
+                  end
+                  row
+                else
+                  super
+                end
               end
             EOV
           end
         end
 
         #
-        # +acts_has_many+ - available method in all model and switch on 
+        # +acts_has_many+ - available method in all model and switch on
         #   extension functional in concrete model (need located this method
         #   after relation which include in dependence, or anywhere but set depend relation)
         # options
@@ -112,23 +118,31 @@ module ActiveRecord
         #   :relations( array) - concrete name of depended relation
         #   :through( boolean) - off or on has_many_through_update method
         #
-        
-        def acts_has_many(options = {})
-          dependent_relations = []
-          options_default = { compare: :title, through: false }
 
-          options = options_default.merge options
-              
+        def acts_has_many *opt
+          options = { compare: :title, through: false }
+          options.update opt.extract_options!
+          options.assert_valid_keys :compare, :through, :relations
+          if options[:relations]
+            ActiveSupport::Deprecation.warn "Use simple list relations insted 'relation: Array'! Parameter 'relation: []'  will be romoved in v1.0!"
+          end
+          options[:relations] ||= opt
+
           options[:relations] = self.reflect_on_all_associations(:has_many)
-            .map{|o| o.name} if options[:relations].nil?
-           
+            .map(&:name) if options[:relations].blank?
+
+          dependent_relations = []
           options[:relations].each do |relation|
-            dependent_relations << relation.to_s.tableize
+            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
-         
+
           #
-          # +has_many_through_update+ (return array) [ 1 - array objects records, 2 - array delete ids ] 
-          # options 
+          # +has_many_through_update+ (return array) [ 1 - array objects records, 2 - array delete ids ]
+          # options
           #   :update( array) - data for update (id and data)
           #   :new( array) - data for create record (data)
           #
@@ -136,20 +150,19 @@ module ActiveRecord
           #
 
           has_many_through = ''
-          if(options[:through])
+          if options[:through]
             has_many_through = """
               def self.has_many_through_update(options)
                 record_add = []
                 record_del = []
-  
+
                 # update
                 options[:update].each do |id, data|
-                  add, del = #{self}.find(id)
-                    .has_many_update(:data => data, :relation => options[:relation])
+                  add, del = #{self}.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?
-                
+
                 # new
                 unless options[:new].nil?
                   options[:new].uniq!
@@ -159,25 +172,25 @@ module ActiveRecord
                       .where('#{options[:compare]}' => data['#{options[:compare]}'.to_sym])
                       .first_or_create(data)
                     record_del.delete record_add.last.id
-                  end 
+                  end
                 end
-                
-                record_add = #{self}.where('id IN (?)', record_add) unless record_add.empty? 
+
+                record_add = #{self}.where('id IN (?)', record_add) unless record_add.empty?
                 [record_add, record_del]
               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}
+                has_many_update data, :#{relation}
               end
             """
           end
-          
+
           class_eval <<-EOV
             include ActiveRecord::Acts::HasMany::InstanceMethods
             class << self
@@ -191,96 +204,97 @@ module ActiveRecord
 
             def model
               #{self}
-            end             
-            
+            end
+
             #{extend_methods}
             #{has_many_through}
-            
+
             attr_accessor :tmp_current_relation, :tmp_parrent_id
+            validates :#{options[:compare]}, uniqueness: true, presence: true
             before_destroy :destroy_filter
           EOV
         end
       end
-      
+
       module InstanceMethods
-        
+
         #
-        # +has_many_update!+ identicaly to has_many_update but 
+        # +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)
+        #   data - date for update
+        #   obj - parrent row (maybe miss)
         #
 
-        def has_many_update!(*data)
+        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
+            raise ArgumentError, """has_many_update don't have data about parent object, 
+                * maybe you use 'acts_has_many_for' incorrectly,
+                * if you don't use 'acts_has_many_for' in parent model you can give parent object"""
           end
 
           new_id, del_id = has_many_update data[0]
-          parrent = eval(tmp_current_relation.classify).find(tmp_parrent_id)
+          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]
+        # +has_many_update+ ( return array) [new_id, remove_id]
         # options maybe Hash, or list parameters
-        #   :data( type: hash) - data for updte
-        #   :relation( type: str, symbol) - modifi with tableize (maybe miss)
-        # 
-
-        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]
+        #   data ( type: hash) - data for updte
+        #   relation( type: str, symbol) - modifi with tableize (maybe miss)
+        #
+
+        def has_many_update *options
+          if options.size == 1 && options.first.include?(:data) && options[0].include?(:relation)
+            data = options.first[:data]
+            relation = options.first[:relation]
+            ActiveSupport::Deprecation.warn "Use simple list parameters (data, relation), parameter with 'Hash' type will be romoved in v1.0!"
           elsif options.size == 2
-            data = options[0]
+            data = options.first
             relation = options[1]
           else
             relation = tmp_current_relation
-            data = options[0]
+            data = options.first
           end
-          
-          data_default = {}
-          data_default[model.compare] = ""
-          data = data_default.merge data
+
+          data = { model.compare => ''}.merge data
 
           if relation.blank?
-            p "Notice: 'has_many_update' don't know about current relation, and check all relations"
+            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 maybe Hash, or simple parameter
-        #   :relation( string, symbol) - exclude current relation (maybe miss)
+        # options:
+        #   relation (String, Symbol) - for exclude current relation
         #
-        
-        def actuale? (options={relation: ""})
-          if options.is_a? Hash and options.include? :relation 
-            relation = options[:relation].to_s.tableize
+
+        def actuale? opt={relation: ""}
+          if opt.is_a? Hash
+            opt.assert_valid_keys :relation
+            ActiveSupport::Deprecation.warn "Use simple parameter 'String' or 'Symbol', parameter with 'Hash' type will be romoved in v1.0!"
+            relation = opt[:relation].to_s.tableize
           else
-            relation = options.to_s.tableize 
+            relation = opt.to_s.tableize
           end
 
           actuale = false
           model.dependent_relations.each do |dependent_relation|
-            tmp = self.send(dependent_relation)
+            tmp = self.send dependent_relation
             if relation == dependent_relation
               actuale ||= tmp.all.size > 1
             else
@@ -290,9 +304,9 @@ module ActiveRecord
           actuale
         end
       end
-      
+
     private
-      
+
       #
       # +destroy_filter+ - method for before_destroy, check actuale record and
       # return true for delete or false for leave
@@ -302,22 +316,22 @@ module ActiveRecord
         not actuale?
       end
 
-      # 
+      #
       # base operations in this gem
       #
 
-      def has_many_cleaner(data, relation)
+      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 = model.where(compare).first_or_create data
           object_id = object.id
         else
-          object_tmp = model.where(compare)[0]
+          object_tmp = model.where(compare).first
           unless object_tmp.nil?
             # set new object and delete old
             delete_id = (object_id == object_tmp.id) ? nil : object_id
@@ -325,14 +339,14 @@ module ActiveRecord
           else
             # update old object
             if object_id.nil?
-              object = model.where(compare).first_or_create(data)
+              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)
+                update_attributes data
               end
             end
           end

data/lib/acts_has_many/version.rb

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

metadata

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