passive_record 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 538bfa9bf872e0e23675e06d820897253504c6c3
-  data.tar.gz: ece1e692df2cfd1a30d9240fc4fdfca11388f8a3
+  metadata.gz: 1d9a56d9aea21fdf0049781ce8d07cf85d1e996a
+  data.tar.gz: 9817a28de29ec3e02268234a41562925cf04adc5
 SHA512:
-  metadata.gz: 066ce8866a53c2725e9c8e642be67e0ac2dd86fbaeab3b435c354bcf6e30255b90b1082515721ed7c132246aa30a89e3d555e8611db38033f722f9e66cb075c5
-  data.tar.gz: 9ed65e8664ff3c288ad8dbabe17efae62b8be398ea8f1849d97ac8e72f515bcdc02bef4c4b4af10e06ddb6c6e4817bd129873e4ad743f600e33f1f784c860d85
+  metadata.gz: 611cd1f3b49bf74734443e19d4b5c1a95f23f598d986d9ea34f57ce5685d206440e3591417f076bbd3020979c5b36165a8518318e5ad0436bccb074bc13febee
+  data.tar.gz: e0a1d8f0b8a67b4eaa526336740e818ba7ceffcf09171b1ed7456402b1dcfda7761a38645c6c7480513abf53b4f0ffa8872596e0574c8823c5ca347a3fb879c7

data/README.md

@@ -104,7 +104,7 @@ PassiveRecord may be right for you!
   - `User.find_by(conditions_hash)`
   - `User.find_all_by(conditions_hash)`
   - `User.all` and `User.each`
-  -  User is `Enumerable` through `User.all`, so we have `User.count`, `User.first`, etc.
+  - `User.each` enumerates over `User.all`, giving `User.count`, `User.first`, etc.
   - `User.where(conditions_hash)` (returns a `PassiveRecord::Query` object)
   - `User.descendants`
   - `User.destroy_all`
@@ -130,11 +130,11 @@ PassiveRecord may be right for you!
   - `parent.child_id=`
   - `parent.create_child(attrs)`
 
-### Has Many
+### Has Many / Has Many Through / HABTM
 
-  A model `Parent` which declares `has_many :children` will gain:
+  A model `Parent` which declares `has_many :children` or `has_and_belongs_to_many :children` will gain:
 
-  - `parent.children` (returns a `Relation`)
+  - `parent.children` (returns a `Relation`, documented below)
   - `parent.children_ids`
   - `parent.children=`
   - `parent.children_ids=`
@@ -144,9 +144,31 @@ PassiveRecord may be right for you!
   - `parent.children.empty?`
   - `parent.children.where` (returns a `Core::Query`)
 
+### Explicit Relations
+
+  Parent models which declare `has_many :children` gain a `parent.children` instance that returns an explicit PassiveRecord relation object, which has the following public interface:
+
+  - `parent.children.all`
+  - `parent.children.each` enumerates over `parent.children.all`, giving `parent.children.count`, `parent.children.first`, etc.
+  - `parent.children.all?(&predicate)`
+  - `parent.children.empty?`
+  - `parent.children.where(conditions)` (returns a `Core::Query`)
+  - `parent.children<<` (insert a new child into the relation)
+
+### Queries
+
+  `Core::Query` objects acquired through `where` are chainable and have their own API.
+
+  - `where(conditions).all`
+  - `where(conditions).each` enumerates over `where(conditions).all`, so we have `where(conditions).count`, `where(conditions).first`, etc.
+  - `where(conditions).create(attrs)`
+  - `where(conditions).first_or_create(attrs)`
+  - `where(conditions).where(further_conditions)` (chaining)
+
 ## Hooks
 
-  - `after_create :call_method`
+  - `before_create :call_a_method`
+  - `after_create :call_another_method, :and_then_call_another_one`
   - `after_update { or_use_a_block }`
 
 ## Copyright

data/lib/passive_record/associations.rb

