passive_record 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bae7d40e8ae674093246626a73f247c24cfdd442
-  data.tar.gz: d02d5675a5ec0857d1e15e24a7fb7149a880d362
+  metadata.gz: e925955215f05a8a105989c34bbd462e730676b9
+  data.tar.gz: cdc707806939051ec202a2962bef24f88ef4921b
 SHA512:
-  metadata.gz: b0a66bb01e629e8b313aad8febe2085ad4b00a36af23e925393068501d01c988fe3b001d20822c640b4fcdbe7224b192bc93f23cacd78dbbbbbe743cb29d40c5
-  data.tar.gz: 23ccde9e6bc44c98080e854746b4078edf4585c4b59e53a278754c234e1c7d99add543e04dc7d5199ab699fd5e887d1f3e8a42a2025c19e416e3c63c9141f090
+  metadata.gz: 1da3e90a67086a5b536549d46663c6afeb50791f334ddaee2edaf4a4670980fa25ffe10dd49183d4d037dcb261cf0872fa157651c7e2a77c99e15830625d14c3
+  data.tar.gz: 0559e101eff6e7e1dde11ae84bcdedc4f75096889670ce2d1e388afab1a5c63405f8a5b9c685f3e71c28de957b33662b94464c8b9b29a9a171dded3a0208bbe3

data/README.md

@@ -15,7 +15,8 @@ We implement a simplified subset of AR's interface in pure Ruby.
 ## Why?
 
 Do you need to track objects by ID and look them up again,
-or look them up based on attributes, or even utilize some limited relational semantics,
+or look them up based on attributes,
+or even utilize some relational semantics,
 but have no real need for persistence?
 
 PassiveRecord may be right for you.
@@ -23,10 +24,12 @@ PassiveRecord may be right for you.
 
 ## Features
 
-  - Just 'include PassiveRecord' to activate a PORO in the system
   - New objects are tracked and assigned IDs
-  - Query on attributes and simple relations (belongs_to, has_one, has_many)
+  - Build relationships with belongs_to, has_one and has_many
+  - Query on attributes and associations
+  - Supports many-to-many and self-referential relationships
   - No database required!
+  - Just `include PassiveRecord` to activate a PORO in the system
 
 ## Examples
 
@@ -70,6 +73,7 @@ PassiveRecord may be right for you.
 
     $ gem install passive_record
 
+
 ## Synopsis
 
     $ passive_record

data/lib/passive_record.rb

@@ -6,6 +6,7 @@ require 'passive_record/core/identifier'
 require 'passive_record/core/query'
 
 require 'passive_record/associations'
+require 'passive_record/hooks'
 
 module PassiveRecord
   def self.included(base)
@@ -52,6 +53,7 @@ module PassiveRecord
   module ClassMethods
     include PassiveRecord::Core
     include PassiveRecord::Associations
+    include PassiveRecord::Hooks
 
     include Enumerable
     extend Forwardable
@@ -76,17 +78,21 @@ module PassiveRecord
     end
 
     def create(attrs={})
-      registrable = new #(*args)
+      instance = new
 
-      registrable.singleton_class.class_eval { attr_accessor :id }
-      registrable.send(:"id=", Identifier.generate)
-      register(registrable)
+      instance.singleton_class.class_eval { attr_accessor :id }
+      instance.send(:"id=", Identifier.generate)
+      register(instance)
 
       attrs.each do |(k,v)|
-        registrable.send("#{k}=", v)
+        instance.send("#{k}=", v)
       end
 
-      registrable
+      after_create_hooks.each do |hook|
+        hook.run(instance)
+      end
+
+      instance
     end
 
     protected

data/lib/passive_record/hooks.rb

@@ -0,0 +1,37 @@
+module PassiveRecord
+  module Hooks
+    class Hook
+      def initialize(*meth_syms,&blk)
+        @methods_to_call = meth_syms
+        @block_to_invoke = blk
+      end
+
+      def run(instance)
+        @methods_to_call.each do |meth|
+          instance.send(meth)
+        end
+
+        unless @block_to_invoke.nil?
+          instance.instance_eval(&@block_to_invoke)
+        end
+      end
+    end
+
+    def hooks
+      @hooks ||= {}
+    end
+
+    def after_hooks
+      hooks[:after] ||= {}
+    end
+
+    def after_create_hooks
+      after_hooks[:create] ||= []
+    end
+
+    def after_create(*meth_syms, &blk)
+      hook = Hook.new(*meth_syms,&blk)
+      after_create_hooks.push(hook)
+    end
+  end
+end

data/lib/passive_record/version.rb

@@ -1,4 +1,4 @@
 module PassiveRecord
   # passive_record version
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/passive_record_spec.rb

@@ -11,95 +11,115 @@ describe Model do
       end
     end
 
-    describe "#count" do
-      it 'should indicate the size of the models list' do
-        expect { SimpleModel.create }.to change { SimpleModel.count }.by(1)
+    context 'should be enumerable over models' do
+      describe "#count" do
+        it 'should indicate the size of the models list' do
+          expect { SimpleModel.create }.to change { SimpleModel.count }.by(1)
+        end
       end
     end
 
-    describe "#find_by" do
-      it 'should be retrievable by query' do
-        expect(SimpleModel.find_by(foo: 'foo_value')).to eq(model)
+    context 'querying by attributes' do
+      describe "#find_by" do
+        it 'should be retrievable by query' do
+          expect(SimpleModel.find_by(foo: 'foo_value')).to eq(model)
+        end
       end
     end
-  end
 
-  context 'one-to-one relationships' do
-    let(:child) { Child.create }
-    let(:another_child) { Child.create }
+    xcontext 'querying by associations'
+  end
 
-    it 'should create children' do
-      expect { child.create_dog }.to change { Dog.count }.by(1)
-      expect(child.dog).to eq(Dog.first)
-    end
+  context 'hooks' do
+    context 'after create hooks' do
+      it 'should use a symbol to invoke a method' do
+        expect(Child.create.name).to eq("Alice")
+      end
 
-    it 'should have inverse relationships' do
-      dog = child.create_dog
-      expect(dog.child).to eq(child)
-      another_dog = another_child.create_dog
-      expect(another_dog.child).to eq(another_child)
+      it 'should use a block' do
+        expect(Parent.create.created_at).to be_a(Time)
+      end
     end
   end
 
-  context 'one-to-many relationships' do
-    let(:parent) { Parent.create }
+  context 'associations' do
+    context 'one-to-one relationships' do
+      let(:child) { Child.create }
+      let(:another_child) { Child.create }
 
-    it 'should create children' do
-      expect { parent.create_child }.to change{ Child.count }.by(1)
-      expect(parent.children).to all(be_a(Child))
+      it 'should create children' do
+        expect { child.create_dog }.to change { Dog.count }.by(1)
+        expect(child.dog).to eq(Dog.first)
+      end
+
+      it 'should have inverse relationships' do
+        dog = child.create_dog
+        expect(dog.child).to eq(child)
+        another_dog = another_child.create_dog
+        expect(another_dog.child).to eq(another_child)
+      end
     end
 
-    it 'should create inverse relationships' do
-      child = parent.create_child
-      expect(child.parent).to eq(parent)
+    context 'one-to-many relationships' do
+      let(:parent) { Parent.create }
+
+      it 'should create children' do
+        expect { parent.create_child }.to change{ Child.count }.by(1)
+        expect(parent.children).to all(be_a(Child))
+      end
+
+      it 'should create inverse relationships' do
+        child = parent.create_child
+        expect(child.parent).to eq(parent)
 
-      another_child = parent.create_child
-      expect(another_child.parent).to eq(parent)
+        another_child = parent.create_child
+        expect(another_child.parent).to eq(parent)
 
-      expect(child.id).not_to eq(another_child.id)
-      expect(parent.children).to eq([child, another_child])
+        expect(child.id).not_to eq(another_child.id)
+        expect(parent.children).to eq([child, another_child])
+      end
     end
-  end
 
-  context 'one-to-many through relationships' do
-    let(:parent) { Parent.create }
-    let(:child) { parent.create_child }
-    subject(:dogs) { parent.dogs }
+    context 'one-to-many through relationships' do
+      let(:parent) { Parent.create }
+      let(:child) { parent.create_child }
+      subject(:dogs) { parent.dogs }
 
-    it 'should collect children of children' do
-      child.create_dog
-      expect(dogs).to all(be_a(Dog))
-      expect(dogs.first).to eq(child.dog)
+      it 'should collect children of children' do
+        child.create_dog
+        expect(dogs).to all(be_a(Dog))
+        expect(dogs.first).to eq(child.dog)
+      end
     end
-  end
 
-  context 'many-to-many' do
-    let(:patient) { Patient.create }
-    let(:doctor)  { Doctor.create }
-    let!(:appointment) { Appointment.create(patient: patient, doctor: doctor) }
+    context 'many-to-many' do
+      let(:patient) { Patient.create }
+      let(:doctor)  { Doctor.create }
+      let!(:appointment) { Appointment.create(patient: patient, doctor: doctor) }
 
-    it 'should manage many-to-many relations' do
-      expect(appointment.doctor).to eq(doctor)
-      expect(appointment.patient).to eq(patient)
+      it 'should manage many-to-many relations' do
+        expect(appointment.doctor).to eq(doctor)
+        expect(appointment.patient).to eq(patient)
 
-      expect(patient.doctors).to eq([doctor])
-      expect(doctor.patients).to eq([patient])
+        expect(patient.doctors).to eq([doctor])
+        expect(doctor.patients).to eq([patient])
+      end
     end
-  end
 
-  context 'self-referential many-to-many' do
-    let!(:user_a) { User.create }
-    let!(:user_b) { User.create }
+    context 'self-referential many-to-many' do
+      let!(:user_a) { User.create }
+      let!(:user_b) { User.create }
 
-    it 'should permit relations' do
-      expect(user_a.friends).to be_empty
+      it 'should permit relations' do
+        expect(user_a.friends).to be_empty
 
-      # need to create bidirectional friendship
-      Friendship.create(user: user_a, friend: user_b)
-      Friendship.create(user: user_b, friend: user_a)
+        # need to create bidirectional friendship
+        Friendship.create(user: user_a, friend: user_b)
+        Friendship.create(user: user_b, friend: user_a)
 
-      expect(user_a.friends).to eq([user_b])
-      expect(user_b.friends).to eq([user_a])
+        expect(user_a.friends).to eq([user_b])
+        expect(user_b.friends).to eq([user_a])
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -17,11 +17,19 @@ end
 class Child < Model
   has_one :dog
   belongs_to :parent
+
+  after_create :give_name
+
+  attr_reader :name
+  def give_name; @name = "Alice" end
 end
 
 class Parent < Model
   has_many :children
   has_many :dogs, :through => :children
+
+  attr_reader :created_at
+  after_create { @created_at = Time.now }
 end
 
 ###

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passive_record
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Joseph Weissman
@@ -141,6 +141,7 @@ files:
 - lib/passive_record/associations/has_one.rb
 - lib/passive_record/core/identifier.rb
 - lib/passive_record/core/query.rb
+- lib/passive_record/hooks.rb
 - lib/passive_record/hstruct.rb
 - lib/passive_record/version.rb
 - passive_record.gemspec
@@ -171,4 +172,3 @@ signing_key:
 specification_version: 4
 summary: no-persistence relational algebra
 test_files: []
-has_rdoc: