candy 0.0.2 → 0.1.0

data/README.markdown

@@ -0,0 +1,105 @@
+# Candy
+
+__"Mongo like candy!"__ — _Blazing Saddles_
+
+Candy aims to be the simplest possible ORM for the MongoDB database. If MongoMapper is Rails, Candy is Sinatra. Mix the Candy module into any class, and every new object for that class will create a Mongo document. Objects act like OpenStructs -- you can assign or retrieve any property without declaring it in code.
+
+Other distinctive features:
+
+* Sane defaults are used for the connection, database, and collection.  If you're running Mongo locally you can have zero configuration.
+* Candy has no `save` or `save!` method. Property changes are persisted to the database immediately. Mongo's atomic update operators (in particular $set) are used so that updates are as fast as possible and don't clobber unrelated fields.
+* Candy properties have _no memory._ Every value retrieval goes against the database, so your objects are never stale. (You can always implement caching via Ruby attributes if you want it.)
+* Query result sets are Enumerator objects on top of Mongo cursors. If you're using Ruby 1.9 you'll get very efficient enumeration using fibers. 
+* Whole documents are never written nor read. Queries only return the **_id** field, and getting or setting a property only accesses that property.
+* __Coming soon:__ Array and embedded document operations.
+* __Coming soon:__ A smart serializer (Candy::Wrapper) to convert almost any object for assignment to a Candy property.
+
+Candy was extracted from [Candygram](http://github.com/SFEley/candygram), my delayed job system for MongoDB.  I'm presently in the middle of refactoring Candygram to depend on Candy instead, which will simplify a lot of the Mongo internals.
+
+## Installation
+
+Come on, you've done this before:
+
+    $ sudo gem install candy
+    
+Candygram requires the **mongo** gem, and you'll probably be much happier if you install the **mongo\_ext** gem as well. The author uses only Ruby 1.9, but it _should_ work in Ruby 1.8.7. If it doesn't, please report a bug in Github's issue tracking system. (If you're using 1.8.6, I hosed you by using the Enumerator class. Sorry. I might fix this if enough noise gets made.)
+
+## Configuration
+
+The simplest possible thing that works:
+
+    class Zagnut
+      include Candy
+    end
+    
+That's it. Honest. Some Mongo plumbing is hooked in and instantiated the first time the `.collection` attribute is accessed:
+ 
+    Zagnut.connection # => Defaults to localhost port 27017
+    Zagnut.db         # => Defaults to your username
+    Zagnut.collection # => Defaults to the class name ('Zagnut')
+    
+You can override the DB or collection by providing new name strings or Mongo::DB and Mongo::Collection objects. Or you can set certain global variables to make it easier for multiple Candy classes in an application to use the same database:
+
+* **$MONGO_HOST**
+* **$MONGO_PORT**
+* **$MONGO_OPTIONS** (A hash of options to the Connection object)
+* **$MONGO_DB** (A simple string with the database name)
+
+All of the above is pretty general-purpose. If you want to use this class-based Mongo functionality in your own projects, simply include `Candy::Crunch` in your own classes.
+
+## Using It
+
+The trick here is to think of Candy objects like OpenStructs.  Or if that's too technical, imagine the objects as thin candy shells around a chewy `method_missing` center:
+
+    class Zagnut
+      include Candy
+    end
+    
+    zag = Zagnut.new      # A blank document enters the Zagnut collection
+    zag.taste = "Chewy!"  # Properties are created and saved as they're used
+    zag.calories = 600
+    
+    nut = Zagnut.first(:taste => "Chewy!")
+    nut.calories          # => 600
+    
+    kingsize = Zagnut.new
+    kingsize.calories = 900
+    
+    bars = Zagnut.all     # => An Enumerator object with #each and friends 
+    sum = bars.inject {|sum,bar| sum + bar.calories}  # => 1500
+    
+
+If, in the middle of that code execution, somebody else changed the properties of one of the objects, you might get different answers. Every property access requeries the Mongo document. That sounds insane, but Mongo is _fast_ so we can get away with it; and it avoids any brittleness or complexity of having refresh methods or checking for stale data. (Later versions may include more document-based access via block operations. Let me know if you would like to see that.)
+
+### Method_missing?  _Really?_
+
+Yes.  It may seem at first like an inversion: Candy only stores attributes that you _don't_ declare in your class definition.  But there's a method to this madn...  (No, wait, it's missing.)
+
+Here's the reason. I have no idea what kind of logic you might want to put in your classes. I don't want to guess what you want to store or not -- and more to the point, I don't want to make _you_ guess.  Unless you want to.
+
+Candy properties are dumb.  They don't have calculations. They don't cache. They have nothing to do with instance variables. If you _want_ to make something smarter, just set up your accessors and have them talk to  Candy behind the scenes:
+
+    class Zagnut
+      include Candy
+      
+      def weight
+        @weight ||= _weight  # _weight is undeclared, so Candy looks it up
+      end
+
+      def weight=(val)
+        self._weight = @weight = val   # _weight= is undeclared, so Candy stores it
+      end      
+    end
+        
+    
+== Contributing
+ 
+At this early stage, one of the best things you could do is just to tell me that you have an interest in using this thing. You can email me at sfeley@gmail.com -- if I get more than, say, three votes of interest, I'll throw a projects page on the wiki.
+
+Beyond that, report issues, please.  If you want to fork it and add features, fabulous.  Send me a pull request.
+
+Oh, and if you like science fiction stories, check out my podcast [Escape Pod](http://escapepod.org).  End of plug.
+
+== Copyright
+
+Copyright (c) 2010 Stephen Eley. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.0

data/candy.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{candy}
-  s.version = "0.0.2"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Stephen Eley"]
-  s.date = %q{2010-01-20}
+  s.date = %q{2010-02-16}
   s.description = %q{Candy is a lightweight ORM for the MongoDB database. If MongoMapper is Rails, Candy is Sinatra. 
 It provides a module you mix into any class, enabling the class to connect to Mongo on its own
 and push its objects into a collection. Candied objects act like OpenStructs, allowing attributes
@@ -20,20 +20,23 @@ converts almost any object for assignment to any attribute.
   s.email = %q{sfeley@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+     "README.markdown"
   ]
   s.files = [
     ".document",
      ".gitignore",
      "LICENSE",
-     "README.rdoc",
+     "README.markdown",
      "Rakefile",
      "VERSION",
      "candy.gemspec",
      "lib/candy.rb",
      "lib/candy/crunch.rb",
      "lib/candy/exceptions.rb",
+     "lib/candy/qualified_const_get.rb",
+     "lib/candy/wrapper.rb",
      "spec/candy/crunch_spec.rb",
+     "spec/candy/wrapper_spec.rb",
      "spec/candy_spec.rb",
      "spec/spec.opts",
      "spec/spec.watchr",
@@ -46,6 +49,7 @@ converts almost any object for assignment to any attribute.
   s.summary = %q{The simplest MongoDB ORM}
   s.test_files = [
     "spec/candy/crunch_spec.rb",
+     "spec/candy/wrapper_spec.rb",
      "spec/candy_spec.rb",
      "spec/spec_helper.rb"
   ]

data/lib/candy/crunch.rb

@@ -1,5 +1,5 @@
 require 'mongo'
-require 'etc'
+require 'etc'  # To get the current username for database default
 
 module Candy
   
@@ -95,6 +95,18 @@ module Candy
         @collection ||= db.create_collection(name)
       end
       
+      # Creates an index on the specified property, with an optional direction specified as either :asc or :desc.
+      # (Note that this is deliberately a very simple method. If you want multi-key or unique indexes, just call
+      # #create_index directly on the collection.)
+      def index(property, direction=:asc)
+        case direction
+        when :asc then mongo_direction = Mongo::ASCENDING
+        when :desc then mongo_direction = Mongo::DESCENDING
+        else
+          raise TypeError, "Index direction should be :asc or :desc"
+        end
+        collection.create_index(property => mongo_direction)
+      end
     end
     
     module InstanceMethods

data/lib/candy/exceptions.rb

@@ -4,4 +4,6 @@ module Candy
   class CandyError < StandardError; end
     
   class ConnectionError < CandyError; end
+  
+  class TypeError < CandyError; end
 end

data/lib/candy/qualified_const_get.rb

@@ -0,0 +1,24 @@
+# From: http://redcorundum.blogspot.com/2006/05/kernelqualifiedconstget.html
+# We need this to properly handle namespaced class resolution in Candy::Wrapper.unwrap.
+
+module Kernel
+  def qualified_const_get(str)
+    path = str.to_s.split('::')
+    from_root = path[0].empty?
+    if from_root
+      from_root = []
+      path = path[1..-1]
+    else
+      start_ns = ((Class === self)||(Module === self)) ? self : self.class
+      from_root = start_ns.to_s.split('::')
+    end
+    until from_root.empty?
+      begin
+        return (from_root+path).inject(Object) { |ns,name| ns.const_get(name) }
+      rescue NameError
+        from_root.delete_at(-1)
+      end
+    end
+    path.inject(Object) { |ns,name| ns.const_get(name) }
+  end
+end

data/lib/candy/wrapper.rb

@@ -0,0 +1,123 @@
+require 'mongo'
+require 'date'  # Only so we know what one is. Argh.
+require 'candy/qualified_const_get'
+
+module Candy
+  
+  # Utility methods to serialize and unserialize many types of objects into BSON.
+  module Wrapper
+    
+    BSON_SAFE = [String, 
+                NilClass, 
+                TrueClass, 
+                FalseClass, 
+                Fixnum, 
+                Float, 
+                Time,
+                Regexp,
+                ByteBuffer, 
+                Mongo::ObjectID, 
+                Mongo::Code,
+                Mongo::DBRef]
+    
+    # Makes an object safe for the sharp pointy edges of MongoDB. Types properly serialized
+    # by the BSON.serialize call get passed through unmolested; others are unpacked and their
+    # pieces individually shrink-wrapped.
+    def self.wrap(thing)
+      # Pass the simple cases through
+      return thing if BSON_SAFE.include?(thing.class)
+      case thing
+      when Symbol
+        wrap_symbol(thing)
+      when Array
+        wrap_array(thing)
+      when Hash
+        wrap_hash(thing)
+      when Numeric  # The most obvious are in BSON_SAFE, but not all
+        thing
+      when Date
+        thing.to_time
+      # Problem children
+      when Proc
+        raise TypeError, "Candy can't wrap Proc objects!"
+      when Range
+        raise TypeError, "Candy can't wrap ranges!"
+      else
+        wrap_object(thing)  # Our catchall machinery
+      end
+    end
+    
+    # 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
+    def self.wrap_hash(hash)
+      wrapped = {}
+      hash.each {|k, v| wrapped[wrap(k)] = wrap(v)}
+      wrapped
+    end
+    
+    # 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
+    end
+    
+    # Returns a nested hash containing the class and instance variables of the object.  It's not the
+    # deepest we could ever go (it doesn't handle singleton methods, etc.) but it's a start.
+    def self.wrap_object(object)
+      wrapped = {"class" => object.class.name}
+      ivars = {}
+      object.instance_variables.each do |ivar|
+        # Different Ruby versions spit different things out for instance_variables.  Annoying.
+        ivar_name = '@' + ivar.to_s.sub(/^@/,'')
+        ivars[ivar_name] = wrap(object.instance_variable_get(ivar_name))
+      end
+      wrapped["ivars"] = ivars unless ivars.empty?
+      {"__object_" => wrapped}
+    end
+    
+    # Undoes any complicated magic from the Wrapper.wrap method.  Almost everything falls through
+    # untouched except for symbol strings and hashed objects.
+    def self.unwrap(thing)
+      case thing
+      when Hash
+        if thing["__object_"]
+          unwrap_object(thing)
+        else
+          unwrap_hash(thing)
+        end
+      when Array
+        thing.map {|element| unwrap(element)}
+      when /^__sym_(.+)/
+        $1.to_sym
+      else
+        thing
+      end
+    end
+    
+    # Traverses the hash, unwrapping both keys and values.  Returns the hash that results.
+    def self.unwrap_hash(hash)
+      unwrapped = {}
+      hash.each {|k,v| unwrapped[unwrap(k)] = unwrap(v)}
+      unwrapped
+    end
+    
+    # Turns a hashed object back into an object of the stated class, setting any captured instance 
+    # variables.  The main limitation is that the object's class *must* respond to Class.new without 
+    # any parameters; we will not attempt to guess at any complex initialization behavior.
+    def self.unwrap_object(hash)
+      if innards = hash["__object_"]
+        klass = Kernel.qualified_const_get(innards["class"])
+        object = klass.new
+        if innards["ivars"]
+          innards["ivars"].each do |name, value|
+            object.instance_variable_set(name, unwrap(value))
+          end
+        end
+        object
+      end
+    end 
+  end
+end 

data/lib/candy.rb

@@ -1,5 +1,6 @@
 require 'candy/exceptions'
 require 'candy/crunch'
+require 'candy/wrapper'
 
 # Mix me into your classes and Mongo will like them!
 module Candy
@@ -7,6 +8,8 @@ module Candy
   module ClassMethods
     include Crunch::ClassMethods
     
+    attr_reader :stamp_create, :stamp_update
+    
     # Retrieves an object from Mongo by its ID and returns it.  Returns nil if the ID isn't found in Mongo.
     def find(id)
       if collection.find_one(id)
@@ -37,6 +40,14 @@ module Candy
       end  
     end
     
+    # Configures objects to set `created_at` and `updated_at` properties at the appropriate times.
+    # Pass `:create` or `:update` to limit it to just one or the other.  Defaults to both.
+    def timestamp(*args)
+      args = [:create, :update] if args.empty?
+      @stamp_create = args.include?(:create)
+      @stamp_update = args.include?(:update)
+    end
+    
   private
     # Returns a hash of options matching those enabled in Mongo::Collection#find, if any of them exist
     # in the set of search conditions.
@@ -55,7 +66,8 @@ module Candy
     
     # We push ourselves into the DB before going on with our day.
     def initialize(*args, &block)
-      @__candy = check_for_candy(args) || self.class.collection.insert({})
+      @__candy = check_for_candy(args) || 
+        self.class.collection.insert(self.class.stamp_create ? {:created_at => Time.now.utc} : {})
       super
     end
 
@@ -68,12 +80,40 @@ module Candy
     # Retrieving any unknown attribute will return that value from this record in the Mongo collection.
     def method_missing(name, *args, &block)
       if name =~ /(.*)=$/  # We're assigning
-        self.class.collection.update({"_id" => @__candy}, {"$set" => {$1 => args[0]}})
+        set $1, Wrapper.wrap(args[0])
+      else
+        Wrapper.unwrap(self.class.collection.find_one(@__candy, :fields => [name.to_s])[name.to_s])
+      end
+    end
+    
+    # Given either a property/value pair or a hash (which can contain several property/value pairs), sets those
+    # values in Mongo using the atomic $set. The first form is functionally equivalent to simply using the
+    # magic assignment operator; i.e., `me.set(:foo, 'bar')` is the same as `me.foo = bar`.
+    def set(*args)
+      if args.length > 1  # This is the property/value form
+        hash = {args[0] => args[1]}
       else
-        self.class.collection.find_one(@__candy, :fields => [name.to_s])[name.to_s]
+        hash = args[0]
       end
+      hash.merge!(:updated_at => Time.now.utc) if self.class.stamp_update
+      update '$set' => hash
     end
     
+    # Given a Candy array property, appends a value or values to the end of that array using the atomic $push.  
+    # (Note that we don't actually check the property to make sure it's an array and $push is valid. If it isn't, 
+    # this operation will silently fail.)
+    def push(property, *values)
+      values.each do |value|
+        update '$push' => {property => Wrapper.wrap(value)}
+      end
+    end
+    
+    # Given a Candy integer property, increments it by the given value (which defaults to 1) using the atomic $inc.
+    # (Note that we don't actually check the property to make sure it's an integer and $inc is valid. If it isn't, 
+    # this operation will silently fail.)
+    def inc(property, increment=1)
+      update '$inc' => {property => increment}
+    end
   private
   
     # Returns the secret decoder ring buried in the arguments to "new"
@@ -86,6 +126,11 @@ module Candy
       end
     end
     
+    # Updates the Mongo document with the given element or elements.
+    def update(element)
+      self.class.collection.update({"_id" => @__candy}, element)
+    end
+    
   end
   
   def self.included(receiver)

data/spec/candy/crunch_spec.rb

@@ -144,6 +144,26 @@ describe Candy::Crunch do
   
   end
   
+  describe "index" do
+    it "can be created with just a property name" do
+      PeanutBrittle.index(:blah)
+      PeanutBrittle.collection.index_information.values[1].should == [["blah", Mongo::ASCENDING]]
+    end
+    
+    it "can be created with a direction" do
+      PeanutBrittle.index(:fwah, :desc)
+      PeanutBrittle.collection.index_information.values[1].should == [["fwah", Mongo::DESCENDING]]
+    end
+    
+    it "throws an exception if you give it a type other than :asc or :desc" do
+      lambda{PeanutBrittle.index(:yah, 5)}.should raise_error(Candy::TypeError, "Index direction should be :asc or :desc")  
+    end
+    
+    after(:each) do
+      PeanutBrittle.collection.drop_indexes
+    end
+  end
+  
   after(:each) do
     PeanutBrittle.connection = nil
   end

data/spec/candy/wrapper_spec.rb

@@ -0,0 +1,197 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Candy
+  describe Candy::Wrapper do
+    
+    # A simple class to test argument encoding
+    class Missile
+      attr_accessor :payload
+      attr_accessor :rocket
+
+      def explode
+        "Dropped the #{payload}."
+      end
+    end
+    
+    describe "wrapping" do
+
+      it "can wrap an array of simple arguments" do
+        a = ["Hi", 1, nil, 17.536]
+        Wrapper.wrap_array(a).should == a
+      end
+  
+      it "can wrap a string" do
+        Wrapper.wrap("Hi").should == "Hi"
+      end
+
+      it "can wrap nil" do
+        Wrapper.wrap(nil).should == nil
+      end
+  
+      it "can wrap true" do
+        Wrapper.wrap(true).should be_true
+      end
+  
+      it "can wrap false" do
+        Wrapper.wrap(false).should be_false
+      end
+  
+      it "can wrap an integer" do
+        Wrapper.wrap(5).should == 5
+      end
+  
+      it "can wrap a float" do
+        Wrapper.wrap(17.950).should == 17.950
+      end
+  
+      it "can wrap an already serialized bytestream" do
+        b = BSON.serialize(:foo => 'bar')
+        Wrapper.wrap(b).should == b
+      end
+  
+      it "can wrap an ObjectID" do
+        i = Mongo::ObjectID.new
+        Wrapper.wrap(i).should == i
+      end
+
+      it "can wrap the time" do
+        t = Time.now
+        Wrapper.wrap(t).should == t
+      end
+  
+      it "can wrap a regular expression" do
+        r = /ha(l+)eluja(h?)/i
+        Wrapper.wrap(r).should == r
+      end
+  
+      it "can wrap a Mongo code object (if we ever need to)" do
+        c = Mongo::Code.new('5')
+        Wrapper.wrap(c).should == c
+      end
+  
+      it "can wrap a Mongo DBRef (if we ever need to)" do
+        d = Mongo::DBRef.new('foo', Mongo::ObjectID.new)
+        Wrapper.wrap(d).should == d
+      end
+  
+      it "can wrap a date as a time" do
+        d = Date.today
+        Wrapper.wrap(d).should == Date.today.to_time
+      end
+  
+      it "can wrap other numeric types (which might throw exceptions later but oh well)" do
+        c = Complex(2, 5)
+        Wrapper.wrap(c).should == c
+      end
+  
+      it "can wrap a symbol in a way that preserves its symbolic nature" do
+        Wrapper.wrap(:oldglory).should == "__sym_oldglory"
+      end
+  
+      it "wraps an array recursively" do
+        a = [5, 'hi', [':symbol', 0], nil]
+        Wrapper.wrap(a).should == a
+      end
+    
+      it "wraps a hash's keys" do
+        h = {"foo" => "bar", :yoo => "yar"}
+        Wrapper.wrap(h).keys.should == ["foo", "__sym_yoo"]
+      end
+  
+      it "wraps a hash's values" do
+        h = {:foo => :bar, :yoo => [:yar, 5]}
+        Wrapper.wrap(h).values.should == ["__sym_bar", ["__sym_yar", 5]]
+      end
+    
+      it "rejects procs" do
+        p = Proc.new {puts "This should fail!"}
+        lambda{Wrapper.wrap(p)}.should raise_error(TypeError)
+      end
+      
+      it "rejects ranges" do
+        r = (1..3)
+        lambda{Wrapper.wrap(r)}.should raise_error(TypeError)
+      end
+    
+      describe "objects" do
+        before(:each) do
+          @missile = Missile.new
+          @missile.payload = "15 megatons"
+          @missile.rocket = [2, Object.new]
+          @this = Wrapper.wrap(@missile)
+        end
+      
+        it "returns a hash" do
+          @this.should be_a(Hash)
+        end
+      
+        it "keys the hash to be an object" do
+          @this.keys.should == ["__object_"]
+        end
+      
+        it "knows the object's class" do
+          @this["__object_"]["class"].should =~ /Missile$/
+        end
+      
+        it "captures all the instance variables" do
+          ivars = @this["__object_"]["ivars"]
+          ivars.should have(2).elements
+          ivars["@payload"].should == "15 megatons"
+          ivars["@rocket"][1]["__object_"]["class"].should == "Object"
+        end
+      
+          
+      
+      end
+    end
+  
+    describe "unwrapping" do
+      before(:each) do
+        @wrapped = {"__object_" => {
+          "class" => Missile.name,
+          "ivars" => {
+            "@payload" => "6 kilotons",
+            "@rocket" => [1, {"__object_" => {
+              "class" => "Object"
+            }}]
+          }
+        }}
+      end
+      it "passes most things through untouched" do
+        Wrapper.unwrap(5).should == 5
+      end
+    
+      it "turns symbolized strings back into symbols" do
+        Wrapper.unwrap("__sym_blah").should == :blah
+      end
+    
+      it "turns hashed objects back into objects" do
+        obj = Wrapper.unwrap(@wrapped)
+        obj.should be_a(Missile)
+        obj.payload.should == "6 kilotons"
+        obj.rocket[0].should == 1
+        obj.rocket[1].should be_an(Object)
+      end
+      
+      it "traverses a hash and unwraps whatever it needs to" do
+        hash = {"__sym_foo" => "__sym_bar", "missile" => @wrapped}
+        unwrapped = Wrapper.unwrap(hash)
+        unwrapped[:foo].should == :bar
+        unwrapped["missile"].should be_a(Missile)
+      end
+    
+      it "traverses an array and unwraps whatever it needs to" do
+        array = ["__sym_foo", 5, @wrapped, nil, "hi"]
+        unwrapped = Wrapper.unwrap(array)
+        unwrapped[0].should == :foo
+        unwrapped[1].should == 5
+        unwrapped[2].should be_a(Missile)
+        unwrapped[3].should be_nil
+        unwrapped[4].should == "hi"
+      end
+  
+    end
+    
+
+  end
+end

data/spec/candy_spec.rb

@@ -44,6 +44,29 @@ describe "Candy" do
     @this.licks.should == 7
   end
   
+  it "can set properties explicity" do
+    @this.set(:licks, 17)
+    @this.licks.should == 17
+  end
+  
+  it "can set properties from a hash" do
+    @this.set(:licks => 19, :center => -2.5)
+    @this.licks.should == 19
+    @this.center.should == -2.5
+  end
+  
+  it "wraps objects" do
+    o = Object.new
+    @this.object = o
+    @verifier.find_one["object"]["__object_"]["class"].should == "Object"
+  end
+  
+  it "unwraps objects" do
+    @verifier.update({:_id => @this.id}, {:center => {"__object_" => {:class => "Object", :ivars => {"@foo" => "bar"}}}})
+    @this.center.should be_an(Object)
+    @this.center.instance_variable_get(:@foo).should == "bar"
+  end
+  
   describe "retrieval" do
     it "can find a record by its ID" do
       @this.licks = 10
@@ -110,6 +133,69 @@ describe "Candy" do
       
   end
   
+  describe "arrays" do
+    it "can push items" do
+      @this.push(:colors, 'red')
+      @this.colors.should == ['red']
+    end
+    
+    it "can push an array of items" do
+      @this.push(:potpourri, 'red', 75, nil)
+      @this.potpourri.should == ['red', 75, nil]
+    end
+  end
+  
+  describe "numbers" do
+    it "can be incremented by 1 when not set" do
+      @this.inc(:bites)
+      @this.bites.should == 1
+    end
+    
+    it "can be incremented by 1 when set" do
+      @this.bites = 11
+      @this.inc(:bites)
+      @this.bites.should == 12
+    end
+    
+    it "can be incremented by any number" do
+      @this.bites = -6
+      @this.inc(:bites, 15)
+      @this.bites.should == 9
+    end
+  end
+  
+  describe "timestamp" do
+    it "can be set on creation" do
+      Zagnut.class_eval("timestamp :create")
+      z = Zagnut.new
+      z.created_at.should be_a(Time)
+      z.updated_at.should be_nil
+    end
+    
+    it "can be set on modification" do
+      Zagnut.class_eval("timestamp :update")
+      z = Zagnut.new
+      z.created_at.should be_nil
+      z.updated_at.should be_nil
+      z.bites = 11
+      z.created_at.should be_nil
+      z.updated_at.should be_a(Time)
+    end
+    
+    it "sets both by default" do
+      Zagnut.class_eval("timestamp")
+      z = Zagnut.new
+      z.bites = 11
+      z.created_at.should be_a(Time)
+      z.updated_at.should be_a(Time)
+    end
+    
+    
+    after(:each) do
+      Zagnut.class_eval("timestamp nil")
+    end
+    
+  end
   
   after(:each) do
     Zagnut.collection.remove

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: candy
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Stephen Eley
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-20 00:00:00 -05:00
+date: 2010-02-16 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -67,19 +67,22 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.markdown
 files: 
 - .document
 - .gitignore
 - LICENSE
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
 - candy.gemspec
 - lib/candy.rb
 - lib/candy/crunch.rb
 - lib/candy/exceptions.rb
+- lib/candy/qualified_const_get.rb
+- lib/candy/wrapper.rb
 - spec/candy/crunch_spec.rb
+- spec/candy/wrapper_spec.rb
 - spec/candy_spec.rb
 - spec/spec.opts
 - spec/spec.watchr
@@ -114,5 +117,6 @@ specification_version: 3
 summary: The simplest MongoDB ORM
 test_files: 
 - spec/candy/crunch_spec.rb
+- spec/candy/wrapper_spec.rb
 - spec/candy_spec.rb
 - spec/spec_helper.rb

data/README.rdoc

@@ -1,17 +0,0 @@
-= candy
-
-Description goes here.
-
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Copyright
-
-Copyright (c) 2010 Stephen Eley. See LICENSE for details.