mongo_thing 0.0.1

data/.bundle/config

@@ -0,0 +1,3 @@
+--- 
+BUNDLE_WITHOUT: ""
+BUNDLE_PATH: development

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg

data/Gemfile

@@ -0,0 +1,15 @@
+# Use `bundle install` in order to install these gems
+# Use `bundle exec rake` in order to run the specs using the bundle
+source "http://rubygems.org"
+
+gem "mongo", "~> 1.0"
+gem "bson", "~> 1.0"
+gem "bson_ext", "~> 1.0"
+gem "activesupport", "3.0.0.beta3"
+
+group :development do
+  gem "rake"
+  gem "ruby-debug"
+  gem "rspec", "1.3.0"
+  gem "jeweler"
+end

data/MIT_LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Durran Jordan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,36 @@
+require "rubygems"
+require "bundler"
+
+begin
+  Bundler.require(:development)
+  Jeweler::Tasks.new do |gem|
+    gem.name = "mongo_thing"
+    gem.summary = "ODM framework for MongoDB"
+    gem.email = "daniel@flyingmachinestudios.com"
+    gem.homepage = ""
+    gem.authors = ["Daniel Higginbotham"]
+
+    gem.add_dependency("mongo", "~> 1.0.1")
+    gem.add_dependency("bson", "~> 1.0.1")
+  end
+  
+  require "spec/rake/spectask"
+  Spec::Rake::SpecTask.new(:spec) do |spec|
+    spec.pattern = "spec/**/*_spec.rb"
+    spec.spec_opts = ["--options", "spec/spec.opts"]
+  end
+
+  Spec::Rake::SpecTask.new(:rcov) do |spec|
+    spec.libs << "lib" << "spec"
+    spec.pattern = "spec/**/*_spec.rb"
+    spec.spec_opts = ["--options", "spec/spec.opts"]
+    spec.rcov = true
+  end
+  
+  task :default => :spec do
+  end
+rescue LoadError => e
+  puts "Error loading dependcy: #{e}."
+end
+
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/mongo_thing/cursor.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module MongoThing #:nodoc
+  class Cursor
+    include Enumerable
+    # Operations on the Mongo::Cursor object that will not get overriden by the
+    # MongoThing::Cursor are defined here.
+    OPERATIONS = [
+      :admin,
+      :close,
+      :closed?,
+      :count,
+      :explain,
+      :fields,
+      :full_collection_name,
+      :hint,
+      :limit,
+      :order,
+      :query_options_hash,
+      :query_opts,
+      :selector,
+      :skip,
+      :snapshot,
+      :sort,
+      :timeout
+    ]
+
+    attr_reader :collection
+
+    # The operations above will all delegate to the proxied Mongo::Cursor.
+    #
+    # Example:
+    #
+    # <tt>cursor.close</tt>
+    OPERATIONS.each do |name|
+      define_method(name) { |*args| @cursor.send(name, *args) }
+    end
+
+    # Iterate over each document in the cursor and yield to it.
+    #
+    # Example:
+    #
+    # <tt>cursor.each { |doc| p doc.title }</tt>
+    def each
+      @cursor.each do |document|
+        yield @klass.new(document)
+      end
+    end
+
+    # Create the new +MongoThing::Cursor+.
+    #
+    # Options:
+    #
+    # collection: The MongoThing::Collection instance.
+    # cursor: The Mongo::Cursor to be proxied.
+    #
+    # Example:
+    #
+    # <tt>MongoThing::Cursor.new(Person, cursor)</tt>
+    def initialize(klass, cursor)
+      @klass, @cursor = klass, cursor
+    end
+
+    # Return the next document in the cursor. Will instantiate a new MongoThing
+    # document with the attributes.
+    #
+    # Example:
+    #
+    # <tt>cursor.next_document</tt>
+    def next_document
+      @klass.new(@cursor.next_document)
+    end
+
+    # Returns an array of all the documents in the cursor.
+    #
+    # Example:
+    #
+    # <tt>cursor.to_a</tt>
+    def to_a
+      @cursor.to_a.collect { |attrs| @klass.new(attrs) }
+    end
+  end
+end

data/lib/mongo_thing/document.rb

