mongodoc 0.0.0

data/features/support/support.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require 'cucumber'
+require 'spec/expectations'
+require 'spec/bson_matchers'
+require 'mongodoc'
+require File.join(File.dirname(__FILE__), '..', '..', 'spec', 'test_classes')
+require File.join(File.dirname(__FILE__), '..', '..', 'spec', 'test_documents')
+
+World(BsonMatchers)

data/lib/mongodoc.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+
+gem 'mongo', '0.16'
+gem 'durran-validatable', '1.8.2'
+
+require 'mongo'
+require 'activesupport'
+require 'validatable'
+
+module MongoDoc
+  VERSION = '0.1'
+  
+  class NoConnectionError < RuntimeError; end
+  class NoDatabaseError < RuntimeError; end
+end
+
+require 'mongodoc/base'

data/lib/mongodoc/attributes.rb

@@ -0,0 +1,97 @@
+require 'mongodoc/proxy'
+require 'mongodoc/parent_proxy'
+
+module MongoDoc
+  module Document
+    module Attributes
+      def self.extended(klass)
+        klass.class_inheritable_array :_keys
+        klass._keys = []
+        klass.class_inheritable_array :_associations
+        klass._associations = []
+
+        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          attr_accessor :_parent
+
+          def _root
+            @_root
+          end
+
+          def _root=(root)
+            @_root = root
+            _associations.each do|a|
+              association = send(a)
+              association._root = root if association
+            end
+          end
+
+          def path_to_root(prev)
+            return prev unless _parent
+            _parent.path_to_root(prev)
+          end
+        RUBY
+      end
+
+      def _attributes
+        _keys + _associations
+      end
+
+      def key(*args)
+        args.each do |name|
+          _keys << name unless _keys.include?(name)
+          attr_accessor name
+        end
+      end
+
+      def has_one(*args)
+        args.each do |name|
+          _associations << name unless _associations.include?(name)
+          attr_reader name
+
+          define_method("#{name}=") do |value|
+            if value
+              raise NotADocumentError unless Document === value
+              value._parent = ParentProxy.new(self, name)
+              value._root = _root || self
+            end
+            instance_variable_set("@#{name}", value)
+          end
+
+          validates_associated name
+        end
+      end
+
+      def has_many(*args)
+        options = args.extract_options!
+        collection_class = if class_name = options.delete(:class_name)
+          type_name_with_module(class_name).constantize
+        end
+
+        args.each do |name|
+          _associations << name unless _associations.include?(name)
+
+          define_method("#{name}") do
+            association = instance_variable_get("@#{name}")
+            unless association
+              association = Proxy.new(:root => _root || self, :parent => self, :assoc_name => name, :collection_class => collection_class || self.class.type_name_with_module(name.to_s.classify).constantize)
+              instance_variable_set("@#{name}", association)
+            end
+            association
+          end
+
+          validates_associated name
+
+          define_method("#{name}=") do |array|
+            proxy = send("#{name}")
+            proxy.clear
+            proxy << array
+          end
+        end
+      end
+
+      def type_name_with_module(type_name)
+        (/^::/ =~ type_name) ? type_name : "#{parents}::#{type_name}"
+      end
+    end
+  end
+end

data/lib/mongodoc/base.rb

