passive_record 0.3.10 → 0.3.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a864962f49adde921cd337981fea7046b072a91
-  data.tar.gz: f6dfa54709c92ab2628fbe07a2831f71f714b930
+  metadata.gz: 1a62578ddc6b83eea82b4cf49d13debdaa28a981
+  data.tar.gz: bb333fee35ac2726caa54e119ac9dd8ee30c1804
 SHA512:
-  metadata.gz: 9aba9642fa965b2b5460e5eec9521d426fe3041dfb53c5e234000eebb36d41caba198f88f011a399900dfdea4c6b68f721aa3421873d3a7edc26a3f54ee3ac04
-  data.tar.gz: 19fb03f821db6c570d24a546960d3b729c0b4e78f29189bee1c9ae820d87d227b74fb765b1eade54c6db602d903653d7683387f741c066253a6c6fb19b6b657e
+  metadata.gz: 454ae9685e3ab7a3ced60986178e18c2d30bdc413f5d8ea4ccf7d320e5d731ddf844072186dfdd1335251c0ebcb4eed575c3028ba58b684dfb437951d5b8a86c
+  data.tar.gz: 24509793436c201f1f4be7e73d3b85808b360aae77847c4f1f73b211aa3ce8b4b8319cd2abf142a0ecfb0e31b97fa2389d39ca58afcad35708f44f6beed7e226

data/lib/passive_record/associations.rb

@@ -25,29 +25,123 @@ module PassiveRecord
       target_class_name = opts.delete(:class_name) { (parent_name_sym.to_s).split('_').map(&:capitalize).join }
       association = BelongsToAssociation.new(self, target_class_name, parent_name_sym)
       associate!(association)
+
+      define_method(:"#{parent_name_sym}_id") do
+        send(parent_name_sym)&.id
+      end
+
+      define_method(parent_name_sym) do
+        relation = instance_eval{relata}.detect { |rel| rel.association == association }
+        association.parent_class.find(relation.parent_model_id)
+      end
+
+      define_method(:"#{parent_name_sym}=") do |new_parent|
+        send(:"#{parent_name_sym}_id=", new_parent.id)
+      end
+
+      define_method(:"#{parent_name_sym}_id=") do |new_parent_id|
+        relation = instance_eval{relata}.detect { |rel| rel.association == association }
+        relation.parent_model_id = new_parent_id
+      end
     end
 
     def has_one(child_name_sym)
       child_class_name = (child_name_sym.to_s).split('_').map(&:capitalize).join
       association = HasOneAssociation.new(self, child_class_name, child_name_sym)
       associate!(association)
+
+      define_method(:"#{child_name_sym}_id") do
+        send(child_name_sym)&.id
+      end
+
+      define_method(child_name_sym) do
+        relation = instance_eval{relata}.detect { |rel| rel.association == association }
+        relation.lookup
+      end
+
+      define_method(:"create_#{child_name_sym}") do |attrs={}|
+        relation = instance_eval{relata}.detect { |rel| rel.association == association }
+        relation.create(attrs)
+      end
+
+      define_method(:"#{child_name_sym}=") do |new_child|
+        send(:"#{child_name_sym}_id=", new_child.id)
+      end
+
+      define_method(:"#{child_name_sym}_id=") do |new_child_id|
+        relation = instance_eval{relata}.detect { |rel| rel.association == association }
+        # detach existing child...
+        relation.lookup.send(:"#{relation.parent_model_id_field}=", nil)
+
+        relation.child_class.
+          find(new_child_id).
+          update(relation.parent_model_id_field => relation.id)
+      end
     end
 
     def has_many(collection_name_sym, opts={})
       target_class_name = opts.delete(:class_name) { (collection_name_sym.to_s).split('_').map(&:capitalize).join }
 
+      association = nil
       if opts.key?(:through)
         through_class_collection_name = opts.delete(:through)
 
         through_class_name = (through_class_collection_name.to_s).split('_').map(&:capitalize).join
         base_association = associations.detect { |assn| assn.child_class_name == through_class_name }
 
-        association = HasManyThroughAssociation.new(self, target_class_name, collection_name_sym, through_class_collection_name, base_association)
+        association = HasManyThroughAssociation.new(
+          self, target_class_name, collection_name_sym, through_class_collection_name, base_association)
 
         associate!(association)
+
+        define_method(:"#{collection_name_sym}=") do |new_collection|
+          relation = instance_eval{relata}.detect { |rel| rel.association == association }
+
+          intermediary = relation.intermediary_relation
+
+          # drop all intermediary relations
+          intermediary.where( relation.parent_model_id_field => relation.id ).each do |intermediate|
+            intermediate.destroy
+          end
+
+          # add in new ones...
+          target_name = relation.association.target_name_symbol.to_s
+          new_collection.each do |child|
+            intermediary.create(target_name.singularize + "_id" => child.id, relation.parent_model_id_field => relation.id )
+          end
+        end
       else
         association = HasManyAssociation.new(self, target_class_name, collection_name_sym)
         associate!(association)
