jnunemaker-mongomapper 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/History

@@ -0,0 +1,2 @@
+0.1.0 6/26/2009
+* Initial release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 John Nunemaker
+
+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/README.rdoc

@@ -0,0 +1,25 @@
+= MongoMapper
+
+Awesome gem for modeling your domain and storing it in mongo.
+
+== Dependencies
+
+* ActiveSupport (activesupport)
+* Mongo Ruby Driver (mongodb-mongo)
+* My fork of the validatable gem (jnunemaker-validatable)
+
+== Documentation
+
+http://rdoc.info/projects/jnunemaker/mongomapper
+
+== More Info
+
+You can learn more about mongo here:
+http://www.mongodb.org/
+
+You can learn more about the mongo ruby driver here:
+http://github.com/mongodb/mongo-ruby-driver/tree/master
+
+== Copyright
+
+Copyright (c) 2009 John Nunemaker. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,72 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "mongomapper"
+    gem.summary = %Q{Awesome gem for modeling your domain and storing it in mongo}
+    gem.email = "nunemaker@gmail.com"
+    gem.homepage = "http://github.com/jnunemaker/mongomapper"
+    gem.authors = ["John Nunemaker"]
+    gem.rubyforge_project = "mongomapper"
+    
+    gem.add_dependency('activesupport')
+    gem.add_dependency('mongodb-mongo')
+    gem.add_dependency('jnunemaker-validatable')
+    
+    gem.add_development_dependency('mocha')
+    gem.add_development_dependency('jnunemaker-matchy', '0.4.0')
+    gem.add_development_dependency('thoughtbot-quietbacktrace')
+  end
+
+  Jeweler::RubyforgeTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "MongoMapper #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/mongomapper/document.rb

