hsume2-mapped-record 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-06-07
+
+* 1 major enhancement:
+  * Initial release

data/LICENSE

@@ -0,0 +1,25 @@
+
+LICENSE
+
+(The MIT License)
+
+Copyright (c) 2009 Henry Hsu
+
+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/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+LICENSE
+Manifest.txt
+README.rdoc
+Rakefile
+lib/mapped-record.rb
+lib/mapped-record/hash/mappable.rb
+lib/mapped-record/mapping.rb
+script/console
+script/destroy
+script/generate
+test/database.yml
+test/hashed-record/hash/test_mappable.rb
+test/hashed-record/test_mapping.rb
+test/test_helper.rb
+test/test_mapped_record.rb

data/README.rdoc

@@ -0,0 +1,131 @@
+= mapped-record
+
+http://github.com/hsume2/mapped-record
+
+Auto-magically map Hash[keys] to ActiveRecord.attributes.
+
+Suppose you have a hash <tt>a_hash = { 'FullName' => 'Your Name' }</tt>, and an Active Record object
+with a +:full_name+ attribute to create with 'Your Name'. It's easy to deal with this on a one-time basis:
+
+  model.create( :full_name => a_hash['FullName'] )
+
+However, add in 20 other keys and it gets tiresome.
+
+Suppose you could define hash +keys+ and their target ActiveRecord +attribute+ in one place; then, initialize
+Active Record objects with the corresponding data. Continue reading.
+
+== Getting Started
+
+All you have to do is add +attr_mapped+ to your model.
+
+  class Person < ActiveRecord::Base
+    attr_mapped 'FullName' => :full_name
+  end
+  
+Then you can create and update like so:
+
+  p = Person.create_with(h)
+  h['FullName'] = 'Mr. Name'
+  p.update_with(h)
+
++mapped-record+ is more powerful than that. See Mapping Types for efficient ways to assign mappings.
+See Mapping Helpers for extra-added features (e.g. post-processing data).
+
+== Mapping Types
+
+Mappings can be created in the following ways:
+
+=== Automatic mappings (implicit)
+
+If you use,
+  attr_mapped 'FullName'
++attr_mapped+ will automatically downcase_and_underscore the key to +:full_name+, which is often useful.
+Whenever used, specify these first.
+
+=== Manual mappings (explicit)
+
+To manually set which Active Record attribute you want a key to map to, add manual mappings in the options hash.
+  attr_mapped 'FullName' => :full_name
+  attr_mapped { 'FullName' => :full_name } # same as above
+  attr_mapped 'FullName' => :full_name, 'Email' # will fail, because the options hash is considered the last argument
+
+=== Namespace mappings
+
+Suppose you have a lot of keys starting with +PBType+ which you want removed. Then add <tt>:namespace => 'PBType'</tt> to remove the prefix and then map automatically (also in the options hash)
+
+  attr_mapped 'PBTypeName', 'PBTypeAddress', 'PBTypeCode', { :namespace => 'PBType' }
+
+will map +PBTypeName+ to +:name+, +PBTypeAddress+ to +:address+, etc.
+
+Namespaces only apply to the keys for each +attr_mapped+ call. So
+
+  class PBPerson < ActiveRecord::Base
+    attr_mapped 'PBTypeName', { :namespace => 'PBType' }
+    attr_mapped 'PBTypeAddr'
+  end
+
+will map +PBTypeName+ to +:name+, but +PBTypeAddr+ to +:pb_type_addr+.
+
+=== Mapping priority
+
+Regardless of how many times you call +attr_mapped+, mappings are overridden in increasing order of
+priority:
+ 
+* implicit
+* namespace
+* explicit
+  
+That means explicit will always override namespace and implicit, regardless of the order in which #attr_mapped is called. To illustrate this behavior:
+
+  class PBPerson < ActiveRecord::Base
+    attr_mapped 'PBTypeName', { :namespace => 'PBType' }
+    attr_mapped 'PBTypeName'
+    attr_mapped { 'PBTypeName' => :actually_this }
+    
+    attr_mapped 'PBTypeName', { :namespace => 'PBType', 'PBTypeName' => :actually_this } # even in this confusing example
+  end
+
+will map to +:actually_this+. 
+
+== Mapping Helpers
+
+=== :id
+
+If one of the hash keys should map to the Active Record id, setting it like <tt>attr_mapped :key => :id</tt>
+won't work. Active Record won't let you mass assign +:id+ anyway. Instead
+  attr_mapped 'PBTypeName', { :namespace => 'PBType', :id => 'PBKey' }
+to force creation with +PBKey+'s value.
+
+=== :serialize
+
+You can also specify which keys to serialize after they've been mapped. Using,
+  attr_mapped 'PBArray', { :namespace => 'PB', :serialize => 'PBArray' }
+will map +PBArray+ to +:array+ and call <tt>serialize :array</tt> in the Active Record.
+
+=== :filter
+
+You can add proc filters to process data from hashes before it's used by Active Record.
+
+Suppose all the dates are in the wrong format, then,
+  MYDATE = Proc.new { |p| Time.at(p + 978307200) }
+  attr_mapped 'PBDate', { :filter => { 'PBDate' => PBPerson::MYDATE } }
+
+== Named Mappings
+
+If for some reason, you want to use multiple mappings on the same model, you can create named mappings
+with +attr_mapped_named+, where the first argument is the mapping name, followed by the same as +attr_mapped+.
+
+  class Person < ActiveRecord::Base
+    attr_mapped_named :phone_record, 'FullName'
+  end
+
+=== Dynamic methods
+
++mapped-record+ will then dynamically create methods so you can:
+
+  p = Person.create_with_phone_record(h)
+  p.update_with_phone_record(h)
+
+== Credit
+
+... where deserved. A lot of cues from thoughtbot/paperclip[http://github.com/thoughtbot/paperclip] on how to set up the gem and testing, so thanks.

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+%w[rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/mapped-record'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('mapped-record', MappedRecord::VERSION) do |p|
+  p.developer('Henry Hsu', 'henry@qlane.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name
+  p.extra_deps         = [
+    ['activesupport','>= 2.0.2'],
+  ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"],
+    ['thoughtbot-shoulda', '>= 0'],
+    ['sqlite3-ruby', '>= 0']
+  ]
+  p.summary = 'Auto-magically map Hash[keys] to ActiveRecord.attributes'
+  p.description = 'Auto-magically map Hash[keys] to ActiveRecord.attributes'
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }

data/lib/mapped-record/hash/mappable.rb

@@ -0,0 +1,22 @@
+class Hash
+  # Returns a new Hash where the keys have been swapped with those defined in <tt>Mapping[named_mapping]</tt>.
+  def map_with(named_mapping)
+    if Mapping.has?(named_mapping)
+      m = Mapping[named_mapping]
+
+      result = self.inject({}) do |result, element|
+        mapping = m[element.first]
+
+        to = mapping[:to] if mapping
+        proc = mapping[:filter] if mapping
+
+        if to
+          result[to] = element.last unless proc
+          result[to] = proc.call(element.last) if proc
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/mapped-record/mapping.rb

@@ -0,0 +1,130 @@
+module MappedRecord
+  class Mapping  
+    class << self
+      # Assigns a named mapping accessible throughout the runtime environment.
+      #
+      #  Mapping.create :my_mapping, 'Ready', 'Set', 'Go'
+      #
+      # The mapping is then accessible from <tt>Mapping[:my_mapping]</tt>
+      #
+      # Given a list of strings, those keys will be mapped automatically to downcase and
+      # underscored attributes. (Specify these first).
+      # 
+      # Configuration options:
+      # [<tt>:filter</tt>]
+      #   Specify a hash of keys and procs to call before assigning to attributes.
+      #    attr_mapped 'Date', { :after => { 'Date' => Proc.new { ... } } }
+      # [<tt>:namespace</tt>]
+      #   A prefix string to remove before automatically mapping.
+      #    attr_mapped 'PBOne', 'PBTwo', { :namespace => 'PB' }
+      # [<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
+
+        options = map_attrs.extract_options!
+        verbose = parse_verbose(options)
+
+        serialize_mappings = []
+        namespace = nil
+        type = IMPLICIT
+
+        options.each_pair do |key, value|
+          case key
+          when :namespace
+            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][:filter] = proc
+            end
+          when String, Symbol # deals with explicit mappings
+            raise MappingError, "Must be symbol" unless value.kind_of?(Symbol)
+            update_mapping(mapping_name, key, value.to_sym, EXPLICIT)
+          end
+        end
+
+        mapping_temp = Hash.new
+
+        map_attrs.each do |attr|
+          raise MappingError, "Must be string or 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
+              mapped_attr = mapped_attr.sub(/^#{namespace}/, '')
+              type = NAMESPACE
+            end
+          end
+          mapped_attr = mapped_attr.underscore.gsub(' ', '_')
+          update_mapping(mapping_name, attr, mapped_attr.to_sym, type)
+        end
+
+        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
+
+      # Returns true if mapping of +mapping_name+ is assigned.
+      def has?(mapping_name)
+        named_mappings.include?(mapping_name)
+      end
+
+      # Returns true of no mappings are assigned.
+      def empty?
+        named_mappings.empty?
+      end
+
+      # Returns true of no mappings are assigned.
+      def blank?
+        named_mappings.blank?
+      end
+
+      # Clear all mappings.
+      def reset
+        named_mappings.clear
+      end
+
+      # Access named mappings straight from the class.
+      def [](key)
+        named_mappings[key]
+      end
+
+      # Assign mappings straight from the class.
+      def []=(key, values)
+        create(key, *values)
+      end
+
+      attr_accessor :named_mappings # :nodoc:
+
+      def named_mappings # :nodoc:
+        @named_mappings ||= Hash.new
+      end
+
+      private :named_mappings
+
+      def update_mapping(mapping_name, key, value, type) # :nodoc:
+        named_mapping = named_mappings[mapping_name]
+        named_mapping[key] ||= Hash.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?
+          named_mapping[key][:to] = value and named_mapping[key][:type] = type
+        end
+      end
+
+      private :update_mapping
+    end
+  end
+end
+
+Mapping = MappedRecord::Mapping

data/lib/mapped-record.rb

@@ -0,0 +1,183 @@
+#  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:
+
+  IMPLICIT = 0 # :nodoc:
+  NAMESPACE = 1 # :nodoc:
+  EXPLICIT = 2 # :nodoc:
+
+  class << self
+    def included base #:nodoc:
+      base.extend ClassMethods
+    end
+  end
+  
+  #--
+  # TODO subclass this to signify each kind of error
+  #++
+  class MappingError < StandardError; end # :nodoc:
+
+  module ClassMethods
+    # Assigns a mapping for the current ActiveRecord class.
+    #
+    #  class Person < ActiveRecord::Base
+    #    attr_mapped 'PBName', 'PBAddress', 'PBEmail', { :namespace => 'Email' }
+    #  end
+    #
+    # Given a list of strings, those keys will be mapped automatically to downcase and
+    # underscored attributes. (Specify these first).
+    # 
+    # Configuration options:
+    # [<tt>:id</tt>]
+    #   The key to map to the primary key.
+    #    attr_mapped { :id => 'Key' }
+    # [<tt>:serialize</tt>]
+    #   Any keys to serialize after mapping.
+    #    attr_mapped 'Array', 'Blob', { :serialize => ['Array', 'Blob'] }
+    # [<tt>:filter</tt>]
+    #   Specify a hash of keys and procs to call before assigning to attributes.
+    #    attr_mapped 'Date', { :after => { 'Date' => Proc.new { ... } } }
+    # [<tt>:namespace</tt>]
+    #   A prefix string to remove before automatically mapping.
+    #    attr_mapped 'PBOne', 'PBTwo', { :namespace => 'PB' }
+    # [<tt>'key' => :attribute, 'key2' => :attribute2, ...</tt>]
+    #   As many manual mappings as needed.
+    def attr_mapped(*map_attrs)
+      attr_mapped_named(class_name, *map_attrs)
+    end
+    
+    # Assigns mappings to a name.
+    #
+    #  class Person < ActiveRecord::Base
+    #    attr_mapped_named :public, 'PBName', 'PBAddress', 'PBEmail', { :namespace => 'Email' }
+    #  end
+    #
+    # The mapping can then be used with dynamic create and update methods.
+    # From the example above:
+    #   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
+      end
+
+      unless self.respond_to?(:attr_hashed_id)
+        class_inheritable_accessor :attr_hashed_id
+        write_inheritable_attribute :attr_hashed_id, ''
+      end
+
+      raise ArgumentError, "Mapping name not given." if named_mapping.nil?
+      raise MappingError, "No options given." if map_attrs.blank?
+
+      options = map_attrs.extract_options!
+
+      serialize_mappings = []
+
+      options.each_pair do |key, value|
+        case key
+        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)
+          serialize_mappings |= keys
+        end
+      end
+      options.delete(:id)
+      options.delete(:serialize)
+
+      map_attrs << options
+      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
+        self.attr_mapped_serialized[named_mapping] = update_serialized(named_mapping)
+      end
+
+      serialize_mappings.each do |attr|
+        raise MappingError, "Serializing :id not allowed." if !self.attr_hashed_id.blank? && attr == self.attr_hashed_id        
+        to_serialize = Mapping[named_mapping][attr][:to].to_sym
+
+        # need to know serialized attributes to 'watch'
+        self.attr_mapped_serialized[named_mapping][attr] = to_serialize
+
+        self.instance_eval { serialize to_serialize }
+      end
+    end
+
+    # Accepts a hash to map and creates the Active Record object with its values.
+    def create_with(hash = {}, named_mapping = nil)
+      named_mapping = self.class_name unless named_mapping
+
+      self.create(with_attributes(named_mapping, hash)) do |r|
+        id = hash[self.attr_hashed_id]
+        r.id = id if id
+      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)
+      attrs.delete(:id) if attrs[:id]
+      attrs
+    end
+
+    # Maintains that +serialize+ is set for correct attribute.
+    def update_serialized(named_mapping)
+      self.attr_mapped_serialized[named_mapping].inject({}) do |result, element|
+        key = element.first
+        serialized_as = element.last
+
+        to_serialize = Mapping[named_mapping][key][:to].to_sym
+        if to_serialize != serialized_as
+          warn "[MappedRecord] overriding :#{serialized_as} with :#{to_serialize}, will not remove 'serialize :#{serialized_as}'"
+          self.instance_eval { serialize to_serialize }
+          result[key] = to_serialize
+        end
+      end
+    end
+
+    private :update_serialized
+  end
+
+  module InstanceMethods
+    # 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?
+        self.save
+      else
+        false
+      end
+    end
+  end
+end
+
+if Object.const_defined?("ActiveRecord")
+  ActiveRecord::Base.send(:include, MappedRecord)
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/mapped-record.rb'}"
+puts "Loading mapped-record gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"

data/test/hashed-record/hash/test_mappable.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../../test_helper.rb'
+
+class TestMappable < Test::Unit::TestCase
+  context "Hash" do
+    setup do
+      @hash = {"PhotoCount"=>1, "KeyList"=>["2"], "KeyPhotoKey"=>"2", "RollID"=>3, "RollDateAsTimerInterval"=>263609145.0, "RollName"=>"May 9, 2009"}
+    end
+
+    should "have #map_with method" do
+      assert_respond_to @hash, :map_with
+    end
+
+    context "with mapping" do
+      setup do
+        Mapping.create :iphoto_roll2, 'PhotoCount', 'KeyList', 'RollName', 'RollID', :namespace => 'Roll', 'KeyPhotoKey' => :key_photo_id, 'RollDateAsTimerInterval' => :date, :filter => { 'RollDateAsTimerInterval' => Proc.new { |p| Time.at(p.to_f + 978307200) } }
+      end
+      
+      should "map properly" do
+        mapped_hash = @hash.map_with(:iphoto_roll2)
+        assert_not_nil mapped_hash
+        assert_equal 1, mapped_hash[:photo_count]
+        assert_equal "2", mapped_hash[:key_photo_id]
+        assert_equal ["2"], mapped_hash[:key_list]
+        assert_equal Time.at(263609145.0 + 978307200), mapped_hash[:date]
+        assert_equal "May 9, 2009", mapped_hash[:name]
+        assert_equal 3, mapped_hash[:id]
+      end
+    end
+  end
+end

