poly_belongs_to 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fef63bc76533283e3fa03444fb55e430cbfed81
-  data.tar.gz: d19cf96a1ad099257eb1396eb84587cd8e983965
+  metadata.gz: 2485663b8e0b1364a05b151975b527c56e95bada
+  data.tar.gz: 33338ae33151a22083b535ea79a706b237cf64aa
 SHA512:
-  metadata.gz: 4f503a3cfc275e89ac94915d2b53fb5f4bba1d2c03fcdfda31da38112da9c211216b6f4505691cae6e5ee01d76df61d4d5b09de9a380026ef4a7fac5f70125a0
-  data.tar.gz: ff310a8b501f3c21133f720eb55f2d66655ac9740370dd2b44e1eab0b27fbce1c946682e7c9a49e297fdb9d5192971ab159159235fed0f60af2b7e90fa512a1b
+  metadata.gz: 52ceb7ef74ed74c91012ae7ac3fa662da98653ee5258f538544911147ff873eaafad836b39bd095532ae28c79bbe07071ab62a7b636f4cc000a5748f69f0310c
+  data.tar.gz: 5c0e6bd0b258619346e12753beb23a15ea830f884d19eee585a137b692ac1309575dfc2c9e7f7e041794c3044fae8ab4facf597e29fc2ab2e6f712cc908f72d8

data/README.md

@@ -144,25 +144,18 @@ otherwise**.  You can duplicate a record, or use a self recursive command **pbt_
 to duplicate a record and all of it's has_one/has_many children records at once.  Afterwards
 be sure to use the save method.
 
-> NOTE: This will need to be included manually.  The reason for this is because you need to
-know what's involved when using this.  It's purposefully done this way to lead to reading
-the documentation for PolyBelongsTo's duplication methods.
 
 ####Known Issues
  - Carrierwave records won't duplicate.  To ensure that other records will still save and
 prevent any rollback issues use .save(validate: false) ... I'm considering possible options
 to remedy this and
 other scenarios.
- - For deep duplication you need to be very aware of the potential for infinite loops with
-your records if there are any circular references.
+ - **PROBLEM SOLVED** ~~For deep duplication you need to be very aware of the potential for infinite loops with
+your records if there are any circular references.~~ 
 
 ###How To Use
 
-Include it into ActiveRecord::Base in an initializer /config/initializers/poly_belongs_to.rb
-```ruby
-ActiveRecord::Base.send(:include, PolyBelongsTo::Dup)
-```
-Then use the dup/build methods as follows
+Use the dup/build methods as follows
 
 ```ruby
 # If you were to create a new contact for example
@@ -183,11 +176,6 @@ contact.pbt_deep_dup_build( User.last.profile )
 contact.save
 ```
 
-##Planning
-
-I'm in the process of planning mapping out record hierarchy.  Also with this
-it will add recognition for circular references.
-
 ##Contributing
 
 Feel free to fork and make pull requests.  Please bring up an issue before a pull

data/lib/poly_belongs_to.rb

@@ -2,103 +2,13 @@
 # The MIT License (MIT)
 # Copyright (C) 2015 by Daniel P. Clark
 $: << File.join(File.dirname(__FILE__), "/poly_belongs_to")
+require 'active_support/concern'
 require 'poly_belongs_to/version'
+require 'poly_belongs_to/core'
+require 'poly_belongs_to/singleton_set'
 require 'poly_belongs_to/dup'
-require 'poly_belongs_to/poly_belongs_to'
+require 'poly_belongs_to/pbt'
 require 'poly_belongs_to/faked_collection'
-require 'active_support/concern'
-
-module PolyBelongsTo
-  module Core
-    extend ActiveSupport::Concern
-
-    included do
-      def self.pbt
-        reflect_on_all_associations(:belongs_to).first.try(:name)
-      end
-
-      def self.pbts
-        reflect_on_all_associations(:belongs_to).map(&:name)
-      end
-      
-      def self.poly?
-        !!reflect_on_all_associations(:belongs_to).first.try {|i| i.options[:polymorphic] }
-      end
-
-      def self.pbt_params_name(allow_as_nested = true)
-        if poly?
-          allow_as_nested ? "#{table_name}_attributes".to_sym : name.downcase.to_sym
-        else
-          name.downcase.to_sym
-        end
-      end
-
-      def self.pbt_id_sym
-        val = pbt
-        val ? "#{val}_id".to_sym : nil
-      end
-
-      def self.pbt_type_sym
-        poly? ? "#{pbt}_type".to_sym : nil
-      end
-    end
-    
-    def pbt
-      self.class.pbt
-    end
-
-    def pbts
-      self.class.pbts
-    end
-    
-    def poly?
-      self.class.poly?
-    end
-
-    def pbt_id
-      val = pbt
-      val ? eval("self.#{val}_id") : nil
-    end
-
-    def pbt_type
-      poly? ? eval("self.#{pbt}_type") : nil
-    end
-
-    def pbt_parent
-      val = pbt
-      if val
-        if poly?
-          eval "#{pbt_type}.find(#{pbt_id})"
-        else
-          eval "#{val.capitalize.to_s}.find(#{pbt_id})"
-        end
-      else
-        nil
-      end
-    end
-
-    def pbt_parents
-      if poly?
-        Array[pbt_parent].compact
-      else
-        self.class.pbts.map {|i|
-          try{ eval("#{i.capitalize}").find eval("self.#{i}_id") }
-        }.compact
-      end
-    end
-
-    def pbt_id_sym
-      self.class.pbt_id_sym
-    end
-
-    def pbt_type_sym
-      self.class.pbt_type_sym
-    end
-
-    def pbt_params_name(allow_as_nested = true)
-      self.class.pbt_params_name(allow_as_nested)
-    end
-  end
-end
+ActiveRecord::Base.send(:include, PolyBelongsTo::Core )
+ActiveRecord::Base.send(:include, PolyBelongsTo::Dup  )
 
-ActiveRecord::Base.send(:include, PolyBelongsTo::Core)

data/lib/poly_belongs_to/core.rb

@@ -0,0 +1,92 @@
+module PolyBelongsTo
+  module Core
+    extend ActiveSupport::Concern
+
+    included do
+      def self.pbt
+        reflect_on_all_associations(:belongs_to).first.try(:name)
+      end
+
+      def self.pbts
+        reflect_on_all_associations(:belongs_to).map(&:name)
+      end
+      
+      def self.poly?
+        !!reflect_on_all_associations(:belongs_to).first.try {|i| i.options[:polymorphic] }
+      end
+
+      def self.pbt_params_name(allow_as_nested = true)
+        if poly?
+          allow_as_nested ? "#{table_name}_attributes".to_sym : name.downcase.to_sym
+        else
+          name.downcase.to_sym
+        end
+      end
+
+      def self.pbt_id_sym
+        val = pbt
+        val ? "#{val}_id".to_sym : nil
+      end
+
+      def self.pbt_type_sym
+        poly? ? "#{pbt}_type".to_sym : nil
+      end
+    end
+    
+    def pbt
+      self.class.pbt
+    end
+
+    def pbts
+      self.class.pbts
+    end
+    
+    def poly?
+      self.class.poly?
+    end
+
+    def pbt_id
+      val = pbt
+      val ? self.send("#{val}_id") : nil
+    end
+
+    def pbt_type
+      poly? ? self.send("#{pbt}_type") : nil
+    end
+
+    def pbt_parent
+      val = pbt
+      if val
+        if poly?
+          "#{pbt_type}".constantize.find(pbt_id)
+        else
+          "#{val.capitalize}".constantize.find(pbt_id)
+        end
+      else
+        nil
+      end
+    end
+
+    def pbt_parents
+      if poly?
+        Array[pbt_parent].compact
+      else
+        self.class.pbts.map {|i|
+          try{ "#{i.capitalize}".constantize.find(self.send("#{i}_id")) }
+        }.compact
+      end
+    end
+
+    def pbt_id_sym
+      self.class.pbt_id_sym
+    end
+
+    def pbt_type_sym
+      self.class.pbt_type_sym
+    end
+
+    def pbt_params_name(allow_as_nested = true)
+      self.class.pbt_params_name(allow_as_nested)
+    end
+  end
+end

data/lib/poly_belongs_to/dup.rb

@@ -4,34 +4,37 @@ module PolyBelongsTo
 
     included do
       def self.pbt_dup_build(item_to_build_on, item_to_duplicate)
+        singleton_record = yield if block_given? 
         if PolyBelongsTo::Pbt::IsReflected[item_to_build_on, item_to_duplicate]
           PolyBelongsTo::Pbt::AsCollectionProxy[item_to_build_on, item_to_duplicate].
-            build PolyBelongsTo::Pbt::AttrSanitizer[item_to_duplicate]
+            build PolyBelongsTo::Pbt::AttrSanitizer[item_to_duplicate] if (
+              block_given? ? singleton_record.add?(item_to_duplicate) : true)
         end
       end
 
       def self.pbt_deep_dup_build(item_to_build_on, item_to_duplicate)
-        pbt_dup_build(item_to_build_on, item_to_duplicate)
+        singleton_record = (block_given? ? yield : PolyBelongsTo::SingletonSet.new)
+        pbt_dup_build(item_to_build_on, item_to_duplicate) {singleton_record}
         PolyBelongsTo::Pbt::Reflects[item_to_duplicate].each do |ref|
-          child = eval("item_to_duplicate.#{ref}")
+          child = item_to_duplicate.send(ref)
           PolyBelongsTo::Pbt::AsCollectionProxy[item_to_build_on, item_to_duplicate].
             each do |builder|
               child.respond_to?(:build) ? child.each {|spawn|
-                builder.pbt_deep_dup_build(spawn)
-              } : builder.pbt_deep_dup_build(child)
-            end
+                builder.pbt_deep_dup_build(spawn) {singleton_record}
+              } : builder.pbt_deep_dup_build(child) {singleton_record}
+          end unless singleton_record.include?(item_to_build_on)
         end
         item_to_build_on       
       end
 
    end
 
-    def pbt_dup_build(item_to_duplicate)
-      self.class.pbt_dup_build(self, item_to_duplicate)
+    def pbt_dup_build(item_to_duplicate, &block)
+      self.class.pbt_dup_build(self, item_to_duplicate, &block)
     end
 
-    def pbt_deep_dup_build(item_to_duplicate)
-      self.class.pbt_deep_dup_build(self, item_to_duplicate)
+    def pbt_deep_dup_build(item_to_duplicate, &block)
+      self.class.pbt_deep_dup_build(self, item_to_duplicate, &block)
     end
 
   end

data/lib/poly_belongs_to/faked_collection.rb

@@ -4,10 +4,14 @@ module PolyBelongsTo
       raise "Not a has_one rleationship for FakedCollection" unless PolyBelongsTo::Pbt::IsSingular[obj,child]
       @obj = obj
       @child = child
-      @instance = eval("@obj.#{PolyBelongsTo::Pbt::CollectionProxy[@obj,@child]}")
+      @instance = @obj.send(PolyBelongsTo::Pbt::CollectionProxy[@obj,@child])
       self
     end
 
+    def id
+      @instance.try(:id)
+    end
+
     def all
       Array[@instance].compact
     end
@@ -45,7 +49,7 @@ module PolyBelongsTo
     end
 
     def build(*args)
-      @instance = eval("@obj.#{PolyBelongsTo::Pbt::BuildCmd[@obj, @child]}(#{args.join(',')})")
+      @instance = @obj.send(PolyBelongsTo::Pbt::BuildCmd[@obj, @child], *args)
       self
     end
 

data/lib/poly_belongs_to/{poly_belongs_to.rb → pbt.rb}

