hsume2-mapped-record 0.0.1 → 0.0.2

data/History.txt

@@ -2,3 +2,12 @@
 
 * 1 major enhancement:
   * Initial release
+
+== 0.0.1 2009-06-13
+
+* 5 minor enhancements:
+  * using define_method instead of instance_eval
+  * using indifferent access
+  * added coverage (99.6%)
+  * disallow invalid attr_mapped_named names
+  * added better exceptions

data/lib/mapped-record.rb

@@ -1,18 +1,18 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
 #  See +attr_mapped+ or the README for details.
 #
 #
 #  Created by Henry Hsu on 2009-06-07.
 #  Copyright 2009 Qlane. All rights reserved.
-# 
-
-$:.unshift(File.dirname(__FILE__)) unless
-$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+#
 
 require 'mapped-record/hash/mappable'
 require 'mapped-record/mapping'
 
 module MappedRecord
-  VERSION = '0.0.1' # :nodoc:
+  VERSION = '0.0.2' # :nodoc:
 
   IMPLICIT = 0 # :nodoc:
   NAMESPACE = 1 # :nodoc:
@@ -21,14 +21,36 @@ module MappedRecord
   class << self
     def included base #:nodoc:
       base.extend ClassMethods
+      base.send :include, InstanceMethods
     end
   end
-  
-  #--
-  # TODO subclass this to signify each kind of error
-  #++
+
   class MappingError < StandardError; end # :nodoc:
 
+  class TargetError < MappingError
+    attr_reader :message
+    def initialize(mapping_name, key, target = nil, expected = [])
+      @message = "Got #{target.class} for target. #{expected.join(' or ')} expected." if target
+      @message = "Got #{key.class} for key. #{expected.join(' or ')} expected." unless target
+    end
+  end
+
+  class NamespaceError < MappingError; end
+
+  class CollisionError < MappingError
+    attr_reader :message
+    def initialize(mapping_name, key, value, collisions)
+      targets = collisions.map { |c| c.first } << key
+      @message = "Collision: #{targets.join(', ')} map to '#{value}'"
+    end
+  end
+
+  class NameError < MappingError
+    def initialize(message)
+      @message = "#{message} is an invalid mapping name."
+    end
+  end
+
   module ClassMethods
     # Assigns a mapping for the current ActiveRecord class.
     #
@@ -57,7 +79,7 @@ module MappedRecord
     def attr_mapped(*map_attrs)
       attr_mapped_named(class_name, *map_attrs)
     end
-    
+
     # Assigns mappings to a name.
     #
     #  class Person < ActiveRecord::Base
@@ -69,11 +91,9 @@ module MappedRecord
     #   p = Person.create_with_public({ 'PBName' => 'Mr. Name' })
     #   p.update_with_public({ 'PBName' => 'Full Name' })
     def attr_mapped_named(named_mapping = nil, *map_attrs)
-      include InstanceMethods
-
       unless self.respond_to?(:attr_mapped_serialized)
         class_inheritable_accessor :attr_mapped_serialized
-        write_inheritable_attribute :attr_mapped_serialized, Hash.new
+        write_inheritable_attribute :attr_mapped_serialized, HashWithIndifferentAccess.new
       end
 
       unless self.respond_to?(:attr_hashed_id)
@@ -81,7 +101,8 @@ module MappedRecord
         write_inheritable_attribute :attr_hashed_id, ''
       end
 
-      raise ArgumentError, "Mapping name not given." if named_mapping.nil?
+      raise NameError.new(named_mapping) if named_mapping.nil?
+      raise NameError.new(named_mapping) unless named_mapping.to_s[/[a-zA-Z_]?[a-zA-Z_0-9]+/] == named_mapping.to_s
       raise MappingError, "No options given." if map_attrs.blank?
 
       options = map_attrs.extract_options!
@@ -93,8 +114,14 @@ module MappedRecord
         when :id
           self.attr_hashed_id = value.to_s
         when :serialize
-          keys = [value.to_s] unless value.kind_of?(Array) # TODO if-else blocks probably more efficient
-          keys = value.collect { |v| v.to_s } if value.kind_of?(Array)
+          case value
+          when String, Symbol, Array
+          else
+            raise TargetError.new(named_mapping, key, value, [String, Symbol, Array])
+          end
+          
+          value = [value] unless value.kind_of?(Array)
+          keys = value.collect { |v| v.to_s }
           serialize_mappings |= keys
         end
       end
