godfat-dm-mapping 0.7.0 → 0.7.1

data/CHANGES

@@ -1,5 +1,13 @@
 = dm-mapper changes history
 
+=== dm-mapping 0.7.1,
+don't open module Migration and edit it, instead, use include, more see:
+* added DataMapper::Mapping::AbstractAdapter
+* added DataMapper::Mapping::Sqlite3Adapter
+* added DataMapper::Mapping::MysqlAdapter
+* added DataMapper::Mapping::PostgresAdapter
+* each adapter was included in related adapter in DataMapper.
+
 === dm-mapping 0.7.0, 2008-09-01
 * feature added
  - added postgres support.

data/README

@@ -1,4 +1,4 @@
-= dm-mapping 0.7.0
+= dm-mapping 0.7.1
 by Lin Jen-Shin (a.k.a. godfat-真常[http://godfat.org])
   godfat (XD) godfat.org
 

data/Rakefile

@@ -12,6 +12,7 @@ PROJ.name = 'dm-mapping'
 PROJ.ruby_opts.delete '-w'
 
 PROJ.gem.dependencies << ['dm-core', '>=0.9.3'] << ['extlib', '>=0.9.3']
+PROJ.gem.development_dependencies << ['minitest', '>=1.3.0']
 # PROJ.gem.executables = ["bin/#{PROJ.name}"]
 
 task :default do
@@ -46,7 +47,7 @@ PROJ.rdoc.main = 'README'
 PROJ.rdoc.exclude += ['Rakefile', '^tasks', '^test']
 PROJ.rdoc.include << '\w+'
 PROJ.rdoc.opts << '--diagram' if !WIN32 and `which dot` =~ %r/\/dot/
-PROJ.rdoc.opts += ['--charset=utf-8', '--inline-source', 
+PROJ.rdoc.opts += ['--charset=utf-8', '--inline-source',
                    '--line-numbers', '--promiscuous']
 
 PROJ.spec.opts << '--color'

data/dm-mapping.gemspec

@@ -3,11 +3,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dm-mapping}
-  s.version = "0.7.0"
+  s.version = "0.7.1"
 
   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-10-22}
+  s.date = %q{2008-12-17}
   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"]
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--diagram", "--charset=utf-8", "--inline-source", "--line-numbers", "--promiscuous", "--main", "README"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{ludy}
-  s.rubygems_version = %q{1.3.0}
+  s.rubygems_version = %q{1.3.1}
   s.summary = %q{DataMapper plugin that helps you manipulate an existing database. It creates mappings between existing columns and model's properties.}
   s.test_files = ["test/test_dm-mapping.rb"]
 
@@ -28,15 +28,18 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<dm-core>, [">= 0.9.3"])
       s.add_runtime_dependency(%q<extlib>, [">= 0.9.3"])
-      s.add_development_dependency(%q<bones>, [">= 2.1.0"])
+      s.add_development_dependency(%q<bones>, [">= 2.1.1"])
+      s.add_development_dependency(%q<minitest>, [">= 1.3.0"])
     else
       s.add_dependency(%q<dm-core>, [">= 0.9.3"])
       s.add_dependency(%q<extlib>, [">= 0.9.3"])
-      s.add_dependency(%q<bones>, [">= 2.1.0"])
+      s.add_dependency(%q<bones>, [">= 2.1.1"])
+      s.add_dependency(%q<minitest>, [">= 1.3.0"])
     end
   else
     s.add_dependency(%q<dm-core>, [">= 0.9.3"])
     s.add_dependency(%q<extlib>, [">= 0.9.3"])
-    s.add_dependency(%q<bones>, [">= 2.1.0"])
+    s.add_dependency(%q<bones>, [">= 2.1.1"])
+    s.add_dependency(%q<minitest>, [">= 1.3.0"])
   end
 end

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

@@ -2,121 +2,125 @@
 require 'dm-mapping/type_map'
 
 module DataMapper
-  module Adapters
-    class AbstractAdapter
-      module Migration
-        # returns all tables' name in the repository.
-        #  e.g.
-        #       ['comments', 'users']
-        def storages
-          raise NotImplementedError
-        end
+  module Mapping
+    module AbstractAdapter
+      # returns all tables' name in the repository.
+      #  e.g.
+      #       ['comments', 'users']
+      def storages
+        raise NotImplementedError
+      end
 
-        # returns all fields, with format [[name, type, attrs]]
-        #  e.g.
-        #       [[: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|
-            primitive = dmm_primitive(field)
-            type, chain = self.class.type_map.lookup_primitive(primitive) ||
-                          dmm_lookup_primitive(primitive)
+      # returns all fields, with format [[name, type, attrs]]
+      #  e.g.
+      #       [[: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|
+          primitive = dmm_primitive(field)
+          type, chain = self.class.type_map.lookup_primitive(primitive) ||
+                        dmm_lookup_primitive(primitive)
 
-            [dmm_field_name(field).to_sym, type, dmm_attributes(field)]
-          }
-        end
+          [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,  {: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|
-            result[storage] = fields(storage)
-            result
-          }
-        end
+      # returns a hash with storage names in keys and
+      # corresponded fields in values. e.g.
+      #   {'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|
+          result[storage] = fields(storage)
+          result
+        }
+      end
 
-        # automaticly generate model class(es) and mapping
-        # all fields with mapping /.*/ for you.
-        #  e.g.
-        #       dm.auto_genclass!
-        #       # => [DataMapper::Mapping::User,
-        #       #     DataMapper::Mapping::SchemaInfo,
-        #       #     DataMapper::Mapping::Session]
-        #
-        # you can change the scope of generated models:
-        #  e.g.
-        #       dm.auto_genclass! :scope => Object
-        #       # => [User, SchemaInfo, Session]
-        #
-        # 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
+      # automaticly generate model class(es) and mapping
+      # all fields with mapping /.*/ for you.
+      #  e.g.
+      #       dm.auto_genclass!
+      #       # => [DataMapper::Mapping::User,
+      #       #     DataMapper::Mapping::SchemaInfo,
+      #       #     DataMapper::Mapping::Session]
+      #
+      # you can change the scope of generated models:
+      #  e.g.
+      #       dm.auto_genclass! :scope => Object
+      #       # => [User, SchemaInfo, Session]
+      #
+      # 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|
+        storages.map{ |storage|
 
-            mapped = opts[:storages].each{ |target|
-              case target
-                when Regexp;
-                  break storage if storage =~ target
+          mapped = opts[:storages].each{ |target|
+            case target
+              when Regexp;
+                break storage if storage =~ target
 
-                when Symbol, String;
-                  break storage if storage == target.to_s
+              when Symbol, String;
+                break storage if storage == target.to_s
 
-                else
-                  raise ArgumentError.new("invalid argument: #{target.inspect}")
-              end
-            }
+              else
+                raise ArgumentError.new("invalid argument: #{target.inspect}")
+            end
+          }
 
-            dmm_genclass mapped, opts[:scope] if mapped.kind_of?(String)
-          }.compact
-        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
+      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_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
+      def dmm_lookup_primitive primitive
+        raise TypeError.new("#{primitive} not found for #{self.class}")
       end
     end
   end
 end
+
+module DataMapper
+  module Adapters
+    AbstractAdapter.send(:include, Mapping::AbstractAdapter)
+  end
+end

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

@@ -2,59 +2,63 @@
 require 'dm-mapping/adapters/abstract_adapter'
 
 module DataMapper
-  module Adapters
-    class MysqlAdapter < DataObjectsAdapter #:nodoc: all
-      module Migration
-        def storages
-          query 'SHOW TABLES'
-        end
-
-        private
-        # construct needed table metadata
-        def dmm_query_storage storage
-          sql = <<-SQL.compress_lines
-            SELECT column_name, column_default, is_nullable, data_type,
-                   character_maximum_length, column_key, extra
-            FROM `information_schema`.`columns`
-            WHERE `table_schema` = ? AND `table_name` = ?
-          SQL
-
-          query(sql, db_name, storage)
-        end
-
-        def dmm_field_name field
-          field.column_name
-        end
-
-        def dmm_primitive field
-          field.data_type
-        end
-
-        def dmm_attributes field, attrs = {}
-            attrs[:serial] = true if field.extra == 'auto_increment'
-            attrs[:key] = true if field.column_key != ''
-            attrs[:nullable] = field.is_nullable == 'YES'
-            attrs[:default] = field.column_default if field.column_default
-            attrs[:size] = field.character_maximum_length if
-              field.character_maximum_length
-
-            attrs
-        end
-
-        def dmm_lookup_primitive primitive
-          p = primitive.upcase
-
-          return Integer    if p == 'YEAR'
-          return Integer    if p =~          /\w*INT(EGER)?( SIGNED| UNSIGNED)?( ZEROFILL)?/
-          return BigDecimal if p =~ /(DOUBLE|FLOAT|DECIMAL)( SIGNED| UNSIGNED)?( ZEROFILL)?/
-          return String     if p =~ /\w*BLOB|\w*BINARY|ENUM|SET|CHAR/
-          return DM::Text   if p =~ /\w*TEXT/
-          return TrueClass  if %w[BOOL BOOLEAN].member?(p)
-          return Time       if p == 'TIME'
-
-          super(primitive)
-        end
+  module Mapping
+    module MysqlAdapter
+      def storages
+        query 'SHOW TABLES'
+      end
+
+      private
+      # construct needed table metadata
+      def dmm_query_storage storage
+        sql = <<-SQL.compress_lines
+          SELECT column_name, column_default, is_nullable, data_type,
+                 character_maximum_length, column_key, extra
+          FROM `information_schema`.`columns`
+          WHERE `table_schema` = ? AND `table_name` = ?
+        SQL
+
+        query(sql, db_name, storage)
+      end
+
+      def dmm_field_name field
+        field.column_name
+      end
+
+      def dmm_primitive field
+        field.data_type
+      end
+
+      def dmm_attributes field, attrs = {}
+          attrs[:serial] = true if field.extra == 'auto_increment'
+          attrs[:key] = true if field.column_key != ''
+          attrs[:nullable] = field.is_nullable == 'YES'
+          attrs[:default] = field.column_default if field.column_default
+          attrs[:size] = field.character_maximum_length if
+            field.character_maximum_length
+
+          attrs
+      end
+
+      def dmm_lookup_primitive primitive
+        p = primitive.upcase
+
+        return Integer    if p == 'YEAR'
+        return Integer    if p =~          /\w*INT(EGER)?( SIGNED| UNSIGNED)?( ZEROFILL)?/
+        return BigDecimal if p =~ /(DOUBLE|FLOAT|DECIMAL)( SIGNED| UNSIGNED)?( ZEROFILL)?/
+        return String     if p =~ /\w*BLOB|\w*BINARY|ENUM|SET|CHAR/
+        return DM::Text   if p =~ /\w*TEXT/
+        return TrueClass  if %w[BOOL BOOLEAN].member?(p)
+        return Time       if p == 'TIME'
+
+        super(primitive)
       end
     end
   end
 end
