mongoid_nested_fields 0.1.1 → 0.1.2

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/lib/mongoid_nested_fields/nested_field_holder.rb

@@ -6,7 +6,7 @@ module MongoidNestedFields
       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
+            v = v['_type'].classify.constantize.new(v.to_hash)
           end
           v
         end
@@ -15,9 +15,6 @@ module MongoidNestedFields
     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
     

data/lib/mongoid_nested_fields/nested_field_part.rb

@@ -5,10 +5,14 @@ module MongoidNestedFields
     module ClassMethods
       
       def nested_field(name, options = {})
+        options.merge!({:nested => true})
+        
         add_nested_field(name)
+        
         set_validations
-        options[:type] = Array
+        set_field_options(name, options)
         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
@@ -30,12 +34,34 @@ module MongoidNestedFields
         
         define_method(name) do
           read_attribute(name).map{ |v| v.respond_to?(:to_mongo) ? v.to_mongo : v }
-          
+          read_attribute(name)
+        end
+
+      end
+      
+      def field(name, options = {})
+        add_field(name)
+        set_field_options(name, options)
+        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 set_field_options(field, options)
+        @_field_options ||= {}
+        @_field_options[field] = options
+      end
+      
+      def field_options
+        @_field_options || {}
+      end
+      
       def set_validations
         validate :nested_fields_must_be_valid
       end
@@ -45,31 +71,22 @@ module MongoidNestedFields
         @_allowed_types_in_field ||= {}
         @_allowed_types_in_field[field] ||= []
         @_allowed_types_in_field[field] << type
-        @_allowed_types_in_field[field].flatten!.uniq!
+        @_allowed_types_in_field[field].flatten!
+        @_allowed_types_in_field[field].uniq! unless @_allowed_types_in_field[field].nil?
       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 ||= []
@@ -84,8 +101,6 @@ module MongoidNestedFields
       
     end
     
-    
-    
     def self.included(base)
       base.extend(ClassMethods)
       base.send(:include, ActiveModel::Validations)
@@ -112,9 +127,16 @@ module MongoidNestedFields
       @_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]
+      fields = self.class.instance_variable_get(:@_fields)
+      raise "Field #{name} doesn't exist in #{self.class}" if fields.nil? or !fields.include?(name.to_sym)
+      @_attributes[name.to_sym]
+    end
+    
+    def [](key)
+      read_attribute(key)
     end
     
     def attributes
@@ -124,7 +146,11 @@ module MongoidNestedFields
     def to_mongo
       attrs = MongoidNestedFields::NestedFieldHash.new
       attributes.each_key do |key|
-        attrs[key.to_s] = self.send(key.to_sym)
+        if self.send(key.to_sym).is_a?(Array)
+          attrs[key.to_s] = self.send(key.to_sym).map{ |v| v.respond_to?(:to_mongo) ? v.to_mongo : v }
+        else
+          attrs[key.to_s] = self.send(key.to_sym)
+        end
       end
       attrs['_type'] = _type
       attrs.origin   = self

data/lib/mongoid_nested_fields/nested_field_setter.rb

@@ -8,8 +8,9 @@ module MongoidNestedFields
         @_nested_fields << name.to_s
         options[:type] = MongoidNestedFields::NestedFieldHolder
         
-        set_allowed_types_in_field(name, options.delete(:allowed_types))      
-        set_validations
+        _set_allowed_types_in_field(name, options.delete(:allowed_types))      
+        _set_validations
+        _set_serialization
 
         field(name, options)
         meth = options.delete(:as) || name
@@ -25,7 +26,7 @@ module MongoidNestedFields
             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)
+            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)
@@ -33,25 +34,31 @@ module MongoidNestedFields
         
       end
       
-      def set_validations
-        validate :nested_fields_must_be_valid
+      def _set_serialization
+        before_save :_serialize_nested_fields
+        after_save  :_restore_nested_fields
       end
-      
-      def set_allowed_types_in_field(field, type)
+    
+      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!
+        @_allowed_types_in_field[field].flatten!
+        @_allowed_types_in_field[field].uniq! unless @_allowed_types_in_field[field].nil?
       end
-      def allowed_types_in_field(field)
+      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)
+      def _is_allowed_type?(field, type)
         field = field.to_sym
-        allowed_types_in_field(field).include?(type)
+        _allowed_types_in_field(field).include?(type)
       end
     end
     
@@ -59,32 +66,49 @@ module MongoidNestedFields
       reciever::ClassMethods.send :include, ClassMethods
     end
     
-    def _nested_fields
-      self.class.instance_variable_get(:@_nested_fields)
-    end
+    private
     
-    def rebuild_nested_fields
-      _nested_fields.each do |c|
-        value = self.send(c)
-        self.send("#{c}=", value) unless value.nil?
+      def _nested_fields
+        self.class.instance_variable_get(:@_nested_fields)
+      end
+    
+      def _serialize_nested_fields
+        _nested_fields.each do |nested_field|
+          serialized_nested_field = []
+          value = read_attribute(nested_field)
+          value.each do |part|
+            serialized_nested_field << (part.respond_to?(:to_mongo) ? part.to_mongo : part)
+          end unless value.nil?
+          write_attribute(nested_field, serialized_nested_field)
+        end
+      end
+    
+      def _restore_nested_fields
+        _nested_fields.each do |nested_field|
+          restored_nested_field = []
+          value = read_attribute(nested_field)
+          value.each do |part|
+            restored_nested_field << (part.respond_to?(:origin) ? part.origin : part)
+          end unless value.nil?
+          write_attribute(nested_field, restored_nested_field)
+        end
       end
-    end
     
-    def nested_fields_must_be_valid
+      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
+        _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/mongoid_nested_fields.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mongoid_nested_fields}
-  s.version = "0.1.1"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["retro"]

data/test/test_mongoid_nested_fields.rb

@@ -78,7 +78,7 @@ class TestMongoidNestedFields < Test::Unit::TestCase
         ]
         c.save
         
-        assert_equal c.image_with_caption.first, {'_type' => 'image_with_caption', 'image' => 'IMAGE', 'caption' => 'CAPTION'}
+        assert_equal c.image_with_caption.first.class, ::ImageWithCaption
       end
       should "allow of nesting content fields and content field parts" do
         class ::Image
@@ -107,13 +107,13 @@ class TestMongoidNestedFields < Test::Unit::TestCase
           ]
         }]
         
-        assert_equal c.gallery, [{
+        assert_equal c.gallery.first.to_mongo, {
                                   '_type' => 'image_gallery',
                                   'gallery_name' => 'Test',
                                   'gallery' => [
                                     {'_type' => 'image', 'image' => 'IMG'}
                                   ]
-                                }]
+                                }
         
       end
       
@@ -186,10 +186,46 @@ class TestMongoidNestedFields < Test::Unit::TestCase
         
         document = ContentItem.first
         
-        assert_equal document.paragraph_with_title.first.origin.class, ::ParagraphWithTitle
+        assert_equal document.paragraph_with_title.first.class, ::ParagraphWithTitle
         
       end
       
+      should "return options for field definitions" do
+        class ::ParagraphWithTitle
+          include MongoidNestedFields::NestedField
+          field :title, :custom_option => 'custom'
+          field :paragraph
+          nested_field :test_hash, :allowed_types => [Hash]
+        end
+        field_options = ::ParagraphWithTitle.field_options
+        assert_equal field_options, {
+                                      :title => {:custom_option => 'custom'},
+                                      :paragraph => {},
+                                      :test_hash => {:nested => true}
+                                    }
+      end
+      
+      should "allow access through []" do
+        class ::ParagraphWithTitle
+          include MongoidNestedFields::NestedField
+          field :title, :custom_option => 'custom'
+          field :paragraph
+        end
+        
+        p = ParagraphWithTitle.new(:title => 'test')
+        assert_equal p['title'], 'test'
+      end
+      
+      should_raise do
+        class ::ParagraphWithTitle
+          include MongoidNestedFields::NestedField
+          field :title, :custom_option => 'custom'
+          field :paragraph
+        end
+        p = ParagraphWithTitle.new
+        p['non_existing_attr']
+      end
+      
     end
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - retro
@@ -218,7 +218,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4348957618995795359
+      hash: -3846493665174645855
       segments: 
       - 0
       version: "0"