mongoid-included 0.0.5 → 0.2.0

data/lib/mongoid-included.rb

@@ -1,3 +1 @@
-require 'mongoid'
 require 'mongoid-included/document_inclusion'
-require 'mongoid-included/embedded_name'

data/lib/mongoid-included/document_inclusion.rb

@@ -1,69 +1,72 @@
+require 'mongoid-included/embedded_name'
+require 'mongoid-included/inclusion_errors'
 module Mongoid
   module DocumentInclusion
     extend ActiveSupport::Concern
-    
-    class NotMongoidDocument < StandardError; end;
-    class DocumentAlreadyIncluded < StandardError; end;
       
     included do
-      extend ActiveModel::Naming
-      cattr_accessor :inclusion_model
+      cattr_accessor :included_by
+      cattr_accessor :including_many
+      cattr_accessor :including_one
     end
     
     module ClassMethods
       def included_in(_model, args = {})
-        raise NotMongoidDocument,       "Child document must include Mongoid::Document" unless mongoid_document? self
-        raise NotMongoidDocument,       "Parent document must include Mongoid::Document" unless mongoid_document? self.parent
-        raise DocumentAlreadyIncluded,  "Child document already included" if inclusion_model
+        raise NotMongoidDocument,       "Parent must be Mongoid::Document" unless _mongoid_document? self.parent
+        raise DocumentAlreadyIncluded,  "Document already included" if included_by.present?
         embedded_in _model, args
-        self.inclusion_model = true
+        
+        self.included_by = _model
+        self.extend ActiveModel::Naming
+        _overwrite_model_name
       end
       
       def includes_many(_model, args = {})
-        verify_dependencies(_model)
-        embeds_many _model, args.merge(:class_name => included_klass(_model))
-        self.inclusion_model = true
+        _verify_dependencies(_model)
+        embeds_many _model, args.merge(:class_name => _included_klass(_model))
+        (self.including_many ||= []) << _model
       end
       
       def includes_one(_model, args = {})
-        verify_dependencies(_model)
-        embeds_one _model, args.merge(:class_name => included_klass(_model))
-        self.inclusion_model = true
+        _verify_dependencies(_model)
+        embeds_one _model, args.merge(:class_name => _included_klass(_model))
+        (self.including_one ||= []) << _model
       end
       
-      def model_name
-        @_model_name ||=begin
-          if self.parent != Object
-            Mongoid::EmbeddedName.new(self, self.parent)
-          else
-            super
+      private
+      
+      def _overwrite_model_name
+        self.class_eval <<-EOF
+          @_model_name ||=begin
+            if self.parent != Object
+              Mongoid::EmbeddedName.new(self, self.parent)
+            else
+              super
+            end
           end
-        end
+        EOF
       end
       
-      private
-      
-      def model_klass_name(_model)
+      def _model_klass_name(_model)
         _model.to_s.classify
       end
       
-      def model_klass(_model)
+      def _model_klass(_model)
         _model.to_s.classify.constantize
       end
       
-      def included_klass(_model)
-        "#{self}::#{model_klass_name(_model)}"
+      def _included_klass(_model)
+        "#{self}::#{_model_klass_name(_model)}"
       end
         
-      def mongoid_document?(_model)
+      def _mongoid_document?(_model)
         _model.ancestors.include?(Mongoid::Document)
       end
       
-      def verify_dependencies(_model)
-        raise NotMongoidDocument,       "Parent document must include Mongoid::Document" unless mongoid_document? self
-        raise NotMongoidDocument,       "Child document must include Mongoid::Document" unless mongoid_document? model_klass(included_klass(_model))
+      def _verify_dependencies(_model)
+        raise NotMongoidDocument, "Child must be Mongoid::Document" unless _mongoid_document? _model_klass(_included_klass(_model))
       end
-      
     end
   end
 end
+Mongoid::Document.send(:include, ::Mongoid::DocumentInclusion)

data/lib/mongoid-included/embedded_name.rb

@@ -5,7 +5,6 @@ module Mongoid
 
     def initialize(klass, namespace, pluralize_namespace = true)
       name ||= klass.name
-      # super(name)
       @unnamespaced = name.sub(/^#{namespace.name}::/, '') if namespace
 
       @klass = klass
@@ -21,5 +20,9 @@ module Mongoid
       @route_key = ActiveSupport::Inflector.pluralize(@param_key).freeze
       @i18n_key = name.underscore.to_sym
     end
+    
+    def _singularize(string, replacement='_')
+      ActiveSupport::Inflector.underscore(string).tr('/', replacement)
+    end
   end
 end

data/lib/mongoid-included/inclusion_errors.rb

@@ -0,0 +1,6 @@
+module Mongoid
+  module DocumentInclusion
+    class NotMongoidDocument < StandardError; end;
+    class DocumentAlreadyIncluded < StandardError; end;
+  end
+end

data/lib/mongoid-included/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Included
-    VERSION = "0.0.5"
+    VERSION = "0.2.0"
   end
 end

data/mongoid-included.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_runtime_dependency("activemodel", ["~> 3.1.0.beta1"])
   s.add_runtime_dependency(%q<mongoid>, ["~> 2.0"])
   s.add_development_dependency("rspec", ["~> 2.6.0"])
   s.add_development_dependency("bson_ext", ["~> 1.3"])

data/spec/models/invoice.rb

@@ -1,6 +1,6 @@
 class Invoice
   include Mongoid::Document
-  include Mongoid::DocumentInclusion
+
   field :title  
   validates_presence_of :title
 end

data/spec/models/invoice/item.rb

@@ -1,6 +1,5 @@
 class Invoice::Item
   include Mongoid::Document
-  include Mongoid::DocumentInclusion
   
   field :name  
   field :test, :default => "ale"

data/spec/models/invoice/not_included.rb

@@ -0,0 +1,3 @@
+class Invoice::NotIncluded
+  include Mongoid::Document
+end

data/spec/models/invoice/user.rb

@@ -1,6 +1,5 @@
 class Invoice::User
   include Mongoid::Document
-  include Mongoid::DocumentInclusion
   
   field :name
 end

data/spec/spec_helper.rb

@@ -15,6 +15,7 @@ end
 require 'models/invoice'
 require 'models/invoice/item'
 require 'models/invoice/user'
+require 'models/invoice/not_included'
 require 'models/inclusion'
     
 Mongoid.configure do |config|

data/spec/unit/included_spec.rb

@@ -1,115 +1,51 @@
 require 'spec_helper'
 
-describe "Mongoid::Included" do
-
-  context "when parent class includes a child" do
-    it "delegates options to mongoid relation macro" do
-      Invoice.relations["user"].inverse_of.should == :invoice
-    end
-    
-    it "embeds many children with given association name" do
-      Invoice.relations.keys.include? "items"
-      Invoice.relations["items"].macro.should == :embeds_many
-    end
-    
-    it "embeds one child with given association name" do
-      Invoice.relations.keys.include? "item"
-      Invoice.relations["user"].macro.should == :embeds_one
-    end
-    
-    it "embeds child with given association class" do
-      Invoice.relations["items"].class_name.should == "Invoice::Item"
-    end
-    
-    it "issues an error if parent is not mongoid document" do
-      Object.const_set "NonMongoidDocument", Class.new
-      NonMongoidDocument.send(:include, Mongoid::DocumentInclusion)
-      NonMongoidDocument.const_set "NonMongoidEmbed", Class.new
-      begin
-        NonMongoidDocument.includes_many :non_mongoid_embeds
-      rescue => e
-        e.class.should == Mongoid::DocumentInclusion::NotMongoidDocument
-        e.message.should =~ /Parent document must include Mongoid::Document/
-      end
-    end
-    
-    it "issues an error if child is not mongoid document" do
-      Object.const_set "NonMongoidDocument", Class.new
-      NonMongoidDocument.const_set "NonMongoidEmbed", Class.new
-      NonMongoidDocument.send(:include, Mongoid::Document)
-      NonMongoidDocument.send(:include, Mongoid::DocumentInclusion)
-      begin
-        NonMongoidDocument.includes_many :non_mongoid_embeds
-      rescue => e
-        e.class.should == Mongoid::DocumentInclusion::NotMongoidDocument
-        e.message.should =~ /Child document must include Mongoid::Document/
-      end
+describe "Child Model" do
+  context "when being included" do
+    it "strips namespace from #param_key" do
+      Invoice::Item.model_name.param_key.should == "item"
     end
   
-  end
+    it "strips namespace from #route_key" do
+      Invoice::Item.model_name.route_key.should == "items"
+    end
   
-  context "when child class is included in parent" do
+    it "pluralize namespace in #partial_path" do
+      Invoice::Item.model_name.partial_path.should == "invoices/items/item"
+    end
     
     it "delegates options to mongoid relation macro" do
       Invoice::User.relations["invoice"].inverse_of.should == :user
     end
-    
+
     it "is embedded in parent class" do
-      Invoice::Item.relations.keys.include? "invoice"
+      Invoice::Item.relations.keys.should include "invoice"
       Invoice::Item.relations["invoice"].macro.should == :embedded_in
     end
-    
-    it "issues an error if child is not mongoid document" do
-      Object.const_set "NonMongoidDocument", Class.new
-      NonMongoidDocument.const_set "NonMongoidChild", Class.new
-      NonMongoidDocument.send(:include, Mongoid::Document)
-      NonMongoidDocument.send(:include, Mongoid::DocumentInclusion)
-      NonMongoidDocument::NonMongoidChild.send(:include, Mongoid::DocumentInclusion)
-      begin
-        NonMongoidDocument::NonMongoidChild.included_in :invoice
-      rescue => e
-        e.class.should == Mongoid::DocumentInclusion::NotMongoidDocument
-        e.message.should =~ /Child document must include Mongoid::Document/
-      end
-    end    
-    
-    it "issues an error if parent is not mongoid document" do
-      Object.const_set "NonMongoidDocument", Class.new
-      NonMongoidDocument.const_set "NonMongoidChild", Class.new
-      NonMongoidDocument::NonMongoidChild.send(:include, Mongoid::Document)
-      NonMongoidDocument::NonMongoidChild.send(:include, Mongoid::DocumentInclusion)
-      begin
-        NonMongoidDocument::NonMongoidChild.included_in :invoice
-      rescue => e
-        e.class.should == Mongoid::DocumentInclusion::NotMongoidDocument
-        e.message.should =~ /Parent document must include Mongoid::Document/
-      end
-    end
-    
-    context "when overwriting #model_name" do
-      it "strips namespace from #param_key" do
-        Invoice::Item.model_name.param_key.should == "item"
-      end
-    
-      it "strips namespace from #route_key" do
-        Invoice::Item.model_name.route_key.should == "items"
-      end
-    
-      it "pluralize namespace in #partial_path" do
-        Invoice::Item.model_name.partial_path.should == "invoices/items/item"
-      end
+    it "#includded_in returns parent model" do
+      Invoice::Item.included_by.should == :invoice
     end
-    
     it "forbids inclusion in another parent" do
-      begin
-        Invoice::Item.included_in :invoice
-      rescue => e
-        e.class.should == Mongoid::DocumentInclusion::DocumentAlreadyIncluded
-      end
+      expect { Invoice::Item.included_in :invoice }.
+      to raise_error Mongoid::DocumentInclusion::DocumentAlreadyIncluded, /Document already included/
     end
-    
-    
   end
   
+  context "when not included" do
+    it "should preserve original name" do
+      Invoice::NotIncluded.model_name.should == "Invoice::NotIncluded"
+    end
+  end
+  
+  it "issues an error if parent is not mongoid document" do
+    Object.const_set "NonMongoidDocument", Class.new
+    NonMongoidDocument.const_set "NonMongoidChild", Class.new
+    NonMongoidDocument::NonMongoidChild.send(:include, Mongoid::Document)
+    NonMongoidDocument::NonMongoidChild.send(:include, Mongoid::DocumentInclusion)
+    expect { NonMongoidDocument::NonMongoidChild.included_in :invoice }.
+    to raise_error(Mongoid::DocumentInclusion::NotMongoidDocument, /Parent must be Mongoid::Document/)
+  end
+  
+
 end
 

data/spec/unit/including_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe "Parent Model" do
+  
+  let(:parent) { Invoice }
+  
+  describe "#includes_many" do
+    context "when including one model" do
+      it "#includding_many returns array with one model" do
+        parent.including_many.should include(:items)
+      end
+      it "embeds child with association name" do
+        parent.relations.keys.should include "items"
+        parent.relations["items"].macro.should == :embeds_many
+      end
+      it "embeds child with association class" do
+        parent.relations["items"].class_name.should == "Invoice::Item"
+      end
+    end
+    context "when including two models" do
+      it "#includding_many returns array with two models" do
+        parent.includes_many :not_includeds
+        parent.including_many.should include(:items, :not_includeds)
+      end
+    end
+    context "when not including with #includes_many" do
+      it "#includding_many returns an empty array" do
+        Invoice::Item.including_many.should be_blank
+      end
+    end
+  end
+  
+  describe "#includes_one" do
+    context "when including one model" do
+      it "#including_one returns array with one model" do
+        parent.including_one.should include(:user)
+      end
+      it "delegates options to mongoid relation macro" do
+        parent.relations["user"].inverse_of.should == :invoice
+      end
+      it "embeds one child with given association name" do
+        parent.relations.keys.should include "user"
+        parent.relations["user"].macro.should == :embeds_one
+      end
+    end
+    context "when including two models" do
+      it "#includding_one returns array with two models" do
+        parent.includes_one :not_includeds
+        parent.including_one.should include(:user, :not_includeds)
+      end
+    end
+    context "when not including with #includes_one" do
+      it "#includding_one returns an empty array" do
+        Invoice::Item.including_one.should be_blank
+      end
+    end
+  end
+
+  it "issues an error if child is not mongoid document" do
+    Object.const_set "NonMongoidDocument", Class.new
+    NonMongoidDocument.const_set "NonMongoidEmbed", Class.new
+    NonMongoidDocument.send(:include, Mongoid::Document)
+    NonMongoidDocument.send(:include, Mongoid::DocumentInclusion)
+    expect {NonMongoidDocument.includes_many :non_mongoid_embeds }.
+    to raise_error(Mongoid::DocumentInclusion::NotMongoidDocument, /Child must be Mongoid::Document/)
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-included
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,23 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-06 00:00:00.000000000 -03:00
+date: 2011-07-07 00:00:00.000000000 -03:00
 default_executable: 
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activemodel
-  requirement: &2156553760 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.1.0.beta1
-  type: :runtime
-  prerelease: false
-  version_requirements: *2156553760
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &2156553220 !ruby/object:Gem::Requirement
+  requirement: &2152036440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +22,10 @@ dependencies:
         version: '2.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2156553220
+  version_requirements: *2152036440
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2156552720 !ruby/object:Gem::Requirement
+  requirement: &2152300640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +33,10 @@ dependencies:
         version: 2.6.0
   type: :development
   prerelease: false
-  version_requirements: *2156552720
+  version_requirements: *2152300640
 - !ruby/object:Gem::Dependency
   name: bson_ext
-  requirement: &2156552240 !ruby/object:Gem::Requirement
+  requirement: &2152299720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,7 +44,7 @@ dependencies:
         version: '1.3'
   type: :development
   prerelease: false
-  version_requirements: *2156552240
+  version_requirements: *2152299720
 description: Helper to facilitate inclusion of namespaced documents in another Mongoid
   Document
 email: angelim@angelim.com.br
@@ -86,6 +75,7 @@ files:
 - lib/mongoid-included.rb
 - lib/mongoid-included/document_inclusion.rb
 - lib/mongoid-included/embedded_name.rb
+- lib/mongoid-included/inclusion_errors.rb
 - lib/mongoid-included/version.rb
 - log/development.log
 - mongoid-included.gemspec
@@ -94,9 +84,11 @@ files:
 - spec/models/inclusion.rb
 - spec/models/invoice.rb
 - spec/models/invoice/item.rb
+- spec/models/invoice/not_included.rb
 - spec/models/invoice/user.rb
 - spec/spec_helper.rb
 - spec/unit/included_spec.rb
+- spec/unit/including_spec.rb
 has_rdoc: true
 homepage: http://github.com/angelim/mongoid-included
 licenses: []
@@ -128,6 +120,8 @@ test_files:
 - spec/models/inclusion.rb
 - spec/models/invoice.rb
 - spec/models/invoice/item.rb
+- spec/models/invoice/not_included.rb
 - spec/models/invoice/user.rb
 - spec/spec_helper.rb
 - spec/unit/included_spec.rb
+- spec/unit/including_spec.rb