mongoid_nested_fields 0.1.1

data/.autotest

@@ -0,0 +1 @@
+require 'autotest/growl'

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,21 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem 'mongoid', "2.0.0.beta.20"
+gem "bson_ext", "1.1.5"
+gem 'yajl-ruby', ">= 0.7.8"
+gem 'activesupport', ">= 3.0.3"
+gem 'activemodel', ">= 3.0.3"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem 'autotest'
+  gem 'autotest-growl'
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,51 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ZenTest (4.4.2)
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activesupport (3.0.3)
+    autotest (4.4.6)
+      ZenTest (>= 4.4.1)
+    autotest-growl (0.2.4)
+      autotest (>= 4.2.4)
+    bson (1.1.5)
+    bson_ext (1.1.5)
+    builder (2.1.2)
+    git (1.2.5)
+    i18n (0.5.0)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    mongo (1.1.5)
+      bson (>= 1.1.5)
+    mongoid (2.0.0.beta.20)
+      activemodel (~> 3.0)
+      mongo (~> 1.1)
+      tzinfo (~> 0.3.22)
+      will_paginate (~> 3.0.pre)
+    rake (0.8.7)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+    tzinfo (0.3.23)
+    will_paginate (3.0.pre2)
+    yajl-ruby (0.7.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (>= 3.0.3)
+  activesupport (>= 3.0.3)
+  autotest
+  autotest-growl
+  bson_ext (= 1.1.5)
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  mongoid (= 2.0.0.beta.20)
+  rcov
+  shoulda
+  yajl-ruby (>= 0.7.8)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Mihael Konjevic - retro - konjevic@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,55 @@
+= mongoid_nested_fields
+
+MongoidNestedFields is a gem aimed at CMS projects that need handling of complex types in one field. Nested fields can be nested into each other. Validations are performed on whole tree.
+
+== Example
+
+  class Article
+    include Mongoid::Document
+  
+    field :title
+    nested_field :body, :allowed_types => [ParagraphWithSubtitle, ImageWithCaption, ImageGallery]
+  
+  end
+
+  class ParagraphWithSubtitle
+    include MongoidNestedFields::NestedField
+  
+    field :paragraph
+    field :subtitle
+  
+    validates_presence_of :paragraph
+  end
+
+  class ImageWithCaption
+    include MongoidNestedFields::NestedField
+  
+    field :image
+    field :caption
+  
+  end
+
+  class ImageGallery
+    include MongoidNestedFields::NestedField
+  
+    field :gallery_name
+    nested_field :gallery, :allowed_types => [ImageWithCaption]
+  
+  end
+
+
+== Contributing to mongoid_nested_fields
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2010 Mihael Konjevic - retro. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mongoid_nested_fields"
+  gem.homepage = "http://github.com/retro/mongoid_nested_fields"
+  gem.license = "MIT"
+  gem.summary = %Q{MongoidNestedFields allows you to handle complex data structures inside one field in MongoDB.}
+  gem.description = %Q{MongoidNestedFields allows you to handle complex data structures inside one field in MongoDB. It also validates whole object graph on field validation}
+  gem.email = "konjevic@gmail.com"
+  gem.authors = ["retro"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mongoid_content_block #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/mongoid_nested_fields/errors/unexpected_type.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module MongoidNestedFields
+  module Errors
+    class UnexpectedType < TypeError
+      def initialize(type, field)
+        super("Unexpected type #{type} in field #{field}")
+      end
+    end
+  end
+end

data/lib/mongoid_nested_fields/errors.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require 'mongoid_nested_fields/errors/unexpected_type'

data/lib/mongoid_nested_fields/nested_field_hash.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module MongoidNestedFields
+  class NestedFieldHash < Hash
+    attr_accessor :origin
+  end
+end

data/lib/mongoid_nested_fields/nested_field_holder.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module MongoidNestedFields
+  class NestedFieldHolder
+    def self.get(value)
+      if value.is_a? Array
+        value = value.map do |v|
+          if((v.is_a?(Hash) or v.is_a?(BSON::OrderedHash)) and !v['_type'].nil?)
+            v = v['_type'].classify.constantize.new(v.to_hash).to_mongo
+          end
+          v
+        end
+      end
+      value
+    end
+    
+    def self.set(value)
+      if value.is_a? Array
+        value = value.map{ |v| v.respond_to?(:to_mongo) ? v.to_mongo : v}
+      end
+      value
+    end
+    
+  end
+end

data/lib/mongoid_nested_fields/nested_field_part.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+
+module MongoidNestedFields
+  module NestedField
+    module ClassMethods
+      
+      def nested_field(name, options = {})
+        add_nested_field(name)
+        set_validations
+        options[:type] = Array
+        set_allowed_types_in_field(name, options.delete(:allowed_types))
+        define_method("#{name}=") do |value|
+          raise TypeError unless [String, Array].include?(value.class)
+          if value.is_a? String
+            parser = Yajl::Parser.new
+            value = parser.parse(value)
+          end
+          processed_values = []
+          value.to_a.each do |v|
+            v.stringify_keys!
+            if(v.is_a?(Hash) && !v['_type'].nil?)
+              v = v['_type'].classify.constantize.new(v)
+              
+            end
+            raise MongoidNestedFields::Errors::UnexpectedType.new(v.class, name) unless self.class.is_allowed_type?(name, v.class)
+            processed_values << v
+          end
+          write_attribute(name, processed_values)
+        end
+        
+        define_method(name) do
+          read_attribute(name).map{ |v| v.respond_to?(:to_mongo) ? v.to_mongo : v }
+          
+        end
+        
+        
+      end
+      
+      def set_validations
+        validate :nested_fields_must_be_valid
+      end
+      
+      def set_allowed_types_in_field(field, type)
+        field = field.to_sym
+        @_allowed_types_in_field ||= {}
+        @_allowed_types_in_field[field] ||= []
+        @_allowed_types_in_field[field] << type
+        @_allowed_types_in_field[field].flatten!.uniq!
+      end
+      def allowed_types_in_field(field)
+        field = field.to_sym
+        @_allowed_types_in_field ||= {}
+        return @_allowed_types_in_field[field] || []
+      end
+      def is_allowed_type?(field, type)
+        field = field.to_sym
+        allowed_types_in_field(field).include?(type)
+      end
+      
+      def field(name, options = {})
+        add_field(name)
+        
+        define_method("#{name}=") do |value|
+          klass = options[:type].nil? ? String : options.delete(:type).classify.constantize
+          write_attribute(name, klass.new(value))
+        end
+        
+        define_method(name) do
+          read_attribute(name)
+        end
+        
+      end
+      
+      def add_field(name)
+        @_fields ||= []
+        @_fields << name.to_sym
+      end
+      
+      def add_nested_field(name)
+        add_field(name)
+        @_nested_fields ||= []
+        @_nested_fields << name.to_sym
+      end
+      
+    end
+    
+    
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, ActiveModel::Validations)
+    end
+    
+    def _type=(t)
+    end
+    
+    def _type
+      self.class.to_s.underscore
+    end
+    
+    def initialize(attrs)
+      attrs.each_pair do |k,v|
+        if v.is_a?(Hash) && !v['_type'].nil?
+          v = v['_type'].classify.constantize.new(v)
+        end
+        self.send("#{k}=", v)
+      end
+    end
+    
+    def write_attribute(name, value)
+      @_attributes ||= {}
+      @_attributes[name.to_sym] = value
+    end
+    
+    def read_attribute(name)
+      @_attributes ||= {}
+      @_attributes[name.to_sym].respond_to?(:to_mongo) ? @_attributes[name.to_sym].to_mongo : @_attributes[name.to_sym]
+    end
+    
+    def attributes
+      @_attributes
+    end
+    
+    def to_mongo
+      attrs = MongoidNestedFields::NestedFieldHash.new
+      attributes.each_key do |key|
+        attrs[key.to_s] = self.send(key.to_sym)
+      end
+      attrs['_type'] = _type
+      attrs.origin   = self
+      attrs
+    end
+    
+    def _nested_fields
+      self.class.instance_variable_get(:@_nested_fields)
+    end
+    
+    def nested_fields_must_be_valid
+      _nested_fields.each do |field|
+        value = read_attribute(field)
+        i = 0
+        field_errors = {}
+        value.each do |v|
+          if v.respond_to?(:invalid?) and v.invalid?
+            field_errors[i.to_s] = v.errors
+            i += 1
+          end
+        end if value.respond_to? :each
+        errors.add(field, field_errors) unless field_errors.empty?
+      end unless _nested_fields.nil?
+    end
+    
+  end
+end

data/lib/mongoid_nested_fields/nested_field_setter.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+module MongoidNestedFields
+  module NestedFieldSetter
+    module ClassMethods
+      def nested_field(name, options = {})
+        @_nested_fields ||= []
+        @_nested_fields << name.to_s
+        options[:type] = MongoidNestedFields::NestedFieldHolder
+        
+        set_allowed_types_in_field(name, options.delete(:allowed_types))      
+        set_validations
+
+        field(name, options)
+        meth = options.delete(:as) || name
+        define_method("#{meth}=") do |value|
+          raise TypeError unless [String, Array, NilClass].include?(value.class)
+          if value.is_a? String
+            parser = Yajl::Parser.new
+            value = parser.parse(value)
+          end
+          processed_values = []
+          value.to_a.each do |v|
+            v.stringify_keys! if v.is_a? Hash
+            if((v.is_a?(Hash) or v.is_a?(BSON::OrderedHash)) and !v['_type'].nil?)
+              v = v['_type'].classify.constantize.new(v.to_hash)
+            end
+            raise MongoidNestedFields::Errors::UnexpectedType.new(v.class, name) unless self.class.is_allowed_type?(name, v.class)
+            processed_values << v
+          end
+          write_attribute(name, processed_values)
+        end
+        
+      end
+      
+      def set_validations
+        validate :nested_fields_must_be_valid
+      end
+      
+      def set_allowed_types_in_field(field, type)
+        field = field.to_sym
+        @_allowed_types_in_field ||= {}
+        @_allowed_types_in_field[field] ||= []
+        @_allowed_types_in_field[field] << type
+        @_allowed_types_in_field[field].flatten!.uniq!
+      end
+      def allowed_types_in_field(field)
+        field = field.to_sym
+        @_allowed_types_in_field ||= {}
+        return @_allowed_types_in_field[field] || []
+      end
+      def is_allowed_type?(field, type)
+        field = field.to_sym
+        allowed_types_in_field(field).include?(type)
+      end
+    end
+    
+    def self.included(reciever)
+      reciever::ClassMethods.send :include, ClassMethods
+    end
+    
+    def _nested_fields
+      self.class.instance_variable_get(:@_nested_fields)
+    end
+    
+    def rebuild_nested_fields
+      _nested_fields.each do |c|
+        value = self.send(c)
+        self.send("#{c}=", value) unless value.nil?
+      end
+    end
+    
+    def nested_fields_must_be_valid
+      
+      _nested_fields.each do |field|
+        value = read_attribute(field)
+        i = 0
+        field_errors = {}
+        value.each do |v|
+          if v.respond_to?(:origin) and v.origin.respond_to?(:invalid?) and v.origin.invalid?
+            field_errors[i.to_s] = v.origin.errors
+            i += 1
+          end
+        end if value.respond_to? :each
+        errors.add(field, field_errors) unless field_errors.empty?
+      end unless _nested_fields.nil?
+    end
+    
+  end
+end

data/lib/mongoid_nested_fields.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'mongoid'
+require 'active_support/inflector'
+require 'active_model/validations'
+require 'yajl'
+
+%w(nested_field_setter nested_field_holder nested_field_part nested_field_hash errors).each do |f|
+  require "mongoid_nested_fields/#{f}"
+end
+
+Mongoid::Document.send(:include, MongoidNestedFields::NestedFieldSetter)
+
+module MongoidNestedFields
+  
+end

data/mongoid_nested_fields.gemspec

@@ -0,0 +1,92 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mongoid_nested_fields}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["retro"]
+  s.date = %q{2010-12-26}
+  s.description = %q{MongoidNestedFields allows you to handle complex data structures inside one field in MongoDB. It also validates whole object graph on field validation}
+  s.email = %q{konjevic@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/mongoid_nested_fields.rb",
+    "lib/mongoid_nested_fields/errors.rb",
+    "lib/mongoid_nested_fields/errors/unexpected_type.rb",
+    "lib/mongoid_nested_fields/nested_field_hash.rb",
+    "lib/mongoid_nested_fields/nested_field_holder.rb",
+    "lib/mongoid_nested_fields/nested_field_part.rb",
+    "lib/mongoid_nested_fields/nested_field_setter.rb",
+    "mongoid_nested_fields.gemspec",
+    "test/helper.rb",
+    "test/test_mongoid_nested_fields.rb"
+  ]
+  s.homepage = %q{http://github.com/retro/mongoid_nested_fields}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{MongoidNestedFields allows you to handle complex data structures inside one field in MongoDB.}
+  s.test_files = [
+    "test/helper.rb",
+    "test/test_mongoid_nested_fields.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mongoid>, ["= 2.0.0.beta.20"])
+      s.add_runtime_dependency(%q<bson_ext>, ["= 1.1.5"])
+      s.add_runtime_dependency(%q<yajl-ruby>, [">= 0.7.8"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.3"])
+      s.add_runtime_dependency(%q<activemodel>, [">= 3.0.3"])
+      s.add_development_dependency(%q<autotest>, [">= 0"])
+      s.add_development_dependency(%q<autotest-growl>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<mongoid>, ["= 2.0.0.beta.20"])
+      s.add_dependency(%q<bson_ext>, ["= 1.1.5"])
+      s.add_dependency(%q<yajl-ruby>, [">= 0.7.8"])
+      s.add_dependency(%q<activesupport>, [">= 3.0.3"])
+      s.add_dependency(%q<activemodel>, [">= 3.0.3"])
+      s.add_dependency(%q<autotest>, [">= 0"])
+      s.add_dependency(%q<autotest-growl>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<mongoid>, ["= 2.0.0.beta.20"])
+    s.add_dependency(%q<bson_ext>, ["= 1.1.5"])
+    s.add_dependency(%q<yajl-ruby>, [">= 0.7.8"])
+    s.add_dependency(%q<activesupport>, [">= 3.0.3"])
+    s.add_dependency(%q<activemodel>, [">= 3.0.3"])
+    s.add_dependency(%q<autotest>, [">= 0"])
+    s.add_dependency(%q<autotest-growl>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,250 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'test/unit'
+require 'shoulda'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'mongoid_nested_fields'
+
+class Test::Unit::TestCase
+end
+
+# For the queasy, this is MIT licensed. See comment at the end.
+
+module ExceptionMacros
+  # Make sure a block raises an exception.
+  # Call with optional arguments :instance_of/:kind_of and :message
+  # If :instance_of or :kind_of is specified, assert on the given type. 
+  #   Otherwise only assert that an exception is raised.
+  #   Note: The shorthand should_raise(LoadError) is equivalent to should_raise(:instance_of => LoadError)
+  # If :message is specified, will assert that exception.message =~ :message.
+  #
+  # Examples:
+  #   should_raise {a block}
+  #   should_raise(LoadError) {a block}
+  #   should_raise(:instance_of => LoadError) {a block}
+  #   should_raise(:kind_of => LoadError) {a block}
+  #   should_raise(:message => "no such file to load") {a block}
+  #   should_raise(:message => /load/) {a block}
+  #   should_raise(LoadError, :message => /load/) {a block}
+  #   should_raise(:kind_of => LoadError, :message => /load/) {a block}
+  #   should_raise(:instance_of => LoadError, :message => /load/) {a block}
+  def should_raise(*args, &block)
+    opts = args.last.is_a?(Hash) ? args.pop : {}
+    
+    if args.first.is_a?(Class)
+      type  = args.first
+      exact = true
+    else
+      type  = opts[:instance_of] || opts[:kind_of]
+      exact = !!opts[:instance_of]
+    end
+    message = opts[:message]
+    
+    # Make sure we don't have a false sense of security and bork if incorrect options are supplied.
+    [:message, :instance_of, :kind_of].each { |acceptable_arg| opts.delete(acceptable_arg) }
+    raise ArgumentError, "Unknown parameter(s): #{opts.keys.inspect}. Only :message, :instance_of and :kind_of are supported." if opts.size > 0
+    
+    context "block #{block.inspect}" do # To avoid dupes
+      if type
+      
+        should "raise an exception of type #{type.inspect}" do
+          begin
+            yield
+          rescue Exception => ex
+            @raised_exception = ex
+          end
+          if exact
+            assert_instance_of type, @raised_exception
+          else
+            assert_kind_of type, @raised_exception
+          end
+        end
+      
+      else
+      
+        should "raise an exception" do
+          has_raised = false
+          begin
+            yield
+          rescue Exception => ex
+            has_raised = true
+          end
+          assert has_raised, "The block was expected to raise an exception, but didn't"
+        end
+      
+      end
+    end
+    
+    if message
+      context "raising an exception" do
+        setup do
+          begin
+            yield
+          rescue Exception => ex
+            @raised_exception = ex
+          end
+        end
+        
+        should "contain a message that matches #{message.inspect}" do
+          assert_match message, @raised_exception.message
+        end
+      end
+    end
+  end
+end
+
+Test::Unit::TestCase.send :extend, ExceptionMacros
+
+# A test suite for the macro
+
+=begin
+require "#{ File.dirname(__FILE__) }/../test_helper"
+
+class ExceptionMacroTest < Test::Unit::TestCase
+  # All of the basic Ruby 1.8 exceptions, except for 'fatal'
+  EXCEPTIONS = [
+    Exception,
+      NoMemoryError, 
+      ScriptError, 
+        LoadError, 
+        NotImplementedError, 
+        SyntaxError, 
+      SecurityError, 
+      SignalException, 
+        Interrupt, 
+      StandardError, 
+        ArgumentError, 
+        IndexError, 
+        IOError, 
+          EOFError, 
+        LocalJumpError, 
+        NameError,
+          NoMethodError, 
+        RangeError, 
+          FloatDomainError, 
+        RegexpError, 
+        RuntimeError, 
+        SystemCallError, 
+        ThreadError, 
+        TypeError, 
+        ZeroDivisionError,
+      SystemExit, 
+      SystemStackError]
+  
+  EXCEPTIONS_WITH_PARAMS = {
+    Interrupt => 0,
+    SystemCallError => 2,
+    SignalException => 2
+  }
+  
+  PLAIN_EXCEPTIONS = EXCEPTIONS - EXCEPTIONS_WITH_PARAMS.keys
+
+  context "Raising all the types of exceptions" do
+    PLAIN_EXCEPTIONS.each do |x|
+      context "for exception #{x.inspect}, with a straight exception class argument" do
+        should_raise(x) { raise x }
+      end
+    end
+    
+    EXCEPTIONS_WITH_PARAMS.each_pair do |x, p|
+      context "for exception #{x.inspect} with param #{p.inspect}, with a :kind_of exception" do
+        should_raise(:kind_of => x) { raise x, p }
+      end
+    end
+    
+    (PLAIN_EXCEPTIONS - [SystemCallError]).each do |x|
+      context "for exception #{x.inspect}, with an :instance_of exception" do
+        should_raise(:instance_of => x) { raise x }
+      end
+    end
+  end
+  
+  context "Using an unknown param_type" do
+    should_raise(ArgumentError, :message => /:unknown_param_type/) do
+      should_raise(:unknown_param_type => 'foo') {}
+    end
+  end
+  
+  should_raise do
+    require "more vespene gas"
+  end
+  # 1 assertion
+  
+  should_raise(LoadError) do
+    require "more vespene gas"
+  end
+  # 1 more restrictive assertion
+  
+  should_raise(:instance_of => LoadError) do
+    require "more vespene gas"
+  end
+  # 1 assertion, the same as should_raise(LoadError)
+  
+  should_raise(:kind_of => ScriptError) do
+    require "more vespene gas"
+  end
+  # 1 assertion, slightly less strict than with :instance_of (note: LoadError < ScriptError)
+  
+  should_raise(:message => "no such file to load") do
+    require "more vespene gas"
+  end
+  # 2 assertions
+  
+  should_raise(:message => /vespene/) do
+    require "more vespene gas"
+  end
+  # 2 assertions
+  
+  should_raise(LoadError, :message => "such file to load") do
+    require "more vespene gas"
+  end
+  # 2 assertions
+  
+  should_raise(:kind_of => LoadError, :message => "file to load") do
+    require "more vespene gas"
+  end
+  # 2 assertions
+  
+  should_raise(:instance_of => LoadError, :message => "to load") do
+    require "more vespene gas"
+  end
+  # 2 assertions
+end
+=end
+
+
+=begin
+Copyright (c) 2008 Mathieu Martin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=end

data/test/test_mongoid_nested_fields.rb

@@ -0,0 +1,195 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestMongoidNestedFields < Test::Unit::TestCase
+  context "MongoidNestedFields" do
+    setup do
+      Mongoid.configure do |config|
+        name = "mongoid_content_block_development"
+        host = "localhost"
+        config.master = Mongo::Connection.new.db(name)
+        config.persist_in_safe_mode = false
+      end
+    
+      class ContentItem
+        include Mongoid::Document
+        nested_field :paragraph, :allowed_types => [String, Hash]
+      end
+      ContentItem.destroy_all
+    end
+  
+    context "Class that includes Mongoid::Document" do
+  
+      should "have nested_field class method" do
+        assert ContentItem.respond_to?(:nested_field)
+      end
+    
+      should "correctly set field via nested_field" do
+        c = ContentItem.new
+        assert c.respond_to?(:paragraph)
+      end
+    
+      should "set nested_field as MongoidNestedFields::NestedFieldHolder" do
+        assert_equal ContentItem.fields['paragraph'].type, MongoidNestedFields::NestedFieldHolder
+      end
+    
+      should_raise MongoidNestedFields::Errors::UnexpectedType do
+        # Test if we can put unexpected type in value array
+        c = ContentItem.new
+        c.paragraph = [1]
+      end
+      
+      should_raise TypeError do
+        c = ContentItem.new
+        c.paragraph = {:k => 'v'}
+      end
+    
+      should "set nested_field to array of values with allowed types" do
+        c = ContentItem.new
+        c.paragraph = ["String", {'k' => 'Value'}]
+        assert_equal c.paragraph, ["String", {'k' => 'Value'}]
+      end
+    
+      should "set nested_field from JSON" do
+        c = ContentItem.new
+        c.paragraph = "[\"String\",{\"k\":\"Value\"}]"
+        assert_equal c.paragraph, ["String", {'k' => 'Value'}]
+      end
+    
+      should "use correct class to set value if _type attribute is present" do
+        
+        class ::ImageWithCaption
+          include MongoidNestedFields::NestedField
+          field :image
+          field :caption
+          def image
+            read_attribute('image').upcase
+          end
+          def caption
+            read_attribute('caption').upcase
+          end
+        end
+        
+        ContentItem.nested_field :image_with_caption, :allowed_types => [ImageWithCaption]
+        c = ContentItem.new
+        c.image_with_caption = [
+          {'_type' => 'ImageWithCaption', :image => 'Image', :caption => 'Caption'}
+        ]
+        c.save
+        
+        assert_equal c.image_with_caption.first, {'_type' => 'image_with_caption', 'image' => 'IMAGE', 'caption' => 'CAPTION'}
+      end
+      should "allow of nesting content fields and content field parts" do
+        class ::Image
+          include MongoidNestedFields::NestedField
+          field :image
+          
+          def image
+            read_attribute('image').upcase
+          end
+          
+        end
+        
+        class ::ImageGallery
+          include MongoidNestedFields::NestedField
+          nested_field :gallery, :allowed_types => [Image]
+          field :gallery_name
+        end
+        
+        ContentItem.nested_field :gallery, :allowed_types => [ImageGallery]
+        c = ContentItem.new
+        c.gallery = [{
+          '_type' => 'image_gallery',
+          'gallery_name' => 'Test',
+          :gallery => [
+            {:_type => 'image', :image => 'img'}
+          ]
+        }]
+        
+        assert_equal c.gallery, [{
+                                  '_type' => 'image_gallery',
+                                  'gallery_name' => 'Test',
+                                  'gallery' => [
+                                    {'_type' => 'image', 'image' => 'IMG'}
+                                  ]
+                                }]
+        
+      end
+      
+      should "validate each content field" do
+        class ::ParagraphWithTitle
+          include MongoidNestedFields::NestedField
+          field :title
+          field :paragraph
+          
+          validates_presence_of :paragraph
+        end
+        
+        ContentItem.nested_field :paragraph_with_title, :allowed_types => [ParagraphWithTitle]
+        c = ContentItem.new
+        c.paragraph_with_title = [{
+          :_type => 'paragraph_with_title',
+          :title => 'Title'
+        }]
+        c.invalid?
+        assert c.invalid?
+      end
+      
+      should "validate nested fields" do
+        class ::Para
+          include MongoidNestedFields::NestedField
+          field :para
+          field :subtitle
+          validates_presence_of :para
+        end
+        class ::Title
+          include MongoidNestedFields::NestedField
+          field :title
+          nested_field :paragraph, :allowed_types => [Para]
+        end
+        
+        ContentItem.nested_field :test_para_title, :allowed_types => [Title]
+        
+        c = ContentItem.new(:test_para_title => [{
+          '_type' => 'title',
+          :title => 'Title',
+          :paragraph => [{
+            '_type' => 'para',
+            :subtitle => 'Subtitle'
+          }]
+        }])
+        
+        assert c.invalid?
+      end
+      
+      should "load correctly from database" do
+        class ::ParagraphWithTitle
+          include MongoidNestedFields::NestedField
+          field :title
+          field :paragraph
+        
+          validates_presence_of :paragraph
+        end
+      
+        ContentItem.destroy_all
+      
+        ContentItem.nested_field :paragraph_with_title, :allowed_types => [ParagraphWithTitle]
+        c = ContentItem.new
+        c.paragraph_with_title = [{
+          :_type => 'paragraph_with_title',
+          :title => 'Title',
+          :paragraph => 'Para'
+        }]
+        
+        c.save
+        
+        document = ContentItem.first
+        
+        assert_equal document.paragraph_with_title.first.origin.class, ::ParagraphWithTitle
+        
+      end
+      
+    end
+  end
+end

metadata

@@ -0,0 +1,242 @@
+--- !ruby/object:Gem::Specification 
+name: mongoid_nested_fields
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- retro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 20
+        version: 2.0.0.beta.20
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 5
+        version: 1.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - 8
+        version: 0.7.8
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 3
+        version: 3.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 3
+        version: 3.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: autotest-growl
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id011
+description: MongoidNestedFields allows you to handle complex data structures inside one field in MongoDB. It also validates whole object graph on field validation
+email: konjevic@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .autotest
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/mongoid_nested_fields.rb
+- lib/mongoid_nested_fields/errors.rb
+- lib/mongoid_nested_fields/errors/unexpected_type.rb
+- lib/mongoid_nested_fields/nested_field_hash.rb
+- lib/mongoid_nested_fields/nested_field_holder.rb
+- lib/mongoid_nested_fields/nested_field_part.rb
+- lib/mongoid_nested_fields/nested_field_setter.rb
+- mongoid_nested_fields.gemspec
+- test/helper.rb
+- test/test_mongoid_nested_fields.rb
+has_rdoc: true
+homepage: http://github.com/retro/mongoid_nested_fields
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -4348957618995795359
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: MongoidNestedFields allows you to handle complex data structures inside one field in MongoDB.
+test_files: 
+- test/helper.rb
+- test/test_mongoid_nested_fields.rb