data/test/hashed-record/test_mapping.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestMapping < Test::Unit::TestCase
+  context "Mapping" do
+    setup do
+      @sample_hash = {"PhotoCount"=>1, "KeyList"=>["2"], "KeyPhotoKey"=>"2", "RollID"=>3, "RollDateAsTimerInterval"=>263609145.0, "RollName"=>"May 9, 2009"}
+    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 }
+      end
+
+      should "have mapping named #{@mapping_name}" do
+        assert Mapping.has?(@mapping_name)
+        assert Mapping[@mapping_name].is_a?(Hash)
+      end
+      
+      should "have #[] method" do
+        assert_respond_to Mapping, :[]
+      end
+      
+      should "have #[]= method do the same as #create" do
+        assert_respond_to Mapping, :[]=
+        Mapping[:alt_test_mapping] = 'ImplicitMapping', 'AnotherMapping', 'ForNamespaceMapping', {'ExplicitMapping' => :explicit, :namespace => 'ForNamespace', :filter => { 'ImplicitMapping' => @@proc }}
+        assert_equal Mapping[:alt_test_mapping], Mapping[@mapping_name]
+      end
+
+      should_map_implicit :test_mapping, 'ImplicitMapping', :implicit_mapping
+      should_map_implicit :test_mapping, 'AnotherMapping', :another_mapping
+      should_map_namespace :test_mapping, 'ForNamespaceMapping', :mapping
+      should_map_explicit :test_mapping, 'ExplicitMapping', :explicit
+
+      should "map proc" do
+        assert_same @@proc, Mapping[@mapping_name]['ImplicitMapping'][:filter]
+      end
+    end
+
+    context "with options" do
+      
+      setup { Mapping.reset }
+      
+      should "allow symbol mapping" do
+        assert_nothing_raised(MappedRecord::MappingError) { Mapping.create :mixed, :key => :symbol }
+        Mapping.reset
+        assert_nothing_raised(MappedRecord::MappingError) { 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 }
+      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
+        end
+
+        should_map_explicit :mixed, :symbol_key, :key
+        should_map_explicit :mixed, "symbol_key", :other_key
+        should_map_implicit :mixed, 'StringMapping', :string_mapping
+        should_map_implicit :mixed, :SymbolMapping, :symbol_mapping
+      end
+    end
+
+    context "resetting mappings" do
+      should "have #reset method" do
+        assert_respond_to(Mapping, :reset)
+      end
+      
+      should "clear mappings" do
+        assert(!Mapping.blank?, "Mapping is blank.")
+        Mapping.reset
+        assert(Mapping.blank?, "Mappings should be blank.")
+      end
+    end
+
+    context "called multiple times" do
+
+      # Namespaces work on a per-#attr_mapped basis
+      context "with different namespaces" do
+        setup do
+          Mapping.create :diff_ns, 'ForNamespaceMapping', :namespace => 'ForNamespace'
+          Mapping.create :diff_ns, 'ForNamespaceMapping', :namespace => 'For'
+        end
+
+        should_map_namespace :diff_ns, 'ForNamespaceMapping', :namespace_mapping
+      end
+
+      context "with all (naturally ordered) mappings" do
+        setup do
+          Mapping.create :natural, 'OrderedMapping'
+          Mapping.create :natural, 'OrderedMapping', :namespace => 'Ordered'
+          Mapping.create :natural, 'OrderedMapping' => :ordered
+        end
+
+        should_map_explicit :natural, 'OrderedMapping', :ordered
+      end
+
+      context "with all (inverse ordered) mappings" do
+        setup do
+          Mapping.create :reversed, 'OrderedMapping' => :ordered
+          Mapping.create :reversed, 'OrderedMapping', :namespace => 'Ordered'
+          Mapping.create :reversed, 'OrderedMapping'
+        end
+
+        should_map_explicit :reversed, 'OrderedMapping', :ordered
+      end
+    end
+
+    # ==================
+    # = Tests overlaps =
+    # ==================
+    context "with namespace and explicit overlap" do
+      setup { Mapping.create :ns_e_overlap, 'ImplicitMapping', 'AnotherMapping', 'ExplicitMapping' => :explicit_mapping, :namespace => 'Explicit' }
+      should_map_explicit :ns_e_overlap, 'ExplicitMapping', :explicit_mapping
+    end
+
+    context "with namespace and implicit overlap" do
+      setup { Mapping.create :ns_i_overlap, 'ImplicitMapping', 'ImplicitMappingSecond', 'ExplicitMapping' => :explicit_mapping, :namespace => 'Implicit' }
+      should_map_namespace :ns_i_overlap, 'ImplicitMapping', :mapping
+    end
+
+    context "with explicit and implicit overlap" do
+      setup { Mapping.create :e_i_overlap, 'ImplicitMapping', 'ImplicitMapping' => :explicit_mapping, :namespace => 'NoMatch' }
+      should_map_explicit :e_i_overlap, 'ImplicitMapping', :explicit_mapping
+    end
+
+    # ========================
+    # = Raising MappingError =
+    # ========================
+    should "raise MappingError when #namespace causes mapping to be ''" do
+      assert_raises MappedRecord::MappingError 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
+        Mapping.create :many_to_one, 'Root', 'MappingWithRoot', :namespace => 'MappingWith'
+      end
+    end
+    
+    should "raise MappingError with un-named mapping" do
+      Mapping.reset
+      assert_raises MappedRecord::MappingError 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
+    #   Mapping.reset
+    #   assert_raise(MappedRecord::MappingError) do
+    #     Mapping.create 1, 'Root'
+    #   end
+    # end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,93 @@
+require 'stringio'
+require 'rubygems'
+require 'test/unit'
+gem 'thoughtbot-shoulda', ">= 2.9.0"
+require 'shoulda'
+
+gem 'sqlite3-ruby'
+
+require 'active_record'
+require 'active_support'
+
+require File.dirname(__FILE__) + '/../lib/mapped-record'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config['test'])
+
+def reset_class class_name
+  ActiveRecord::Base.send(:include, MappedRecord)
+  Object.send(:remove_const, class_name) rescue nil
+  klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
+  klass.class_eval{ include MappedRecord }
+  klass
+end
+ 
+def reset_table table_name, &block
+  block ||= lambda{ true }
+  ActiveRecord::Base.connection.create_table :dummies, {:force => true}, &block
+end
+ 
+def modify_table table_name, &block
+  ActiveRecord::Base.connection.change_table :dummies, &block
+end
+ 
+def rebuild_model(*args)
+  ActiveRecord::Base.connection.create_table :dummies, :force => true do |t|
+    t.string :name
+    t.datetime :date
+    t.references :key_photo
+    t.integer :photo_count
+    t.text :key_list
+    t.references :library
+  end
+  rebuild_class(*args)
+end
+ 
+def rebuild_class(*args)
+  ActiveRecord::Base.send(:include, MappedRecord)
+  Object.send(:remove_const, "Dummy") rescue nil
+  Object.const_set("Dummy", Class.new(ActiveRecord::Base))
+  Dummy.class_eval do
+    include MappedRecord
+  end
+  if args.size > 0
+    Dummy.class_eval do
+      attr_mapped_named(*args)
+    end  
+  end
+end
+
+def should_map name, field, mapping, type, klass=Mapping
+  type_s = ''
+  case type
+  when MappedRecord::EXPLICIT
+    type_s = 'explicit'
+  when MappedRecord::IMPLICIT
+    type_s = 'implicit'
+  when MappedRecord::NAMESPACE
+    type_s = 'namespace'
+  else
+    raise "Unknown mapping type"
+  end
+
+  should "map #{type_s} from #{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.")
+    assert_equal(mapping, klass[name][field][:to], "Mapping doesn't match.")
+    assert_equal(type, klass[name][field][:type], "Mapping type doesn't match.")
+  end
+end
+
+def should_map_explicit name, field, mapping, klass=Mapping
+  should_map name, field, mapping, MappedRecord::EXPLICIT, klass
+end
+
+def should_map_implicit name, field, mapping, klass=Mapping
+  should_map name, field, mapping, MappedRecord::IMPLICIT, klass
+end
+
+def should_map_namespace name, field, mapping, klass=Mapping
+  should_map name, field, mapping, MappedRecord::NAMESPACE, klass
+end

