candy 0.1.0 → 0.2.1

data/lib/candy/wrapper.rb

@@ -8,6 +8,7 @@ module Candy
   module Wrapper
     
     BSON_SAFE = [String, 
+                Symbol,
                 NilClass, 
                 TrueClass, 
                 FalseClass, 
@@ -27,8 +28,8 @@ module Candy
       # Pass the simple cases through
       return thing if BSON_SAFE.include?(thing.class)
       case thing
-      when Symbol
-        wrap_symbol(thing)
+      # when Symbol
+      #   wrap_symbol(thing)
       when Array
         wrap_array(thing)
       when Hash
@@ -47,21 +48,32 @@ module Candy
       end
     end
     
-    # Takes an array and returns the same array with unsafe objects wrapped
+    # Takes an array and returns the same array with unsafe objects wrapped.
     def self.wrap_array(array)
       array.map {|element| wrap(element)}
     end
     
-    # Takes a hash and returns it with both keys and values wrapped
+    # Takes a hash and returns it with values wrapped. Keys are converted to strings, and 
+    # wrapped with single quotes if they were already strings.  (So that we can easily tell
+    # hash keys from string keys later on.)
     def self.wrap_hash(hash)
       wrapped = {}
-      hash.each {|k, v| wrapped[wrap(k)] = wrap(v)}
+      hash.each do |key, value|  
+        case key
+        when Symbol
+          wrapped[key.to_s] = wrap(value)
+        when String
+          wrapped["'#{key}'"] = wrap(value)
+        else
+          wrapped[wrap(key)] = wrap(value)
+        end
+      end
       wrapped
     end
     
-    # Returns a string that's distinctive enough for us to unwrap later and produce the same symbol
+    # Returns a string that's distinctive enough for us to unwrap later and produce the same symbol.
     def self.wrap_symbol(symbol)
-      "__sym_" + symbol.to_s
+      "__:" + symbol.to_s
     end
     
     # Returns a nested hash containing the class and instance variables of the object.  It's not the
@@ -89,19 +101,33 @@ module Candy
           unwrap_hash(thing)
         end
       when Array
-        thing.map {|element| unwrap(element)}
-      when /^__sym_(.+)/
-        $1.to_sym
+        CandyArray.embed(*thing.map {|element| unwrap(element)})
+      # when /^__:(.+)/
+      #   $1.to_sym
       else
         thing
       end
     end
     
-    # Traverses the hash, unwrapping both keys and values.  Returns the hash that results.
+    # Traverses the hash, unwrapping values and converting keys back to symbols.  Returns 
+    # the results as a CandyHash object.
     def self.unwrap_hash(hash)
       unwrapped = {}
-      hash.each {|k,v| unwrapped[unwrap(k)] = unwrap(v)}
-      unwrapped
+      hash.each do |key, value|
+        case key
+        when /^'(.+)'$/
+          unwrapped[$1] = unwrap(value)
+        when String
+          unwrapped[key.to_sym] = unwrap(value)
+        else
+          unwrapped[unwrap(key)] = unwrap(value)
+        end
+      end
+      if klass = unwrapped.delete(CLASS_KEY)
+        qualified_const_get(klass).embed(unwrapped)
+      else
+        CandyHash.embed(unwrapped)
+      end
     end
     
     # Turns a hashed object back into an object of the stated class, setting any captured instance 

data/spec/candy/array_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Candy::CandyArray do
+    before(:all) do
+      @verifier = Zagnut.collection
+    end
+  
+    before(:each) do
+      @this = Zagnut.new
+      @this.bits = ['peanut', 'almonds', 'titanium']
+    end
+    
+    it "writes the array" do
+      @verifier.find_one['bits'][1].should == 'almonds'
+    end
+    
+    it "reads the array" do
+      that = Zagnut(@this.id)
+      that.bits[2].should == 'titanium'
+    end
+    
+    it "cascades appends" do
+      @this.bits << 'kryptonite'
+      that = Zagnut(@this.id)
+      that.bits[-1].should == 'kryptonite'
+    end
+    
+    it "cascades substitutions" do
+      @this.bits[0] = 'raisins'
+      that = Zagnut(@this.id)
+      that.bits.should == ['raisins', 'almonds', 'titanium']
+    end
+    
+    it "cascades deletions" do
+      @this.bits.shift.should == 'peanut'
+      that = Zagnut(@this.id)
+      that.bits.size.should == 2
+    end
+    
+    it "cascades deeply" do
+      @this.bits.push [5, 11, {foo: [:bar]}]
+      that = Zagnut(@this.id)
+      that.bits[3][2][:foo][0].should == :bar
+    end
+
+    after(:each) do
+      Zagnut.collection.remove
+    end
+  
+end

data/spec/candy/collection_spec.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Candy::Collection do
+  
+  before(:each) do
+    @this = Zagnut.new
+    @this.color = "red"
+    @this.weight = 11.8
+    @that = Zagnut.new
+    @that.color = "red"
+    @that.pieces = 6
+    @that.weight = -5
+    @the_other = Zagnut.new
+    @the_other.color = "blue"
+    @the_other.pieces = 7
+    @the_other.weight = 0
+  end
+
+  
+  it "can get all objects matching a search condition" do
+    those = Zagnuts.color("red")
+    those.count.should == 2
+  end
+    
+  it "can get all objects in a collection" do
+    those = Zagnuts.all
+    those.count.should == 3
+  end
+  
+  it "still returns if nothing matches" do
+    Zagnuts.color("green").to_a.should == []
+  end
+  
+  it "can take options" do
+    those = Zagnuts.color("red").sort("weight", :down)
+    those.collect{|z| z.weight}.should == [11.8, -5]
+  end
+  
+  it "can be iterated" do
+    these = Zagnuts.color("red").sort(:weight)
+    this = these.first
+    this.pieces.should == 6
+    this.weight.should == -5
+    this = these.next
+    this.pieces.should be_nil
+    this.weight.should == 11.8
+  end
+  
+  it "can take scoping on a class or instance level" do
+    these = Zagnuts.color("red")
+    these.pieces(6)
+    these.count.should == 1
+  end
+  
+  it "can get the collection by a method at the top level" do
+    these = Zagnuts
+    these.count.should == 3
+  end
+  
+  # Test class for scoped magic method generation
+  class BabyRuth
+    include Candy::Piece
+  end
+  
+  class BabiesRuth
+    include Candy::Collection
+    collects :baby_ruth
+  end
+  
+  it "can get the object by a method within the enclosing namespace" do
+    foo = BabyRuth.new
+    foo.color = 'green'
+    bar = BabiesRuth(color: 'green')
+    bar.count.should == 1
+  end
+  
+  # Test class to verify magic method generation doesn't override anything
+  def Jawbreakers(param=nil)
+    "Broken everywhere!"
+  end
+  
+  class Jawbreaker
+    include Candy::Piece
+  end
+  
+  class Jawbreakers
+    include Candy::Collection
+    collects :jawbreaker
+  end
+  
+  it "doesn't create a namespace method if one already exists" do
+    too = Jawbreaker.new
+    too.calories = 55
+    tar = Jawbreakers()
+    tar.should == 'Broken everywhere!'
+  end
+  
+
+  after(:each) do
+    Zagnut.collection.remove
+  end
+end

data/spec/candy/crunch_spec.rb

@@ -11,7 +11,7 @@ describe Candy::Crunch do
   describe "connection" do
     before(:each) do
       # Make sure we don't waste time making bogus connections
-      PeanutBrittle.options[:connect] = false
+      Candy.connection_options[:connect] = false
     end
 
     it "takes yours if you give it one" do
@@ -24,39 +24,22 @@ describe Candy::Crunch do
       PeanutBrittle.connection.nodes.should == [["localhost", 27017]]
     end
     
-    it "uses the host you provide" do
-      PeanutBrittle.host = 'example.org'
-      PeanutBrittle.connection.nodes.should == [["example.org", 27017]]
-    end
-
-    it "uses the port you provide" do
-      PeanutBrittle.host = 'localhost'
-      PeanutBrittle.port = 3000
-      PeanutBrittle.connection.nodes.should == [["localhost", 3000]]
-    end
 
-    it "uses any options you provide" do
-      l = Logger.new(STDOUT)
-      PeanutBrittle.options[:logger] = l
-      PeanutBrittle.connection.logger.should == l
-    end
-
-    it "uses the $MONGO_HOST setting if you don't override it" do
-      $MONGO_HOST = 'example.net'
+    it "uses the Candy.host setting if you don't override it" do
+      Candy.host = 'example.net'
       PeanutBrittle.connection.nodes.should == [["example.net", 27017]]
     end
 
-    it "uses the $MONGO_PORT setting if you don't override it" do
-      PeanutBrittle.host = 'localhost'
-      $MONGO_PORT = 33333
+    it "uses the Candy.port setting if you don't override it" do
+      Candy.host = 'localhost'
+      Candy.port = 33333
       PeanutBrittle.connection.nodes.should == [["localhost", 33333]]
     end
 
-    it "uses the $MONGO_OPTIONS setting if you don't override it" do
+    it "uses the Candy.connection_options setting if you don't override it" do
       l = Logger.new(STDOUT)
-      PeanutBrittle.options = nil  # Gotta be careful of our order on this one
-      $MONGO_OPTIONS = {:logger => l, :connect => false}
-      PeanutBrittle.connection.logger.should == $MONGO_OPTIONS[:logger]
+      Candy.connection_options = {:logger => l, :connect => false}
+      PeanutBrittle.connection.logger.should == Candy.connection_options[:logger]
     end   
     
     it "clears the database when you set it" do
@@ -66,18 +49,16 @@ describe Candy::Crunch do
     end
 
     after(:each) do
-      $MONGO_HOST = nil
-      $MONGO_PORT = nil
-      $MONGO_OPTIONS = nil
-      PeanutBrittle.host = nil
-      PeanutBrittle.port = nil
-      PeanutBrittle.options = nil
+      Candy.host = nil
+      Candy.port = nil
+      Candy.connection_options = nil
+      PeanutBrittle.connection = nil
     end
   end
   
   describe "database" do
     before(:each) do
-      $MONGO_DB = nil
+      Candy.db = nil
     end
     
     it "takes yours if you give it one" do
@@ -95,8 +76,8 @@ describe Candy::Crunch do
       lambda{PeanutBrittle.db = 5}.should raise_error(Candy::ConnectionError, "The db attribute needs a Mongo::DB object or a name string.")
     end
   
-    it "uses the $MONGO_DB setting if you don't override it" do
-      $MONGO_DB = 'foobar'
+    it "uses the Candy.db setting if you don't override it" do
+      Candy.db = 'foobar'
       PeanutBrittle.db.name.should == 'foobar'
     end
   
@@ -118,7 +99,7 @@ describe Candy::Crunch do
     end
     
     after(:all) do
-      $MONGO_DB = 'candy_test'  # Get back to our starting point
+      Candy.db = 'candy_test'  # Get back to our starting point
     end
   end
   

data/spec/candy/hash_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Candy::CandyHash do
+  before(:all) do
+    @verifier = Zagnut.collection
+  end
+
+  before(:each) do
+    @this = Zagnut.new
+    @this.filling = {taste: 'caramel', ounces: 0.75}
+  end
+  
+  it "writes the hash" do
+    @verifier.find_one['filling']['ounces'].should == 0.75
+  end
+  
+  it "reads the hash" do
+    that = Zagnut(@this.id)
+    that.filling.taste.should == 'caramel'
+    that.filling.should be_a(Hash)
+  end
+  
+  it "cascades changes" do
+    @this.filling[:calories] = 250
+    that = Zagnut(@this.id)
+    that.filling.calories.should == 250
+  end
+  
+  it "cascades deeply" do
+    @this.filling.subfilling = {texture: :gravel}
+    that = Zagnut(@this.id)
+    that.filling.subfilling.texture.should == :gravel
+  end
+  
+  after(:each) do
+    Zagnut.collection.remove
+  end
+end

data/spec/candy/piece_spec.rb

@@ -0,0 +1,259 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Candy::Piece do
+  
+  class Nougat
+    attr_accessor :foo
+  end
+  
+  before(:all) do
+    @verifier = Zagnut.collection
+  end
+  
+  before(:each) do
+    @this = Zagnut.new
+  end
+  
+
+  it "lazy inserts" do
+    @this.id.should be_nil
+  end
+  
+  it "knows its ID after inserting" do
+    @this.name = 'Zagnut'
+    @this.id.should be_a(Mongo::ObjectID)
+  end
+  
+  
+  it "can be given a hash of data to insert immediately" do
+    that = Zagnut.new({calories: 500, morsels: "chewy"})
+    @verifier.find_one(calories: 500)["morsels"].should == "chewy"
+  end
+
+  it "saves any attribute it doesn't already handle to the database" do
+    @this.bite = "Tasty!"
+    @verifier.find_one["bite"].should == "Tasty!"
+  end
+
+  it "retrieves any attribute it doesn't already know about from the database" do
+    @this.chew = "Munchy!"
+    @verifier.update({:_id => @this.id}, {:chew => "Yummy!"})
+    that = Zagnut(@this.id)
+    that.chew.should == "Yummy!"
+  end
+
+  it "can roundtrip effectively" do
+    @this.swallow = "Gulp."
+    @this.swallow.should == "Gulp."
+  end
+
+  it "handles missing attributes gracefully" do
+    @this.licks.should == nil
+  end
+  
+  it "allows multiple attributes to be set" do
+    @this.licks = 7
+    @this.center = 0.5
+    @this.licks.should == 7
+  end
+  
+  
+  it "wraps objects" do
+    nougat = Nougat.new
+    nougat.foo = 5
+    @this.center = nougat
+    @verifier.find_one["center"]["__object_"]["class"].should == Nougat.name
+  end
+  
+  it "unwraps objects" do
+    @this.blank = ""  # To force a save
+    center = Nougat.new
+    center.foo = :bar
+    @verifier.update({'_id' => @this.id}, '$set' => {:center => {"__object_" => {:class => Nougat.name, :ivars => {"@foo" => 'bar'}}}})
+    @this.refresh.center.should be_a(Nougat)
+    @this.center.instance_variable_get(:@foo).should == 'bar'
+  end
+  
+  it "wraps symbols" do
+    @this.crunch = :chomp
+    @verifier.find_one["crunch"].should == :chomp
+  end
+
+  
+  it "considers objects equal if they point to the same MongoDB ref" do
+    @this.blank = ""
+    that = Zagnut(@this.id)
+    that.should == @this
+  end
+  
+  it "considers objects unequal if they don't have the same MongoDB ref" do
+    @this.calories = 5
+    that = Zagnut.new(calories: 5)
+    @this.should_not == that
+  end
+  
+  it "considers objects unequal if this one hasn't been saved yet" do
+    that = Zagnut.new
+    @this.should_not == that
+  end
+  
+  it "considers objects unequal if compared to something without an id" do
+    that = Object.new
+    @this.should_not == that
+  end
+  
+  
+
+  describe "retrieval" do
+    it "can find a record by its ID" do
+      @this.licks = 10
+      that = Zagnut.first(@this.id)
+      that.licks.should == 10
+    end
+        
+    it "returns nil on an object that can't be found" do
+      id = Mongo::ObjectID.new
+      Zagnut(id).should be_nil
+    end
+    
+    it "can get a single object by attributes" do
+      @this.pieces = 7.5
+      @this.color = "red"
+      that = Zagnut.first("pieces" => 7.5)
+      that.color.should == "red"
+    end
+    
+    it "returns nil if a first object can't be found" do
+      @this.pieces = 11
+      Zagnut.first("pieces" => 5).should be_nil
+    end
+    
+    it "can get a single object by attribute method" do
+      @this.color = "blue"
+      @this.smushy = true
+      that = Zagnut.color("blue")
+      that.should be_smushy
+    end
+    
+    it "can get the object by a method at the top level" do
+      @this.intensity = :Yowza
+      that = Zagnut(@this.id)
+      that.intensity.should == :Yowza
+    end
+    
+    # Test class for scoped magic method generation
+    class BabyRuth
+      include Candy::Piece
+    end
+    
+    it "can get the object by a method within the enclosing namespace" do
+      foo = BabyRuth.new
+      foo.color = 'green'
+      bar = BabyRuth(foo.id)
+      bar.color.should == 'green'
+    end
+    
+    # Test class to verify magic method generation doesn't override anything
+    def Jawbreaker(param=nil)
+      "Broken!"
+    end
+    
+    class Jawbreaker
+      include Candy::Piece
+    end
+    
+    it "doesn't create a namespace method if one already exists" do
+      too = Jawbreaker.new
+      too.calories = 55
+      tar = Jawbreaker(too.id)
+      tar.should == 'Broken!'
+    end
+    
+  end
+  
+  describe "updates" do
+    before(:each) do
+      @this.ounces = 17
+      @this.crunchy = :very
+      @that = Zagnut.new
+      @that.ounces = 11
+      @that.crunchy = :very
+    end
+    
+    it "will insert a document if the key field's value isn't found" do
+      Zagnut.update(:ounces, {ounces: 15, crunchy: :not_very, flavor: 'butterscotch'})
+      @verifier.count.should == 3
+      Zagnut.ounces(15).flavor.should == 'butterscotch'
+    end
+    
+    it "will update a document if the key field's value is found" do
+      Zagnut.update(:ounces, {ounces: 11, crunchy: :barely, salt: 0})
+      @verifier.count.should == 2
+      @that.refresh
+      @that.crunchy.should == :barely
+    end
+    
+    it "can match on multiple keys" do
+      Zagnut.update([:crunchy, :ounces], {ounces: 17, crunchy: :very, calories: 715})
+      @verifier.count.should == 2
+      @this.refresh
+      @this.calories.should == 715
+    end
+      
+    it "won't match on multiple keys if they aren't all found" do
+      Zagnut.update([:crunchy, :ounces], {ounces: 11, crunchy: :not_quite, color: 'brown'})
+      @verifier.count.should == 3
+      Zagnut.crunchy(:not_quite).color.should == 'brown'
+    end
+  end
+  
+  describe "embedding" do
+    describe "Candy objects" do
+      before(:each) do
+        @inner = KitKat.new
+        @inner.crunch = 'wafer'   
+        @this.inner = @inner
+      end
+
+      it "writes the object" do
+        @verifier.find_one['inner']['crunch'].should == 'wafer'
+      end
+      
+      it "reads the object" do
+        that = Zagnut(@this.id)
+        that.inner.crunch.should == 'wafer'
+      end
+      
+      it "maintains the class" do
+        that = Zagnut(@this.id)
+        that.inner.should be_a(KitKat)
+      end
+      
+      it "cascades changes" do
+        @this.inner.coating = 'chocolate'
+        @verifier.find_one['inner']['coating'].should == 'chocolate'
+      end
+      
+      it "cascades deeply" do
+        @this.inner.inner = Zagnut.embed(beauty: 'recursive!')
+        that = Zagnut(@this.id)
+        that.inner.inner.beauty.should == 'recursive!'
+      end
+    end
+    
+    
+    
+    
+  end
+  
+  
+  
+  
+  
+  
+  after(:each) do
+    KitKat.collection.remove
+    Zagnut.collection.remove
+  end
+  
+end