repository 0.0.1

data/spec/lib/criterion_factory_spec.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require 'helper'
+
+module Repository
+  describe Criterion::Factory do
+    it "builds with equals" do
+      criterion = Criterion::Factory.equals('active', true)
+      criterion.should == Criterion::Equals.new(:subject => 'active', :value => true)
+    end
+    
+    it "builds with key and one argument" do
+      criterion = Criterion::Factory.key(99)
+      criterion.should == Criterion::Key.new(:subject => 'key', :value => 99)
+    end
+    
+    it "builds with key and two arguments" do
+      criterion = Criterion::Factory.key('address_id', 99)
+      criterion.should == Criterion::Key.new(:subject => 'address_id', :value => 99)
+    end
+    
+    it "converts a symbol into a string for the subject field name" do
+      criterion = Criterion::Factory.key(:address_id, 99)
+      criterion.should == Criterion::Key.new(:subject => 'address_id', :value => 99)
+    end
+
+
+    describe "individual criteria" do
+      before do
+        @repository = Repository.new(User)
+      end
+
+      def crit(&block)
+        @repository.criterion_from &block
+      end
+
+      it "equals" do
+        crit do |user|
+          user.equals('name', 'alice')
+        end.should == Criterion::Equals.new(:subject => "name", :value => "alice")
+      end
+
+      it "key" do
+        pending
+        crit do |user|
+          user.key(99)
+        end.should == Criterion::Key.new(:value => 99)
+      end
+
+      it "contains" do
+        crit do |user|
+          user.contains("name", "foo")
+        end.should == Criterion::Contains.new(:subject => "name", :value => "foo")
+      end
+
+      it "joins"
+    end
+
+    describe "conjunctions" do
+
+      it "and"
+
+      it "or"
+    end
+
+
+  end
+
+
+end

data/spec/lib/criterion_join_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require 'helper'
+
+module Repository
+  describe Criterion::Join do
+    before do
+      [::Repository[User], ::Repository[Address]].each do |repository|
+        repository.clear
+        repository.storage.clear
+      end
+
+      ::Repository[Address].size.should == 0
+      ::Repository[Address].storage.size.should == 0
+
+      @alice = User.new(id: 1, :name => "Alice")
+      @bob = User.new(id: 2, :name => "Bob")
+      @charlie = User.new(id: 3, :name => "Charlie")
+      ::Repository[User].store [@alice, @bob, @charlie]
+
+      @chez_alice = Address.new(id: 111, :user_id => @alice.id, :street => "12 Apple St.")
+      @chez_alice2 = Address.new(id: 222, :user_id => @alice.id, :street => "8 Artichoke Ave.")
+      @chez_bob = Address.new(id: 333, :user_id => @bob.id, :street => "28 Banana St.")
+      @chez_charlie = Address.new(id: 444, :user_id => @charlie.id, :street => "42 Cherry St.")
+      ::Repository[Address].store [@chez_alice, @chez_alice2, @chez_bob, @chez_charlie]
+
+      @nested_criterion = Criterion::Contains.new(:subject => "name", :value => "a")
+    end
+
+    describe 'the nested criterion' do
+      it "should find only 2 out of the 3 users" do
+        ::Repository[User].search(@nested_criterion).should include_only(@alice, @charlie)
+      end
+    end
+
+    it "can be used as the target of an Equals criterion" do
+      straight_id_criterion = Criterion::Equals.new(:subject => :user_id, :value => [@alice.id, @charlie.id])
+      addresses = ::Repository[Address].search(straight_id_criterion)
+      addresses.should == [@chez_alice, @chez_alice2, @chez_charlie]
+    end
+  end
+
+end