+
+
+        define_method(:"#{collection_name_sym}=") do |new_collection|
+          relation = instance_eval{relata}.detect { |rel| rel.association == association }
+
+          # detach existing children...
+          relation.all.each do |child|
+            child.send(:"#{relation.parent_model_id_field}=", nil)
+          end
+
+          # reattach new children
+          new_collection.each do |child|
+            child.send(:"#{relation.parent_model_id_field}=", relation.id)
+          end
+        end
+      end
+
+      define_method(collection_name_sym) do
+        relation = instance_eval{relata}.detect { |rel| rel.association == association }
+        relation
+      end
+
+      define_method(:"#{collection_name_sym.to_s.singularize}_ids") do
+        send(collection_name_sym).map(&:id)
+      end
+
+      define_method(:"create_#{collection_name_sym.to_s.singularize}") do |attrs={}|
+        relation = instance_eval{relata}.detect { |rel| rel.association == association }
+        relation.create(attrs)
       end
     end
 

data/lib/passive_record/instance_methods.rb

@@ -31,22 +31,6 @@ module PassiveRecord
       ]
     end
 
-    def respond_to?(meth,*args,&blk)
-      if find_relation_by_target_name_symbol(meth)
-        true
-      else
-        super(meth,*args,&blk)
-      end
-    end
-
-    def method_missing(meth, *args, &blk)
-      if (matching_relation = find_relation_by_target_name_symbol(meth))
-        send_relation(matching_relation, meth, *args)
-      else
-        super(meth,*args,&blk)
-      end
-    end
-
     protected
     def attribute_names
       attr_names = instance_variables
@@ -67,67 +51,5 @@ module PassiveRecord
         assn.to_relation(self)
       end || []
     end
-
-    def find_relation_by_target_name_symbol(meth)
-      relata.detect do |relation|
-        possible_target_names(relation).include?(meth.to_s)
-      end
-    end
-
-    def possible_target_names(relation)
-      target_name = relation.association.target_name_symbol.to_s
-      [
-        target_name,
-        "#{target_name}=",
-        "#{target_name}_id",
-        "#{target_name}_ids",
-        "#{target_name.singularize}_ids",
-        "#{target_name}_id=",
-        "create_#{target_name}",
-        "create_#{target_name.singularize}"
-      ]
-    end
-
-    def send_relation(matching_relation, meth, *args)
-      target_name = matching_relation.association.target_name_symbol.to_s
-
-      case meth.to_s
-      when target_name
-        if matching_relation.singular?
-          matching_relation.lookup
-        else
-          matching_relation
-        end
-      when "#{target_name}="
-        if args.first.is_a?(Array)
-          if matching_relation.is_a?(Associations::HasManyThroughRelation)
-            intermediary = matching_relation.intermediary_relation
-            args.first.each do |child|
-              intermediary.
-                where((target_name.singularize + "_id").to_sym => child.id).
-                first_or_create
-            end
-          else
-            args.first.each do |child|
-              child.send(matching_relation.parent_model_id_field + "=", id)
-            end
-          end
-        else
-          matching_relation.parent_model_id = args.first.id
-        end
-      when "create_#{target_name}", "create_#{target_name.singularize}"
-        matching_relation.create(*args)
-      when "#{target_name}_id"
-        if matching_relation.is_a?(Associations::HasOneRelation)
-          matching_relation.lookup&.id
-        elsif matching_relation.is_a?(Associations::BelongsToRelation)
-          matching_relation.parent_model_id
-        end
-      when "#{target_name}_id="
-        matching_relation.parent_model_id = args.first
-      when "#{target_name}_ids", "#{target_name.singularize}_ids"
-        matching_relation.parent_model.send(target_name).map(&:id)
-      end
-    end
   end
 end

data/lib/passive_record/version.rb

@@ -1,4 +1,4 @@
 module PassiveRecord
   # passive_record version
-  VERSION = "0.3.10"
+  VERSION = "0.3.11"
 end

data/spec/passive_record_spec.rb

@@ -273,6 +273,9 @@ describe "passive record models" do
         toy = Toy.create
         toy.child = child
         expect(child.toy).to eq(toy)
+
+        child.toy = Toy.create
+        expect(child.toy).not_to eq(toy)
       end
     end
 
@@ -309,7 +312,7 @@ describe "passive record models" do
 
         expect(child.id).not_to eq(another_child.id)
         expect(parent.children.all).to eq([child, another_child])
-        expect(parent.children_ids).to eq([child.id, another_child.id])
+        expect(parent.child_ids).to eq([child.id, another_child.id])
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passive_record
 version: !ruby/object:Gem::Version
-  version: 0.3.10
+  version: 0.3.11
 platform: ruby
 authors:
 - Joseph Weissman