@@ -0,0 +1,163 @@
+require 'mongodoc/bson'
+require 'mongodoc/connection'
+require 'mongodoc/value_equals'
+require 'mongodoc/query'
+require 'mongodoc/attributes'
+
+module MongoDoc
+  module Document
+    class DocumentInvalidError < RuntimeError; end
+    class NotADocumentError < RuntimeError; end
+
+    def self.included(klass)
+      klass.instance_eval do
+        extend MongoDoc::Document::Attributes
+        extend MongoDoc::Document::BSONCreate
+        include MongoDoc::Document::ToBSON
+        include MongoDoc::Document::ValueEquals
+        include MongoDoc::Document::Identity
+        include Validatable
+      end
+    end
+
+    module ValueEquals
+      def ==(other)
+        return false unless self.class === other
+        self.class._attributes.all? {|var| self.send(var) == other.send(var)}
+      end
+    end
+    
+    module Identity
+      attr_accessor :_id
+      alias :id :_id
+      alias :to_param :_id
+
+      def new_record?
+        _id.nil?
+      end
+    end
+    
+    module ToBSON
+      def to_bson(*args)
+        {MongoDoc::BSON::CLASS_KEY => self.class.name}.tap do |bson_hash|
+          bson_hash['_id'] = _id unless _id.nil?
+          self.class._attributes.each do |name|
+            bson_hash[name.to_s] = send(name).to_bson(args)
+          end
+        end
+      end
+    end
+    
+    module BSONCreate
+      def bson_create(bson_hash, options = {})
+        new.tap do |obj|
+          bson_hash.each do |name, value|
+            obj.send("#{name}=", MongoDoc::BSON.decode(value, options))
+          end
+        end
+      end
+    end
+  end
+
+  class Base
+    include MongoDoc::Document
+
+    def attributes=(attrs)
+      attrs.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def initialize(attrs = {})
+      self.attributes = attrs
+    end
+
+    def save(validate = true)
+      return _root.save(validate) if _root
+      unless validate and not valid?
+        _save(false)
+      else
+        false
+      end
+    end
+    
+    def save!
+      return _root.save! if _root
+      if valid?
+        _save(true)
+      else
+        raise DocumentInvalidError
+      end
+    end
+
+    def update_attributes(attrs)
+      self.attributes = attrs
+      return false unless valid?
+      _propose_update_attributes(self, path_to_root(attrs), false)
+    end
+
+    def update_attributes!(attrs)
+      self.attributes = attrs
+      if valid?
+        _propose_update_attributes(self, path_to_root(attrs), true)
+      else
+        raise DocumentInvalidError
+      end
+    end
+
+    def self.collection_name
+      self.to_s.tableize.gsub('/', '.')
+    end
+
+    def self.collection
+      MongoDoc.database.collection(collection_name)
+    end
+
+    def self.count
+      collection.count
+    end
+
+    def self.create(attrs = {}, safe = false)
+      instance = new(attrs)
+      instance.valid? and _create(instance, false)
+    end
+    
+    def self.create!(attrs = {})
+      instance = new(attrs)
+      if instance.valid?
+        _create(instance, true)
+      else
+        raise DocumentInvalidError
+      end
+    end
+
+    def self.find_one(id)
+      MongoDoc::BSON.decode(collection.find_one(id))
+    end
+
+    protected
+
+    def _propose_update_attributes(src, attrs, safe)
+      if _parent
+        _parent.send(:_propose_update_attributes, src, attrs, safe)
+      else
+        _update_attributes(attrs, safe)
+      end
+    end
+
+    def _save(safe)
+      self._id = self.class.collection.save(self.to_bson, :safe => safe)
+    end
+
+    def _update_attributes(attrs,  safe)
+      self.class.collection.update({'_id' => self._id}, MongoDoc::Query.set_modifier(attrs.to_bson), :safe => safe)
+      result = MongoDoc.database.db_command({'getlasterror' => 1})
+      return (result and result.has_key?('updatedExisting') and result['updatedExisting'])
+    end
+
+    def self._create(instance, safe)
+      instance._id = collection.insert(instance.to_bson, :safe => safe)
+      instance
+    end
+  end
+end

data/lib/mongodoc/bson.rb

@@ -0,0 +1,45 @@
+require 'mongodoc/ext/array'
+require 'mongodoc/ext/binary'
+require 'mongodoc/ext/boolean_class'
+require 'mongodoc/ext/date'
+require 'mongodoc/ext/date_time'
+require 'mongodoc/ext/dbref'
+require 'mongodoc/ext/hash'
+require 'mongodoc/ext/nil_class'
+require 'mongodoc/ext/numeric'
+require 'mongodoc/ext/object'
+require 'mongodoc/ext/object_id'
+require 'mongodoc/ext/regexp'
+require 'mongodoc/ext/string'
+require 'mongodoc/ext/symbol'
+require 'mongodoc/ext/time'
+
+module MongoDoc
+  module BSON
+    CLASS_KEY = "json_class"
+
+    def self.decode(bson, options = {})
+      return bson if options[:raw_json]
+      case bson
+      when Hash
+        bson_create(bson, options)
+      when Array
+        array_create(bson, options)
+      else
+        bson
+      end
+    end
+    
+    def self.bson_create(bson_hash, options = {})
+      return bson_hash if options[:raw_json]
+      klass = bson_hash.delete(CLASS_KEY)
+      return bson_hash.each_pair {|key, value| bson_hash[key] = decode(value, options)} unless klass
+      klass.constantize.bson_create(bson_hash, options)
+    end
+
+    def self.array_create(bson_array, options = {})
+      return bson_array if options[:raw_json]
+      bson_array.map {|item| decode(item, options)}
+    end
+  end
+end

data/lib/mongodoc/connection.rb

@@ -0,0 +1,20 @@
+module MongoDoc
+  def self.database(name = nil)
+    if name
+      @@database = connection.db(name)
+    else
+      raise NoDatabaseError unless defined? @@database
+      @@database
+    end
+  end
+  
+  def self.connection
+    raise NoConnectionError unless defined? @@connection
+    @@connection
+  end
+    
+  def self.connect(*args)
+    opts = args.extract_options!
+    @@connection = Mongo::Connection.new(args[0], args[1], opts)
+  end
+end

data/lib/mongodoc/ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def to_bson(*args)
+    map {|item| item.to_bson(args)}
+  end
+end

data/lib/mongodoc/ext/binary.rb

@@ -0,0 +1,7 @@
+module Mongo
+  class Binary
+    def to_bson(*args)
+      self
+    end
+  end
+end

data/lib/mongodoc/ext/boolean_class.rb

@@ -0,0 +1,11 @@
+class FalseClass
+  def to_bson(*args)
+    self
+  end
+end
+
+class TrueClass
+  def to_bson(*args)
+    self
+  end
+end

data/lib/mongodoc/ext/date.rb

@@ -0,0 +1,16 @@
+class Date
+  def to_bson(*args)
+    {
+      MongoDoc::BSON::CLASS_KEY => self.class.name,
+      'dt' => strftime,
+      'sg' => start
+    }
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  def self.bson_create(bson_hash, options = nil)
+    Date.parse(*bson_hash.values_at('dt', 'sg'))
+  end
+
+end

data/lib/mongodoc/ext/date_time.rb

@@ -0,0 +1,13 @@
+class DateTime
+  def to_bson(*args)
+    {
+      MongoDoc::BSON::CLASS_KEY => self.class.name,
+      'dt' => strftime,
+      'sg' => start
+    }
+  end
+
+  def self.bson_create(bson_hash, options = nil)
+    DateTime.parse(*bson_hash.values_at('dt', 'sg'))
+  end
+end

data/lib/mongodoc/ext/dbref.rb

@@ -0,0 +1,7 @@
+module Mongo
+  class DBRef
+    def to_bson(*args)
+      self
+    end
+  end
+end

data/lib/mongodoc/ext/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+  def to_bson(*args)
+    {}.tap do |hash|
+      each {|key, value| hash[key.to_s] = value.to_bson}
+    end
+  end  
+end

data/lib/mongodoc/ext/nil_class.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def to_bson(*args)
+    self
+  end
+end

data/lib/mongodoc/ext/numeric.rb

@@ -0,0 +1,17 @@
+class Numeric
+  def to_bson(*args)
+    self
+  end
+end
+
+class Float
+  def to_bson(*args)
+    self
+  end
+end
+
+class Integer
+  def to_bson(*args)
+    self
+  end
+end