data/spec/lib/criterion_key_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require 'helper'
+
+module Repository
+  describe Criterion do
+    before do
+      @alice = User.new(:name => "Alice", :id => 1)
+      @bob = User.new(:name => "Bob", :id => 2)
+      @charlie = User.new(:name => "Charlie", :id => 3)
+    end
+    
+    describe Criterion::Key do
+      before do
+        @c = Criterion::Key.new(:value => "1")
+      end
+
+      it "uses 'id' as its subject" do
+        @c.subject.should == "id"
+      end
+
+      it "has a swell descriptor" do
+        Criterion::Key.new({}).descriptor.should == "#"
+      end
+
+      it "converts its value to an integer" do
+        @c.value.should == [1]
+      end
+      
+      describe '#match' do
+        it "matches an id" do
+          @c.match?(@alice).should be_true
+        end
+
+        it "fails to match an id" do
+          @c.match?(@bob).should be_false
+        end
+
+        describe "a set of ints" do
+          before do
+            @c = Criterion::Key.new(:value => [1,2])
+          end
+
+          it "matches" do
+            @c.should be_match @alice
+            @c.should be_match @bob
+          end
+
+          it "fails to match an int" do
+            @c.should_not be_match @charlie          
+          end
+        end
+      end
+
+      describe "a string value in the criterion" do
+        it "should match an int value in the object" do
+          @c = Criterion::Key.new(:value => "1")
+          @c.should be_match @alice            
+        end
+      end
+
+    end
+
+  end
+end

data/spec/lib/criterion_refers_to_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require 'helper'
+
+module Repository
+  describe Criterion do
+    before do
+      @alice = User.new(:name => "Alice", :id => 1)
+      @bob = User.new(:name => "Bob", :id => 2)
+      @charlie = User.new(:name => "Charlie", :id => 3)
+    end
+  end
+end

data/spec/lib/criterion_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+require 'helper'
+
+module Repository
+  describe Criterion do
+    before do
+      @alice = User.new(:name => "Alice", :id => 1)
+      @bob = User.new(:name => "Bob", :id => 2)
+      @charlie = User.new(:name => "Charlie", :id => 3)
+    end
+
+    it "has some fields" do
+      c = Criterion.new(:subject => "name", :descriptor => "is named", :value => "alex", :property_name => "nombre")
+      c.subject.should == "name"
+      c.descriptor.should == "is named"
+      c.value.should == "alex"
+      c.property_name.should == "nombre"
+    end
+    
+    it 'should be equal if the instance variables are equivalent' do
+      c1 = Criterion.new(:subject => "name", :descriptor => "is named", :value => "alex", :property_name => "nombre")
+      c2 = Criterion.new(:subject => "name", :descriptor => "is named", :value => "alex", :property_name => "nombre")
+      c1.should == c2
+    end
+
+    it "has some default values" do
+      c = Criterion.new(:value => "123")
+      c.subject.should == "id"
+      c.descriptor.should == "id criterion"
+      c.value.should == "123"
+      c.property_name.should == "id"
+    end
+
+    it "converts a missing value into 'nil'" do
+      c = Criterion.new({})
+      c.value.should be_nil
+    end
+
+    it "converts a blank value into 'nil'" do
+      c = Criterion.new({:value => ""})
+      c.value.should be_nil
+    end
+
+    it "uses the subject as the property name by default" do
+      c = Criterion.new(:subject => "name", :value => "alex")
+      c.property_name.should == "name"
+    end
+
+    it "converts the subject to a string" do
+      c = Criterion.new(:subject => :name, :value => "alex")
+      c.subject.should == "name"
+    end
+
+    it "makes a nice description" do
+      c = Criterion.new(:subject => "name", :descriptor => "is named", :value => "alex")
+      c.description.should == "is named alex"
+    end
+
+    describe "operator overloading" do
+      before do
+        @c1 = Criterion::Equals.new(:subject => "name", :value => "alex")
+        @c2 = Criterion::Equals.new(:subject => "name", :value => "kane")
+      end
+      
+      it 'generates an And criterion when used with +' do
+        c3 = @c1 + @c2
+        c3.class.should == Criterion::And
+        c3.criteria.should == [@c1, @c2]
+      end
+
+      it 'generates an And criterion when used with &' do
+        c3 = @c1 & @c2
+        c3.class.should == Criterion::And
+        c3.criteria.should == [@c1, @c2]
+      end
+
+      it 'generates an Or criterion when used with |' do
+        c3 = @c1 | @c2
+        c3.class.should == Criterion::Or
+        c3.criteria.should == [@c1, @c2]
+      end
+    end
+
+    describe '#match' do
+      it "matches nothing (since it's a base class)" do
+        c = Criterion.new(:subject => "name", :value => "alex")
+        c.match?(User.new(:name => "alex")).should be_false
+      end
+    end
+
+    describe '#described_value' do
+      it "describes its value" do
+        c = Criterion.new(:value => "123")
+        c.described_value.should == "123"
+      end
+
+      it "returns 'any' if the criterion is not set" do
+        Criterion.new(:value => nil).described_value.should == 'any'
+      end
+
+      it "returns 'any' if the criterion is blank" do
+        Criterion.new(:value => "").described_value.should == 'any'
+      end
+
+      it "returns 'none' if the criterion is zero" do
+        Criterion.new(:value => 0).described_value.should == 'none'
+      end
+    end
+
+    describe '#find_in'  do
+      it "calls the storage" do
+        c = Criterion.new(:value => nil)
+        storage = Object.new
+        storage.should_receive(:find).with(c)
+        c.find_in(storage)
+      end
+    end
+
+  end
+end