@@ -9,25 +9,25 @@ module PolyBelongsTo
 
     BuildCmd = lambda {|obj, child|
       return nil unless obj && child
-      dup_name = "#{CollectionProxy[obj,child]}"
+      dup_name = CollectionProxy[obj, child]
       IsSingular[obj, child] ? "build_#{dup_name}" : IsPlural[obj, child] ? "#{dup_name}.build" : nil
     }
 
     Reflects = lambda {|obj|
       return [] unless obj
       [:has_one, :has_many].map { |has|
-        eval(obj.class.name).reflect_on_all_associations(has).map(&:name).map(&:to_sym)
+        obj.class.name.constantize.reflect_on_all_associations(has).map(&:name).map(&:to_sym)
       }.flatten
     }
 
     ReflectsAsClasses = lambda {|obj|
       Reflects[obj].map {|ref|
-        eval (eval("obj.#{ref}").try(:klass) || eval("obj.#{ref}").class).name
+        (obj.send(ref).try(:klass) || obj.send(ref).class).name.constantize
       }
     }
     
-    IsReflected = lambda {|obj,child|
-      !!SingularOrPlural[obj, child]
+    IsReflected = lambda {|obj, child|
+      !!CollectionProxy[obj, child]
     }
 
     SingularOrPlural = lambda {|obj, child|
@@ -35,7 +35,7 @@ module PolyBelongsTo
       reflects = Reflects[obj]
       if reflects.include?(ActiveModel::Naming.singular(child).to_sym)
         :singular
-      elsif reflects.include?(ActiveModel::Naming.plural(child).to_sym)
+      elsif CollectionProxy[obj, child]
         :plural
       else
         nil
@@ -52,20 +52,14 @@ module PolyBelongsTo
 
     CollectionProxy = lambda {|obj, child|
       return nil unless obj && child
-      reflects = Reflects[obj]
-      proxy = ActiveModel::Naming.singular(child).to_sym
-      return proxy if reflects.include? proxy
-      proxy = ActiveModel::Naming.plural(child).to_sym
-      reflects.include?(proxy) ? proxy : nil
+      names = [ActiveModel::Naming.singular(child).to_s, ActiveModel::Naming.plural(child).to_s].uniq
+      Reflects[obj].detect {|ref| "#{ref}"[/(?:#{ names.join('|') }).{,3}/]}
     }
   
     AsCollectionProxy = lambda {|obj, child|
       return [] unless obj && child
-      reflects = Reflects[obj]
-      proxy = ActiveModel::Naming.singular(child).to_sym
-      return PolyBelongsTo::FakedCollection.new(obj, child) if reflects.include? proxy
-      proxy = ActiveModel::Naming.plural(child).to_sym
-      reflects.include?(proxy) ? eval("obj.#{PolyBelongsTo::Pbt::CollectionProxy[obj, child]}") : []
+      return PolyBelongsTo::FakedCollection.new(obj, child) if IsSingular[obj, child]
+      !!CollectionProxy[obj, child] ? obj.send(PolyBelongsTo::Pbt::CollectionProxy[obj, child]) : []
     }
   end
   

data/lib/poly_belongs_to/singleton_set.rb

@@ -0,0 +1,45 @@
+require 'set'
+module PolyBelongsTo
+  class SingletonSet
+    def initialize
+      @set = Set.new
+      @flagged = Set.new
+      self
+    end
+
+    def formatted_name(record)
+      "#{record.class.name}-#{record.id}"
+    end
+
+    def add?(record)
+      result = @set.add?( formatted_name( record ) )
+      return result if result
+      flag(record)
+      result
+    end
+
+    def add(record)
+      add?(record)
+    end
+
+    def <<(record)
+      add?(record)
+    end
+
+    def include?(record)
+      @set.include?(formatted_name(record))
+    end
+
+    def flag(record)
+      @flagged << formatted_name(record)
+    end
+
+    def flagged?(record)
+      @flagged.include?(formatted_name(record))
+    end
+
+    def method_missing(mthd)
+      @set.send(mthd)
+    end
+  end  
+end

data/lib/poly_belongs_to/version.rb

@@ -1,3 +1,3 @@
 module PolyBelongsTo
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end