tractor 0.3.1 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/lib/tractor/model/base.rb

@@ -19,9 +19,7 @@ module Tractor
     end
   end
   
-  class Set
-    include Enumerable
-    
+  class Association
     attr_accessor :key, :klass
 
     def initialize(key, klass)
@@ -30,17 +28,23 @@ module Tractor
     end
     
     def push(val)
-      Tractor.redis.sadd key, val.id
+      Tractor.redis.sadd(key, val.id)
+    end
+    
+    def delete(id)
+      Tractor.redis.srem(key, id)
+    end
+    
+    def ids
+      Tractor.redis.smembers(key)
     end
     
     def all
-      ids = Tractor.redis.smembers(key)
-      ids.inject([]){ |a, id| a << klass.find_by_id(id); a }
+      ids.inject([]){ |o, id| o << klass.find_by_id(id); o }
     end
   end
   
   class Index
-    include Enumerable
     attr_reader :klass, :name, :value
     
     def initialize(klass, name, value)
@@ -73,7 +77,6 @@ module Tractor
       def initialize(attributes={})
         @attribute_store = {}
         @association_store = {}
-        
         attributes.each do |k,v|
           send("#{k}=", v)
         end
@@ -85,12 +88,14 @@ module Tractor
         Tractor.redis["#{self.class}:#{self.id}"] = Marshal.dump(self)
         Tractor.redis.sadd "#{self.class}:all", self.id
         add_to_indices
+        add_to_associations
         
         return self
       end
       
       def destroy
         delete_from_indices(attribute_store)
+        remove_from_associations
         Tractor.redis.srem("#{self.class}:all", self.id)
         Tractor.redis.del "#{self.class}:#{self.id}"
       end
@@ -102,6 +107,23 @@ module Tractor
         save
       end
       
+      def remove_from_associations
+        self.class.associations.each do |key, value|
+          foreign_key_value = self.send(value[:foreign_key])
+          return unless foreign_key_value
+          value[:foreign_klass].find_by_id(foreign_key_value).send(key).delete(self.id)
+        end
+      end
+      
+      def add_to_associations
+        self.class.associations.each do |key, value|
+          foreign_key_value = self.send(value[:foreign_key])
+          
+          return unless foreign_key_value
+          value[:foreign_klass].find_by_id(foreign_key_value).send(key).push(self)
+        end
+      end
+      
       def add_to_indices
         self.class.indices.each do |name|
           index = Index.new(self.class, name, send(name))
@@ -134,14 +156,6 @@ module Tractor
           m.save
           m
         end
-        
-        def ids
-          Tractor.redis.smembers "#{self}:all"
-        end
-        
-        def count
-          ids.size
-        end
 
         def find_by_id(id)
           redis_obj = Tractor.redis["#{self}:#{id}"]
@@ -153,26 +167,24 @@ module Tractor
         # use method missing to do craziness, or define a find_by on each index (BETTER)
         def find_by_attribute(name, value)
           raise "No index on '#{name}'" unless indices.include?(name)
-
-          ids = ids_for_find(name, value)
-          ids.map do |id|
-            find_by_id(id)
-          end
-        end
-        
-        def ids_for_find(name, value)
-          Tractor.redis.smembers(Index.key_for(self, name, value))
+          find({name => value})
         end
 
         def find(options = {})
           return [] if options.empty?
+          unions = []
           sets = options.map do |name, value|
-            Index.key_for(self, name, value)
+            if value.is_a?(Array) && value.any?
+              unions << union_name = "#{value}-#{Time.now.to_f}"
+              Tractor.redis.sunionstore(union_name, *value.map{|v| Index.key_for(self, name, v) })
+              union_name
+            else
+              Index.key_for(self, name, value)
+            end
           end
           ids = Tractor.redis.sinter(*sets)
-          ids.map do |id|
-            find_by_id(id)
-          end
+          Tractor.redis.del(unions.join(","))
+          ids.map {|id| find_by_id(id) }
         end
         
         def attribute(name, options={})
@@ -180,22 +192,32 @@ module Tractor
           attributes[name] = options
           setter(name, options[:type])
           getter(name, options[:type])