@@ -0,0 +1,176 @@
+# encoding: utf-8
+module MongoThing #:nodoc:
+  module Document
+    extend ActiveSupport::Concern
+    
+    included do
+      class << self
+        attr_accessor :properties
+        def properties(*set)
+          if !set.empty?
+            @properties = set
+          else
+            @properties | [:_id]
+          end
+        end
+      end
+      self.properties = []
+      
+      delegate :db, :collection, :to => "self.class"
+    end
+    
+    module ClassMethods
+      # Return the database associated with this class.
+      def db
+        collection.db
+      end
+      
+      def collection
+        MongoThing.db.collection(self.name)
+      end
+      
+      # Finding
+      # Returns an array of Document objects
+      # Wonder if it would be desirable to expose the cursor?
+      def find(selector={}, opts={})
+        mongo_cursor = collection.find(selector, opts)
+        Cursor.new(self, mongo_cursor).to_a
+      end
+      
+      def [](doc_id)
+        find_one(doc_id)
+      end
+      
+      def find_one(spec_or_object_id=nil, opts={})
+        self.new(collection.find_one(spec_or_object_id, opts))
+      end
+      
+      # Creating
+      def create(document)
+        self.new(document).save
+      end
+      
+      # Deleting
+      def remove(selector={}, opts={})
+        collection.remove(selector, opts)
+      end
+    end
+
+    module InstanceMethods
+      # OpenStruct like behavior
+      def method_missing(mid, *args) # :nodoc:
+        mname = mid.id2name
+        chomped = mname.chomp('=')
+        len = args.length
+        if self.class.properties.include?(chomped.to_sym)
+          if mname == chomped && len > 0 || len > 1
+            raise NoMethodError, "undefined method `#{mname}' for #{self}", caller(1)
+          end
+          new_attribute(mname.chomp('='))
+          self.send(mid, *args)
+        else
+          raise NoMethodError, "undefined method `#{mname}' for #{self}", caller(1)
+        end
+      end
+      
+      def new_attribute(name)
+        name = name.to_sym
+        unless self.respond_to?(name)
+          class << self; self; end.class_eval do
+            define_method(name) { @attributes.send(name) }
+            define_method("#{name}=") { |x| @attributes.send("#{name}=".to_sym, x) }
+          end
+        end
+        name
+      end
+
+      # Performs equality checking on the document ids. For more robust
+      # equality checking please override this method.
+      def ==(other)
+        return false unless other.is_a?(Document)
+        id == other.id
+      end
+
+      # Delegates to ==
+      def eql?(comparison_object)
+        self == (comparison_object)
+      end
+      
+      def to_hash
+        @attributes.to_hash
+      end
+
+      # Clone the current +Document+. This will return all attributes with the
+      # exception of the document's id and versions.
+      def clone
+        self.class.instantiate(@attributes.except("_id").except("versions").dup, true)
+      end
+
+
+      # Instantiate a new +Document+, setting the Document's attributes if
+      # given. If no attributes are provided, they will be initialized with
+      # an empty +Hash+.
+      #
+      # If a primary key is defined, the document's id will be set to that key,
+      # otherwise it will be set to a fresh +BSON::ObjectID+ string.
+      #
+      # Options:
+      #
+      # attrs: The attributes +Hash+ to set up the document with.
+      def initialize(attrs = {})
+        @attributes = NestedOpenStruct.new
+        self.attributes = attrs
+        @new_record = true if id.nil?
+      end
+      
+      def attributes=(attrs={})
+        attrs.each do |k,v|
+          self.send("#{k}=", v)
+        end
+      end
+
+      # Returns the class name plus its attributes.
+      def inspect
+        attrs = fields.map { |name, field| "#{name}: #{@attributes[name].inspect}" }
+        if Mongoid.allow_dynamic_fields
+          dynamic_keys = @attributes.keys - fields.keys - ["_id", "_type"]
+          attrs += dynamic_keys.map { |name| "#{name}: #{@attributes[name].inspect}" }
+        end
+        "#<#{self.class.name} _id: #{id}, #{attrs * ', '}>"
+      end
+
+      # Reloads the +Document+ attributes from the database.
+      def reload
+        if self.id
+          self.attributes = self.class[self.id].to_hash
+        else
+          raise ArgumentError, "this document has not been saved"
+        end
+      end
+
+      # Return an array with this +Document+ only in it.
+      def to_a
+        [ self ]
+      end
+
+      # Returns the id of the Document, used in Rails compatibility.
+      def to_param
+        id
+      end
+    
+      def id
+        @attributes._id
+      end
+      
+      def id=(new_id)
+        @attributes._id = new_id
+      end
+      
+      def save
+        @attributes._id = BSON::ObjectID.new if @attributes._id.nil?
+        collection.save(self.to_hash)
+        self
+      end
+    end
+  end
+end