+
+module DataMapper
+  module Adapters
+    MysqlAdapter.send(:include, Mapping::MysqlAdapter)
+  end
+end

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

@@ -2,72 +2,76 @@
 require 'dm-mapping/adapters/abstract_adapter'
 
 module DataMapper
-  module Adapters
-    class PostgresAdapter < DataObjectsAdapter #:nodoc: all
-      module Migration
-        def storages
-          sql = <<-SQL.compress_lines
-            SELECT table_name FROM "information_schema"."tables"
-            WHERE table_schema = current_schema()
-          SQL
-
-          query(sql)
-        end
+  module Mapping
+    module PostgresAdapter
+      def storages
+        sql = <<-SQL.compress_lines
+          SELECT table_name FROM "information_schema"."tables"
+          WHERE table_schema = current_schema()
+        SQL
 
-        private
-        def dmm_query_storage storage
-          sql = <<-SQL.compress_lines
-            SELECT column_name FROM "information_schema"."key_column_usage"
-            WHERE table_schema = current_schema() AND table_name = ?
-          SQL
+        query(sql)
+      end
 
-          keys = query(sql, storage).to_set
+      private
+      def dmm_query_storage storage
+        sql = <<-SQL.compress_lines
+          SELECT column_name FROM "information_schema"."key_column_usage"
+          WHERE table_schema = current_schema() AND table_name = ?
+        SQL
 
-          sql = <<-SQL.compress_lines
-            SELECT column_name, column_default, is_nullable,
-                   character_maximum_length, udt_name
-            FROM "information_schema"."columns"
-            WHERE table_schema = current_schema() AND table_name = ?
-          SQL
+        keys = query(sql, storage).to_set
 
-          query(sql, storage).map{ |struct|
-            struct.instance_eval <<-END_EVAL
-              def key?
-                #{keys.member?(struct.column_name)}
-              end
-            END_EVAL
-            struct
-          }
-        end
+        sql = <<-SQL.compress_lines
+          SELECT column_name, column_default, is_nullable,
+                 character_maximum_length, udt_name
+          FROM "information_schema"."columns"
+          WHERE table_schema = current_schema() AND table_name = ?
+        SQL
 
-        def dmm_field_name field
-          field.column_name
-        end
+        query(sql, storage).map{ |struct|
+          struct.instance_eval <<-END_EVAL
+            def key?
+              #{keys.member?(struct.column_name)}
+            end
+          END_EVAL
+          struct
+        }
+      end
 
-        def dmm_primitive field
-          field.udt_name
-        end
+      def dmm_field_name field
+        field.column_name
+      end
 
-        def dmm_attributes field, attrs = {}
-          # strip data type
-          field.column_default.gsub!(/(.*?)::[\w\s]*/, '\1') if field.column_default
+      def dmm_primitive field
+        field.udt_name
+      end
 