@@ -105,9 +132,15 @@ module MappedRecord
       Mapping.create named_mapping, *map_attrs
 
       if Mapping.has?(named_mapping)
-        self.instance_eval %Q{ def create_with_#{named_mapping}(hash); create_with(hash, :#{named_mapping}); end; }
-        self.class_eval %Q{ def update_with_#{named_mapping}(hash); update_with(hash, :#{named_mapping}); end }
-        self.attr_mapped_serialized[named_mapping] ||= Hash.new
+        # create dynamic methods
+        self.class.send(:define_method, :"create_with_#{named_mapping}") do |hash|
+          create_with(hash, :"#{named_mapping}")
+        end
+        self.send(:define_method, :"update_with_#{named_mapping}") do |hash|
+          update_with(hash, :"#{named_mapping}")
+        end
+
+        self.attr_mapped_serialized[named_mapping] ||= HashWithIndifferentAccess.new
         self.attr_mapped_serialized[named_mapping] = update_serialized(named_mapping)
       end
 
@@ -132,11 +165,6 @@ module MappedRecord
       end
     end
 
-    # A helper to check if the Active Record object responds to mapped-record methods.
-    def acts_like_mapped?
-      true
-    end
-
     # Maps the values in +hash+ with +named_mapping+ for use in Active Record.
     def with_attributes(named_mapping, hash)
       attrs = hash.map_with(named_mapping)
@@ -166,7 +194,7 @@ module MappedRecord
     # Accepts a hash to map and update the object with.
     def update_with(hash = {}, named_mapping = nil)
       named_mapping = self.class.class_name unless named_mapping
-      
+
       self.attributes = self.class.with_attributes(named_mapping, hash)
 
       if !self.changes.blank?

data/lib/mapped-record/mapping.rb

@@ -20,13 +20,11 @@ module MappedRecord
       # [<tt>'key' => :target, 'key2' => :target2, ...</tt>]
       #   As many manual mappings as needed.
       def create(mapping_name, *map_attrs)
-        raise MappingError, "Not creating mapping with nil name" if mapping_name.nil?
-        named_mappings[mapping_name] ||= Hash.new
+        raise NameError, "Not creating mapping with nil name" if mapping_name.nil?
+        named_mappings[mapping_name] ||= HashWithIndifferentAccess.new
 
         options = map_attrs.extract_options!
-        verbose = parse_verbose(options)
 
-        serialize_mappings = []
         namespace = nil
         type = IMPLICIT
 
@@ -36,25 +34,24 @@ module MappedRecord
             namespace = value.to_s unless value.to_s.blank?
           when :filter
             value.each_pair do |attr, proc|
-              named_mappings[mapping_name][attr.to_s] ||= Hash.new
+              named_mappings[mapping_name][attr.to_s] ||= HashWithIndifferentAccess.new
               named_mappings[mapping_name][attr.to_s][:filter] = proc
             end
           when String, Symbol # deals with explicit mappings
-            raise MappingError, "Must be symbol" unless value.kind_of?(Symbol)
+            raise TargetError.new(mapping_name, key, value, [String, Symbol]) unless value.kind_of?(Symbol)
             update_mapping(mapping_name, key, value.to_sym, EXPLICIT)
           end
         end
 
-        mapping_temp = Hash.new
+        mapping_temp = HashWithIndifferentAccess.new
 
         map_attrs.each do |attr|
-          raise MappingError, "Must be string or symbol." unless attr.kind_of?(String) or attr.kind_of?(Symbol)
+          raise TargetError.new(mapping_name, attr, nil, [Symbol]) unless attr.kind_of?(String) or attr.kind_of?(Symbol)
 
           mapped_attr = attr.to_s
           if namespace
-            match = mapped_attr[/^#{namespace}/]
-            raise MappingError, "Causes mapping to be ''" if mapped_attr == match
-            if match
+            raise NamespaceError, "Causes mapping to be ''" if mapped_attr == namespace
+            if mapped_attr.match(/^#{namespace}/)
               mapped_attr = mapped_attr.sub(/^#{namespace}/, '')
               type = NAMESPACE
             end
@@ -66,13 +63,13 @@ module MappedRecord
         named_mappings[mapping_name]
       end
 
-      def parse_verbose(options) # :nodoc:
-        if !options[:verbose].nil? && (options[:verbose].kind_of?(FalseClass) || options[:verbose].kind_of?(TrueClass))
-          verbose = options[:verbose]
-          options.delete(:verbose) 
-          verbose
-        end
-      end
+      # def parse_verbose(options) # :nodoc:
+      #   if !options[:verbose].nil? && (options[:verbose].kind_of?(FalseClass) || options[:verbose].kind_of?(TrueClass))
+      #     verbose = options[:verbose]
+      #     options.delete(:verbose) 
+      #     verbose
+      #   end
+      # end
 
       # Returns true if mapping of +mapping_name+ is assigned.
       def has?(mapping_name)
@@ -104,20 +101,27 @@ module MappedRecord
         create(key, *values)
       end
 
-      attr_accessor :named_mappings # :nodoc:
+      attr_reader :named_mappings # :nodoc:
 
       def named_mappings # :nodoc:
-        @named_mappings ||= Hash.new
+        @named_mappings ||= HashWithIndifferentAccess.new
       end
 
-      private :named_mappings
+      # Returns all defined mappings.
+      def all
+        named_mappings
+      end
 
       def update_mapping(mapping_name, key, value, type) # :nodoc:
         named_mapping = named_mappings[mapping_name]
-        named_mapping[key] ||= Hash.new
+        named_mapping[key] ||= HashWithIndifferentAccess.new
 
         if named_mapping[key][:to].nil? or type >= named_mapping[key][:type]
-          raise MappingError, "Multiple keys pointing to the same symbol" unless named_mapping.select { |key_name, mapping| key_name != key && mapping[:to] == value }.blank?
+          # check collision
+          collisions = named_mapping.select { |key_name, mapping| key_name.to_s != key.to_s && mapping[:to] == value }
+          raise CollisionError.new(mapping_name, key, value, collisions) unless collisions.blank?
+
+          # assign mapping
           named_mapping[key][:to] = value and named_mapping[key][:type] = type
         end
       end

data/test/hashed-record/test_mapping.rb

@@ -5,17 +5,22 @@ class TestMapping < Test::Unit::TestCase
     setup do
       @sample_hash = {"PhotoCount"=>1, "KeyList"=>["2"], "KeyPhotoKey"=>"2", "RollID"=>3, "RollDateAsTimerInterval"=>263609145.0, "RollName"=>"May 9, 2009"}
     end
+
+		should "use use hash with indifferent access" do
+			assert(Mapping.send(:named_mappings).kind_of?(HashWithIndifferentAccess), "Should be hash with indifferent access.")
+		end
     
     context "creating named mapping" do
       setup do
         @mapping_name = :test_mapping
         @@proc = Proc.new { |p| 'PROC-ED' }
-        Mapping.create @mapping_name, 'ImplicitMapping', 'AnotherMapping', 'ForNamespaceMapping', 'ExplicitMapping' => :explicit, :namespace => 'ForNamespace', :filter => { 'ImplicitMapping' => @@proc }
+        Mapping.create @mapping_name, 'ImplicitMapping', :AnotherMapping, 'ForNamespaceMapping', 'ExplicitMapping' => :explicit, :namespace => 'ForNamespace', :filter => { 'ImplicitMapping' => @@proc }
       end
 
       should "have mapping named #{@mapping_name}" do
         assert Mapping.has?(@mapping_name)
         assert Mapping[@mapping_name].is_a?(Hash)
+				assert Mapping.all.include?(@mapping_name)
       end
       
       should "have #[] method" do
@@ -43,27 +48,29 @@ class TestMapping < Test::Unit::TestCase
       setup { Mapping.reset }
       
       should "allow symbol mapping" do
-        assert_nothing_raised(MappedRecord::MappingError) { Mapping.create :mixed, :key => :symbol }
+        assert_nothing_raised(MappedRecord::TargetError) { Mapping.create :mixed, :key => :symbol }
         Mapping.reset
-        assert_nothing_raised(MappedRecord::MappingError) { Mapping.create :mixed, :symbol }
+        assert_nothing_raised(MappedRecord::TargetError) { Mapping.create :mixed, :symbol }
       end
       
-      should "not allow non-symbol mappings" do
-        assert_raise(MappedRecord::MappingError) { Mapping.create :mixed, :key => 1 }
-        assert_raise(MappedRecord::MappingError) { Mapping.create :mixed, :key => Fixnum }
-        assert_raise(MappedRecord::MappingError) { Mapping.create :mixed, :key => 'String' }
-        assert_raise(MappedRecord::MappingError) { Mapping.create :mixed, 1 }
-        assert_raise(MappedRecord::MappingError) { Mapping.create :mixed, Fixnum }
+      should "raise TargetError with non-Symbol targets" do
+        assert_raise(MappedRecord::TargetError) { Mapping.create :mixed, :key => 1 }
+        assert_raise(MappedRecord::TargetError) { Mapping.create :mixed, :key => Fixnum }
+				assert_raise(MappedRecord::TargetError) { Mapping.create :mixed, :key => 'String' }
+				assert_raise(MappedRecord::TargetError) { Mapping.create :mixed, 'key2' => 'String' }
+        assert_raise(MappedRecord::TargetError) { Mapping.create :mixed, 1 }
+        assert_raise(MappedRecord::TargetError) { Mapping.create :mixed, Fixnum }
+				assert_raise(MappedRecord::TargetError) { Mapping.create :mixed, Mapping.class }
       end
 
       context "with mixed options" do
         # 4 combinations of symbol:string
         # validate :to is string or symbol
         setup do
-          Mapping.create :mixed, :SymbolMapping, 'StringMapping', :symbol_key => :key, "symbol_key" => :other_key
+          Mapping.create :mixed, :SymbolMapping, 'StringMapping', :symbol_key, "symbol_key" => :other_key
         end
 
-        should_map_explicit :mixed, :symbol_key, :key
+        should_map_explicit :mixed, :symbol_key, :other_key
         should_map_explicit :mixed, "symbol_key", :other_key
         should_map_implicit :mixed, 'StringMapping', :string_mapping
         should_map_implicit :mixed, :SymbolMapping, :symbol_mapping
@@ -77,8 +84,10 @@ class TestMapping < Test::Unit::TestCase
       
       should "clear mappings" do
         assert(!Mapping.blank?, "Mapping is blank.")
+				assert(!Mapping.empty?, "Mapping is blank.")
         Mapping.reset
         assert(Mapping.blank?, "Mappings should be blank.")
+				assert(Mapping.empty?, "Mappings should be blank.")
       end
     end
 
@@ -136,30 +145,32 @@ class TestMapping < Test::Unit::TestCase
     # ========================
     # = Raising MappingError =
     # ========================
-    should "raise MappingError when #namespace causes mapping to be ''" do
-      assert_raises MappedRecord::MappingError do
+    should "raise NamespaceError when #namespace causes mapping to be ''" do
+      assert_raises MappedRecord::NamespaceError do
         Mapping.create :ns_to_blank, 'ImplicitMapping', 'ImplicitMappingSecond', :namespace => 'ImplicitMapping'
       end
     end
 
-    should "raise MappingError with many-to-one mappings" do # because it will have unexpected results
-      assert_raises MappedRecord::MappingError do
+    should "raise CollisionError with many-to-one mappings" do # because it will have unexpected results
+      assert_raises MappedRecord::CollisionError do
         Mapping.create :many_to_one, 'Root', 'MappingWithRoot', :namespace => 'MappingWith'
       end
     end
     
-    should "raise MappingError with un-named mapping" do
+    should "raise NameError with un-named mapping" do
       Mapping.reset
-      assert_raises MappedRecord::MappingError do
+      assert_raises MappedRecord::NameError do
         Mapping.create nil, 'Root', 'MappingWithRoot', :namespace => 'MappingWith'
       end
       assert(Mapping.blank?, "Mapping shouldn't be set.")
     end
     
-    # should "raise MappingError with invalid mapping names" do
+    # should "raise NameError with invalid mapping names" do
     #   Mapping.reset
-    #   assert_raise(MappedRecord::MappingError) do
+    #   assert_raise(MappedRecord::NameError) do
     #     Mapping.create 1, 'Root'
+    # 				Mapping.create 'name with spaces', 'Root'
+    # 				Mapping.create 'name with |n\/al|# ch*r%ct!rs', 'Root'
     #   end
     # end
   end

data/test/test_helper.rb

@@ -71,7 +71,7 @@ def should_map name, field, mapping, type, klass=Mapping
     raise "Unknown mapping type"
   end
 
-  should "map #{type_s} from #{field} => #{mapping} for mapping :#{name}" do
+  should "map #{type_s} from #{field.kind_of?(Symbol) ? ':' : ''}#{field} => #{mapping} for mapping :#{name}" do
     assert_not_nil(klass.blank?, "Mappings not set up correctly.")
     assert_not_nil(klass[name], "Mapping #{name} not set up correctly.")
     assert_not_nil(klass[name][field], "Mapping #{name}'s #{field} not set up correctly.")

data/test/test_mapped_record.rb

@@ -14,12 +14,8 @@ class TestMappedRecord < Test::Unit::TestCase
       assert_respond_to Dummy, :attr_mapped_named
     end
 
-    should "act like mapped" do
-      assert Dummy.acts_like?(:mapped)
-    end
-
-    should "raise ArgumentError when no mapping name and no options not given" do
-      assert_raises ArgumentError do
+    should "raise NameError when no mapping name and no options not given" do
+      assert_raises MappedRecord::NameError do
         Dummy.class_eval do
           attr_mapped_named
         end
@@ -53,7 +49,7 @@ class TestMappedRecord < Test::Unit::TestCase
       end
     end
 
-    context "when #attr_mapped_named" do # TODO should not allow mapping names with spaces
+    context "when #attr_mapped_named" do
       context "with dummy mapping and options" do
 
         setup do
@@ -79,6 +75,26 @@ class TestMappedRecord < Test::Unit::TestCase
           assert Dummy.serialized_attributes.include?("mapping")
         end
 
+        context "with indifferent access" do
+          setup do
+            rebuild_class :dummy2, :ImplicitMapping, :AnotherMapping, :ForNamespaceMapping, :ExplicitMapping => :explicit, :namespace => 'ForNamespace', :id => 'ForID', :filter => { :ImplicitMapping => @@proc }, :serialize => :ImplicitMapping
+          end
+          
+          # using same tests as above
+          should_map_implicit :dummy2, 'ImplicitMapping', :implicit_mapping
+          should_map_implicit :dummy2, 'AnotherMapping', :another_mapping
+          should_map_namespace :dummy2, 'ForNamespaceMapping', :mapping
+          should_map_explicit :dummy2, 'ExplicitMapping', :explicit
+
+          should "map proc" do
+            assert_same @@proc, Mapping[:dummy2]['ImplicitMapping'][:filter]
+          end
+
+          should "serialize" do
+            assert Dummy.serialized_attributes.include?("implicit_mapping")
+          end
+        end
+
         context "a subclass" do
           setup do
             class ::SubDummy < Dummy; end
@@ -120,6 +136,20 @@ class TestMappedRecord < Test::Unit::TestCase
         end
       end
 
+			should "raise NameError when mapping name has invalid characters" do
+				assert_raises MappedRecord::NameError do
+					rebuild_class 'name with spaces', 'ImplicitMapping'
+          rebuild_class 'namewith|n\/al|#ch*r%ct!rs', 'ImplicitMapping'
+        end
+			end
+			
+			should "raise TargetError when serialize target is not String, Symbol or Array" do
+				assert_raises MappedRecord::TargetError do
+          rebuild_class :serialize_fail, 'ImplicitMapping', 'AnotherMapping', 'ForNamespaceMapping',  :serialize => Fixnum
+					rebuild_class :serialize_fail, 'ImplicitMapping', 'AnotherMapping', 'ForNamespaceMapping',  :serialize => Proc.new{ |p| puts p }
+        end
+			end
+
       # ============================================
       # = #attr_mapped_named called multiple times =
       # ============================================

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hsume2-mapped-record
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Henry Hsu
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-07 00:00:00 -07:00
+date: 2009-06-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency