mongo_doc_rails2 0.6.1

data/lib/mongo_doc/associations/collection_proxy.rb

@@ -0,0 +1,121 @@
+# Thanks Sandro!
+# http://github.com/sandro
+module MongoDoc
+  module Associations
+    class CollectionProxy
+      include ProxyBase
+
+      # List of array methods (that are not in +Object+) that need to be
+      # delegated to +collection+.
+      ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map { |n| n.to_s }
+
+      # List of additional methods that must be delegated to +collection+.
+      MUST_DEFINE = %w[to_a to_ary inspect to_bson ==]
+
+      DO_NOT_DEFINE = %w[concat insert replace]
+
+      (ARRAY_METHODS + MUST_DEFINE - DO_NOT_DEFINE).uniq.each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)                 # def each(*args, &block)
+            collection.send(:#{method}, *args, &block) #   collection.send(:each, *args, &block)
+          end                                          # end
+        RUBY
+      end
+
+      attr_reader :collection
+
+      def _modifier_path=(path)
+        super
+        collection.each do |item|
+          item._modifier_path = _modifier_path + '.$' if ProxyBase.is_document?(item)
+        end
+      end
+
+      def _root=(value)
+        @_root = value
+        collection.each do |item|
+          item._root = value if ProxyBase.is_document?(item)
+        end
+      end
+
+      %w(_root _selector_path).each do |setter|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{setter}=(val)
+            super
+            collection.each do |item|
+              item.#{setter} = #{setter} if ProxyBase.is_document?(item)
+            end
+          end
+        RUBY
+      end
+
+      def initialize(options)
+        @collection = []
+        super
+      end
+
+      alias _append <<
+      def <<(item)
+        attach(item)
+        _append item
+        self
+      end
+      alias push <<
+
+      alias add []=
+      def []=(index, item)
+        attach(item)
+        add(index, item)
+      end
+      alias insert []=
+
+      def build(attrs)
+        item = _assoc_class.new(attrs)
+        push(item)
+      end
+
+      def concat(array)
+        array.each do |item|
+          push(item)
+        end
+      end
+
+      # Lie about our class. Borrowed from Rake::FileList
+      # Note: Does not work for case equality (<tt>===</tt>)
+      def is_a?(klass)
+        klass == Array || super(klass)
+      end
+      alias kind_of? is_a?
+
+      def replace(other)
+        clear
+        concat(other)
+      end
+
+      alias _unshift unshift
+      def unshift(item)
+        attach(item)
+        _unshift(item)
+      end
+
+      def valid?
+        all? do |child|
+          if ProxyBase.is_document?(child)
+            child.valid?
+          else
+            true
+          end
+        end
+      end
+
+      protected
+
+      def attach_document(doc)
+        doc._modifier_path = _modifier_path + '.$'
+        doc._selector_path = _selector_path
+        doc._root = _root
+        _root.send(:register_save_observer, doc)
+      end
+    end
+  end
+end

data/lib/mongo_doc/associations/document_proxy.rb

@@ -0,0 +1,65 @@
+module MongoDoc
+  module Associations
+    class DocumentProxy
+      include ProxyBase
+
+      attr_reader :document
+
+      delegate :to_bson, :id, :to => :document
+
+      %w(_modifier_path _selector_path).each do |setter|
+        class_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{setter}=(path)
+            super
+            document.#{setter} = #{setter} if ProxyBase.is_document?(document)
+          end
+        RUBY
+      end
+
+      def _root=(value)
+        @_root = value
+        document._root = value if ProxyBase.is_document?(document)
+      end
+
+      def ==(other)
+        if self.class === other
+          document == other.document
+        else
+          document == other
+        end
+      end
+
+      def build(attrs)
+        item = _assoc_class.new(attrs)
+        self.document = item
+      end
+
+      def document=(doc)
+        attach(doc)
+        @document = doc
+      end
+
+      def valid?
+        if ProxyBase.is_document?(document)
+          document.valid?
+        else
+          true
+        end
+      end
+
+      private
+
+      def method_missing(method, *args)
+        unless document.respond_to?(method)
+          raise NoMethodError, "undefined method `#{method.to_s}' for proxied \"#{document}\":#{document.class.to_s}"
+        end
+
+        if block_given?
+          document.send(method, *args)  { |*block_args| yield(*block_args) }
+        else
+          document.send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_doc/associations/hash_proxy.rb

@@ -0,0 +1,102 @@
+module MongoDoc
+  class InvalidEmbeddedHashKey < RuntimeError; end
+
+  module Associations
+    class HashProxy
+      include ProxyBase
+
+      HASH_METHODS = (Hash.instance_methods - Object.instance_methods).map { |n| n.to_s }
+
+      MUST_DEFINE = %w[to_a inspect to_bson ==]
+
+      DO_NOT_DEFINE = %w[merge! replace store update]
+
+      (HASH_METHODS + MUST_DEFINE - DO_NOT_DEFINE).uniq.each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)            # def each(*args, &block)
+            hash.send(:#{method}, *args, &block)  #   hash.send(:each, *args, &block)
+          end                                     # end
+        RUBY
+      end
+
+      attr_reader :hash
+
+      %w(_modifier_path _selector_path).each do |setter|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{setter}=(path)
+            super
+            hash.each do |key, doc|
+              doc.#{setter} = #{setter} + '.' + key.to_s if ProxyBase.is_document?(doc)
+            end
+          end
+        RUBY
+      end
+
+      def initialize(options)
+        @hash = {}
+        super
+      end
+
+      alias put []=
+      def []=(key, value)
+        raise InvalidEmbeddedHashKey.new("Key name [#{key}] must be a valid element name, see http://www.mongodb.org/display/DOCS/BSON#BSON-noteonelementname") unless valid_key?(key)
+        put(key, attach(key, value))
+      end
+      alias store []=
+
+      def build(key, attrs)
+        item = _assoc_class.new(attrs)
+        store(key, item)
+      end
+
+      # Lie about our class. Borrowed from Rake::FileList
+      # Note: Does not work for case equality (<tt>===</tt>)
+      def is_a?(klass)
+        klass == Hash || super(klass)
+      end
+      alias kind_of? is_a?
+
+      def merge!(other)
+        other.each_pair do |key, value|
+          self[key] = if block_given?
+            yield key, [key], value
+          else
+            value
+          end
+        end
+      end
+      alias update merge!
+
+      def replace(other)
+        clear
+        merge!(other)
+      end
+
+      def valid?
+        values.all? do |child|
+          if ProxyBase.is_document?(child)
+            child.valid?
+          else
+            true
+          end
+        end
+      end
+
+      protected
+
+      def attach(key, value)
+        if ProxyBase.is_document?(value)
+          proxy = DocumentProxy.new(:path => _selector_path, :assoc_name => key, :root => _root, :parent => self)
+          proxy.document = value
+          proxy
+        else
+          value
+        end
+      end
+
+      def valid_key?(key)
+        (String === key or Symbol === key) and key.to_s !~ /(_id|query|\$.*|.*\..*)/
+      end
+    end
+  end
+end

data/lib/mongo_doc/associations/proxy_base.rb

@@ -0,0 +1,48 @@
+module MongoDoc
+  module Associations
+    module ProxyBase
+      def self.included(klass)
+        klass.class_eval do
+          attr_reader :_assoc_class, :_assoc_name, :_modifier_path, :_root, :_selector_path
+        end
+      end
+
+      %w(_modifier_path _selector_path).each do |setter|
+        module_eval(<<-RUBY, __FILE__, __LINE__)
+          def #{setter}=(path)
+            @#{setter} = (path.blank? ? '' : path + '.') + _assoc_name.to_s
+          end
+        RUBY
+      end
+
+      def _root=(root)
+        @_root = root
+      end
+
+      def initialize(options)
+        @_assoc_name = options[:assoc_name]
+        @_assoc_class = options[:assoc_class]
+        self._root = options[:root]
+        self._selector_path = self._modifier_path = options[:path]
+      end
+
+      def self.is_document?(object)
+        object.respond_to?(:_root)
+      end
+
+      protected
+
+      def attach(obj)
+        attach_document(obj) if ProxyBase.is_document?(obj)
+        obj
+      end
+
+      def attach_document(doc)
+        doc._modifier_path = _modifier_path
+        doc._selector_path = _selector_path
+        doc._root = _root
+        _root.send(:register_save_observer, doc)
+      end
+    end
+  end
+end

data/lib/mongo_doc/attributes.rb

@@ -0,0 +1,84 @@
+module MongoDoc
+  module Attributes
+    def self.included(klass)
+      klass.class_eval do
+        class_inheritable_array :_keys
+        self._keys = []
+        class_inheritable_array :_associations
+        self._associations = []
+
+        attr_accessor :_id
+
+        extend ClassMethods
+      end
+    end
+
+    def attributes
+      hash = {}
+      self.class._attributes.each do |attr|
+        hash[attr] = send(attr)
+      end
+      hash
+    end
+
+    def attributes=(attrs)
+      attrs.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    module ClassMethods
+
+      def self.extended(klass)
+        klass.class_eval do
+          singleton_class.alias_method_chain :attr_accessor, :mongo
+        end
+      end
+
+      def _attributes
+        _keys + _associations
+      end
+
+      def attr_accessor_with_mongo(*args)
+        opts = args.extract_options!
+        default = opts.delete(:default)
+        type = opts.delete(:type)
+        args.each do |name|
+          _keys << name unless _keys.include?(name)
+          attr_writer name
+
+          if default
+            define_method("_default_#{name}", default.kind_of?(Proc) ? default : proc { default })
+            private "_default_#{name}"
+
+            module_eval(<<-RUBY, __FILE__, __LINE__)
+              def #{name}                                # def birth_date
+                unless defined? @#{name}                 #   unless defined? @birth_date
+                  @#{name} = _default_#{name}            #     @birth_date = _default_birth_date
+                end                                      #   end
+                class << self; attr_reader :#{name} end  #   class << self; attr_reader :birth_date end
+                @#{name}                                 #   @birth_date
+              end                                        # end
+            RUBY
+          else
+            attr_reader name
+          end
+
+          if type and type.respond_to?(:cast_from_string)
+            module_eval(<<-RUBY, __FILE__, __LINE__)
+              def #{name}_with_type=(value)               # def birth_date_with_type=(value)
+                if value.kind_of?(String)                 #   if value.kind_of?(String)
+                  value = #{type}.cast_from_string(value) #     value = Date.cast_from_string(value)
+                end                                       #   end
+                self.#{name}_without_type = value         #   self.birth_date_without_type = value
+              end                                         # end
+            RUBY
+            alias_method_chain "#{name}=", :type
+          end
+        end
+      end
+      alias key attr_accessor_with_mongo
+
+    end
+  end
+end

data/lib/mongo_doc/bson.rb

@@ -0,0 +1,31 @@
+require 'mongo_doc/ext'
+
+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