@@ -15,7 +15,7 @@ module PassiveRecord
       @associations&.map do |assn|
         if assn.is_a?(HasOneAssociation) || assn.is_a?(BelongsToAssociation)
           (assn.target_name_symbol.to_s + "_id").to_sym
-        else # plural ids
+        else
           (assn.target_name_symbol.to_s.singularize + "_ids").to_sym
         end
       end || []
@@ -50,5 +50,32 @@ module PassiveRecord
         associate!(association)
       end
     end
+
+    def has_and_belongs_to_many(collection_name_sym)
+      habtm_join_class_name =
+        self.name.split('::').last.singularize +
+        collection_name_sym.to_s.camelize.singularize +
+        "JoinModel"
+      inverse_habtm_join_class_name =
+        collection_name_sym.to_s.camelize.singularize +
+        self.name.split('::').last.singularize +
+        "JoinModel"
+
+      if (Object.const_get(inverse_habtm_join_class_name) rescue false)
+        has_many inverse_habtm_join_class_name.underscore.pluralize.to_sym
+        has_many collection_name_sym, :through => inverse_habtm_join_class_name.underscore.pluralize.to_sym
+      else
+        auto_collection_sym = self.name.split('::').last.underscore.pluralize.to_sym
+        eval <<-ruby
+        class ::#{habtm_join_class_name}                        # class UserRoleJoinModel
+          include PassiveRecord                                 #   include PassiveRecord
+          belongs_to :#{collection_name_sym.to_s.singularize}   #   belongs_to :role
+          belongs_to :#{auto_collection_sym.to_s.singularize}   #   belongs_to :user
+        end                                                     # end
+        ruby
+        has_many habtm_join_class_name.underscore.pluralize.to_sym
+        has_many(collection_name_sym, :through => habtm_join_class_name.underscore.pluralize.to_sym)
+      end
+    end
   end
 end

data/lib/passive_record/associations/has_many.rb

@@ -11,7 +11,6 @@ module PassiveRecord
     end
 
     class HasManyRelation < HasOneRelation
-      include Enumerable 
       include Enumerable
       extend Forwardable
 
@@ -28,13 +27,13 @@ module PassiveRecord
         all.empty?
       end
 
-      def where(conditions)
-        child_class.where(conditions.merge(parent_model_id_field => parent_model.id))
+      def where(conditions={})
+        child_class.where(conditions.merge(parent_model_id_field.to_sym => parent_model.id))
       end
-      
+
       def <<(child)
         child.send(parent_model_id_field + "=", parent_model.id)
-        lookup
+        all
       end
 
       def singular?

data/lib/passive_record/associations/has_many_through.rb

@@ -7,14 +7,11 @@ module PassiveRecord
     end
 
     class HasManyThroughRelation < HasManyRelation
-      def intermediary_relation
-        association.base_association.to_relation(parent_model)
-      end
-
-      def_delegators :all, :intermedia
-
-      def results
-        intermediary_relation.all
+      def <<(child)
+        intermediary_relation.
+          where((target_sym.to_s.singularize + "_id").to_sym => child.id).
+          first_or_create
+        all
       end
 
       def all
@@ -30,6 +27,15 @@ module PassiveRecord
         end
       end
 
+
+      def intermediary_relation
+        association.base_association.to_relation(parent_model)
+      end
+
+      def results
+        intermediary_relation.all
+      end
+
       def target_sym
         name_str = association.target_name_symbol.to_s
         singular_target_sym = name_str.singularize.to_sym

data/lib/passive_record/associations/has_one.rb

@@ -1,7 +1,6 @@
 module PassiveRecord
   module Associations
     class HasOneAssociation < Struct.new(:parent_class, :child_class_name, :child_name_sym)
-
       def to_relation(parent_model)
         HasOneRelation.new(self, parent_model)
       end

data/lib/passive_record/class_methods.rb

@@ -30,13 +30,10 @@ module PassiveRecord
     end
 
     def find_by(conditions)
