mongomodel 0.1

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2010 Sam Pohlenz
+
+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.md

@@ -0,0 +1,34 @@
+MongoModel
+==========
+
+MongoModel is a Ruby ORM for interfacing with [MongoDB](http://www.mongodb.org/) databases.
+
+
+Installation
+============
+
+MongoModel is distributed as a gem. Install with:
+
+    gem install mongomodel
+
+
+Sample Usage
+============
+
+    require 'mongomodel'
+    
+    MongoModel.configuration = { 'host' => 'localhost', 'database' => 'mydb' }
+    
+    class Article < MongoModel::Document
+      property :title, String, :default => 'Untitled'
+      property :body, String
+      property :published_at, Time, :protected => true
+      property :approved, Boolean, :default => false, :protected => true
+      
+      timestamps!
+      
+      validates_presence_of :title, :body
+      
+      belongs_to :author, :class => User
+    end
+    

data/Rakefile

@@ -0,0 +1,47 @@
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs << 'lib'
+  t.spec_opts = ['--options', "#{File.expand_path(File.dirname(__FILE__))}/spec/spec.opts"]
+end
+
+namespace :spec do
+  desc "Run specs in nested documenting format"
+  Spec::Rake::SpecTask.new(:doc) do |t|
+    t.libs << 'lib'
+    t.spec_opts = ['--options', "#{File.expand_path(File.dirname(__FILE__))}/spec/specdoc.opts"]
+  end
+end
+
+desc "Generate documentation"
+Rake::RDocTask.new(:doc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('lib')
+end
+
+begin
+  require 'jeweler'
+  require File.dirname(__FILE__) + "/lib/mongomodel/version"
+  
+  Jeweler::Tasks.new do |gem|
+    gem.name = "mongomodel"
+    gem.summary = "MongoDB ORM for Ruby/Rails"
+    gem.description = "MongoModel is a MongoDB ORM for Ruby/Rails similar to ActiveRecord, DataMapper."
+    gem.email = "sam@sampohlenz.com"
+    gem.homepage = "http://github.com/spohlenz/mongomodel"
+    gem.authors = ["Sam Pohlenz"]
+    gem.version = MongoModel::VERSION
+
+    gem.add_dependency('activesupport', '>= 3.0.pre')
+    gem.add_dependency('activemodel', '>= 3.0.pre')
+    gem.add_dependency('mongo', '>= 0.18.3')
+  end
+  
+  Jeweler::GemcutterTasks.new  
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/bin/console

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+puts "Loading MongoModel sandbox..."
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'irb'
+require 'irb/completion'
+
+require 'mongomodel'
+
+IRB.setup(nil)
+
+IRB.conf[:USE_READLINE] = true
+IRB.conf[:PROMPT_MODE] = :SIMPLE
+
+irb = IRB::Irb.new
+
+IRB.conf[:MAIN_CONTEXT] = irb.context
+
+examples = <<-EXAMPLES
+  
+  class Article < MongoModel::Document
+    property :title, String
+    property :published, Boolean, :default => false
+    
+    timestamps!
+    
+    default_scope :order => :title.asc
+    
+    named_scope :published, :conditions => { :published => true }
+    named_scope :latest, lambda { |num| { :limit => num, :order => 'created_at DESC' } }
+  end
+  
+EXAMPLES
+
+puts examples
+irb.context.evaluate(examples, 0)
+
+trap("SIGINT") do
+  irb.signal_handle
+end
+catch(:IRB_EXIT) do
+  irb.eval_input
+end

data/lib/mongomodel.rb

@@ -0,0 +1,92 @@
+require 'active_support'
+require 'active_model'
+
+require 'mongo'
+
+require 'mongomodel/support/core_extensions'
+require 'mongomodel/support/exceptions'
+require 'mongomodel/version'
+
+require 'active_support/core_ext/module/attribute_accessors'
+
+module MongoModel
+  autoload :Document,         'mongomodel/document'
+  autoload :EmbeddedDocument, 'mongomodel/embedded_document'
+  
+  autoload :Properties,       'mongomodel/concerns/properties'
+  autoload :Attributes,       'mongomodel/concerns/attributes'
+  autoload :AttributeMethods, 'mongomodel/concerns/attribute_methods'
+  autoload :Associations,     'mongomodel/concerns/associations'
+  autoload :Validations,      'mongomodel/concerns/validations'
+  autoload :Callbacks,        'mongomodel/concerns/callbacks'
+  autoload :Logging,          'mongomodel/concerns/logging'
+  autoload :Timestamps,       'mongomodel/concerns/timestamps'
+  autoload :PrettyInspect,    'mongomodel/concerns/pretty_inspect'
+  autoload :RecordStatus,     'mongomodel/concerns/record_status'
+  autoload :AbstractClass,    'mongomodel/concerns/abstract_class'
+  autoload :ActiveModelCompatibility, 'mongomodel/concerns/activemodel'
+  
+  autoload :MongoOptions,     'mongomodel/support/mongo_options'
+  autoload :MongoOrder,       'mongomodel/support/mongo_options'
+  autoload :MongoOperator,    'mongomodel/support/mongo_options'
+  autoload :Types,            'mongomodel/support/types'
+  autoload :Configuration,    'mongomodel/support/configuration'
+  
+  autoload :Collection,       'mongomodel/support/collection'
+  
+  module AttributeMethods
+    autoload :Read,           'mongomodel/concerns/attribute_methods/read'
+    autoload :Write,          'mongomodel/concerns/attribute_methods/write'
+    autoload :Query,          'mongomodel/concerns/attribute_methods/query'
+    autoload :BeforeTypeCast, 'mongomodel/concerns/attribute_methods/before_type_cast'
+    autoload :Protected,      'mongomodel/concerns/attribute_methods/protected'
+    autoload :Dirty,          'mongomodel/concerns/attribute_methods/dirty'
+  end
+  
+  module Attributes
+    autoload :Store,          'mongomodel/attributes/store'
+    autoload :Typecasting,    'mongomodel/attributes/typecasting'
+    autoload :Mongo,          'mongomodel/attributes/mongo'
+  end
+  
+  module Associations
+    module Base
+      autoload :Definition,   'mongomodel/concerns/associations/base/definition'
+      autoload :Association,  'mongomodel/concerns/associations/base/association'
+      autoload :Proxy,        'mongomodel/concerns/associations/base/proxy'
+    end
+    
+    autoload :BelongsTo,           'mongomodel/concerns/associations/belongs_to'
+    autoload :HasManyByIds,        'mongomodel/concerns/associations/has_many_by_ids'
+    autoload :HasManyByForeignKey, 'mongomodel/concerns/associations/has_many_by_foreign_key'
+  end
+  
+  module DocumentExtensions
+    autoload :Persistence,       'mongomodel/document/persistence'
+    autoload :OptimisticLocking, 'mongomodel/document/optimistic_locking'
+    autoload :Finders,           'mongomodel/document/finders'
+    autoload :DynamicFinders,    'mongomodel/document/dynamic_finders'
+    autoload :Indexes,           'mongomodel/document/indexes'
+    autoload :Scopes,            'mongomodel/document/scopes'
+    autoload :Scope,             'mongomodel/document/scopes'
+    autoload :Validations,       'mongomodel/document/validations'
+    autoload :Callbacks,         'mongomodel/document/callbacks'
+  end
+  
+  mattr_accessor :logger
+  
+  def self.configuration
+    @_configuration ||= Configuration.defaults
+  end
+  
+  def self.configuration=(config)
+    @_database = nil
+    @_configuration = Configuration.new(config)
+  end
+  
+  def self.database
+    @_database ||= configuration.establish_connection
+  end
+end
+
+I18n.load_path << File.dirname(__FILE__) + '/mongomodel/locale/en.yml'

data/lib/mongomodel/attributes/mongo.rb

@@ -0,0 +1,40 @@
+module MongoModel
+  module Attributes
+    module Mongo
+      def to_mongo
+        inject({}) do |result, (k, v)|
+          property = properties[k]
+          
+          if property
+            result[property.as] = property.to_mongo(v)
+          else
+            converter = Types.converter_for(v.class)
+            result[k.to_s] = converter.to_mongo(v)
+          end
+          
+          result
+        end
+      end
+      
+      def from_mongo!(hash)
+        hash.each do |k, v|
+          property = properties_as[k.to_s]
+          
+          if property
+            self[property.name] = property.from_mongo(v)
+          else
+            self[k.to_sym] = v
+          end
+        end
+      end
+    
+    private
+      def properties_as
+        @properties_as ||= properties.inject({}) do |result, (name, property)|
+          result[property.as] = property
+          result
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/attributes/store.rb

@@ -0,0 +1,30 @@
+require 'active_support/core_ext/module/delegation'
+
+module MongoModel
+  module Attributes
+    class Store < ActiveSupport::OrderedHash
+      include Typecasting
+      include Mongo
+      
+      attr_reader :instance
+      delegate :properties, :to => :instance
+      
+      def initialize(instance)
+        super()
+        @instance = instance
+        set_defaults!
+      end
+      
+      def inspect
+        "{#{map { |k, v| "#{k.inspect}=>#{v.inspect}"}.join(', ')}}"
+      end
+    
+    private
+      def set_defaults!
+        properties.each do |name, property|
+          self[name] = property.default(instance)
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/attributes/typecasting.rb

@@ -0,0 +1,51 @@
+module MongoModel
+  module Attributes
+    module Typecasting
+      def []=(key, value)
+        values_before_typecast[key] = value
+        super(key, typecast(key, value))
+      end
+      
+      # Check if key has a value that typecasts to true.
+      #
+      # attributes = Attributes::Store.new(:comments_count => Property.new(:comments_count, Integer))
+      #
+      # attributes[:comments_count] = 0
+      # attributes.has?(:comments_count)
+      # => false
+      #
+      # attributes[:comments_count] = 1
+      # attributes.has?(:comments_count)
+      # => true
+      #
+      def has?(key)
+        value = self[key]
+        boolean_typecast(key, value)
+      end
+      
+      def before_type_cast(key)
+        values_before_typecast[key]
+      end
+    
+    private
+      def typecast(key, value)
+        unless value.nil?
+          property = properties[key]
+          property ? property.cast(value) : value
+        end
+      end
+      
+      def boolean_typecast(key, value)
+        if property = properties[key]
+          value ? property.boolean(value) : false
+        else
+          !!value
+        end
+      end
+      
+      def values_before_typecast
+        @values_before_typecast ||= {}
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/abstract_class.rb

@@ -0,0 +1,17 @@
+module MongoModel
+  module AbstractClass
+    extend ActiveSupport::Concern
+    
+    def inherited(subclass)
+      subclass.abstract_class = false
+    end
+    
+    module ClassMethods
+      attr_accessor :abstract_class
+      
+      def abstract_class?
+        abstract_class == true
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/activemodel.rb

@@ -0,0 +1,11 @@
+module MongoModel
+  module ActiveModelCompatibility
+    extend ActiveSupport::Concern
+    
+    include ActiveModel::Conversion
+    
+    module ClassMethods
+      include ActiveModel::Naming
+    end
+  end
+end

data/lib/mongomodel/concerns/associations.rb

@@ -0,0 +1,103 @@
+module MongoModel
+  module Associations
+    extend ActiveSupport::Concern
+    
+    def associations
+      @_associations ||= self.class.associations.inject({}) do |result, (name, association)|
+        result[name] = association.for(self)
+        result
+      end
+    end
+    
+    module ClassMethods
+      def belongs_to(name, options={})
+        associations[name] = create_association(BelongsTo, name, options)
+      end
+      
+      def has_many(name, options={})
+        associations[name] = create_association(has_many_type(options), name, options)
+      end
+    
+      def associations
+        read_inheritable_attribute(:associations) || write_inheritable_attribute(:associations, {})
+      end
+    
+    private
+      def has_many_type(options)
+        case options[:by]
+        when :ids
+          HasManyByIds
+        when :foreign_key
+          HasManyByForeignKey
+        else
+          ancestors.include?(Document) ? HasManyByForeignKey : HasManyByIds
+        end
+      end
+      
+      def create_association(type, name, options={})
+        type.new(self, name, options).define!
+      end
+    end
+  end
+end
+
+
+
+#
+# belongs_to :user
+#    => property :user_id
+# belongs_to :author, :class_name => 'User'
+#    => property :author_id
+# belongs_to :commentable, :polymorphic => true
+#    => property :commentable_id
+#    => property :commentable_type
+#
+
+#
+# has_many :contributors, :class_name => 'User', :foreign_key => :publication_id
+# has_many :comments, :as => :commentable
+# has_many :roles
+#
+
+
+
+
+#
+# Documents and EmbeddedDocuments can:
+#   - belong to any Document
+#   - have many Documents by ids
+#
+# Documents can also:
+#   - have many Documents by foreign key
+#
+
+# class Author < Document; end
+# 
+# class Comment < Document
+#   # Creates properties :commentable_id and :commentable_type
+#   belongs_to :commentable, :polymorphic => true
+# end
+# 
+# class Page < EmbeddedDocument
+#   # Creates property :editor_id
+#   belongs_to :editor, :class => 'Author'
+#   
+#   # Creates property :related_article_ids
+#   has_many :related_articles, :class => 'Article'
+#   
+#   # Polymorphic association, uses commentable_id/commentable_type on Comment class
+#   has_many :comments, :as => :commentable
+# end
+# 
+# class Article < Document
+#   # Creates property :author_id
+#   belongs_to :author
+#   
+#   # Creates property :recommended_by_ids
+#   has_many :recommended_by, :by => :ids, :class => 'Author'
+#   
+#   # Creates property :parent_article_id
+#   belongs_to :parent_article, :class => 'Article'
+#   # Uses parent_article_id property on referenced class
+#   has_many :child_articles, :by => :foreign_key, :foreign_key => :parent_article_id, :class => 'Article'
+# end