light_mongo 0.0.1

data/lib/util.rb

@@ -0,0 +1,20 @@
+# Pulled with vigour from Rails 2.3.5
+# and rewritten to be carbon neutral.
+module LightMongo
+  class Util
+    def self.blank?(object)
+      return true if object.is_a? NilClass
+      return true if object.is_a? FalseClass
+      return false if object.is_a? TrueClass
+      return object.empty? if object.is_a? Array
+      return object.empty? if object.is_a? Hash
+      return object !~ /\S/ if object.is_a? String
+      return false if object.is_a? Numeric
+      return respond_to?(:empty?) ? empty? : !self
+    end
+    
+    def self.present?(object)
+      !blank?(object)
+    end
+  end
+end

data/spec/document/persistence_spec.rb

@@ -0,0 +1,219 @@
+require File.dirname(__FILE__) + '/../../lib/light_mongo'
+
+describe LightMongo::Document::Persistence do
+  before(:all) do
+    LightMongo.stub!(:database => mock(:database, :connection => nil))
+    @test_class_collection = mock(:test_class_collection)
+    Mongo::Collection.stub!(:new => @test_class_collection)
+
+    class TestClass
+      include LightMongo::Document
+      attr_accessor :name
+    end
+  end
+  
+  describe "the module's inclusion" do
+    it "sets up the collection on a class-level" do
+      TestClass.collection.should == @test_class_collection
+    end
+  end
+  
+  describe "#save" do
+    before(:each) do
+      @test_object_hash = mock(:test_object_hash)
+      @test_object = TestClass.new
+      @test_object.stub!(:to_hash => @test_object_hash)
+    end
+    
+    it "saves the Document to the collection for that class" do
+      @test_class_collection.should_receive(:save).with(@test_object_hash)
+      @test_object.save
+    end
+  end
+  
+  describe ".create(params)" do
+    before(:each) do
+      @name = mock(:name)
+      @test_object = TestClass.new(:name => @name)
+      @test_object.stub!(:save)
+      TestClass.stub!(:new).with(:name => @name).and_return(@test_object)
+    end
+    
+    it "spawns a new Ruby object from the params" do
+      TestClass.create(:name => @name).name.should == @name
+    end
+    
+    it "saves the Ruby object to the database" do
+      @test_object.should_receive(:save)
+      TestClass.create(:name => @name)
+    end
+  end
+  
+  describe "#id" do
+    before(:each) do
+      @id = mock(:id)
+      @test_object = TestClass.new(:_id => @id)
+    end
+    
+    it "delegates to the Mongo _id" do
+      @test_object.id.should == @id
+    end
+  end
+  
+  describe "#==(other)" do
+    before(:each) do
+      @id = mock(:id)
+      @object_1 = TestClass.new(:_id => @id)
+      @object_2 = TestClass.new(:_id => @id)
+    end
+
+    it "compares on id" do
+      @object_1.should == @object_2
+    end
+  end
+  
+  describe ".find_by_<index>(value)" do
+    before(:each) do
+      @test_class_collection.stub!(:create_index)
+      TestClass.index(:name)
+      @name = mock(:name)
+      @id = mock(:id)
+      
+      @bson_hash = {:class_name => 'TestClass', :name => @name, :_id => @id}
+    end
+    
+    it "finds all objects which match the given index pattern" do
+      @test_class_collection.should_receive(:find).with(:name => @name).and_return([@bson_hash])
+      test_object = TestClass.find_by_name(@name).first
+      test_object.id.should == @id
+      test_object.name.should == @name
+      test_object.class.should == TestClass
+    end
+  end
+  
+  describe ".find(query=nil)" do
+    before(:each) do
+      @no_query_results = mock(:no_query_results)
+      @query_results = mock(:query_results)
+      TestClass.stub!(:new).with(@no_query_results).and_return(@no_query_object = mock(:no_query_object))
+      TestClass.stub!(:new).with(@query_results).and_return(@query_object = mock(:query_object))
+    end
+    
+    it "maps MongoDB::Collection.find" do
+      @test_class_collection.should_receive(:find).and_return([@no_query_results])
+      TestClass.find.should == [@no_query_object]
+      
+      @test_class_collection.should_receive(:find).with({'_id' => query = mock(:query)}).and_return([@query_results])
+      TestClass.find(query).should == [@query_object]
+    end
+  end
+  
+  describe ".index(key, :as => (name | nil))" do
+    def self.it_sets_up_the_index_verbatim
+      it "sets up the index with key #{@key} and name #{@name}" do
+        @test_class_collection.should_receive(:create_index).with(@key)
+        set_up_class(@key, @name)
+        TestClass.should respond_to(('find_by_'+@name.to_s).to_sym)
+      end
+    end
+    
+    def set_up_class(key, name=nil)
+      TestClass.index(key, :as => name)
+
+      @indexable_object = TestClass.new(:top_level_attribute => 'test')
+    end
+    
+    context "when given no key" do
+      it "creates no index and no method" do
+        @test_class_collection.should_not_receive(:create_index)
+        set_up_class(nil)
+        set_up_class('')
+        TestClass.should_not respond_to(:find_by_)
+      end
+    end
+    
+    context "when the given key is usable as a method name" do
+      before(:each) do
+        @key = :top_level_attribute
+      end
+      
+      context "and no name is provided" do
+        it "uses the key as the lookup name" do
+          @test_class_collection.should_receive(:create_index).with(@key)
+          set_up_class(@key)
+          TestClass.should respond_to(('find_by_'+@key.to_s).to_sym)
+        end
+      end
+      
+      context "and a name is provided" do
+        before(:each) do
+          @name = :environment
+        end
+        
+        it_sets_up_the_index_verbatim
+      end
+    end
+    
+    context "when the given key is unusuable as a method name" do
+      before(:each) do
+        @key = 'top_level_attribute.sub_attribute'
+      end
+      
+      context "and no name is provided" do
+        it "adds an index on the key" do
+          @test_class_collection.should_receive(:create_index).with(@key)
+          set_up_class(@key)
+        end
+        
+        it "does not create a method using the key" do
+          @test_class_collection.stub(:create_index)
+          set_up_class(@key)
+          TestClass.should_not respond_to(('find_by_'+@key.to_s).to_sym)
+        end
+      end
+      
+      context "and a name is provided" do
+        before(:each) do
+          @name = :sub_environment
+        end
+        
+        it_sets_up_the_index_verbatim
+      end
+    end
+  end
+  
+  describe ".viable_method_name(method_name)" do
+    context "contains only alphanums and underscores" do
+      it "is valid" do
+        TestClass.viable_method_name('_jkdsf328_32').should be_true
+      end
+      
+      context "and ends in an exclamation mark" do
+        it 'is valid' do
+          TestClass.viable_method_name('_jkdsf328_32!').should be_true
+        end
+      end
+
+      context "and ends in an question mark" do
+        it 'is valid' do
+          TestClass.viable_method_name('_jkdsf328_32?').should be_true
+        end
+      end
+    end
+    
+    context "contains a non [alphanum_!?] anywhere" do
+      it "is invalid" do
+        TestClass.viable_method_name('_jkdsf328_32*').should be_false
+        TestClass.viable_method_name('_jkdsf^328_32').should be_false
+      end
+    end
+    
+    context "contains a [!?] anywhere but the end" do
+      it "is invalid" do
+        TestClass.viable_method_name('_jkds!f328_32').should be_false
+        TestClass.viable_method_name('_jkds?f328_32').should be_false
+      end
+    end
+  end
+
+end