-      #if conditions.is_a?(Array)
-      #  find_by_ids(conditions)
       if conditions.is_a?(Hash)
         where(conditions).first
       else # assume we have an identifier/identifiers
         find(conditions)
-        # find_by_id(conditions)
       end
     end
 
@@ -60,6 +57,10 @@ module PassiveRecord
 
       register(instance)
 
+      before_create_hooks.each do |hook|
+        hook.run(instance)
+      end
+
       attrs.each do |(k,v)|
         instance.send("#{k}=", v)
       end

data/lib/passive_record/core/query.rb

@@ -1,45 +1,58 @@
 module PassiveRecord
   module Core
-    class Query < Struct.new(:klass, :conditions)
+    class Query
+      include Enumerable
+      extend Forwardable
+
+      attr_accessor :klass, :conditions
+
+      def initialize(klass,conditions={})
+        @klass = klass
+        @conditions = conditions
+      end
+
       def all
         return [] unless conditions
-
-        klass.all.select do |instance|
+        klass.select do |instance|
           conditions.all? do |(field,value)|
             if value.is_a?(Hash)
-              assn = instance.send(field)
-              matched = assn && value.all? do |(assn_field,val)|
-                if assn.is_a?(Array)
-                  assn.any? do |assc_model|
-                    assc_model.send(assn_field) == val
-                  end
-                else
-                  if assn.is_a?(Core::Query) || (assn.is_a?(Associations::Relation) && !assn.singular?)
-                    assn.where(assn_field => val) # send(assn_field) == val
-                  else
-                    assn.send(assn_field) == val
-                  end
-                end
-              end
-              matched
+              evaluate_nested_conditions(instance, field, value)
             else
               instance.send(field) == value
             end
           end
         end
       end
+      def_delegators :all, :each
 
-      def first
-        all.first
-      end
-
-      def create
-        klass.create(conditions)
+      def create(attrs={})
+        klass.create(conditions.merge(attrs))
       end
 
       def first_or_create
         first || create
       end
+
+      def where(new_conditions={})
+        @conditions = new_conditions.merge(conditions)
+        self
+      end
+
+      def ==(other_query)
+        @klass == other_query.klass && @conditions == other_query.conditions
+      end
+
+      protected
+      def evaluate_nested_conditions(instance, field, value)
+        association = instance.send(field)
+        association && value.all? do |(association_field,val)|
+          if association.is_a?(Associations::Relation) && !association.singular?
+            association.where(association_field => val).any?
+          else
+            association.send(association_field) == val
+          end
+        end
+      end
     end
   end
 end

data/lib/passive_record/hooks.rb

@@ -20,6 +20,17 @@ module PassiveRecord
       end
     end
 
+    def before_create_hooks
+      @hooks ||= []
+      @hooks.select { |hook| hook.kind == :before_create }
+    end
+
+    def before_create(*meth_syms, &blk)
+      hook = Hook.new(:before_create,*meth_syms,&blk)
+      @hooks ||= []
+      @hooks += [ hook ]
+    end
+
     def after_create_hooks
       @hooks ||= []
       @hooks.select { |hook| hook.kind == :after_create }

data/lib/passive_record/instance_methods.rb

@@ -59,7 +59,7 @@ module PassiveRecord
     end
 
     def find_relation_by_target_name_symbol(meth)
-      relata.detect do |relation|  # matching relation...
+      relata.detect do |relation|
         possible_target_names(relation).include?(meth.to_s)
       end
     end
@@ -90,12 +90,19 @@ module PassiveRecord
         end
       when "#{target_name}="
         if args.first.is_a?(Array)
-          # need to loop through each arg and set id
-          args.first.each do |child|
-            child.send(matching_relation.parent_model_id_field + "=", id)
+          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
-          # assume simple assignment
           matching_relation.parent_model_id = args.first.id
         end
       when "create_#{target_name}", "create_#{target_name.singularize}"

