dm-mapping 0.5.0 → 0.6.0

data/CHANGES

@@ -1,5 +1,16 @@
 = dm-mapper changes history
 
+=== dm-mapping 0.6.0, 2008-08-16
+* mapping returns an array of properties indicating fields it mapped.
+* performance boosted by refactored mapping implementation.
+* changed the way using auto_genclass!, now accepts args like mapping!
+* changed fields to return field name with Symbol instead of String.
+  this would make it be more consistent with DataMapper.
+* storage names remain String.
+* added more mysql data type to map
+* use Extlib::Hook to setup dm-mapping instead of stupid alias_method.
+* removed ensure_require in model. always setup DataMapper before define model.
+
 === dm-mapping 0.5.0, 2008-08-14
 * feature added
  - added mysql support.

data/README

@@ -1,4 +1,4 @@
-= dm-mapping 0.5.0
+= dm-mapping 0.6.0
 by Lin Jen-Shin (a.k.a. godfat-真常[http://godfat.org])
   godfat (XD) godfat.org
 
@@ -15,15 +15,21 @@ by Lin Jen-Shin (a.k.a. godfat-真常[http://godfat.org])
 
 == SYNOPSIS:
 
- require 'dm-mapping'
+ require 'dm-mapping' # this would require 'dm-core'
  dm = DataMapper.setup :default, 'sqlite3:db/development.sqlite3'
 
  class User
    include DataMapper::Resource
-   # mapping all
-   mapping /.*/
+   # mapping all, returns an array of properties indicating fields it mapped
+   mapping /.*/  # e.g. => [#<Property:#<Class:0x18f89b8>:id>,
+                 #          #<Property:#<Class:0x18f89b8>:title>,
+                 #          #<Property:#<Class:0x18f89b8>:body>,
+                 #          #<Property:#<Class:0x18f89b8>:user_id>]
 
-   # mapping for ended with _at, and started with salt_
+   # mapping all (with no argument at all)
+   mapping
+
+   # mapping for field name ended with _at, and started with salt_
    mapping /_at$/, /^salt_/
 
    # mapping id and email
@@ -41,27 +47,28 @@ by Lin Jen-Shin (a.k.a. godfat-真常[http://godfat.org])
  # => ['users']
 
  # there's no guarantee of the order in fields array
- User.fields.sort
- # => [['created_at',  DateTime, {:nullable => true}],
-       ['email',       String,   {:nullable => true, :size => 255,
-                                  :default => 'nospam@nospam.tw'}],
-       ['id',          Integer,  {:nullable => false, :serial => true,
-                                  :key => true}],
-       ['salt_first',  String,   {:nullable => true, :size => 50}],
-       ['salt_second', String,   {:nullable => true, :size => 50}]]
-
- dm.fields('users').sort == User.fields.sort
+ User.fields
+ # => [[:created_at,  DateTime, {:nullable => true}],
+       [:email,       String,   {:nullable => true, :size => 255,
+                                 :default => 'nospam@nospam.tw'}],
+       [:id,          Integer,  {:nullable => false, :serial => true,
+                                 :key => true}],
+       [:salt_first,  String,   {:nullable => true, :size => 50}],
+       [:salt_second, String,   {:nullable => true, :size => 50}]]
+
+ dm.fields('users').sort_by{ |field| field.first.to_s } ==
+        User.fields.sort_by{ |field| field.first.to_s }
  # => true
 
  dm.storages_and_fields
- # => {'users' => [['id',          Integer,  {:nullable => false,
-                                              :serial => true,
-                                              :key => true}],
-                   ['email',       String,   {:nullable => true,
-                                              :default => 'nospam@nospam.tw'}],
-                   ['created_at',  DateTime, {:nullable => true}],
-                   ['salt_first',  String,   {:nullable => true, :size => 50}],
-                   ['salt_second', String,   {:nullable => true, :size => 50}]]}
+ # => {'users' => [[:id,          Integer,  {:nullable => false,
+                                             :serial => true,
+                                             :key => true}],
+                   [:email,       String,   {:nullable => true,
+                                             :default => 'nospam@nospam.tw'}],
+                   [:created_at,  DateTime, {:nullable => true}],
+                   [:salt_first,  String,   {:nullable => true, :size => 50}],
+                   [:salt_second, String,   {:nullable => true, :size => 50}]]}
 
  # there's no guarantee of the order in returned array
  dm.auto_genclass!