data/lib/mongo_thing/named_scope.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module NamedScope
+    # Creates a named_scope for the +Document+, similar to ActiveRecord's
+    # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
+    # chained.
+    #
+    # Example:
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :active, :type => Boolean
+    #     field :count, :type => Integer
+    #
+    #     named_scope :active, :where => { :active => true }
+    #     named_scope :count_gt_one, :where => { :count.gt => 1 }
+    #     named_scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
+    #   end
+    def named_scope(name, options = {}, &block)
+      name = name.to_sym
+      scopes[name] = lambda do |parent, *args|
+        Scope.new(parent, options.scoped(*args), &block)
+      end
+      (class << self; self; end).class_eval <<-EOT
+        def #{name}(*args)
+          scopes[:#{name}].call(self, *args)
+        end
+      EOT
+    end
+    alias :scope :named_scope
+
+    # Return the scopes or default to an empty +Hash+.
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+  end
+end

data/lib/mongo_thing/nested_ostruct.rb

@@ -0,0 +1,49 @@
+# NestedOpenStruct works like OpenStruct except that all hash values are converted
+# to NestedOpenStruct
+
+module MongoThing
+  class NestedOpenStruct < OpenStruct
+    def initialize(hash=nil)
+      @table = {}
+      @nested_open_structs = []
+      if hash
+        for k,v in hash
+          v = NestedOpenStruct.new(v) if v.is_a? Hash
+          v = v.collect{|nv| nv.is_a?(Hash) ? NestedOpenStruct.new(nv) : nv} if v.is_a?(Array)
+          @table[k.to_sym] = v
+          new_ostruct_member(k)
+        end
+      end
+    end
+    
+    def method_missing(mid, *args) # :nodoc:
+      mname = mid.id2name
+      if mname[-1..-1] == "=" && args[0] && args[0].is_a?(Hash)
+        args[0] = NestedOpenStruct.new(args[0])
+      end
+      super
+    end
+    
+    def to_hash
+      marshal_dump
+    end
+    
+    def marshal_dump
+      @table.collect do |k,v|
+        n = if v.is_a?(NestedOpenStruct)
+          v.marshal_dump
+        elsif v.is_a?(Array)
+          v.collect{|a| a.is_a?(NestedOpenStruct) ? a.marshal_dump : a}
+        else
+          v
+        end
+        [k,n]
+      end.inject({}){|h,v|h[v[0]] = v[1]; h}
+    end
+  
+    def marshal_load(x)
+      @table = x
+      @table.each_key{|key| new_ostruct_member(key)}
+    end
+  end
+end

data/lib/mongo_thing/railtie.rb

@@ -0,0 +1,53 @@
+module Rails #:nodoc:
+  module MongoThing #:nodoc:
+    class Railtie < Rails::Railtie #:nodoc:
+
+      # do we want a custom log subscriber for mongoid?
+      # log_subscriber :mongoid, ::Mongoid::Railties::LogSubscriber.new
+
+      rake_tasks do
+        load "mongo-thing/railties/database.rake"
+      end
+
+      # Initialize Mongoid. This will look for a mongoid.yml in the config
+      # directory and configure mongoid appropriately.
+      #
+      # Example mongoid.yml:
+      #
+      #   defaults: &defaults
+      #     host: localhost
+      #     slaves:
+      #       # - host: localhost
+      #         # port: 27018
+      #       # - host: localhost
+      #         # port: 27019
+      #     allow_dynamic_fields: false
+      #     parameterize_keys: false
+      #     persist_in_safe_mode: false
+      #
+      #   development:
+      #     <<: *defaults
+      #     database: mongoid
+      initializer "setup database" do
+        config_file = Rails.root.join("config", "mongoid.yml")
+        if config_file.file?
+          settings = YAML.load(ERB.new(config_file.read).result)[Rails.env]
+          ::MongoThing.connection = settings if settings.present?
+        end
+      end
+
+      initializer "verify that mongoid is configured" do
+        config.after_initialize do
+          begin
+            ::Mongoid.master
+          rescue ::Mongoid::Errors::InvalidDatabase => e
+            unless Rails.root.join("config", "mongoid.yml").file?
+              puts "\nMongoid config not found. Create a config file at: config/mongoid.yml"
+              puts "to generate one run: script/rails generate mongoid:config\n\n"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo_thing/railties/database.rake

@@ -0,0 +1,37 @@
+namespace :db do
+
+  desc 'Drops all the collections for the database for the current Rails.env'
+  task :drop => :environment do
+    Mongoid.master.collections.each{|col| col.drop unless col.name == 'system.users' }
+  end
+
+  desc 'Load the seed data from db/seeds.rb'
+  task :seed => :environment do
+    seed_file = File.join(Rails.root, 'db', 'seeds.rb')
+    load(seed_file) if File.exist?(seed_file)
+  end
+
+  desc 'Create the database, and initialize with the seed data'
+  task :setup => [ 'db:create', 'db:seed' ]
+
+  desc 'Delete data and seed'
+  task :reseed => [ 'db:drop', 'db:seed' ]
+
+  task :create => :environment do
+    # noop
+  end
+
+  task :migrate => :environment do
+    # noop
+  end
+
+  namespace :schema do
+    task :load do
+      # noop
+    end
+  end
+
+  ########
+  # TODO: lots more useful db tasks can be added here. stuff like copyDatabase, etc
+  ########
+end

data/lib/mongo_thing.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+# Copyright (c) 2010 Daniel Higginbotham
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default)
+require 'active_support/core_ext'
+require 'bson'
+require 'ostruct'
+
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
+require 'mongo_thing/cursor'
+require 'mongo_thing/document'
+require 'mongo_thing/nested_ostruct'
+
+
+module MongoThing #:nodoc
+
+  class << self
+    attr_accessor :connection, :db
+    def connection=(conn)
+      case conn
+      when Hash
+        @connection =  Mongo::Connection.new(conn.delete(:host), conn.delete(:port), conn)
+      when Mongo::Connection
+        @connection = conn
+      end
+      self.db = conn if conn[:name]
+    end
+    
+    def db=(new_db)
+      case new_db
+      when String, Symbol
+        @db = connection.db(new_db.to_s)
+      when Hash
+        @db = connection.db(new_db[:name], new_db)
+      when Mongo::DB
+        @db = new_db
+      end
+    end
+    
+  end
+  
+  
+end

data/mongo_thing.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mongo_thing}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Daniel Higginbotham"]
+  s.date = %q{2010-05-09}
+  s.email = %q{daniel@flyingmachinestudios.com}
+  s.files = [
+    ".bundle/config",
+     ".gitignore",
+     "Gemfile",
+     "MIT_LICENSE",
+     "Rakefile",
+     "VERSION",
+     "lib/mongo_thing.rb",
+     "lib/mongo_thing/cursor.rb",
+     "lib/mongo_thing/document.rb",
+     "lib/mongo_thing/named_scope.rb",
+     "lib/mongo_thing/nested_ostruct.rb",
+     "lib/mongo_thing/railtie.rb",
+     "lib/mongo_thing/railties/database.rake",
+     "mongo_thing.gemspec",
+     "spec/config/mongoid.yml",
+     "spec/integration/mongo_thing/document_spec.rb",
+     "spec/integration/mongo_thing/nested_ostruct_spec.rb",
+     "spec/integration/mongo_thing_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{ODM framework for MongoDB}
+  s.test_files = [
+    "spec/integration/mongo_thing/document_spec.rb",
+     "spec/integration/mongo_thing/nested_ostruct_spec.rb",
+     "spec/integration/mongo_thing_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mongo>, ["~> 1.0.1"])
+      s.add_runtime_dependency(%q<bson>, ["~> 1.0.1"])
+    else
+      s.add_dependency(%q<mongo>, ["~> 1.0.1"])
+      s.add_dependency(%q<bson>, ["~> 1.0.1"])
+    end
+  else
+    s.add_dependency(%q<mongo>, ["~> 1.0.1"])
+    s.add_dependency(%q<bson>, ["~> 1.0.1"])
+  end
+end
+

data/spec/config/mongoid.yml

@@ -0,0 +1,19 @@
+:defaults: &defaults
+  :host: localhost
+  :slaves:
+    # - host: localhost
+      # port: 27018
+    # - host: localhost
+      # port: 27019
+  :allow_dynamic_fields: false
+  :parameterize_keys: false
+  :persist_in_safe_mode: false
+  :raise_not_found_error: false
+  :reconnect_time: 5
+  :use_object_ids: true
+  :persist_types: false
+  :option_no_exist: false
+
+:test:
+  <<: *defaults
+  :name: mongo_thing_test

data/spec/integration/mongo_thing/document_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+class Person
+  include MongoThing::Document
+  self.properties = [:name, :address, :friends]
+end
+
+
+describe MongoThing::Document do
+  describe "attributes" do
+    it "should only allow properties to be treated as attributes" do
+      p = Person.new
+      lambda{p.blarg = "Tom"}.should raise_error(NoMethodError)
+    end
+    
+    it "should allow properties to be treated as attributes" do
+      p = Person.new
+      lambda{p.name = "Tom"}.should_not raise_error(NoMethodError)
+    end
+    
+    it "should assign attributes in the initializer" do
+      p = Person.new({
+        :name => "Tom"
+      })
+      p.name.should == "Tom"
+    end
+    
+    it "should raise an error when trying to assign a non-attribute in the initializer" do
+      lambda {
+        p = Person.new({
+          :name => "Tom",
+          :foo  => "bar"
+        })        
+      }.should raise_error(NoMethodError)
+    end
+    
+    it "should return a hash of attributes" do
+      person_hash = {
+       :name => "Tom",
+       :address => {:street => "Tomahawk", :city => "Placeville"},
+       :friends => [
+          {:name => "John", :address => {:street => "Pleasant", :city => "Cityville"}},
+          {:name => "Bill", :address => {:street => "Prospect", :city => "Townville"}}
+        ]
+      }
+      
+      p = Person.new(person_hash)
+      p.to_hash.should == person_hash
+    end
+    
+    it "should set properties using properties method" do
+      class SetProperties
+        include MongoThing::Document
+        properties :one, :two, :three
+      end
+      
+      lambda{SetProperties.new(:one => 1, :two => 2, :three => 3)}.should_not raise_error
+    end
+  end
+  
+  describe "class modifications" do
+    it "should add the 'properties' attribute to class" do
+      Person.respond_to?(:properties).should be_true
+    end
+    
+    it "should default 'properties' to [:_id]" do
+      class Bear
+        include MongoThing::Document
+      end
+      
+      Bear.properties.should == [:_id]
+    end
+  end
+  
+  describe "actual db interaction" do
+    before(:all) do
+      connect_to_test_database
+    end
+    describe "saving" do
+      it "should save a basic document" do
+        p = Person.new
+        p.name = "Tom"
+        p.save
+      end
+    
+      it "should not have an ID before being saved" do
+        p = Person.new
+        p.id.should be_nil
+      end
+    
+      it "should have an ID after being saved" do
+        p = Person.new
+        p.name = "Tom"
+        p.save
+        p.id.should_not be_nil
+      end
+      
+      it "should save a document with 'create'" do
+        Person.create(:name => "Tom").id.should_not be_nil
+      end
+    end
+  
+    describe "finding" do
+      it "should find a person given an ID" do
+        p = Person.new
+        p.name = "Tom"
+        p.save
+        
+        h = Person[p.id]
+        h.name.should == "Tom"
+        h.id.should == p.id
+        
+        i = Person.find_one(p.id)
+        i.name.should == "Tom"
+        i.id.should == p.id
+      end
+      
+      it "should return all matching documents" do
+        Person.create(:name => "Tom")
+        Person.create(:name => "Voldemort")
+        
+        r = Person.find.to_a
+      end
+      
+      it "should initialize documents from find" do
+        Person.create(:name => "Tom")
+        Person.create(:name => "Voldemort")
+        
+        r = Person.find.to_a
+        r[0].name.should == "Tom"
+        r[1].name.should == "Voldemort"
+      end
+      
+      it "should reload a document" do
+        p = Person.create(:name => "Tom")
+        
+        p.name = "Voldemort"
+        p.reload
+        p.name.should == "Tom"
+      end
+    end
+  end
+end

data/spec/integration/mongo_thing/nested_ostruct_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe MongoThing::NestedOpenStruct do
+  before(:each) do
+    @person_hash = {
+     :name => "Tom",
+     :address => {:street => "Tomahawk", :city => "Placeville"},
+     :friends => [
+        {:name => "John", :address => {:street => "Pleasant", :city => "Cityville"}},
+        {:name => "Bill", :address => {:street => "Prospect", :city => "Townville"}}
+      ]
+    }
+  end
+  
+  it "should not modify original hash" do
+    MongoThing::NestedOpenStruct.new(@person_hash)
+    
+    @person_hash.should == {
+     :name => "Tom",
+     :address => {:street => "Tomahawk", :city => "Placeville"},
+     :friends => [
+        {:name => "John", :address => {:street => "Pleasant", :city => "Cityville"}},
+        {:name => "Bill", :address => {:street => "Prospect", :city => "Townville"}}
+      ]
+    }
+  end
+  
+  it "should convert a hash value to a nested open struct" do
+    p = MongoThing::NestedOpenStruct.new(@person_hash)
+    
+    p.name.should == "Tom"
+    p.address.street.should == "Tomahawk"
+    p.address.city.should == "Placeville"
+    p.friends.size.should == 2
+    p.friends[0].name.should == "John"
+    p.friends[0].address.street.should == "Pleasant"
+    p.friends[0].address.city.should == "Cityville"
+  end
+  
+  it "should convert NestedOpenStruct values to hashes when dumping" do
+    p = MongoThing::NestedOpenStruct.new(@person_hash)
+    p.marshal_dump.should == @person_hash
+  end
+  
+  it "should respond identically to marshal_dump and to_hash" do
+    p = MongoThing::NestedOpenStruct.new(@person_hash)
+    p.marshal_dump.should == p.to_hash
+  end
+end

data/spec/integration/mongo_thing_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+# Connection is established in spec_helper
+describe MongoThing do
+  describe "connection" do
+    it "should set the connection given a hash" do
+      MongoThing.connection.host.should == "localhost"
+      MongoThing.connection.size.should == 1
+    end
+    
+    it "should set the database when a name is given in connection settings" do
+      MongoThing.db.should be_a Mongo::DB
+    end
+  end  
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--format progress
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :development)
+require "mongo_thing"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+MODELS = File.join(File.dirname(__FILE__), "models")
+$LOAD_PATH.unshift(MODELS)
+
+
+Dir[ File.join(MODELS, "*.rb") ].sort.each { |file| require File.basename(file) }
+
+Spec::Runner.configure do |config|
+  config.before :suite do
+    connect_to_test_database
+  end
+  
+  config.after(:each) do
+    MongoThing.db.collections.each(&:remove)
+  end
+  
+  config.after :suite do
+    MongoThing.db.collections.each(&:drop)
+  end
+end
+
+# This is probably a very naive way to do thsi
+def connect_to_test_database
+  config = File.read(File.join(File.dirname(__FILE__), 'config', 'mongoid.yml'))
+  settings = YAML.load(ERB.new(config).result)
+  MongoThing.connection = settings[:test] unless MongoThing.connection
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: mongo_thing
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Daniel Higginbotham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-09 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: mongo
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  name: bson
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  requirement: *id002
+  prerelease: false
+description: 
+email: daniel@flyingmachinestudios.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .bundle/config
+- .gitignore
+- Gemfile
+- MIT_LICENSE
+- Rakefile
+- VERSION
+- lib/mongo_thing.rb
+- lib/mongo_thing/cursor.rb
+- lib/mongo_thing/document.rb
+- lib/mongo_thing/named_scope.rb
+- lib/mongo_thing/nested_ostruct.rb
+- lib/mongo_thing/railtie.rb
+- lib/mongo_thing/railties/database.rake
+- mongo_thing.gemspec
+- spec/config/mongoid.yml
+- spec/integration/mongo_thing/document_spec.rb
+- spec/integration/mongo_thing/nested_ostruct_spec.rb
+- spec/integration/mongo_thing_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: ODM framework for MongoDB
+test_files: 
+- spec/integration/mongo_thing/document_spec.rb
+- spec/integration/mongo_thing/nested_ostruct_spec.rb
+- spec/integration/mongo_thing_spec.rb
+- spec/spec_helper.rb