mongodoc 0.2.1 → 0.2.2

data/lib/mongodoc/parent_proxy.rb

@@ -1,44 +0,0 @@
-module MongoDoc
-  class ParentProxy
-    attr_reader :assoc_name, :_parent
-
-    def initialize(parent, assoc_name)
-      raise ArgumentError.new('ParentProxy requires a parent') if parent.nil?
-      raise ArgumentError.new('ParentProxy require an association name') if assoc_name.blank?
-      @_parent = parent
-      @assoc_name = assoc_name
-    end
-
-    def _path_to_root(src, attrs)
-      _parent._path_to_root(src, _annotated_keys(attrs))
-    end
-
-    def _selector_path_to_root(selector)
-      _parent._selector_path_to_root(_annotated_keys(selector))
-    end
-
-    protected
-
-    def _annotated_keys(hash)
-      hash.inject({}) do |annotated, (key, value)|
-        annotated["#{assoc_name}.#{key}"] = value
-        annotated
-      end
-    end
-
-    private
-
-    def method_missing(method, *args)
-      unless @_parent.respond_to?(method)
-        message = "undefined method `#{method.to_s}' for proxied \"#{@_parent}\":#{@_parent.class.to_s}"
-        raise NoMethodError, message
-      end
-
-      if block_given?
-        @_parent.send(method, *args)  { |*block_args| yield(*block_args) }
-      else
-        @_parent.send(method, *args)
-      end
-    end
-  end
-end

data/lib/mongodoc/proxy.rb

@@ -1,83 +0,0 @@
-# Thanks Sandro!
-# http://github.com/sandro
-module MongoDoc
-  class Proxy
-    # 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 ==]
-
-    (ARRAY_METHODS + MUST_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 :assoc_name, :collection, :collection_class, :_parent, :_root
-
-    def _parent=(parent)
-      @_parent = parent
-    end
-
-    def _root=(root)
-      @_root = root
-      collection.each do |item|
-        item._root = root
-      end
-    end
-
-    def initialize(options)
-      @assoc_name = options[:assoc_name]
-      @collection = []
-      @collection_class = options[:collection_class]
-      @_root = options[:root]
-      @_parent = options[:parent]
-    end
-
-    alias_method :append, :<<
-    def <<(item)
-      item = build(item) if Hash === item
-      if Document === item
-        item._parent = self
-        item._root = _root
-        _root.send(:register_save_observer, item)
-      end
-      append item
-      self
-    end
-    alias_method :push, :<<
-    alias_method :concat, :<<
-
-    # 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 _path_to_root(src, attrs)
-      assoc_path = "#{assoc_name}.#{index(src)}"
-      assoc_attrs = attrs.inject({}) do |assoc_attrs, (key, value)|
-        assoc_attrs["#{assoc_path}.#{key}"] = value
-        assoc_attrs
-      end
-      _parent._path_to_root(src, assoc_attrs)
-    end
-
-    def _selector_path_to_root(selector)
-      annotated_selector = selector.inject({}) do |annotated, (key, value)|
-        annotated["#{assoc_name}.#{key}"] = value
-        annotated
-      end
-      _parent._selector_path_to_root(annotated_selector)
-    end
-
-    def build(attrs)
-      collection_class.new(attrs)
-    end
-  end
-end

data/spec/parent_proxy_spec.rb

@@ -1,44 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "MongoDoc::ParentProxy" do
-  class Parent
-    include MongoDoc::Document
-  end
-
-  class Child
-    include MongoDoc::Document
-  end
-
-  before do
-    @parent = Parent.new
-    @assoc_name = 'association'
-  end
-
-  subject do
-    MongoDoc::ParentProxy.new(@parent, @assoc_name)
-  end
-
-  it "has the association name" do
-    should respond_to(:assoc_name)
-  end
-
-  it "has a parent" do
-    should respond_to(:_parent)
-  end
-
-  it "requires a parent" do
-    expect do
-      MongoDoc::ParentProxy.new(nil, @assoc_name)
-    end.should raise_error
-  end
-
-  it "requires an association name" do
-    expect do
-      MongoDoc::ParentProxy.new(@parent, nil)
-    end.should raise_error
-  end
-
-  it "inserts the association name the _path_to_root" do
-    subject._path_to_root(Child.new, :name1 => 'value1', :name2 => 'value2').should == {"#{@assoc_name}.name1" => 'value1', "#{@assoc_name}.name2" => "value2"}
-  end
-end

data/spec/proxy_spec.rb

@@ -1,80 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe MongoDoc::Proxy do
-  class ProxyTest
-    include MongoDoc::Document
-
-    key :name
-  end
-
-  let(:root) { stub('root', :register_save_observer => nil) }
-  let(:proxy) { MongoDoc::Proxy.new(:assoc_name => 'has_many_name', :collection_class => ProxyTest, :root => root, :parent => root) }
-
-  context "#<<" do
-    let(:item) { ProxyTest.new }
-
-    it "appends the item to the collection" do
-      (proxy << item).should include(item)
-    end
-
-    context "when the item is a Hash" do
-      let(:hash) {{:name => 'hash'}}
-
-      it "calls build when the item is a hash" do
-        proxy.should_receive(:build).with(hash).and_return(item)
-        proxy << hash
-      end
-
-      it "registers a save observer" do
-        proxy.stub(:build).and_return(item)
-        root.should_receive(:register_save_observer)
-        proxy << hash
-      end
-
-      it "sets the root" do
-        proxy.stub(:build).and_return(item)
-        proxy << hash
-        item._root.should == root
-      end
-    end
-
-    context "when the item is not a MongoDoc::Document" do
-      it "does not register a save observer" do
-        root.should_not_receive(:register_save_observer)
-        proxy << 'not_doc'
-      end
-
-      it "does not set the root" do
-        item.should_not_receive(:_root=)
-        proxy << 'not_doc'
-      end
-    end
-
-    context "when the item is a MongoDoc::Document" do
-      it "registers a save observer" do
-        root.should_receive(:register_save_observer)
-        proxy << item
-      end
-
-      it "sets the root" do
-        proxy << item
-        item._root.should == root
-      end
-    end
-
-    context "when the item is an array" do
-      it "adds the array" do
-        array = ['something else']
-        proxy << array
-        proxy.should include(array)
-      end
-    end
-  end
-
-  context "#build" do
-    it "builds an object of the collection class from the hash attrs" do
-      name = 'built'
-      proxy.build({:name => name}).name.should == name
-    end
-  end
-end