data/test/test_mapped_record.rb

@@ -0,0 +1,260 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestMappedRecord < Test::Unit::TestCase
+  context "Dummy" do
+    setup do
+      rebuild_class
+    end
+
+    should "have #attr_mapped method" do
+      assert_respond_to Dummy, :attr_mapped
+    end
+
+    should "have #attr_mapped_named method" do
+      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
+        Dummy.class_eval do
+          attr_mapped_named
+        end
+      end
+    end
+
+    should "raise MappingError when name given but options not given" do
+      assert_raises MappedRecord::MappingError do
+        rebuild_class 'some_name'
+      end
+    end
+
+    # =======================
+    # = Setting up mappings =
+    # =======================
+    context "when #attr_mapped" do
+      context "untitled" do
+        setup do
+          Mapping.reset
+          Dummy.class_eval do
+            attr_mapped 'FullName', 'Email'
+          end
+        end
+
+        should "map with class_name as default mapping name" do
+          assert(Mapping.has?(Dummy.class_name), "Mapping name not #{Dummy.class_name}.")
+        end
+
+        should_map_implicit 'Dummy', 'FullName', :full_name
+        should_map_implicit 'Dummy', 'Email', :email
+      end
+    end
+
+    context "when #attr_mapped_named" do # TODO should not allow mapping names with spaces
+      context "with dummy mapping and options" do
+
+        setup do
+          Mapping.reset
+          @@proc = Proc.new { |p| 'PROC-ED' }
+          rebuild_class :dummy, 'ImplicitMapping', 'AnotherMapping', 'ForNamespaceMapping', 'ExplicitMapping' => :explicit, :namespace => 'ForNamespace', :id => 'ForID', :filter => { 'ImplicitMapping' => @@proc }, :serialize => 'ForNamespaceMapping'
+        end
+
+        should_map_implicit :dummy, 'ImplicitMapping', :implicit_mapping
+        should_map_implicit :dummy, 'AnotherMapping', :another_mapping
+        should_map_namespace :dummy, 'ForNamespaceMapping', :mapping
+        should_map_explicit :dummy, 'ExplicitMapping', :explicit
+
+        should "map id" do
+          assert_equal 'ForID', Dummy.attr_hashed_id
+        end
+
+        should "map proc" do
+          assert_same @@proc, Mapping[:dummy]['ImplicitMapping'][:filter]
+        end
+
+        should "serialize" do
+          assert Dummy.serialized_attributes.include?("mapping")
+        end
+
+        context "a subclass" do
+          setup do
+            class ::SubDummy < Dummy; end
+          end
+
+          should "map id" do
+            assert_equal 'ForID', SubDummy.attr_hashed_id
+          end
+
+          should "serialize" do
+            assert SubDummy.serialized_attributes.include?("mapping")
+          end
+
+          teardown do
+            Object.send(:remove_const, "SubDummy") rescue nil
+          end
+        end
+      end
+      
+      context "with multiple serializes" do
+        setup do
+          Mapping.reset
+          rebuild_class :multiple_s, 'KeyOne', 'KeyTwo', :serialize => ['KeyOne', 'KeyTwo']
+        end
+        
+        should "serialize :key_one and :key_two" do
+          assert Dummy.serialized_attributes.include?("key_one")
+          assert Dummy.serialized_attributes.include?("key_two")
+        end
+      end
+
+      # ========================
+      # = Raising MappingError =
+      # ========================
+
+      should "raise MappingError when #serialize and #id overlap" do
+        assert_raises MappedRecord::MappingError do
+          rebuild_class :ser, 'ImplicitMapping', 'AnotherMapping', 'ForNamespaceMapping', 'ExplicitMapping' => :explicit, :namespace => 'ForNamespace', :id => 'AnotherMapping', :serialize => 'AnotherMapping'
+        end
+      end
+
+      # ============================================
+      # = #attr_mapped_named called multiple times =
+      # ============================================
+      context "called multiple times" do
+
+        context "with serialized mapping being overridden" do
+          setup do
+            rebuild_class
+            Dummy.class_eval do
+              attr_mapped_named :overriding, 'AMapping', :serialize => 'AMapping'
+              attr_mapped_named :overriding, 'AMapping' => :mapping
+            end
+          end
+
+          should "update serialize" do
+            assert Dummy.serialized_attributes.include?("mapping")
+          end
+        end
+      end
+    end
+
+    # ======================
+    # = Creating with hash =
+    # ======================
+    context "creating" do
+      context "with named mapping" do
+        setup do
+          Mapping.reset
+          rebuild_model
+          Dummy.class_eval do
+            attr_mapped_named :iphoto_roll, 'PhotoCount', 'KeyList', 'RollName', :namespace => 'Roll', 'KeyPhotoKey' => :key_photo_id, 'RollDateAsTimerInterval' => :date, :id => 'RollID', :serialize => 'KeyList', :filter => { 'RollDateAsTimerInterval' => Proc.new { |p| Time.at(p.to_f + 978307200) } }
+          end
+          @rand = rand(10000)
+          @sample_hash = {"PhotoCount"=>1, "KeyList"=>["2"], "KeyPhotoKey"=>"2", "RollID"=>@rand, "RollDateAsTimerInterval"=>263609145.0, "RollName"=>"May 9, 2009"}
+          @dummy = Dummy.create_with_iphoto_roll(@sample_hash)
+          assert_not_nil @dummy
+        end
+
+        should "have dynamic #create_with_iphoto_roll method" do
+          assert_respond_to Dummy, :create_with_iphoto_roll
+        end
+
+        should "not mass-assign #id" do
+          assert !Dummy.with_attributes(:iphoto_roll, @sample_hash).include?(:id)
+        end
+
+        should "create properly" do
+          assert_equal 1, @dummy.photo_count
+          assert_equal 2, @dummy.key_photo_id
+          assert_equal ["2"], @dummy.key_list
+          assert_equal Time.at(263609145.0 + 978307200), @dummy.date
+          assert_equal "May 9, 2009", @dummy.name
+          assert_equal @rand, @dummy.id
+        end
+
+        should "have #update_with method" do
+          assert_respond_to @dummy, :update_with
+        end
+
+        should "have dynamic #update_with_iphoto_roll method" do
+          assert_respond_to @dummy, :update_with_iphoto_roll
+        end
+
+        should "fail with empty update" do
+          assert !@dummy.update_with_iphoto_roll({})
+        end
+
+        should "fail updating with no changes" do
+          assert !@dummy.update_with_iphoto_roll(@sample_hash)
+        end
+
+        context "then updating" do
+
+          setup do
+            @update_hash = {"PhotoCount"=>2, "KeyList"=>["2", "3"], "KeyPhotoKey"=>"3", "RollID"=>rand(10000), "RollDateAsTimerInterval"=>263609245.0, "RollName"=>"NewName"}
+            assert_not_nil @dummy
+          end
+
+          should "update properly" do
+            assert @dummy.update_with_iphoto_roll(@update_hash)
+            assert_equal 2, @dummy.photo_count
+            assert_equal 3, @dummy.key_photo_id
+            assert_equal ["2", "3"], @dummy.key_list
+            assert_equal Time.at(263609245.0 + 978307200), @dummy.date
+            assert_equal "NewName", @dummy.name
+            assert_equal @rand, @dummy.id
+          end
+        end
+      end
+    end
+    
+    # the rest relies on named mapping (above)
+    context "with unnamed mapping" do
+      setup do
+        Mapping.reset
+        rebuild_model
+        Dummy.class_eval do
+          attr_mapped 'PhotoCount', 'KeyList', 'RollName', :namespace => 'Roll', 'KeyPhotoKey' => :key_photo_id, 'RollDateAsTimerInterval' => :date, :id => 'RollID', :serialize => 'KeyList', :filter => { 'RollDateAsTimerInterval' => Proc.new { |p| Time.at(p.to_f + 978307200) } }
+        end
+        @rand = rand(10000)
+        @sample_hash = {"PhotoCount"=>1, "KeyList"=>["2"], "KeyPhotoKey"=>"2", "RollID"=>@rand, "RollDateAsTimerInterval"=>263609145.0, "RollName"=>"May 9, 2009"}
+        @dummy = Dummy.create_with(@sample_hash)
+      end
+
+      should "have #create_with method" do
+        assert_respond_to Dummy, :create_with
+      end
+
+      should "create properly" do
+        assert_not_nil @dummy
+        assert_equal 1, @dummy.photo_count
+        assert_equal 2, @dummy.key_photo_id
+        assert_equal ["2"], @dummy.key_list
+        assert_equal Time.at(263609145.0 + 978307200), @dummy.date
+        assert_equal "May 9, 2009", @dummy.name
+        assert_equal @rand, @dummy.id
+      end
+
+      context "then updating" do
+
+        setup do
+          @update_hash = {"PhotoCount"=>2, "KeyList"=>["2", "3"], "KeyPhotoKey"=>"3", "RollID"=>rand(10000), "RollDateAsTimerInterval"=>263609245.0, "RollName"=>"NewName"}
+          assert_not_nil @dummy
+        end
+
+        should "update properly" do
+          assert @dummy.update_with(@update_hash)
+          assert_equal 2, @dummy.photo_count
+          assert_equal 3, @dummy.key_photo_id
+          assert_equal ["2", "3"], @dummy.key_list
+          assert_equal Time.at(263609245.0 + 978307200), @dummy.date
+          assert_equal "NewName", @dummy.name
+          assert_equal @rand, @dummy.id
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: hsume2-mapped-record
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Henry Hsu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-07 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: Auto-magically map Hash[keys] to ActiveRecord.attributes
+email: 
+- henry@qlane.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- History.txt
+- LICENSE
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/mapped-record.rb
+- lib/mapped-record/hash/mappable.rb
+- lib/mapped-record/mapping.rb
+- script/console
+- script/destroy
+- script/generate
+- test/database.yml
+- test/hashed-record/hash/test_mappable.rb
+- test/hashed-record/test_mapping.rb
+- test/test_helper.rb
+- test/test_mapped_record.rb
+has_rdoc: false
+homepage: http://github.com/hsume2/mapped-record
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: mapped-record
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Auto-magically map Hash[keys] to ActiveRecord.attributes
+test_files: 
+- test/hashed-record/hash/test_mappable.rb
+- test/hashed-record/test_mapping.rb
+- test/test_helper.rb
+- test/test_mapped_record.rb