@@ -70,9 +77,21 @@ by Lin Jen-Shin (a.k.a. godfat-真常[http://godfat.org])
        DataMapper::Mapping::Session]
 
  # you can change the scope of generated models:
- dm.auto_genclass! Object
+ dm.auto_genclass! :scope => Object
  # => [User, SchemaInfo, Session]
 
+ # you can generate classes for tables you specified only:
+ dm.auto_genclass! :scope => Object, :storages => /^phpbb_/
+ # => [PhpbbUser, PhpbbPost, PhpbbConfig]
+
+ # you can generate classes with String too:
+ dm.auto_genclass! :storages => ['users', 'config'], :scope => Object
+ # => [User, Config]
+
+ # you can generate a class only:
+ dm.auto_genclass! :storages => 'users'
+ # => [DataMapper::Mapping::User]
+
 == REQUIREMENTS:
 
 * dm-core 0.9.3

data/TODO

@@ -1,4 +1,5 @@
 = dm-mapping todo list
 
-* 0.6 postgresql adapter
-* 0.7 automatic determine model relationship
+* better doc...
+* 0.7 postgresql adapter
+* 0.8 automatic determine model relationship

data/dm-mapping.gemspec

@@ -1,11 +1,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dm-mapping}
-  s.version = "0.5.0"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Lin Jen-Shin (a.k.a. godfat \347\234\237\345\270\270)"]
-  s.date = %q{2008-08-14}
+  s.date = %q{2008-08-16}
   s.description = %q{DataMapper plugin that helps you manipulate an existing database. It creates mappings between existing columns and model's properties.}
   s.email = %q{godfat (XD) godfat.org}
   s.extra_rdoc_files = ["CHANGES", "LICENSE", "NOTICE", "README", "TODO", "dm-mapping.gemspec"]

data/lib/dm-mapping.rb

@@ -1,31 +1,17 @@
 
 gem 'dm-core', '=0.9.3'
 require 'dm-core'
+require 'extlib'
 
 module DataMapper
-
-  # default scope for Migration#auto_genclass!.
-  module Mapping # namespace
+  include Extlib::Hook
+  after_class_method :setup do
+    adapter_name = repository.adapter.class.to_s.split('::').last
+    require "dm-mapping/adapters/#{Extlib::Inflection.underscore(adapter_name)}"
   end
 
-  class << self
-    # ensure the using adapter is extended by dm-mapping
-    def ensure_required_dm_mapping_adapter
-      require 'extlib'
-      adapter_name = repository.adapter.class.to_s.split('::').last
-      require "dm-mapping/adapters/#{Extlib::Inflection.underscore(adapter_name)}"
-    end
-
-    # dirty hack that hook requirement after setup.
-    alias_method :__setup_alias_by_dm_mapping__, :setup
-    private :__setup_alias_by_dm_mapping__
-    # dirty hack that hook requirement after setup.
-    # usage is the same as original setup.
-    def setup name, uri_or_options
-      adapter = __setup_alias_by_dm_mapping__ name, uri_or_options
-      ensure_required_dm_mapping_adapter
-      adapter
-    end
+  # default scope for Migration#auto_genclasses! series.
+  module Mapping # namespace
   end
 
 end

data/lib/dm-mapping/adapters/abstract_adapter.rb

@@ -12,27 +12,33 @@ module DataMapper
 
         # returns all fields, with format [[name, type, attrs]]
         #  e.g.
-        #       [['created_at',  DateTime, {}],
-        #        ['email',       String,   {:default => 'nospam@nospam.tw'}],
-        #        ['id',          Integer,  {:serial => true}],
-        #        ['salt_first',  String,   {}],
-        #        ['salt_second', String,   {}]]
+        #       [[:created_at,  DateTime, {:nullable => true}],
+        #        [:email,       String,   {:nullable => true, :size => 255,
+        #                                  :default => 'nospam@nospam.tw'}],
+        #        [:id,          Integer,  {:nullable => false, :serial => true,
+        #                                  :key => true}],
+        #        [:salt_first,  String,   {:nullable => true, :size => 50}],
+        #        [:salt_second, String,   {:nullable => true, :size => 50}]]
         def fields storage
           dmm_query_storage(storage).map{ |field|
-            type, chain = self.class.type_map.
-              lookup_primitive(dmm_primitive(field))
+            primitive = dmm_primitive(field)
+            type, chain = self.class.type_map.lookup_primitive(primitive) ||
+                          dmm_lookup_primitive(primitive)
 
-            [dmm_field_name(field), type, dmm_attributes(field)]
+            [dmm_field_name(field).to_sym, type, dmm_attributes(field)]
           }
         end
 
         # returns a hash with storage names in keys and
         # corresponded fields in values. e.g.
-        #   {'users' => [['id',          Integer,  {:serial => true}],
-        #                ['email',       String,   {:default => 'nospam@nospam.tw'}],
-        #                ['created_at',  DateTime, {}],
-        #                ['salt_first',  String,   {}],
-        #                ['salt_second', String,   {}]]}
+        #   {'users' => [[:id,          Integer,  {:nullable => false,
+        #                                          :serial => true,
+        #                                          :key => true}],
+        #                [:email,       String,   {:nullable => true,
+        #                                          :default => 'nospam@nospam.tw'}],
+        #                [:created_at,  DateTime, {:nullable => true}],
+        #                [:salt_first,  String,   {:nullable => true, :size => 50}],
+        #                [:salt_second, String,   {:nullable => true, :size => 50}]]}
         # see Migration#storages and Migration#fields for detail
         def storages_and_fields
           storages.inject({}){ |result, storage|
@@ -41,7 +47,7 @@ module DataMapper
           }
         end
 
-        # automaticly generate all model classes and mapping
+        # automaticly generate model class(es) and mapping
         # all fields with mapping /.*/ for you.
         #  e.g.
         #       dm.auto_genclass!
@@ -51,23 +57,63 @@ module DataMapper
         #
         # you can change the scope of generated models:
         #  e.g.
-        #       dm.auto_genclass! Object
+        #       dm.auto_genclass! :scope => Object
         #       # => [User, SchemaInfo, Session]
-        def auto_genclass! scope = DataMapper::Mapping
-          require 'extlib'
-          storages_and_fields.map{ |storage, fields|
-            model = Class.new
-            model.__send__ :include, DataMapper::Resource
-            model.storage_names[:default] = storage
-            model.__send__ :mapping, /.*/
-            scope.const_set(Extlib::Inflection.classify(storage), model)
-          }
+        #
+        # you can generate classes for tables you specified only:
+        #  e.g.
+        #       dm.auto_genclass! :scope => Object, :storages => /^phpbb_/
+        #       # => [PhpbbUser, PhpbbPost, PhpbbConfig]
+        #
+        # you can generate classes with String too:
+        #  e.g.
+        #       dm.auto_genclass! :storages => ['users', 'config'], :scope => Object
+        #       # => [User, Config]
+        #
+        # you can generate a class only:
+        #  e.g.
+        #       dm.auto_genclass! :storages => 'users'
+        #       # => [DataMapper::Mapping::User]
+        def auto_genclass! opts = {}
+          opts[:scope] ||= DataMapper::Mapping
+          opts[:storages] ||= /.*/
+          opts[:storages] = [opts[:storages]].flatten
+
+          storages.map{ |storage|
+
+            mapped = opts[:storages].each{ |target|
+              case target
+                when Regexp;
+                  break storage if storage =~ target
+
+                when Symbol, String;
+                  break storage if storage == target.to_s
+
+                else
+                  raise ArgumentError.new("invalid argument: #{target.inspect}")
+              end
+            }
+
+            dmm_genclass mapped, opts[:scope] if mapped.kind_of?(String)
+          }.compact
         end
 
         private
         def dmm_query_storage
           raise NotImplementError.new("#{self.class}#fields is not implemented.")
         end
+
+        def dmm_genclass storage, scope
+          model = Class.new
+          model.__send__ :include, DataMapper::Resource
+          model.storage_names[:default] = storage
+          model.__send__ :mapping, /.*/
+          scope.const_set(Extlib::Inflection.classify(storage), model)
+        end
+
+        def dmm_lookup_primitive primitive
+          raise TypeError.new("#{primitive} not found for #{self.class}")
+        end
       end
     end
   end

data/lib/dm-mapping/adapters/mysql_adapter.rb

@@ -41,6 +41,18 @@ module DataMapper
 
             attrs
         end
+
+        def dmm_lookup_primitive primitive
+          case primitive.upcase
+            when 'TINYINT', 'SMALLINT', 'MEDIUMINT', 'BIGINT', 'YEAR'; Integer
+            when 'DOUBLE'; BigDecimal
+            when 'BOOL'; TrueClass
+            when 'CHAR', 'ENUM', 'SET', 'TINYBLOB', 'MEDIUMBLOB',
+                 'BLOB', 'LONGBLOB', 'BINARY', 'VARBINARY'; String
+            when 'TINYTEXT', 'MEDIUMTEXT', 'LONGTEXT'; DM::Text
+            else super(primitive)
+          end
+        end
       end
     end
   end

data/lib/dm-mapping/model.rb

@@ -5,7 +5,6 @@ module DataMapper
     #  e.g.
     #       DataMapper.repository.adapter.fields storage_name
     def fields
-      DataMapper.ensure_required_dm_mapping_adapter
       DataMapper.repository.adapter.fields storage_name
     end
 
@@ -16,13 +15,20 @@ module DataMapper
     # you can pass it Regexp to map any field it matched, or just
     # the field name in Symbol or String, or a Class telling it
     # map any field which type equals to the Class.
+    # returned value is an array of properties indicating fields it mapped
     #  e.g.
     #       class User
     #         include DataMapper::Resource
-    #         # maping all
-    #         mapping /.*/
+    #         # mapping all
+    #         mapping /.*/  # e.g. => [#<Property:#<Class:0x18f89b8>:id>,
+    #                       #          #<Property:#<Class:0x18f89b8>:title>,
+    #                       #          #<Property:#<Class:0x18f89b8>:body>,
+    #                       #          #<Property:#<Class:0x18f89b8>:user_id>]
     #
-    #         # mapping for ended with _at, and started with salt_
+    #         # mapping all (with no argument at all)
+    #         mapping
+    #
+    #         # mapping for field name ended with _at, and started with salt_
     #         mapping /_at$/, /^salt_/
     #
     #         # mapping id and email
@@ -35,28 +41,29 @@ module DataMapper
     #         mapping :login, Integer
     #       end
     def mapping *targets
-      DataMapper.ensure_required_dm_mapping_adapter
       targets << /.*/ if targets.empty?
 
       fields.map{ |field|
         name, type, attrs = field
 
-        targets.each{ |target|
+        mapped = targets.each{ |target|
           case target
             when Regexp;
-              property name.to_sym, type, attrs if name =~ target
+              break name if name.to_s =~ target
 
             when Symbol, String;
-              property name.to_sym, type, attrs if name == target.to_s
+              break name if name == target.to_sym
 
             when Class;
-              property name.to_sym, type, attrs if type == target
+              break name if type == target
 
             else
               raise ArgumentError.new("invalid argument: #{target.inspect}")
           end
         }
-      }
+
+        property mapped, type, attrs if mapped.kind_of?(Symbol)
+      }.compact
     end
   end
 end

data/lib/dm-mapping/type_map.rb

@@ -4,8 +4,10 @@ module DataMapper
     # reversed lookup for primitive type to ruby type.
     #  e.g.
     #       lookup_primitive('DATETIME')
-    #       # => { DateTime => {:auto_validation => true} }
+    #       # => [DateTime, #<DataMapper::TypeMap::TypeChain:0x830b8>]
     def lookup_primitive primitive, type_map = self
+      return nil unless type_map
+
       type_map.chains.find{ |type, chain|
         primitive.upcase == chain.primitive &&
         [Integer, Float, BigDecimal,

data/lib/dm-mapping/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   module Mapping
-    VERSION = '0.5.0' unless defined?(DataMapper::Mapping::VERSION)
+    VERSION = '0.6.0' unless defined?(DataMapper::Mapping::VERSION)
   end
 end

data/test/abstract.rb

@@ -5,7 +5,7 @@ require 'dm-mapping'
 
 module Abstract
   def setup_data_mapper
-    raise 'please provide an clean database because it is a destructive test!!'
+    raise 'please provide a clean database because it is a destructive test!!'
   end
 
   AttrCommon = {:nullable => true}
@@ -13,18 +13,22 @@ module Abstract
   AttrText = {:size => 65535}.merge AttrCommon
 
   def user_fields
-    [['created_at', DateTime, AttrCommon],
-     ['id',         Integer,  AttrCommonPK],
-     ['login',      String,   {:size => 70}.merge(AttrCommon)],
-     ['sig',        DM::Text, AttrText]]
+    [[:created_at, DateTime, AttrCommon],
+     [:id,         Integer,  AttrCommonPK],
+     [:login,      String,   {:size => 70}.merge(AttrCommon)],
+     [:sig,        DM::Text, AttrText]]
   end
 
   def comment_fields
-    [['body',    DM::Text, AttrText],
-     ['id',      Integer,  AttrCommonPK],
-     ['title',   String,   {:size => 50, :default => 'default title'}.
+    [[:body,    DM::Text, AttrText],
+     [:id,      Integer,  AttrCommonPK],
+     [:title,   String,   {:size => 50, :default => 'default title'}.
                             merge(AttrCommon)],
-     ['user_id', Integer,  AttrCommon]]
+     [:user_id, Integer,  AttrCommon]]
+  end
+
+  def super_user_fields
+    [[:id,      Integer,  AttrCommonPK]]
   end
 
   class User
@@ -37,6 +41,11 @@ module Abstract
     property :created_at, DateTime
   end
 
+  class SuperUser
+    include DataMapper::Resource
+    property :id, Integer, :serial => true
+  end
+
   class Comment
     include DataMapper::Resource
     belongs_to :user
@@ -48,6 +57,14 @@ module Abstract
 
   class Model; end
 
+  Tables = ['abstract_comments', 'abstract_super_users', 'abstract_users']
+
+  def sort_fields fields
+    fields.sort_by{ |field|
+      field.first.to_s
+    }
+  end
+
   def create_fake_model
     [ Model.dup.__send__(:include, DataMapper::Resource),
       setup_data_mapper ]
@@ -59,11 +76,16 @@ module Abstract
     # this is significant faster than DataMapper.auto_migrate!
     User.auto_migrate!
     Comment.auto_migrate!
+    SuperUser.auto_migrate!
+  end
+
+  def new_scope
+    self.class.const_set("Scope#{object_id.object_id}", Module.new)
   end
 
   def test_storages
-    assert_equal ['abstract_comments', 'abstract_users'], dm.storages.sort
-    assert_equal comment_fields, dm.fields('abstract_comments').sort
+    assert_equal Tables, dm.storages.sort
+    assert_equal comment_fields, sort_fields(dm.fields('abstract_comments'))
   end
 
   def test_create_comment
@@ -72,16 +94,25 @@ module Abstract
     assert_equal 'XD', Comment.first.title
   end
 
+  def test_create_user
+    now = Time.now
+    User.create(:created_at => now)
+    assert_equal 1, User.first.id
+    assert_equal now.asctime, User.first.created_at.asctime
+
+    return now
+  end
+
   def test_mapping_all
     test_create_comment # for fixtures
     model, local_dm = create_fake_model
     model.storage_names[:default] = 'abstract_comments'
 
-    assert_equal ['abstract_comments', 'abstract_users'], local_dm.storages.sort
+    assert_equal Tables, local_dm.storages.sort
     assert_equal 'abstract_comments', model.storage_name
 
     assert_equal 1, model.count
-    assert_equal comment_fields, model.fields.sort
+    assert_equal comment_fields, sort_fields(model.fields)
 
     model.send :mapping
     assert_equal 'XD', model.first.title
@@ -102,12 +133,13 @@ module Abstract
   end
 
   def test_storages_and_fields
-    assert_equal user_fields, dm.fields('abstract_users').sort
+    assert_equal user_fields, sort_fields(dm.fields('abstract_users'))
     assert_equal( {'abstract_users' => user_fields,
-                   'abstract_comments' => comment_fields},
+                   'abstract_comments' => comment_fields,
+                   'abstract_super_users' => super_user_fields},
                   dm.storages_and_fields.inject({}){ |r, i|
                     key, value = i
-                    r[key] = value.sort
+                    r[key] = value.sort_by{ |v| v.first.to_s }
                     r
                   } )
   end
@@ -142,15 +174,16 @@ module Abstract
     }
   end
 
-  def test_auto_genclass
-    scope = self.class
+  def test_auto_genclasses
+    scope = new_scope
     assert_equal ["#{scope == Object ? '' : "#{scope}::"}AbstractComment",
-                  "#{scope == Object ? '' : "#{scope}::"}AbstractUser"],
-                 dm.auto_genclass!(scope).map(&:to_s).sort
+                  "#{scope}::AbstractSuperUser",
+                  "#{scope}::AbstractUser"],
+                 dm.auto_genclass!(:scope => scope).map(&:to_s).sort
 
     comment = scope.const_get('AbstractComment')
 
-    assert_equal comment_fields, comment.fields.sort
+    assert_equal comment_fields, sort_fields(comment.fields)
 
     test_create_comment
 
@@ -159,4 +192,38 @@ module Abstract
     assert_equal 'dm-mapping', comment.get(2).body
   end
 
+  def test_auto_genclass
+    scope = new_scope
+    assert_equal ["#{scope}::AbstractUser"],
+                 dm.auto_genclass!(:scope => scope,
+                                   :storages => 'abstract_users').map(&:to_s)
+
+    user = scope.const_get('AbstractUser')
+    assert_equal user_fields, sort_fields(user.fields)
+
+    now = test_create_user
+
+    assert_equal now.asctime, user.first.created_at.asctime
+    user.create(:login => 'godfat')
+    assert_equal 'godfat', user.get(2).login
+  end
+
+  def test_auto_genclass_with_regexp
+    scope = new_scope
+    assert_equal ["#{scope}::AbstractSuperUser", "#{scope}::AbstractUser"],
+                 dm.auto_genclass!(:scope => scope,
+                                   :storages => /_users$/).map(&:to_s).sort
+
+    user = scope.const_get('AbstractSuperUser')
+    assert_equal sort_fields(SuperUser.fields), sort_fields(user.fields)
+  end
+
+  def test_mapping_return_value
+    model, local_dm = create_fake_model
+    model.storage_names[:default] = 'abstract_comments'
+    mapped = model.send :mapping, /.*/
+
+    assert_equal model.properties.map(&:object_id).sort, mapped.map(&:object_id).sort
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-mapping
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - "Lin Jen-Shin (a.k.a. godfat \xE7\x9C\x9F\xE5\xB8\xB8)"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-15 00:00:00 +08:00
+date: 2008-08-17 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency