mongoid-included 0.3.2 → 1.1.0

data/.gitignore

@@ -3,3 +3,4 @@
 .rvmrc
 Gemfile.lock
 pkg/*
+.yardoc/*

data/.rspec

@@ -1 +1 @@
---color --format nested --fail-fast
+--color --format documentation

data/README.md

@@ -1,8 +1,10 @@
 Mongoid::Included
 ====================
 
-Helper module to embed documents using the parent's namespace while preserving url helpers consistency. This is useful to organize your project if you heavily rely on embedded documents. This gem concerns the issue 1429 of rails repository: https://github.com/rails/rails/issues/1429
-Works with [Mongoid 2.0](https://github.com/mongoid/mongoid) and ActiveModel 3.1.0.beta1. 
+Helper module to embed documents using the parent's namespace while preserving url helpers consistency. 
+This is useful to organize your project if you heavily rely on embedded documents. 
+This gem concerns the issue 1429 of rails repository: https://github.com/rails/rails/issues/1429
+Works with [Mongoid 2.4](https://github.com/mongoid/mongoid) and ActiveModel 3.2.0. 
 
 Installation
 ------------
@@ -39,7 +41,6 @@ Example
 
 	class Invoice
 		include Mongoid::Document
-		include Mongoid::DocumentInclusion
 		
 		includes_many :items
 	end
@@ -49,14 +50,13 @@ Example
 
 	class Invoice::Item
 		include Mongoid::Document
-		include Mongoid::DocumentInclusion
 	
 		included_in :invoice
 	end
 	# This will generate the following code:
 		extend ActiveModel::Naming
 		# Overriding .model_name so rails recognizes the class as __Item__ and generate more convenient urls.
-		def model_name
+		def self.model_name
 			if self.parent != Object
 				ActiveModel::Name.new(self, self.parent)
 			else

data/Rakefile

@@ -4,19 +4,10 @@ require 'bundler'
 require "rspec"
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new("spec:functional") do |spec|
-  spec.rspec_opts = %w(--format progress)
-  spec.pattern = "spec/functional/**/*_spec.rb"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = %w(--format documentation)
+  spec.pattern = "spec/**/*_spec.rb"
 end
 
 task :default => :spec
 task :test => :spec
-
-require 'rake/rdoctask'
-require "mongoid-included/version"
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "mongoid-included #{Mongoid::Mirrored::VERSION}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/changelog.txt

@@ -0,0 +1,8 @@
+# v1.0.0
+- Updating dependency to ActiveModel 3.2
+- Getting rid of +Embedded::Name+, since partial_path will be deprecated in ActiveModel
+- Overriding +Model._to_partial_path+, originally implemented in ActiveModel::Conversion
+- :skip_path_pluralization option added for #included_in. Allows conventional use of partial paths, without pluralization.
+
+# v0.3.1
+- Allowing Mongoid 3.0 support in Gemspec

data/example/models/invoice.rb

@@ -1,6 +1,5 @@
 class Invoice
   include Mongoid::Document
-  include Mongoid::DocumentInclusion
   field :title
   
   includes_many :items

data/example/models/invoice/item.rb

@@ -1,6 +1,5 @@
 class Invoice::Item
   include Mongoid::Document
-  include Mongoid::DocumentInclusion
   
   field :description  
   

data/example/models/invoice/user.rb

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

data/example/readme.txt

@@ -5,4 +5,4 @@ the parent's document folder
 
 This conventions respects url generation, 
 correct parameter names in form building 
-and template locations, incluing partials
+and template locations, incluing partials.

data/lib/mongoid-included/document_inclusion.rb

@@ -1,100 +1,149 @@
-require 'mongoid-included/embedded_name'
 require 'mongoid-included/inclusion_errors'
 module Mongoid
   module DocumentInclusion
+    # Adds convenience methods to embed Mongoid documents into others using namespaces.
+    # It also provides methods to define their inverse relation, on root documents.
     extend ActiveSupport::Concern
       
     included do
+      # @return [ Array ] list of classes in which a class is included in an +Embedded Relation+.
       cattr_accessor :included_by
+      # @return [ Array ] list of classes a given class includes in a +Many Relation+.
       cattr_accessor :including_many
+      # @return [ Array ] list of classes a given class includes in a +One Relation+.
       cattr_accessor :including_one
+      
+      self.included_by, self.including_many, self.including_one = [], [], []
     end
     
     module ClassMethods
-      def included_in(_model, args = {})
-        if args && args[:class_name]
-          _class_name = args[:class_name]
+      # Facade for Mongoid::Relations::Macros.embeded_in
+      # @param [ Symbol ] relation_name name for the parent association
+      # @param [ Hash ] args (see Mongoid::Relations::Macros.embeded_in)
+      # @option args [ true, false ] :skip_path_pluralization If Partial Paths should be
+      #   kept as default, using the namespace in singular form
+      # 
+      # @example Skipping pluralization
+      #   class Entry::Image
+      #     included_in :entry, :skip_path_pluralization => true
+      #     image.to_partial_path #=> "entry/images/image"
+      # 
+      # @example With pluralization. This seems a more natural fit for partials placement.
+      #   class Entry::Image
+      #     included_in :entry
+      #     image.to_partial_path #=> "entries/images/image"
+      def included_in(relation_name, args = {})
+        @skip_path_pluralization = args.delete(:skip_path_pluralization)
+        
+        relation_klass = if args[:class_name]
+          infer_klass(args[:class_name])
         else
-          _class_name = _model
-        end
+          infer_klass(relation_name)
+        end 
+        
+        raise NotMongoidDocument,       "Parent must be Mongoid::Document" unless has_mongoid? self.parent
+        raise DocumentAlreadyIncluded,  "Document already included" if (included_by | [ relation_klass ]).size > 1
         
-        raise NotMongoidDocument,       "Parent must be Mongoid::Document" unless _mongoid_document? self.parent
-        raise DocumentAlreadyIncluded,  "Document already included" if (!included_by.blank? && included_by!=[_model_klass(_class_name)]) 
-        embedded_in _model, args
+        embedded_in relation_name, args
+        self.included_by |= [ relation_klass ]
         
-        self.included_by ||= []
-        self.included_by << _model_klass(_class_name) unless included_by.include? _model_klass(_class_name)
         self.extend ActiveModel::Naming
         _overwrite_model_name
       end
       
-      def includes_many(_model, args = {})
-        if args && args[:class_name]
-          _class_name = args[:class_name]
-          self.including_many ||= []
-          self.including_many << _model_klass(_class_name) unless including_many.include? _model_klass(_class_name)
+      # Facade for Mongoid::Relations::Macros.embeds_many
+      # @param [ Symbol ] relation_name Name for the child association
+      # @param [ Hash ] args (see Mongoid::Relations::Macros.embeds_many)
+      def includes_many(relation_name, args = {})
+        relation_klass = if args[:class_name]
+          infer_klass(args[:class_name])
         else
-          _verify_dependencies(_model)
-          _class_name = _included_klass_name(_model)
-          self.including_many ||= []
-          self.including_many << _included_klass(_model) unless including_many.include? _included_klass(_model)
+          klass_to_include(relation_name)
         end
-        embeds_many _model, args.merge(:class_name => _class_name )
+        
+        verify_inclusion_dependencies(relation_klass)
+        self.including_many |= [ relation_klass ]
+
+        embeds_many relation_name, args.merge(:class_name => relation_klass.name )
       end
       
-      def includes_one(_model, args = {})
-        if args && args[:class_name]
-          _class_name = args[:class_name]
-          self.including_one ||= []
-          self.including_one << _model_klass(_class_name) unless including_one.include? _model_klass(_class_name)
+      
+      # Facade for Mongoid::Relations::Macros.embeds_one
+      # @param [ Symbol ] _model Name for the association
+      # @param [ Hash ] args (see Mongoid::Relations::Macros.embeds_one)
+      def includes_one(relation_name, args = {})
+        relation_klass = if args[:class_name]
+          infer_klass(args[:class_name])
         else
-          _verify_dependencies(_model)
-          _class_name = _included_klass_name(_model)
-          self.including_one ||= []
-          self.including_one << _included_klass(_model) unless including_one.include? _included_klass(_model)
+          klass_to_include(relation_name)
         end
-        embeds_one _model, args.merge(:class_name => _class_name)
+        
+        verify_inclusion_dependencies(relation_klass)
+        self.including_one |= [ relation_klass ]
+
+        embeds_one relation_name, args.merge(:class_name => relation_klass.name )
       end
       
       private
       
+      # Overrides +ActiveModel.model_name+ and +Model._to_partial_path+ 
+      #   for ActiveModel compliant classes.
+      # @note This method requires ActiveModel ~> 3.2. This release deprecates
+      #   ActiveModel::Naming#partial_path in favor or model.to_partial_path.
+      # @since 1.0.0
       def _overwrite_model_name
-        self.class_eval <<-EOF
-          def self.model_name
-            @_model_name ||=begin
-              if self.parent != Object
-                Mongoid::EmbeddedName.new(self, self.parent)
-              else
-                namespace = self.parents.detect { |n| n.respond_to?(:_railtie) }
-                ActiveModel::Name.new(self, namespace)
+        if self.parent != Object
+          self.class_eval <<-EOF
+            def self.model_name
+              @_model_name ||=begin
+                ActiveModel::Name.new(self, self.parent)
               end
             end
+          EOF
+          unless @skip_path_pluralization
+            self.class_eval <<-EOF
+              def self._to_partial_path
+                @_to_partial_path ||= begin
+                  plural_namespace = ActiveSupport::Inflector.tableize(self.parent).freeze
+                  plural_element = ActiveSupport::Inflector.pluralize(model_name.element)
+                  path = [plural_namespace, plural_element, model_name.element].join("/").freeze
+                end
+              end
+            EOF
           end
-        EOF
-      end
-      
-      def _model_klass_name(_model)
-        _model.to_s.classify
+        end
       end
       
-      def _model_klass(_model)
-        _model.to_s.classify.constantize
+      # Returns the class for a given name
+      # @param [ Symbol ] _model the relation name
+      # @return [ Object <Mongoid::Document> ] the model class
+      # @example A relation named :entry
+      #   infer_klass("Entry::Image") #=> Entry::Image
+      def infer_klass(klass_name)
+        klass_name.to_s.classify.constantize
       end
       
-      def _included_klass_name(_model)
-        "#{self}::#{_model_klass_name(_model)}"
+      # Returns the class for a given relation
+      # @param [ Symbol ] relation_name the relation name
+      # @return [ Class ] the model class
+      # @example A relation named :comments for an Entry class
+      #   klass_to_include(:comments) #=> Entry::Comment
+      def klass_to_include(relation_name)
+        "#{self}/#{relation_name}".classify.constantize
       end
       
-      def _included_klass(_model)
-        "#{self}::#{_model_klass_name(_model)}".constantize
-      end
-        
-      def _mongoid_document?(_model)
-        _model.included_modules.include?(Mongoid::Document)
+      # If relation name targets a Mongoid Document
+      # @param [ Symbol ] _model the relation name
+      # @return [ true, false ] if relation is a Mongoid::Document
+      def has_mongoid?(embeding_target)
+        embeding_target < Mongoid::Document
       end
       