data/spec/document/serialization/hash_serializer_spec.rb

@@ -0,0 +1,153 @@
+require File.dirname(__FILE__) + '/../../../lib/light_mongo'
+
+describe LightMongo::Document::Serialization::HashSerializer do
+  HashSerializer = LightMongo::Document::Serialization::HashSerializer
+  
+  before(:each) do
+    @current_depth = 0
+  end
+
+  describe ".serialize_object(object_to_serialize, current_depth)" do
+    before(:each) do
+      LightMongo.stub!(:database => mock(:database, :connection => nil), :slow_serialization => true)
+      @test_class_collection = mock(:test_class_collection)
+      Mongo::Collection.stub!(:new => @test_class_collection)
+    end
+    
+    context "when a non-primitive" do
+      context "non-LightMongo::Document object" do
+        before(:each) do
+          class Other
+            attr_accessor :name
+            def initialize
+              @name = self.class.name + object_id.to_s
+            end
+          end
+          
+          @object = Other.new
+        end
+        
+        it "hashifies the object" do
+          HashSerializer.send(:serialize_object, @object, @current_depth+3).
+            should == {'_class_name' => 'Other', 'name' => @object.name}
+        end
+      end
+      
+      context "LightMongo::Document object" do
+        before(:each) do
+          class TestClass
+            include LightMongo::Document
+          end
+          
+          @object = TestClass.new
+          @test_class_collection.stub(:save => (@id = mock(:id)))
+        end
+        
+        context "when below the top level" do
+          before(:each) do
+            @current_depth = 1
+          end
+          
+          it "exports the object" do
+            HashSerializer.send(:serialize_object, @object, @current_depth).
+              should == {'_class_name' => 'TestClass', '_id' => @id, '_embed' => true}
+          end
+        end
+        
+        context "when at the top level" do
+          before(:each) do
+            @current_depth = 0
+          end
+          
+          it "hashifies the object" do
+            HashSerializer.should_receive(:hashify).with(@object, @current_depth)
+            HashSerializer.send(:serialize_object, @object, @current_depth)
+          end
+        end
+      end
+    end
+    
+    context "when a primitive object" do
+      before(:each) do
+        @object = "test string"
+      end
+      
+      it "returns the raw object" do
+        HashSerializer.send(:serialize_object, @object, @current_depth).
+          should == @object
+      end
+    end
+  end
+
+  describe ".dump(object, current_depth)" do
+    context "when the object is a container" do
+      before(:each) do
+        
+        @sub_object_1 = mock(:sub_object_1)
+        @sub_object_2 = mock(:sub_object_2)
+        
+        LightMongo::Document::Serialization::Serializer.
+          stub!(:serialize).
+          with(@sub_object_1, anything).
+          and_return(@serial_1 = mock(:serial_1))
+        LightMongo::Document::Serialization::Serializer.
+          stub!(:serialize).
+          with(@sub_object_2, anything).
+          and_return(@serial_2 = mock(:serial_2))
+      end
+
+      context "and more specifically an Array" do
+        before(:each) do
+          @object = [@sub_object_1, @sub_object_2]
+        end
+      
+        it "iterates over the array, serializing the contents." do
+          HashSerializer.dump(@object).should == [@serial_1, @serial_2]
+        end
+      
+        it "notifies the generic Serializer of the new depth." do
+          LightMongo::Document::Serialization::Serializer.should_receive(:serialize).with(@sub_object_1, @current_depth + 1)
+          HashSerializer.dump(@object, @current_depth)
+        end
+      
+        it "returns an array." do
+          HashSerializer.dump(@object).should be_an(Array)
+        end
+      end
+    
+      context "and more specifically a Hash" do
+        before(:each) do
+          @object = {
+            :sub_object_1 => @sub_object_1,
+            :sub_object_2 => @sub_object_2
+          }
+        end
+      
+        it "iterates over the hash, serializing the contents but retaining the keys." do
+          HashSerializer.dump(@object).should == {:sub_object_1 => @serial_1, :sub_object_2 => @serial_2}
+        end
+      
+        it "notifies the generic Serializer of the new depth." do
+          LightMongo::Document::Serialization::Serializer.should_receive(:serialize).with(@sub_object_1, @current_depth + 1)
+          HashSerializer.dump(@object, @current_depth)
+        end
+      
+        it "returns a Hash." do
+          HashSerializer.dump(@object).should be_an(Hash)
+        end
+      end
+    end
+    
+    context "when the object is a custom object" do
+      before(:each) do
+        class TestClass; end
+        @object = TestClass.new
+      end
+      
+      it "passes off to the object serializer" do
+        HashSerializer.should_receive(:serialize_object).with(@object, @current_depth)
+        HashSerializer.dump(@object, @current_depth)
+      end
+    end
+  end
+end