-          attrs[:serial] = true if field.column_default =~ /nextval\('\w+_seq'\)/
-          attrs[:key] = true if field.key?
-          attrs[:nullable] = field.is_nullable == 'YES'
-          # strip string quotation
-          attrs[:default] = field.column_default.gsub(/^'(.*?)'$/, '\1') if
-            field.column_default && !attrs[:serial]
+      def dmm_attributes field, attrs = {}
+        # strip data type
+        field.column_default.gsub!(/(.*?)::[\w\s]*/, '\1') if field.column_default
 
-          if field.character_maximum_length
-            attrs[:size] = field.character_maximum_length
-          elsif field.udt_name.upcase == 'TEXT'
-            attrs[:size] = DM::Text.size
-          end
+        attrs[:serial] = true if field.column_default =~ /nextval\('\w+_seq'\)/
+        attrs[:key] = true if field.key?
+        attrs[:nullable] = field.is_nullable == 'YES'
+        # strip string quotation
+        attrs[:default] = field.column_default.gsub(/^'(.*?)'$/, '\1') if
+          field.column_default && !attrs[:serial]
 
-          attrs
+        if field.character_maximum_length
+          attrs[:size] = field.character_maximum_length
+        elsif field.udt_name.upcase == 'TEXT'
+          attrs[:size] = DM::Text.size
         end
+
+        attrs
       end
     end
   end
 end
+
+module DataMapper
+  module Adapters
+    PostgresAdapter.send(:include, Mapping::PostgresAdapter)
+  end
+end

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

@@ -2,50 +2,58 @@
 require 'dm-mapping/adapters/abstract_adapter'
 
 module DataMapper
-  module Adapters
-    class Sqlite3Adapter < DataObjectsAdapter #:nodoc: all
-      module Migration
-        def storages
+  module Mapping
+    module Sqlite3Adapter
+      def storages
 # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 177
-          sql = <<-SQL.compress_lines
-            SELECT name
-            FROM sqlite_master
-            WHERE type = 'table' AND NOT name = 'sqlite_sequence'
-          SQL
+        sql = <<-SQL.compress_lines
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+        SQL
 # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
 
-          query sql
-        end
+        query sql
+      end
 
-        private
-        alias_method :dmm_query_storage, :query_table
-        def dmm_field_name field
-          field.name
-        end
+      private
+      # alias_method :dmm_query_storages, :query_table
+      def dmm_query_storage *args, &block
+        query_table(*args, &block)
+      end
 
-        def dmm_primitive field
-          field.type.gsub(/\(\d+\)/, '')
-        end
+      def dmm_field_name field
+        field.name
+      end
+
+      def dmm_primitive field
+        field.type.gsub(/\(\d+\)/, '')
+      end
 
-        def dmm_attributes field, attrs = {}
-          if field.pk != 0
-            attrs[:key] = true
-            attrs[:serial] = true if supports_serial?
-          end
-          attrs[:nullable] = field.notnull != 99
-          attrs[:default] = field.dflt_value[1..-2] if field.dflt_value
-
-          if field.type.upcase == 'TEXT'
-            attrs[:size] = DM::Text.size
-          else
-            ergo = field.type.match(/\((\d+)\)/)
-            size = ergo && ergo[1].to_i
-            attrs[:size] = size if size
-          end
-
-          attrs
+      def dmm_attributes field, attrs = {}
+        if field.pk != 0
+          attrs[:key] = true
+          attrs[:serial] = true if supports_serial?
+        end
+        attrs[:nullable] = field.notnull != 99
+        attrs[:default] = field.dflt_value[1..-2] if field.dflt_value
+
+        if field.type.upcase == 'TEXT'
+          attrs[:size] = DM::Text.size
+        else
+          ergo = field.type.match(/\((\d+)\)/)
+          size = ergo && ergo[1].to_i
+          attrs[:size] = size if size
         end
+
+        attrs
       end
     end
   end
 end
+
+module DataMapper
+  module Adapters
+    Sqlite3Adapter.send(:include, Mapping::Sqlite3Adapter)
+  end
+end

data/lib/dm-mapping/version.rb

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

data/test/test_dm-mapping.rb

@@ -1,7 +1,6 @@
 
 require 'test/abstract'
 require 'minitest/unit'
-
 MiniTest::Unit.autorun
 
 %w[sqlite3 mysql postgres].each{ |adapter|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: godfat-dm-mapping
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
+  version: 0.7.1
 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-10-22 00:00:00 -07:00
+date: 2008-12-17 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,7 +37,16 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.1.0
+        version: 2.1.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
     version: 
 description: DataMapper plugin that helps you manipulate an existing database. It creates mappings between existing columns and model's properties.
 email: godfat (XD) godfat.org