-      def _verify_dependencies(_model)
-        raise NotMongoidDocument, "Child must be Mongoid::Document" unless _mongoid_document? _model_klass(_included_klass_name(_model))
+      # Verifies if an association can be included
+      # @param [ Symbol ] _model the relation name
+      # @raise [ NotMongoidDocument ] if relation is not a Mongoid::Document
+      def verify_inclusion_dependencies(relation_klass)
+        raise NotMongoidDocument, "Child must be Mongoid::Document" unless has_mongoid? relation_klass
       end
     end
   end

data/lib/mongoid-included/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Included
-    VERSION = "0.3.2"
+    VERSION = "1.1.0"
   end
 end

data/mongoid-included.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.authors = ["Alexandre Angelim"]
   s.email = %q{angelim@angelim.com.br}  
   s.homepage = %q{http://github.com/angelim/mongoid-included}    
-  s.summary = %q{Included namespaces documents for Mongoid}  
+  s.summary = %q{Included namespaced documents for Mongoid}  
   s.description = %q{Helper to facilitate inclusion of namespaced documents in another Mongoid Document}
     
   s.rubyforge_project = "mongoid-included"
@@ -19,8 +19,11 @@ 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(%q<mongoid>, [">= 2.0"])
+  s.add_runtime_dependency(%q<mongoid>, [">= 2.4"])
+  s.add_runtime_dependency(%q<activemodel>, ["~> 3.2"])
   s.add_development_dependency("rspec", ["~> 2.6.0"])
   s.add_development_dependency("bson_ext", ["~> 1.3"])
+  s.add_development_dependency "rake", ["~> 0.9"]
+  s.add_development_dependency "yard", ["~> 0.7.4"]
   
 end

data/spec/models/inclusion.rb

@@ -1,5 +1,6 @@
 class Invoice
   includes_many :items
+  includes_many :price_lists
   includes_one :user, :inverse_of => :invoice
   includes_one :other_user, :class_name => "Invoice::User", :inverse_of => :user_invoice
   includes_many :other_items, :class_name => "Invoice::Item"
@@ -13,4 +14,8 @@ end
 class Invoice::User
   included_in :invoice, :inverse_of => :user
   included_in :user_invoice, :class_name => "Invoice", :inverse_of => :other_user
+end
+
+class Invoice::PriceList
+  included_in :invoice, :inverse_of => :price_lists, :skip_path_pluralization => true
 end

data/spec/models/invoice/price_list.rb

@@ -0,0 +1,5 @@
+class Invoice::PriceList
+  include Mongoid::Document
+  
+  field :value, :type => Float
+end

data/spec/spec_helper.rb

@@ -14,6 +14,7 @@ MODELS.each do |_model|
 end
 require 'models/invoice'
 require 'models/invoice/item'
+require 'models/invoice/price_list'
 require 'models/invoice/user'
 require 'models/invoice/not_included'
 require 'models/inclusion'

data/spec/unit/included_spec.rb

@@ -9,9 +9,15 @@ describe "Child Model" do
     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"
+    context "when pluralizing partial path" do
+      it "returns partial path with pluralized embedding class" do
+        Invoice::Item.new.to_partial_path.should == "invoices/items/item"
+      end
+    end
+    context "when skipping partial path pluralization" do
+      it "returns partial path with singular embedding class" do
+        Invoice::PriceList.new.to_partial_path.should == "invoice/price_lists/price_list"
+      end
     end
     
     it "delegates options to mongoid relation macro" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-included
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,23 +9,34 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-26 00:00:00.000000000 -02:00
+date: 2012-01-27 00:00:00.000000000 -02:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &2155089800 !ruby/object:Gem::Requirement
+  requirement: &2153298320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.4'
   type: :runtime
   prerelease: false
-  version_requirements: *2155089800
+  version_requirements: *2153298320
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &2153297520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153297520
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2155089180 !ruby/object:Gem::Requirement
+  requirement: &2153297020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +44,10 @@ dependencies:
         version: 2.6.0
   type: :development
   prerelease: false
-  version_requirements: *2155089180
+  version_requirements: *2153297020
 - !ruby/object:Gem::Dependency
   name: bson_ext
-  requirement: &2155088700 !ruby/object:Gem::Requirement
+  requirement: &2153296140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,7 +55,29 @@ dependencies:
         version: '1.3'
   type: :development
   prerelease: false
-  version_requirements: *2155088700
+  version_requirements: *2153296140
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2153295100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: *2153295100
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2153310960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+  type: :development
+  prerelease: false
+  version_requirements: *2153310960
 description: Helper to facilitate inclusion of namespaced documents in another Mongoid
   Document
 email: angelim@angelim.com.br
@@ -60,6 +93,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- changelog.txt
 - example/controllers/invoices/items_controller.rb
 - example/controllers/invoices/user_controller.rb
 - example/controllers/invoices_controller.rb
@@ -74,7 +108,6 @@ files:
 - example/views/layouts/application.html.erb
 - 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
@@ -85,6 +118,7 @@ files:
 - spec/models/invoice.rb
 - spec/models/invoice/item.rb
 - spec/models/invoice/not_included.rb
+- spec/models/invoice/price_list.rb
 - spec/models/invoice/user.rb
 - spec/spec_helper.rb
 - spec/unit/included_spec.rb
@@ -113,7 +147,7 @@ rubyforge_project: mongoid-included
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Included namespaces documents for Mongoid
+summary: Included namespaced documents for Mongoid
 test_files:
 - spec/functional/invoice.rb
 - spec/functional/item.rb
@@ -121,6 +155,7 @@ test_files:
 - spec/models/invoice.rb
 - spec/models/invoice/item.rb
 - spec/models/invoice/not_included.rb
+- spec/models/invoice/price_list.rb
 - spec/models/invoice/user.rb
 - spec/spec_helper.rb
 - spec/unit/included_spec.rb

data/lib/mongoid-included/embedded_name.rb

@@ -1,43 +0,0 @@
-module Mongoid
-  class EmbeddedName < String
-    attr_reader :singular, :plural, :element, :collection, :partial_path, :route_key, :param_key, :i18n_key
-    alias_method :cache_key, :collection
-
-    def initialize(klass, namespace, pluralize_namespace = true)
-      name ||= klass.name
-      super(name)
-      @unnamespaced = name.sub(/^#{namespace.name}::/, '') if namespace
-      @klass = klass
-      @singular = _singularize(name).freeze
-      @singular_namespace = _singularize(namespace.name).freeze
-      @plural = ActiveSupport::Inflector.pluralize(@singular).freeze
-      @plural_namespace = ActiveSupport::Inflector.pluralize(@singular_namespace).freeze
-      @element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name)).freeze
-      @human = ActiveSupport::Inflector.humanize(@element).freeze
-      @collection = ActiveSupport::Inflector.tableize(name).freeze
-      @partial_path = "#{@collection.sub(@singular_namespace, @plural_namespace)}/#{@element}".freeze
-      @param_key =  _singularize(@unnamespaced).freeze
-      @route_key = ActiveSupport::Inflector.pluralize(@param_key).freeze
-      @i18n_key = name.underscore.to_sym
-    end
-    
-    def human(options={})
-      return @human unless @klass.respond_to?(:lookup_ancestors) &&
-                           @klass.respond_to?(:i18n_scope)
-
-      defaults = @klass.lookup_ancestors.map do |klass|
-        klass.model_name.i18n_key
-      end
-
-      defaults << options[:default] if options[:default]
-      defaults << @human
-
-      options = {:scope => [@klass.i18n_scope, :models], :count => 1, :default => defaults}.merge(options.except(:default))
-      I18n.translate(defaults.shift, options)
-    end
-    
-    def _singularize(string, replacement='_')
-      ActiveSupport::Inflector.underscore(string).tr('/', replacement)
-    end
-  end
-end