+          index(name) if options[:index]
         end
         
         def index(name)
           indices << name unless indices.include?(name)
         end
         
+        # make an assumption about the foreign_key... probably bad :)
         def association(name, klass)
-          associations[name] = name
+          foreign_key = "#{self.to_s.gsub(/^.*::/, '').downcase}_id"
+          klass.associations[name] = {:foreign_key => foreign_key, :klass => klass, :foreign_klass => self}
           
           define_method(name) do
-            @association_store[name] = Set.new("#{self.class}:#{self.id}:#{name}", klass)
+            @association_store[name] = Association.new("#{self.class}:#{self.id}:#{name}", klass)
           end
         end
         
+        def ids
+          Tractor.redis.smembers "#{self}:all"
+        end
+        
+        def count
+          ids.size
+        end
+        
         def all
-          ids = Tractor.redis.smembers("#{self}:all")
           ids.inject([]){ |a, id| a << find_by_id(id); a }
         end
         

data/spec/model/base_spec.rb

@@ -3,38 +3,47 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Tractor::Model::Base do
   attr_reader :redis
   before do
-    class Player < Tractor::Model::Base
-      attribute :id
-      attribute :name
-      attribute :wins_loses
-    end
-    
-    class Game < Tractor::Model::Base
-      attribute :id
-      attribute :board
-      attribute :flying_object
-      attribute :score, :type => :integer
+    module Tractor
+      module Model
+        class Player < Base
+          attribute :id
+          attribute :name
+          attribute :wins_loses
+          attribute :game_id
+        end
+    
+        class Game < Tractor::Model::Base
+          attribute :id
+          attribute :board
+          attribute :flying_object
+          attribute :score, :type => :integer, :index => true
       
-      association :players, Player
+          association :players, Tractor::Model::Player
+        end
+      end
     end
   end
   
+  after do
+    Tractor.redis.flushdb
+  end
+  
   describe ".attribute" do
     it "inserts the values into the attributes class instance variable" do
-      Game.attributes.should include(:board)
+      Tractor::Model::Game.attributes.should include(:board)
     end
     
     it "allows you to specify what type the value should be when it comes out of the tractor" do
-      Game.attributes[:score][:type].should == :integer
+      Tractor::Model::Game.attributes[:score][:type].should == :integer
     end
     
     it "creates a set method for each attribute" do
-      game = Game.new(:board => "fancy")
+      game = Tractor::Model::Game.new(:board => "fancy")
       game.send(:attribute_store)[:board].should == "fancy"
     end
     
     it "creates a get method for each attribute" do
-      game = Game.new(:board => "schmancy")
+      game = Tractor::Model::Game.new(:board => "schmancy")
       game.board.should == "schmancy"
     end
     
@@ -48,39 +57,64 @@ describe Tractor::Model::Base do
     
     describe "when attribute is a integer" do
       it "returns an integer" do
-        game = Game.new(:score => 1222)
+        game = Tractor::Model::Game.new(:score => 1222)
         game.score.should == 1222
         game.score.should be_a(Fixnum)
       end
     end
+    
+    describe "when attribute is an index" do
+      before do
+        class Zombo < Tractor::Model::Base
+          attribute :anything, :index => true
+        end
+      end
+      
+      it "returns creates an index for the attribute" do
+        Zombo.indices.should == [:anything]
+      end
+    end
   end
     
   describe "#association" do
     attr_reader :game, :player1, :player2
     
     before do
-      @game     = Game.new({ :id => 'g1' })
-      @player1  = Player.new({ :id => 'p1', :name => "delicious" })
-      @player2  = Player.new({ :id => 'p2', :name => "gross" })
+      @game     = Tractor::Model::Game.new({ :id => 'g1' })
+      @player1  = Tractor::Model::Player.new({ :id => 'p1', :name => "delicious" })
+      @player2  = Tractor::Model::Player.new({ :id => 'p2', :name => "gross" })
       
       game.save
       player1.save
       player2.save
     end
     
-    it "adds a set with the given name to the instance" do # "Monkey:a1a:SET_NAME"
-      Game.associations.keys.should include(:players)
+    it "adds a method with the given name to the instance" do # "Monkey:a1a:SET_NAME"
+      game.players.should be_a(Tractor::Association)
     end
     
     it "adds a push method for the set on an instance of the class" do
       game.players.push player1