@@ -0,0 +1,234 @@
+module MongoMapper  
+  module Document
+    def self.included(model)
+      model.class_eval do
+        include MongoMapper::EmbeddedDocument
+        include InstanceMethods
+        include SaveWithValidation
+        include RailsCompatibility
+        extend ClassMethods
+        
+        key :_id, String
+        key :created_at, Time
+        key :updated_at, Time
+      end
+    end
+    
+    module ClassMethods
+      def find(*args)
+        options = args.extract_options!
+        
+        case args.first
+          when :first then find_first(options)
+          when :last  then find_last(options)
+          when :all   then find_every(options)
+          else             find_from_ids(args)
+        end
+      end
+      
+      def first(options={})
+        find_first(options)
+      end
+      
+      def last(options={})
+        find_last(options)
+      end
+      
+      def all(options={})
+        find_every(options)
+      end
+      
+      def find_by_id(id)
+        if doc = collection.find_first({:_id => id})
+          new(doc)
+        end
+      end
+      
+      # TODO: remove the rescuing when ruby driver works correctly
+      def count(conditions={})
+        collection.count(conditions)
+      rescue => exception
+        if exception.message =~ /Error with count command/
+          0
+        else
+          raise exception
+        end
+      end
+      
+      def create(*docs)
+        instances = []
+        docs.flatten.each { |attrs| instances << new(attrs).save }
+        instances.size == 1 ? instances[0] : instances
+      end
+      
+      # For updating single document
+      #   Person.update(1, {:foo => 'bar'})
+      #
+      # For updating multiple documents at once:
+      #   Person.update({'1' => {:foo => 'bar'}, '2' => {:baz => 'wick'}}) 
+      def update(*args)
+        updating_multiple = args.length == 1
+        if updating_multiple
+          update_multiple(args[0])
+        else
+          id, attributes = args
+          update_single(id, attributes)
+        end
+      end
+      
+      def delete(*ids)
+        collection.remove(:_id => {'$in' => ids.flatten})
+      end
+      
+      def delete_all(conditions={})
+        collection.remove(conditions)
+      end
+      
+      def destroy(*ids)
+        find_some(ids.flatten).each(&:destroy)
+      end
+      
+      def destroy_all(conditions={})
+        find(:all, :conditions => conditions).each(&:destroy)
+      end
+      
+      def connection(mongo_connection=nil)
+        if mongo_connection.nil?
+          @connection ||= MongoMapper.connection
+        else
+          @connection = mongo_connection
+        end
+        @connection
+      end
+      
+      def database(name=nil)
+        if name.nil?
+          @database ||= MongoMapper.database
+        else
+          @database = connection.db(name)
+        end
+        @database
+      end
+      
+      def collection(name=nil)
+        if name.nil?
+          @collection ||= database.collection(self.to_s.demodulize.tableize)
+        else
+          @collection = database.collection(name)
+        end
+        @collection
+      end
+      
+    private
+      def find_every(options)
+        criteria, options = FinderOptions.new(options).to_a
+        collection.find(criteria, options).to_a.map { |doc| new(doc) }
+      end
+
+      def find_first(options)
+        find_every(options.merge(:limit => 1, :order => 'created_at')).first
+      end
+
+      def find_last(options)
+        find_every(options.merge(:limit => 1, :order => 'created_at desc')).first
+      end
+
+      def find_some(ids)
+        documents = find_every(:conditions => {'_id' => ids})
+        if ids.size == documents.size
+          documents
+        else
+          raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
+        end
+      end
+
+      def find_from_ids(*ids)
+        ids = ids.flatten.compact.uniq
+
+        case ids.size
+          when 0
+            raise(DocumentNotFound, "Couldn't find without an ID")
+          when 1
+            find_by_id(ids[0]) || raise(DocumentNotFound, "Document with id of #{ids[0]} does not exist in collection named #{collection.name}")
+          else
+            find_some(ids)
+        end
+      end
+      
+      def update_single(id, attrs)
+        if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+          raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+        end
+        
+        find(id).update_attributes(attrs)
+      end
+      
+      def update_multiple(docs)
+        unless docs.is_a?(Hash)
+          raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+        end
+        instances = []
+        docs.each_pair { |id, attrs| instances << update(id, attrs) }
+        instances
+      end
+    end
+    
+    module InstanceMethods
+      def collection
+        self.class.collection
+      end
+    
+      def new?
+        read_attribute('_id').blank? || self.class.find_by_id(id).blank?
+      end
+        
+      def save
+        run_callbacks(:before_save)
+        new? ? create : update
+        run_callbacks(:after_save)
+        self
+      end
+    
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        save
+      end
+    
+      def destroy
+        run_callbacks(:before_destroy)
+        collection.remove(:_id => id) unless new?
+        run_callbacks(:after_destroy)
+        freeze
+      end
+    
+      def ==(other)
+        other.is_a?(self.class) && id == other.id
+      end
+    
+    private
+      def create
+        write_attribute('_id', generate_id) if read_attribute('_id').blank?
+        update_timestamps
+        run_callbacks(:before_create)
+        collection.insert(attributes.merge!(embedded_association_attributes))
+        run_callbacks(:after_create)
+      end
+    
+      def update
+        update_timestamps
+        run_callbacks(:before_update)
+        collection.modify({:_id => id}, attributes.merge!(embedded_association_attributes))
+        run_callbacks(:after_update)
+      end
+    
+      def update_timestamps
+        write_attribute('created_at', Time.now.utc) if new?
+        write_attribute('updated_at', Time.now.utc)
+      end
+    
+      def generate_id
+        XGen::Mongo::Driver::ObjectID.new
+      end
+    end
+  end # Document
+end # MongoMapper

data/lib/mongomapper/embedded_document.rb