data/lib/passive_record/version.rb

@@ -1,4 +1,4 @@
 module PassiveRecord
   # passive_record version
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/spec/passive_record_spec.rb

@@ -42,11 +42,11 @@ describe "passive record models" do
 
         it 'should report relations' do
           dog = Dog.create
-          expect(dog.inspect).to eq("Family::Dog (id: #{dog.id.inspect}, created_at: #{dog.created_at}, sound: \"bark\", child_id: nil)")
+          expect(dog.inspect).to eq("Family::Dog (id: #{dog.id.inspect}, breed: \"#{dog.breed}\", created_at: #{dog.created_at}, sound: \"bark\", child_id: nil)")
 
           child = Child.create
           child.dogs << dog
-          expect(dog.inspect).to eq("Family::Dog (id: #{dog.id.inspect}, created_at: #{dog.created_at}, sound: \"bark\", child_id: #{child.id.inspect})")
+          expect(dog.inspect).to eq("Family::Dog (id: #{dog.id.inspect}, breed: \"#{dog.breed}\", created_at: #{dog.created_at}, sound: \"bark\", child_id: #{child.id.inspect})")
 
           expect(child.inspect).to eq("Family::Child (id: #{child.id.inspect}, created_at: #{dog.created_at}, name: \"Alice\", toy_id: nil, dog_ids: [#{dog.id.inspect}], parent_id: nil)")
         end
@@ -249,13 +249,33 @@ describe "passive record models" do
       let(:child) { parent.create_child }
 
       it 'should collect children of children' do
-        child.create_dog
+        child.create_dog(breed: 'mutt')
         expect(parent.dogs.all).to all(be_a(Dog))
         expect(parent.dogs.count).to eq(1)
         expect(parent.dogs.first).to eq(child.dogs.first)
         expect(parent.dog_ids).to eq([child.dogs.first.id])
       end
 
+      it 'should chain where clauses' do
+        child.create_dog(breed: 'mutt')
+        child.create_dog(breed: 'pit')
+
+        # another mutt, not the same childs
+        Dog.create(breed: 'mutt')
+
+        expect(Dog.where(breed: 'mutt').count).to eq(2)
+        expect(child.dogs.where(breed: 'mutt').count).to eq(1)
+
+        expect(
+          child.dogs.
+            where(breed: 'mutt')
+        ).to eq(
+          Dog.
+            where(child_id: child.id).
+            where(breed: 'mutt')
+        )
+      end
+
       it 'should do the nested query example from the readme' do
         child.create_dog
         expect(Dog.find_all_by(child: {parent: parent})).
@@ -312,6 +332,21 @@ describe "passive record models" do
         expect(user_b.friends.all).to eq([user_a])
       end
     end
+
+    context 'direct habtm' do
+      let!(:user) { User.create roles: [role] }
+      let(:role) { Role.create }
+      let(:another_user) { User.create }
+
+      it 'should manage direct habtm relations' do
+        expect(role.users).to include(user)
+        expect(user.roles).to include(role)
+        expect(role.user_ids).to eq([user.id])
+        expect(user.role_ids).to eq([role.id])
+
+        expect {role.users << another_user}.to change{role.users.count}.by(1)
+      end
+    end
   end
 end
 

data/spec/spec_helper.rb

@@ -20,8 +20,10 @@ end
 module Family
   class Dog < Model
     attr_reader :sound
+    attr_accessor :breed
     belongs_to :child
-    after_create {@sound = 'bark'}
+    before_create { @breed = %w[pom pug].sample }
+    after_create { @sound = 'bark' }
   end
 
   class Toy < Model
@@ -78,6 +80,11 @@ end
 class User < Model
   has_many :friendships
   has_many :friends, :through => :friendships
+  has_and_belongs_to_many :roles
+end
+
+class Role < Model
+  has_and_belongs_to_many :users
 end
 
 ### 

metadata

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