-      redis.smembers('Game:g1:players').should == ['p1']
+      redis.smembers('Tractor::Model::Game:g1:players').should == ['p1']
+    end
+    
+    it "adds an ids method for the set that returns all ids in it" do
+      game.players.ids.should be_empty
+      game.players.push player1
+      game.players.ids.should == [player1.id]
+    end
+    
+    it "automatically adds items to association when they are created" do
+      bocci_ball = Tractor::Model::Game.create({ :id => "bocci_ball" })
+      Tractor::Model::Player.create({ :id => "tobias", :name => "deciduous", :game_id => "bocci_ball" })
+      bocci_ball.players.ids.should == ["tobias"]
     end
     
     it "adds an all method for the association to return the items in it" do
       game.players.all.should == []
       game.players.push player1
       game.players.push player2
+      
       player1_from_game = game.players.all[0]
       player2_from_game = game.players.all[1]
       
@@ -90,13 +124,7 @@ describe Tractor::Model::Base do
       player2_from_game.id.should == player2.id
     end
     
-    it "requires the object being added to have been saved to the database before adding it to the set"
-  end
-  
-  describe ".associations" do
-    it "returns all association that have been added to this class" do
-      Game.associations.keys.should == [:players]
-    end
+    it "requires the object being added to have been saved to the database before adding it to the association"
   end
   
   describe ".indices" do
@@ -113,7 +141,7 @@ describe Tractor::Model::Base do
     attr_reader :sorted_attributes
     
     before do
-      @sorted_attributes = Game.attributes.keys.sort{|x,y| x.to_s <=> y.to_s}  
+      @sorted_attributes = Tractor::Model::Game.attributes.keys.sort{|x,y| x.to_s <=> y.to_s}  
     end
   
     it "returns all attributes that have been added to this class" do
@@ -122,17 +150,17 @@ describe Tractor::Model::Base do
     end
     
     it "allows different attributes to be specified for different child classes" do
-      Game.attributes.size.should == 4
-      Player.attributes.size.should == 3
+      Tractor::Model::Game.attributes.size.should == 4
+      Tractor::Model::Player.attributes.size.should == 4
       
-      Game.attributes.keys.should_not include(:name)
-      Player.attributes.keys.should_not include(:flying_object)
+      Tractor::Model::Game.attributes.keys.should_not include(:name)
+      Tractor::Model::Player.attributes.keys.should_not include(:flying_object)
     end
   end
   
   describe "#save" do
     it "raises if id is nil or empty" do
-      game = Game.new
+      game = Tractor::Model::Game.new
       game.id = nil
       lambda { game.save }.should raise_error("Probably wanna set an id")
       game.id = ''
@@ -140,22 +168,22 @@ describe Tractor::Model::Base do
     end
     
     it "should write attributes to redis" do
-      game = Game.new({:id => '1', :board => "large", :flying_object => "disc"})
+      game = Tractor::Model::Game.new({:id => '1', :board => "large", :flying_object => "disc"})
       game.save
       
-      redis["Game:1"].should_not be_nil
-      redis_game = Marshal.load(redis["Game:1"])
+      redis["Tractor::Model::Game:1"].should_not be_nil
+      redis_game = Marshal.load(redis["Tractor::Model::Game:1"])
       redis_game.id.should == "1"
       redis_game.board.should == "large"
       redis_game.flying_object.should == "disc"
     end
     
     it "appends the new object to the Game set" do
-      Game.all.size.should == 0
-      game = Game.new({ :id => '1', :board => "small" })
+      Tractor::Model::Game.all.size.should == 0
+      game = Tractor::Model::Game.new({ :id => '1', :board => "small" })
       game.save
       
-      Game.all.size.should == 1
+      Tractor::Model::Game.all.size.should == 1
     end
   end
     
@@ -188,12 +216,12 @@ describe Tractor::Model::Base do
     before do
       Sammich.create({ :id => 's1', :weight => "medium", :product => "Turkey Avocado" })
       Sammich.create({ :id => 's2', :weight => "medium", :product => "Reuben Sammich" })
-      Player.create({ :id => 'p1', :name => "delicious" })
+      Tractor::Model::Player.create({ :id => 'p1', :name => "delicious" })
     end
     
     it "returns all the ids for a given class" do
       Sammich.ids.should == ['s1', 's2']
-      Player.ids.should == ['p1']
+      Tractor::Model::Player.ids.should == ['p1']
     end
   end
   
@@ -201,24 +229,12 @@ describe Tractor::Model::Base do
     before do
       Sammich.create({ :id => 's1', :weight => "medium", :product => "Turkey Avocado" })
       Sammich.create({ :id => 's2', :weight => "medium", :product => "Reuben Sammich" })
-      Player.create({ :id => 'p1', :name => "delicious" })
+      Tractor::Model::Player.create({ :id => 'p1', :name => "delicious" })
     end
     
     it "returns the count of all items of a given class" do
       Sammich.count.should == 2
-      Player.count.should == 1
-    end
-  end
-  
-  describe ".ids_for_find" do
-    before do
-      Sammich.create({ :id => 's1', :weight => "medium", :product => "Turkey Avocado" })
-      Sammich.create({ :id => 's2', :weight => "medium", :product => "Reuben Sammich" })
-      Player.create({ :id => 'p1', :name => "delicious" })
-    end
-    
-    it "returns all the ids for a given attribute and value on a class" do
-      Sammich.ids_for_find(:weight, "medium").should == ['s1', 's2']
+      Tractor::Model::Player.count.should == 1
     end
   end
   
@@ -328,15 +344,23 @@ describe Tractor::Model::Base do
       Sammich.find({ :weight => "medium" }).size.should == 1
     end
     
-    it "removes the id from all of the associations that it may be in"
+    it "removes the id from all of the associations that it may be in" do
+      bocci_ball = Tractor::Model::Game.create({ :id => "bocci_ball" })
+      tobias = Tractor::Model::Player.create({ :id => "tobias", :name => "deciduous", :game_id => "bocci_ball" })
+      bocci_ball.players.ids.should == ["tobias"]
+      tobias.destroy
+      
+      bocci_ball.players.ids.should == []
+    end
   end
   
   describe ".find" do
     attr_reader :cheese, :balogna
     
     before do
-      @cheese = Sammich.create({ :id => '1', :weight => "medium", :product => "Cheese Sammich" })
-      @balogna = Sammich.create({ :id => '2', :weight => "medium", :product => "Balogna Sammich" })
+      @cheese   = Sammich.create({ :id => '1', :weight => "medium", :product => "Cheese Sammich" })
+      @balogna  = Sammich.create({ :id => '2', :weight => "medium", :product => "Balogna Sammich" })
+      @meat   = Sammich.create({ :id => '3', :weight => "heavy", :product => "Meat & More Sammich" })
     end
     
     context "when searching on 1 attribute" do
@@ -366,6 +390,10 @@ describe Tractor::Model::Base do
     it "returns empty array if nothing matches the given options" do
       Sammich.find( {:weight => "light" } ).should == []
     end
+    
+    it "returns all matching objects if multiple values are given for an attribute" do
+      Sammich.find( {:weight => ["medium", "heavy"]} ).map(&:id).sort.should == ['1','2','3']
+    end
   end
   
   describe ".find_by_attribute" do

data/spec/spec_helper.rb

@@ -39,8 +39,6 @@ class MonkeyClient < Tractor::Model::Mapper
   attribute :birthday, :map => :birthdate
   attribute :evil, :type => :boolean, :map => :evil_monkey #[:evil_monkey, :boolean]
   index :evil
-  
-  association :bananas, BananaClient
 end
 
 class Monkey

data/tractor.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tractor}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Shane Wolf"]
-  s.date = %q{2010-02-24}
+  s.date = %q{2010-05-25}
   s.description = %q{Very simple object mappings for ruby objects}
   s.email = %q{shanewolf@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tractor
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - Shane Wolf
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-24 00:00:00 -08:00
+date: 2010-05-25 00:00:00 -07:00
 default_executable: 
 dependencies: []