data/spec/document/serialization/serializer_spec.rb

@@ -0,0 +1,237 @@
+require File.dirname(__FILE__) + '/../../../lib/document/serialization'
+
+Serializer = LightMongo::Document::Serialization::Serializer
+
+describe Serializer do
+  before(:each) do
+    @object = mock(:object)
+  end
+  
+  describe ".array_deserialize(object)" do
+    before(:each) do
+      @object = [
+        @ivar1 = mock(:ivar1),
+        @ivar2 = mock(:ivar2)
+      ]
+    end
+
+    it "map-deserializes each element in the array" do
+      Serializer.should_receive(:deserialize).with(@ivar1).
+        and_return(desel_ivar1 = mock(:desel_ivar1))
+        
+      Serializer.should_receive(:deserialize).with(@ivar2).
+        and_return(desel_ivar2 = mock(:desel_ivar2))
+        
+      Serializer.send(:array_deserialize, @object).
+        should == [desel_ivar1, desel_ivar2]
+    end
+  end
+  
+  describe ".hash_deserialize(object)" do
+    before(:each) do
+      @object = {
+        :ivar1 => (@ivar1 = mock(:ivar1)),
+        :ivar2 => (@ivar2 = mock(:ivar2))
+      }
+    end
+
+    it "map-deserializes each element in the hash" do
+      Serializer.should_receive(:deserialize).with(@ivar1).
+        and_return(desel_ivar1 = mock(:desel_ivar1))
+        
+      Serializer.should_receive(:deserialize).with(@ivar2).
+        and_return(desel_ivar2 = mock(:desel_ivar2))
+
+      Serializer.send(:hash_deserialize, @object).
+        should == {:ivar1 => desel_ivar1, :ivar2 => desel_ivar2}
+    end
+  end
+  
+  describe ".deserialize(object)" do
+    context "when the object is an array" do
+      before(:each) do
+        @object = []
+      end
+      
+      it "deserializes the array" do
+        Serializer.should_receive(:array_deserialize).with(@object).
+          and_return(desel_array = mock(:desel_array))
+          
+        Serializer.deserialize(@object).should == desel_array
+      end
+    end
+    
+    context "when the object is a hash" do
+      before(:each) do
+        @object = {}
+      end
+      
+      context "and nothing more" do
+        it "deserializes the hash" do
+          Serializer.should_receive(:hash_deserialize).with(@object)
+          Serializer.deserialize(@object)
+        end
+      end
+      
+      context "and a Marshal dump" do
+        before(:each) do
+          @marshal_dump = mock(:marshal_dump)
+          @object['_data'] = @marshal_dump
+        end
+        
+        it "unmarshals the dump" do
+          Marshal.should_receive(:load).with(@marshal_dump).
+            and_return(unmarshalled_data = mock(:unmarshalled_data))
+            
+          Serializer.deserialize(@object).should == unmarshalled_data
+        end
+      end
+      
+      context "and a LightMongo::Document" do
+        before(:each) do
+          class TestClass
+          end
+          
+          @id = mock(:id)
+          @object = {'_id' => @id, '_class_name' => 'TestClass', '_embed' => true}
+        end
+        
+        it "recovers the linked document" do
+          TestClass.stub!(:find).with(@id).and_return([test_instance = mock(:test_instance)])
+          
+          Serializer.deserialize(@object).should == test_instance
+        end
+      end
+    end
+    
+    context "when the object is anything else" do
+      before(:each) do
+        @object = 3
+      end
+      
+      it "returns the object unharmed" do
+        Serializer.deserialize(@object).should == @object
+      end
+    end
+  end
+  
+  describe ".serialize(object, current_depth)" do
+    before(:each) do
+      @depth = 0
+      @serializer = Serializer.new(@object, @depth)
+      @serializer.stub!(:hash_serialize => (@hash_serialized_object = mock(:hash_serialized_object)))
+      Serializer.stub!(:new).with(@object, anything).and_return(@serializer)
+    end
+
+    def self.it_creates_a_new_serializer_instance
+      it "creates a new serializer instance" do
+        Serializer.should_receive(:new).with(@object, @depth).and_return(@serializer)
+        Serializer.serialize(@object, @depth)
+      end
+    end
+    
+    def self.it_hash_serializes_the_object
+      it "hash-serializes the object." do
+        @serializer.should_receive(:hash_serialize)
+        Serializer.serialize(@object, @depth)
+      end
+    end
+    
+    def self.it_returns_the_hash_serialized_object
+      it "returns the hash-serialized object." do
+        Serializer.serialize(@object, @depth).should == @hash_serialized_object
+      end
+    end
+    
+    context "when above the marshalling depth threshold" do
+      before(:each) do
+        @depth = 1
+      end
+      
+      it_creates_a_new_serializer_instance
+      
+      it_hash_serializes_the_object
+      
+      it "does not marshal the object." do
+        @serializer.should_not_receive(:marshal)
+        Serializer.serialize(@object, @depth)
+      end
+      
+      it_returns_the_hash_serialized_object
+    end
+    
+    context "when below the marshalling depth threshold" do
+      before(:each) do
+        @depth = 5
+      end
+      
+      context "and marshalling is turned on" do
+        before(:each) do
+          LightMongo.slow_serialization = false
+        end
+        
+        it_creates_a_new_serializer_instance
+        
+        it "marshals the object." do
+          @serializer.should_receive(:marshal)
+          Serializer.serialize(@object, @depth)
+        end
+        
+        it "does not hash-serialize the object." do
+          @serializer.should_not_receive(:hash_serialize)
+          Serializer.serialize(@object, @depth)
+        end
+        
+        it "returns the marshalled object." do
+          @serializer.stub!(:marshal => (@marshalled_object = mock(:marshalled_object)))
+          Serializer.serialize(@object, @depth).should == @marshalled_object
+        end
+      end
+      
+      context "but marshalling is turned off" do
+        before(:each) do
+          LightMongo.slow_serialization = true
+        end
+
+        it_creates_a_new_serializer_instance
+        
+        it_hash_serializes_the_object
+        
+        it_returns_the_hash_serialized_object
+      end
+    end
+  end
+  
+  describe "#marshal(object)" do
+    it "marshals the object." do
+      Marshal.should_receive(:dump).with(@object)
+      Serializer.new(@object).marshal
+    end
+    
+    it "returns the marshalled object." do
+      Marshal.stub!(:dump).
+        with(@object).
+        and_return(marshalled_object = mock(:marshalled_object))
+      Serializer.new(@object).marshal.should == {'_data' => marshalled_object}
+    end
+  end
+
+  describe "#hash_serialize(object, current_depth)" do
+    before(:each) do
+      @current_depth = mock(:current_depth)
+    end
+    
+    it "serializes the object into a set of nested hashes." do
+      LightMongo::Document::Serialization::HashSerializer.
+        should_receive(:dump).with(@object, @current_depth)
+      Serializer.new(@object, @current_depth).hash_serialize
+    end
+    
+    it "returns the marshalled object." do
+      LightMongo::Document::Serialization::HashSerializer.stub!(:dump).
+        with(@object, @current_depth).
+        and_return(hashed_object = mock(:hashed_object))
+      Serializer.new(@object, @current_depth).hash_serialize.should == hashed_object
+    end
+  end
+end

