poly_belongs_to 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7bb57e153d2b318ee6809a57f925e3adda3ecea
-  data.tar.gz: 61110ab7c6b819e37f4c5b82b542f8edb6e123a6
+  metadata.gz: 295e7bd5fc23bc91323e6bf9d8650e1e4b6f59ab
+  data.tar.gz: 9cfbad7a6779856a5950b7410737ee524b8ef29c
 SHA512:
-  metadata.gz: e2ce49d807729c6e49318be14ee20f106b3f9fd971c3586dcddc064c3d29ada5130ba1cf4e81db5924b396cc9c9273ec70372e95a922956e609e6fb40b3120b7
-  data.tar.gz: d2cd49a7f5a62cbd6f8c2d4de20fcf8675f8a598312bae14d0b565557d8f4690a108b6de7270cefcf212412bc317598afc5828ace0fa71edb013e3db800b5a25
+  metadata.gz: b3421897cbce5956b73d3ff9339c2ec3755d36ed03c830eef435dce662e83f2ece03604b9bfa50357023267c66d7fb82dba76a0ac7845712dcaa76a1b8634b93
+  data.tar.gz: babae7be384227bb9ee4b181f08598d97b3963d926bae0da03a80d89ccb2758fccfbabdd07a1ca95b223a2c7bdb11e2a1cc705d7828fb0f9e1f1e2ad645a17c8

data/README.md

@@ -3,28 +3,15 @@
 [![Code Climate](https://codeclimate.com/github/danielpclark/PolyBelongsTo/badges/gpa.svg)](https://codeclimate.com/github/danielpclark/PolyBelongsTo)
 [![Build Status](https://travis-ci.org/danielpclark/PolyBelongsTo.svg)](https://travis-ci.org/danielpclark/PolyBelongsTo)
 
-Is an ActiveRecord library which will let you check your DB Objects polymorphism in a more across-the-board
-meta-programatically friendly way.
+A standard way to check belongs_to relations on any belongs_to Object and let you check your DB Objects polymorphism in a more across-the-board meta-programatically friendly way.
 
 #Installation
 
-### Gem
-
 Just include it in your Gemfile and then run bundle:
 ```ruby
 gem 'poly_belongs_to'
 ```
 
-###Merge via git
-Be in your Rails project directory.  Make sure you git is up to date with all your latest changes.  Then:
-
-```shell
-git fetch git@github.com:danielpclark/PolyBelongsTo.git install:pbt
-git merge pbt
-```
-
-And then enter a description for this merge into your project.  Save the message, exit, and you're done!
-
 ##Recommended Usage
 
 #####On model class
@@ -47,7 +34,6 @@ MyObject.pbt_params_name
 MyObject.pbt_params_name(false)
 # => :my_object
 User.pbt_params_name
-User.pbt_params_name
 # => :user
 
 # Polymorphic DB field names
@@ -101,8 +87,92 @@ MyObject.new.pbt_type_sym       # nil for non polymorphic Objects
 # => :my_objectable_type
 ```
 
+##Internal Methods Available
+
+```ruby
+# For cleaning attributs for use with build
+PolyBelongsTo::Pbt::AttrSanitizer[ obj ]
+
+# Returns string of either 'child.build' or 'build_child'
+PolyBelongsTo::Pbt::BuildCmd[ obj, child ]
+
+# Returns has_one and has_many relationships for obj as an Array of symbols
+PolyBelongsTo::Pbt::Reflects[ obj ]
+
+# Returns Class Ojects for each has_one and has_many child associations
+PolyBelongsTo::Pbt::ReflectsAsClasses[ obj ]
+
+# Boolean of whether child object/class is a has(one/many) relationship to obj
+PolyBelongsTo::Pbt::IsReflected[ obj, child ]
+
+# Returns :singular if obj->child is has_one and :plural if obj->child is has_many
+PolyBelongsTo::Pbt::SingularOrPlural[ obj, child ]
+
+# Returns true if obj->child relationship is has_one
+PolyBelongsTo::Pbt::IsSingular[ obj, child ]
+
+# Returns true if obj->child relationship is has_many
+PolyBelongsTo::Pbt::IsPlural[ obj, child ]
+
+# Returns the simbol for the CollectionProxy the child belongs to in relation to obj
+PolyBelongsTo::Pbt::CollectionProxy[ obj, child ]
+
+```
+##Record Duplication
+
+**This gives you the advantage of duplicating records regardless of polymorphic associations or
+otherwise**.  You can duplicate a record, or use a self recursive command **pbt_deep_dup_build**
+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 other records to still save and prevent
+rollback 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.
+
+###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
+
+```ruby
+# If you were to create a new contact for example
+contact = User.first.contacts.new
+
+# This is just like contact.profile.build( { ... user's profile attributes ... } )
+contact.pbt_dup_build( User.last.profile )
+
+# Save it!
+contact.save
+
+
+# For a fully recursive copy do the same with pbt_deep_dup_build
+# Keep in mind this is vulnerable to infinite loops!
+contact.pbt_deep_dup_build( User.last.profile )
+
+# Remeber to save!
+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
+request if it's a non-fix change.  Thank you!
 
-And that's that!
 
 #License
 

data/lib/poly_belongs_to.rb

@@ -3,79 +3,84 @@
 # Copyright (C) 2015 by Daniel P. Clark
 $: << File.join(File.dirname(__FILE__), "/poly_belongs_to")
 require 'poly_belongs_to/version'
+require 'poly_belongs_to/dup'
+require 'poly_belongs_to/hierarchy'
+require 'poly_belongs_to/poly_belongs_to'
 require 'active_support/concern'
 
 module PolyBelongsTo
-  extend ActiveSupport::Concern
+  module Core
+    extend ActiveSupport::Concern
 
-  included do
-    def self.pbt
-      reflect_on_all_associations(:belongs_to).first.try(:name)
+    included do
+      def self.pbt
+        reflect_on_all_associations(:belongs_to).first.try(: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 self.poly?
-      !!reflect_on_all_associations(:belongs_to).first.try {|i| i.options[:polymorphic] }
+    def pbt
+      self.class.pbt
     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
+    def poly?
+      self.class.poly?
     end
 
-    def self.pbt_id_sym
+    def pbt_id
       val = pbt
-      val ? "#{val}_id".to_sym : nil
+      val ? eval("self.#{val}_id") : nil
     end
 
-    def self.pbt_type_sym
-      poly? ? "#{pbt}_type".to_sym : nil
+    def pbt_type
+      poly? ? eval("self.#{pbt}_type") : nil
     end
-  end
-  
-  def pbt
-    self.class.pbt
-  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 pbt
-      if poly?
-        eval "#{pbt_type}.find(#{pbt_id})"
+    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
-        eval "#{val.capitalize.to_s}.find(#{pbt_id})"
+        nil
       end
-    else
-      nil
     end
-  end
 
-  def pbt_id_sym
-    self.class.pbt_id_sym
-  end
+    def pbt_id_sym
+      self.class.pbt_id_sym
+    end
 
-  def pbt_type_sym
-    self.class.pbt_type_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)
+    def pbt_params_name(allow_as_nested = true)
+      self.class.pbt_params_name(allow_as_nested)
+    end
   end
 end
 
-ActiveRecord::Base.send(:include, PolyBelongsTo)
+ActiveRecord::Base.send(:include, PolyBelongsTo::Core)

data/lib/poly_belongs_to/dup.rb

@@ -0,0 +1,43 @@
+module PolyBelongsTo
+  module Dup
+    extend ActiveSupport::Concern
+
+    included do
+      def self.pbt_dup_build(item_to_build_on, item_to_duplicate)
+        if PolyBelongsTo::Pbt::IsReflected[item_to_build_on, item_to_duplicate]
+          build_cmd = PolyBelongsTo::Pbt::BuildCmd[item_to_build_on, item_to_duplicate]
+          dup_attrs = PolyBelongsTo::Pbt::AttrSanitizer[item_to_duplicate]
+
+          build_cmd ? eval("item_to_build_on.#{build_cmd}(#{dup_attrs})") : nil
+        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)
+        PolyBelongsTo::Pbt::Reflects[item_to_duplicate].each do |ref|
+          child = eval("item_to_duplicate.#{ref}")
+          if child.respond_to?(:build)
+            child.each do |obj|
+              eval("item_to_build_on.#{PolyBelongsTo::Pbt::CollectionProxy[item_to_build_on, item_to_duplicate]}").
+                pbt_deep_dup_build(obj)
+            end
+          else
+            eval("item_to_build_on.#{PolyBelongsTo::Pbt::CollectionProxy[item_to_build_on, item_to_duplicate]}").
+              pbt_deep_dup_build(child)
+          end
+        end
+        item_to_build_on       
+      end
+
+   end
+
+    def pbt_dup_build(item_to_duplicate)
+      self.class.pbt_dup_build(self, item_to_duplicate)
+    end
+
+    def pbt_deep_dup_build(item_to_duplicate)
+      self.class.pbt_deep_dup_build(self, item_to_duplicate)
+    end
+
+  end
+end

data/lib/poly_belongs_to/hierarchy.rb

@@ -0,0 +1,23 @@
+module PolyBelongsTo
+  module Hierarchy
+    extend ActiveSupport::Concern
+
+    included do
+      def self.pbt_offspring(obj)
+        # planning phase
+      end
+
+      def self.pbt_children(obj, kind)
+        # planning phase
+      end
+    end
+
+    def pbt_offspring
+      self.class.pbt_offspring(self)
+    end
+
+    def pbt_children(kind)
+      self.class.pbt_children(self, kind)
+    end
+  end
+end

data/lib/poly_belongs_to/poly_belongs_to.rb

@@ -0,0 +1,66 @@
+module PolyBelongsTo
+  module Pbt
+    AttrSanitizer = lambda {|obj|
+      return {} unless obj
+      obj.dup.attributes.delete_if {|ky,vl|
+        [:created_at, :updated_at, :deleted_at, obj.pbt_id_sym, obj.pbt_type_sym].include? ky.to_sym
+      } 
+    }
+
+    BuildCmd = lambda {|obj, child|
+      dup_name = "#{CollectionProxy[obj,child]}"
+      IsSingular[obj, child] ? "build_#{dup_name}" : IsPlural[obj, child] ? "#{dup_name}.build" : nil
+    }
+
+    Reflects = lambda {|obj|
+      [:has_one, :has_many].map { |has|
+        eval(obj.class.name).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
+      }
+    }
+    
+    IsReflected = lambda {|obj,child|
+      !!SingularOrPlural[obj, child]
+    }
+
+    SingularOrPlural = lambda {|obj, child|
+      reflects = Reflects[obj]
+      if reflects.include?(ActiveModel::Naming.singular(child).to_sym)
+        :singular
+      elsif reflects.include?(ActiveModel::Naming.plural(child).to_sym)
+        :plural
+      else
+        nil
+      end
+    }
+
+    IsSingular = lambda {|obj, child|
+      eval(obj.class.name).reflect_on_all_associations(:has_one).
+        map(&:name).map(&:to_sym).include? ActiveModel::Naming.singular(child).to_sym
+    }
+
+    IsPlural = lambda {|obj,child|
+      eval(obj.class.name).reflect_on_all_associations(:has_many).
+        map(&:name).map(&:to_sym).include? ActiveModel::Naming.plural(child).to_sym
+    }
+
+    CollectionProxy = lambda {|obj, child|
+      reflects = Reflects[obj]
+      proxy = ActiveModel::Naming.singular(child).to_sym
+      if reflects.include? proxy
+        return proxy
+      end
+      proxy = ActiveModel::Naming.plural(child).to_sym
+      if reflects.include? proxy
+        proxy
+      else
+        nil
+      end
+    }
+  end
+end

data/lib/poly_belongs_to/version.rb

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

data/test/dummy/Rakefile

@@ -3,4 +3,4 @@
 
 require File.expand_path('../config/application', __FILE__)
 
-Rails.application.load_tasks
+DummyApp.load_tasks

data/test/dummy/app/models/address.rb

@@ -0,0 +1,3 @@
+class Address < ActiveRecord::Base
+  belongs_to :addressable, polymorphic: true
+end

data/test/dummy/app/models/contact.rb

@@ -0,0 +1,5 @@
+class Contact < ActiveRecord::Base
+  belongs_to :user
+  has_one    :profile, as: :profileable, dependent: :destroy
+  accepts_nested_attributes_for :profile
+end

data/test/dummy/app/models/photo.rb

@@ -0,0 +1,3 @@
+class Photo < ActiveRecord::Base
+  belongs_to :photoable, polymorphic: true
+end