@@ -0,0 +1,260 @@
+module MongoMapper
+  module EmbeddedDocument
+    class NotImplemented < StandardError; end
+    
+    def self.included(model)
+      model.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+        include Validatable
+        include ActiveSupport::Callbacks
+        include MongoMapper::Serialization
+        
+        define_callbacks  :before_validation_on_create, :before_validation_on_update,
+                          :before_validation,           :after_validation,
+                          :before_create,               :after_create, 
+                          :before_update,               :after_update,
+                          :before_save,                 :after_save,
+                          :before_destroy,              :after_destroy
+      end
+    end
+    
+    module ClassMethods
+      class Association
+        attr_accessor :name
+        
+        def initialize(name)
+          @name = name.to_s
+        end
+        
+        def klass
+          @klass ||= name.classify.constantize
+        end
+        
+        def ivar
+          @ivar ||= "@#{name}"
+        end
+      end
+      
+      def many(association_name)
+        association = Association.new(association_name)
+        associations[association.name] = association
+        class_eval <<-EOS
+          def #{association.name}
+            #{association.ivar} ||= []
+            #{association.ivar}
+          end
+        EOS
+      end
+      
+      def associations
+        @associations ||= HashWithIndifferentAccess.new
+      end
+      
+      def keys
+        @keys ||= HashWithIndifferentAccess.new
+      end
+      
+      def key(name, type, options={})
+        key = Key.new(name, type, options)
+        keys[key.name] = key
+        apply_validations_for(key)
+        define_embedded_document_accessors_for(key)
+        create_indexes_for(key)
+        key
+      end
+      
+      # TODO: remove to_s when ruby driver supports symbols (I sent patch)
+      def ensure_index(name_or_array, options={})
+        keys_to_index = if name_or_array.is_a?(Array)
+          name_or_array.map { |pair| [pair[0].to_s, pair[1]] }
+        else
+          name_or_array.to_s
+        end
+        
+        collection.create_index(keys_to_index, options.delete(:unique))
+      end
+      
+    private
+      def define_embedded_document_accessors_for(key)
+        return unless key.embedded_document?
+        instance_var = "@#{key.name}"
+        
+        define_method(key.name) do
+          key.get(instance_variable_get(instance_var))
+        end
+        
+        define_method("#{key.name}=") do |value|
+          instance_variable_set(instance_var, key.get(value))
+        end
+      end
+      
+      def create_indexes_for(key)
+        ensure_index key.name if key.options[:index]
+      end
+      
+      def apply_validations_for(key)
+        attribute = key.name.to_sym
+
+        if key.options[:required]
+          validates_presence_of(attribute)
+        end
+
+        if key.options[:numeric]
+          number_options = key.type == Integer ? {:only_integer => true} : {}
+          validates_numericality_of(attribute, number_options)
+        end
+
+        if key.options[:format]
+          validates_format_of(attribute, :with => key.options[:format])
+        end
+
+        if key.options[:length]
+          length_options = case key.options[:length]
+          when Integer
+            {:minimum => 0, :maximum => key.options[:length]}
+          when Range
+            {:within => key.options[:length]}
+          when Hash
+            key.options[:length]
+          end
+          validates_length_of(attribute, length_options)
+        end
+      end
+
+    end                                 
+                                        
+    module InstanceMethods
+      def initialize(attrs={})
+        initialize_embedded_associations(attrs)
+        self.attributes = attrs
+      end
+      
+      def attributes=(attrs)
+        attrs.each_pair do |key_name, value|
+          write_attribute(key_name, value) if writer?(key_name)
+        end
+      end
+    
+      def attributes
+        self.class.keys.inject(HashWithIndifferentAccess.new) do |attributes, key_hash|
+          name, key = key_hash
+          value = value_for_key(key)
+          attributes[name] = value unless value.nil?
+          attributes
+        end
+      end
+    
+      def reader?(name)
+        defined_key_names.include?(name.to_s)
+      end
+    
+      def writer?(name)
+        name = name.to_s
+        name = name.chop if name.ends_with?('=')
+        reader?(name)
+      end
+    
+      def before_typecast_reader?(name)
+        name.to_s.match(/^(.*)_before_typecast$/) && reader?($1)
+      end
+    
+      def [](name)
+        read_attribute(name)
+      end
+    
+      def []=(name, value)
+        write_attribute(name, value)
+      end
+    
+      def id
+        read_attribute('_id')
+      end
+    
+      def method_missing(method, *args, &block)
+        attribute = method.to_s
+        
+        if reader?(attribute)
+          read_attribute(attribute)
+        elsif writer?(attribute)
+          write_attribute(attribute.chop, args[0])
+        elsif before_typecast_reader?(attribute)
+          read_attribute_before_typecast(attribute.gsub(/_before_typecast$/, ''))
+        else
+          super
+        end
+      end
+    
+      def ==(other)
+        other.is_a?(self.class) && attributes == other.attributes
+      end
+      
+      def inspect
+        attributes_as_nice_string = defined_key_names.collect do |name|
+          "#{name}: #{read_attribute(name)}"
+        end.join(", ")
+        "#<#{self.class} #{attributes_as_nice_string}>"
+      end
+    
+      def respond_to?(method, include_private=false)
+        return true if reader?(method) || writer?(method) || before_typecast_reader?(method)
+        super
+      end
+      
+    private      
+      def value_for_key(key)
+        if key.native?
+          read_attribute(key.name)
+        else
+          embedded_document = read_attribute(key.name)
+          embedded_document && embedded_document.attributes
+        end
+      end
+      
+      def read_attribute(name)
+        defined_key(name).get(instance_variable_get("@#{name}"))
+      end
+  
+      def read_attribute_before_typecast(name)
+        instance_variable_get("@#{name}_before_typecast")
+      end
+    
+      def write_attribute(name, value)
+        instance_variable_set "@#{name}_before_typecast", value
+        instance_variable_set "@#{name}", defined_key(name).set(value)
+      end
+
+      def defined_key(name)
+        self.class.keys[name]
+      end
+  
+      def defined_key_names
+        self.class.keys.keys
+      end
+  
+      def only_defined_keys(hash={})
+        defined_key_names = defined_key_names()
+        hash.delete_if { |k, v| !defined_key_names.include?(k.to_s) }
+      end
+      
+      def embedded_association_attributes
+        attributes = HashWithIndifferentAccess.new
+        self.class.associations.each_pair do |name, association|
+          attributes[name] = send(name).collect { |item| item.attributes }
+        end
+        attributes
+      end
+      
+      def initialize_embedded_associations(attrs={})
+        self.class.associations.each_pair do |name, association|
+          if collection = attrs.delete(name)
+            association_value = collection.collect do |item|
+              association.klass.new(item)
+            end
+            instance_variable_set(association.ivar, association_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongomapper/finder_options.rb

@@ -0,0 +1,79 @@
+module MongoMapper
+  class FinderOptions
+    attr_reader :options
+    
+    def initialize(options)
+      raise ArgumentError, "FinderOptions must be a hash" unless options.is_a?(Hash)
+      @options = options.symbolize_keys
+      @conditions = @options.delete(:conditions) || {}
+    end
+    
+    def criteria
+      convert_conditions(@conditions.dup)
+    end
+    
+    def options
+      convert_options(@options.dup)
+    end
+    
+    def to_a
+      [criteria, options]
+    end
+    
+    private
+      def convert_conditions(conditions)
+        criteria = {}
+        conditions.each_pair do |field, value|
+          case value
+            when Array
+              criteria[field] = {'$in' => value}
+            when Hash
+              criteria[field] = convert_conditions(value)
+            else
+              criteria[field] = value
+          end
+        end
+        
+        criteria
+      end
+      
+      def convert_options(options)
+        {
+          :fields => convert_fields(options.delete(:fields) || options.delete(:select)),
+          :offset => (options.delete(:offset) || 0).to_i,
+          :limit  => (options.delete(:limit) || 0).to_i,
+          :sort   => convert_sort(options.delete(:order))
+        }
+      end
+      
+      def convert_fields(fields)
+        return if fields.blank?
+        
+        if fields.is_a?(String)
+          fields.split(',').map { |field| field.strip }
+        else
+          fields.flatten.compact
+        end
+      end
+      
+      def convert_sort(sort)
+        return if sort.blank?
+        pieces = sort.split(',')
+        pairs  = pieces.map { |s| convert_sort_piece(s) }
+        
+        hash = OrderedHash.new
+        pairs.each do |pair|
+          field, sort_direction = pair
+          hash[field] = sort_direction
+        end
+        hash.symbolize_keys
+      end
+      
+      def convert_sort_piece(str)
+        field, direction = str.strip.split(' ')
+        direction ||= 'ASC'
+        direction = direction.upcase == 'ASC' ? 1 : -1
+        [field, direction]
+      end
+  end
+end