data/spec/document/serialization_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../../lib/light_mongo'
+
+describe LightMongo::Document::Serialization do
+  before(:each) do
+    LightMongo.stub!(:database => mock(:database, :connection => nil), :slow_serialization => true)
+    @test_class_collection = mock(:test_class_collection)
+    Mongo::Collection.stub!(:new => @test_class_collection)
+
+    class TestClass
+      include LightMongo::Document
+      attr_accessor :test_attribute
+    end
+  end
+    
+  describe "#export" do
+    before(:each) do
+      @test_object = TestClass.new
+
+      @id = mock(:id)
+      @test_class_collection.stub!(:save => @id)
+    end
+    
+    context "if Persistence has been included" do
+      it "saves itself" do
+        @test_object.should_receive(:save)
+        @test_object.export
+      end
+      
+      it "generates a hash of its class name, id, and embed status" do
+        @test_object.export.should == {'_class_name' => 'TestClass', '_id' => @id, '_embed' => true}
+      end
+    end
+    
+    context "if Persistence hasn't been included" do
+      before(:each) do
+        class NoPersistence
+          include LightMongo::Document::Serialization
+        end
+        @no_persistence = NoPersistence.new
+      end
+      
+      it "returns self" do
+        @no_persistence.export.should == @no_persistence
+      end
+    end
+  end
+  
+  describe "#initialize(params)" do
+    before(:each) do
+      @test_value = mock(:test_value).to_s
+    end
+
+    context "when given a hash" do
+      before(:each) do
+        @params = {:test_attribute => @test_value}
+      end
+      
+      it "converts the hash to attributes" do
+        @test_object = TestClass.new(@params)
+        @test_object.test_attribute.should == @test_value
+      end
+    end
+  end
+
+  describe "#from_hash(hash)" do
+    before(:each) do
+      @test_object = TestClass.new
+    end
+
+    it "parses a hash into instance attributes" do
+      @test_object.from_hash(:test_attribute => 'Test value')
+      @test_object.test_attribute.should == 'Test value'
+    end
+  end
+end