data/spec/lib/repository_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require 'helper'
+
+module Repository
+  describe "Repository" do
+    before(:each) do
+      #FIXME
+      ::Repository[User].clear
+      ::Repository[User].storage.clear
+    end
+
+    it "returns the repository for a class via []" do
+      r1 = ::Repository[User]
+      r1.should be_a(Repository)
+      ::Repository[User].should == r1
+    end
+
+    it "can clear all" do
+      ::Repository[User].store([User.new(id: 1), User.new(id: 2)])
+      ::Repository[User].size.should == 2
+      ::Repository.clear_all
+      ::Repository[User].size.should == 0
+    end
+    
+    it "can replace the repository for a given class" do
+      new_repository = Repository.new(User)
+      ::Repository[User] = new_repository
+      ::Repository[User].should == new_repository
+    end
+  end
+
+end

data/spec/lib/stash_spec.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+require 'helper'
+
+module Repository
+  describe Stash do
+
+    before do
+      @frank = User.new(:name => "Frankenstein", :id => 1)
+      @igor = User.new(:name => "Igor", :id => 2)
+      @castle = Address.new(:name => "find a brain", :creator => @frank, :id => 1)
+      @village = Address.new(:name => "buy lunch", :creator => @igor, :id => 2)
+    end
+
+    attr_reader :stash
+    
+    before do
+      @stash = Stash.new
+    end
+
+    it "is empty when created" do
+      stash.size.should == 0
+    end
+
+    it "fails if you try to put an object without a id" do
+      lambda { stash.put(User.new) }.should raise_error(Storage::Unidentified)
+    end
+
+    it "has a size after an object's been put into it" do
+      stash.put(@frank)
+      stash.size.should == 1
+    end
+
+    describe "#clear" do
+      it "clears" do
+        stash.put(@frank)
+        stash.clear
+        stash.size.should == 0
+      end
+    end
+
+    describe "#get" do
+      it "returns an object by id" do
+        stash.put(@frank)
+        stash.get(@frank.id).should == @frank
+        stash[@frank.id].should == @frank
+      end
+
+      # it "returns several objects" do
+      #   stash.put(@frank)
+      #   stash.put(igor)
+      #   stash.get([@frank.id, igor.id]).should == [@frank, igor]
+      # end
+      # 
+      # it "returns them in the presented order" do
+      #   stash.put(@frank)
+      #   stash.put(igor)
+      #   stash.get([igor.id, @frank.id]).should == [igor, @frank]
+      # end
+
+    end
+
+    describe "#put" do
+      it "accepts an array of objects" do
+        stash.put([@frank, @igor])
+        stash.size.should == 2
+        stash[@frank.id].should == @frank
+        stash[@igor.id].should == @igor
+      end
+    # 
+    #   it "freaks if you try to put an object of the wrong type" do
+    #     lambda {
+    #       stash.put(brain)
+    #       }.should raise_error(ArgumentError)
+    #     end
+    # 
+    #     class Animal
+    #       def id; 1; end
+    #     end
+    # 
+    #     class Dog < Animal
+    #       def id; 2; end
+    #     end
+    # 
+    #     class Cat < Animal
+    #       def id; 3; end
+    #     end
+    # 
+    #     it "doesn't freak if you put an object that's a subclass of the stash's type" do
+    #       lambda {
+    #         stash = Stash.new(Animal)
+    #         stash.put(Dog.new)
+    #         stash.put(Cat.new)
+    #         }.should_not raise_error(ArgumentError)
+    #       end
+    # 
+    #       class Dummy
+    #         attr_reader :entered
+    #         def id
+    #           1
+    #         end
+    #         def entered_stash
+    #           @entered = true
+    #         end
+    #       end
+    # 
+    #       it "calls #entered_stash after put" do
+    #         repo = Stash.new(Dummy)
+    #         dummy = Dummy.new
+    #         repo.put(dummy)
+    #         dummy.entered.should be_true
+    #       end
+    # 
+    end
+
+        describe "#find" do
+          before do
+            stash.put(@frank)
+            stash.put(@igor)
+          end
+          
+          it "finds an object by an array of keys" do
+            stash.find([@frank.id, @igor.id]).should include_only [@frank, @igor]
+          end
+
+          it "finds an object by a criterion on id" do
+            stash.find(Criterion::Equals.new(:value => @frank.id)).should == [@frank]
+          end
+
+          it "finds an object by a criterion on a value" do
+            stash.find(Criterion::Contains.new(:subject => "name", :value => "gor")).should == [@igor]
+          end
+
+    #       it "finds a bunch of objects and puts them immediately" do
+    #         stash.find([@frank.id, igor.id]).should == [@frank, igor]
+    #         stash.size.should == 2
+    #         stash[@frank.id].should == @frank
+    #         stash[igor.id].should == igor
+    #       end
+    # 
+    #       it "returns them in the presented order" do
+    #         stash.find([@frank.id, igor.id]).should == [@frank, igor]
+    #         stash.find([igor.id, @frank.id]).should == [igor, @frank]
+    #       end
+    # 
+    #       it "works ok even if there are duplicate keys" do
+    #         stash.find([@frank.id, igor.id, @frank.id, @frank.id, igor.id]).should == [@frank, igor, @frank, @frank, igor]
+    #       end
+    # 
+        end
+    # 
+    #   end
+    # 
+    #   describe "class" do
+    #     class Thing
+    #       def id
+    #         object_id
+    #       end
+    #     end
+    # 
+    #     it "returns the stash for a class via []" do
+    #       r1 = Stash[Thing]
+    #       r1.should be_a(Stash)
+    #       Stash[Thing].should == r1
+    #     end
+    # 
+    #     it "stores itself in a Thread Local" do
+    #       @r1 = nil
+    #       @r2 = nil
+    #       Thread.new {@r1 = Stash[Thing]}
+    #       Thread.new {@r2 = Stash[Thing]}
+    #       @r1.should_not be_nil
+    #       @r2.should_not be_nil
+    #       @r2.should_not == @r1
+    #     end
+    # 
+    #     it "can clear all" do
+    #       Stash[Thing].put([Thing.new, Thing.new])
+    #       Stash[Thing].size.should == 2
+    #       Stash.clear_all
+    #       Stash[Thing].size.should == 0
+    #     end
+    #   end
+
+  end
+end