dm-is-reflective 0.8.0

data/NOTICE

@@ -0,0 +1,30 @@
+= notice and thanks
+
+* dm-is-reflective is a plugin of DataMapper
+    > sudo gem install dm-core
+    http://datamapper.org
+
+* this project skeleton is built through Mr Bones
+    http://codeforpeople.rubyforge.org/bones/
+
+* thanks to Rails team with ActiveRecord, it's inspiring.
+  and some SQL snippets are borrowed from it.
+    http://rubyonrails.org
+
+* Ruby the great language
+    http://www.ruby-lang.org
+
+* Rubygems the great package management
+    http://rubygems.org
+
+* Rake the great task automation
+    http://rake.rubyforge.org
+
+* Facets the great ruby library collection
+    http://facets.rubyforge.org/
+
+* Rubyforge for distributing ruby gems
+    http://rubyforge.org
+
+* Github for hosting git
+    http://github.com

data/README

@@ -0,0 +1,122 @@
+= dm-is-reflective 0.8.0
+by Lin Jen-Shin (aka godfat-真常[http://godfat.org])
+  godfat (XD) godfat.org
+
+== LINKS:
+
+* rdoc[http://ludy.rubyforge.org/dm-is-reflective]
+* github-project[http://github.com/godfat/dm-is-reflective]
+* rubyforge-project[http://rubyforge.org/projects/ludy]
+
+== DESCRIPTION:
+
+ DataMapper plugin that helps you manipulate an existing database.
+ It creates mappings between existing columns and model's properties.
+
+== SYNOPSIS:
+
+ require 'dm-is-reflective' # this would require 'dm-core'
+ dm = DataMapper.setup :default, 'sqlite3:db/development.sqlite3'
+
+ class User
+   include DataMapper::Resource
+   is :reflective
+
+   # 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 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
+   mapping :id, :email
+
+   # mapping all fields with type String, and id
+   mapping String, :id
+
+   # mapping login, and all fields with type Integer
+   mapping :login, Integer
+ end
+
+ # there's no guarantee of the order in storages array
+ dm.storages
+ # => ['users']
+
+ # there's no guarantee of the order in fields array
+ User.fields
+ # => [[:created_at,  DateTime, {:nullable => true}],
+       [:email,       String,   {:nullable => true, :length => 255,
+                                 :default => 'nospam@nospam.tw'}],
+       [:id,          Serial,   {:nullable => false, :serial => true,
+                                 :key => true}],
+       [:salt_first,  String,   {:nullable => true, :length => 50}],
+       [:salt_second, String,   {:nullable => true, :length => 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,          Serial,   {:nullable => false,
+                                             :serial => true,
+                                             :key => true}],
+                   [:email,       String,   {:nullable => true,
+                                             :default => 'nospam@nospam.tw'}],
+                   [:created_at,  DateTime, {:nullable => true}],
+                   [:salt_first,  String,   {:nullable => true, :length => 50}],
+                   [:salt_second, String,   {:nullable => true, :length => 50}]]}
+
+ # there's no guarantee of the order in returned array
+ dm.auto_genclass!
+ # => [DataMapper::Is::Reflective::User,
+       DataMapper::Is::Reflective::SchemaInfo,
+       DataMapper::Is::Reflective::Session]
+
+ # you can change the scope of generated models:
+ 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::Is::Reflective::User]
+
+== REQUIREMENTS:
+
+* dm-core 0.10.0 or later
+* at least one do_* adapter
+
+== INSTALL:
+
+> sudo gem install dm-is-reflective
+
+== LICENSE:
+
+  Apache License 2.0
+
+  Copyright (c) 2008, Lin Jen-Shin (aka godfat 真常)
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'bones'
+Bones.setup
+
+PROJ.name = 'dm-is-reflective'
+PROJ.authors = 'Lin Jen-Shin (aka godfat 真常)'
+PROJ.email = 'godfat (XD) godfat.org'
+PROJ.url = "http://github.com/godfat/#{PROJ.name}"
+PROJ.rubyforge.name = 'ludy'
+
+PROJ.gem.dependencies << ['dm-core', '>=0.10.0'] << ['extlib', '>=0.9.13']
+# PROJ.gem.development_dependencies << ['minitest', '>=1.3.0']
+# PROJ.gem.executables = ["bin/#{PROJ.name}"]
+
+PROJ.ruby_opts.delete '-w' # too many warnings in addressable, dm-core, extlib...
+
+PROJ.description = PROJ.summary = paragraphs_of('README', 'description').join("\n\n")
+PROJ.changes = paragraphs_of('CHANGES', 0..1).join("\n\n")
+PROJ.version = File.read("lib/#{PROJ.name}/version.rb").gsub(/.*VERSION = '(.*)'.*/m, '\1')
+
+PROJ.exclude += ['^tmp', 'tmp$', '^pkg', '^\.gitignore$',
+                 '^ann-', '\.sqlite3$', '\.db$']
+
+PROJ.rdoc.remote_dir = PROJ.name
+
+PROJ.readme_file = 'README'
+PROJ.rdoc.main = 'README'
+PROJ.rdoc.exclude += ['Rakefile', '^tasks', '^test']
+PROJ.rdoc.include << '\w+'
+# PROJ.rdoc.opts << '--diagram' if !Rake::WIN32 and `which dot` =~ %r/\/dot/
+PROJ.rdoc.opts += ['--charset=utf-8', '--inline-source',
+                   '--line-numbers', '--promiscuous']
+
+PROJ.spec.opts << '--color'
+
+PROJ.ann.file = "ann-#{PROJ.name}-#{PROJ.version}"
+PROJ.ann.paragraphs.concat %w[LINKS SYNOPSIS REQUIREMENTS INSTALL LICENSE]
+
+CLEAN.include Dir['**/*.rbc']
+
+task :default do
+  Rake.application.options.show_task_pattern = /./
+  Rake.application.display_tasks_and_comments
+end

data/TODO

@@ -0,0 +1,7 @@
+= dm-is-reflective todo list
+
+* test Model#fields with different repo
+
+* better doc...
+* 0.7.1 for more data types for postgresql adapter
+* 0.9 automatic determine model relationship

data/dm-is-reflective.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dm-is-reflective}
+  s.version = "0.8.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Lin Jen-Shin (aka godfat \347\234\237\345\270\270)"]
+  s.date = %q{2009-06-21}
+  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"]
+  s.files = ["CHANGES", "LICENSE", "NOTICE", "README", "Rakefile", "TODO", "lib/dm-is-reflective.rb", "lib/dm-is-reflective/is/adapters/abstract_adapter.rb", "lib/dm-is-reflective/is/adapters/mysql_adapter.rb", "lib/dm-is-reflective/is/adapters/postgres_adapter.rb", "lib/dm-is-reflective/is/adapters/sqlite3_adapter.rb", "lib/dm-is-reflective/is/reflective.rb", "lib/dm-is-reflective/is/version.rb", "lib/dm-is-reflective/version.rb", "test/abstract.rb", "test/test_dm-is-reflexible.rb"]
+  s.homepage = %q{http://github.com/godfat/dm-is-reflective}
+  s.rdoc_options = ["--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.4}
+  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-is-reflexible.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<dm-core>, [">= 0.10.0"])
+      s.add_runtime_dependency(%q<extlib>, [">= 0.9.13"])
+      s.add_development_dependency(%q<bones>, [">= 2.5.1"])
+    else
+      s.add_dependency(%q<dm-core>, [">= 0.10.0"])
+      s.add_dependency(%q<extlib>, [">= 0.9.13"])
+      s.add_dependency(%q<bones>, [">= 2.5.1"])
+    end
+  else
+    s.add_dependency(%q<dm-core>, [">= 0.10.0"])
+    s.add_dependency(%q<extlib>, [">= 0.9.13"])
+    s.add_dependency(%q<bones>, [">= 2.5.1"])
+  end
+end

data/lib/dm-is-reflective.rb

@@ -0,0 +1,10 @@
+
+gem 'dm-core', '>=0.10.0'
+require 'dm-core'
+
+require 'dm-is-reflective/is/reflective'
+DataMapper::Model.append_extensions(DataMapper::Is::Reflective)
+
+require 'dm-is-reflective/is/adapters/abstract_adapter'
+DataMapper::Adapters::AbstractAdapter.__send__(:include,
+  DataMapper::Is::Reflective::AbstractAdapter)

data/lib/dm-is-reflective/is/adapters/abstract_adapter.rb

@@ -0,0 +1,144 @@
+
+module DataMapper
+  module Is::Reflective
+    module AbstractAdapter
+      # returns all tables' name in the repository.
+      #  e.g.
+      #       ['comments', 'users']
+      def storages
+        reflective_auto_load_adapter_extension
+        storages # call the overrided method
+      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, DataMapper::Types::Serial,  {:nullable => false, :serial => true,
+      #                                  :key => true}],
+      #        [:salt_first,  String,   {:nullable => true, :size => 50}],
+      #        [:salt_second, String,   {:nullable => true, :size => 50}]]
+      def fields storage
+        reflective_query_storage(storage).map{ |field|
+          primitive = reflective_primitive(field)
+
+          type = self.class.type_map.find{ |klass, attrs|
+                   next false if [DataMapper::Types::Object, Time].include?(klass)
+                   attrs[:primitive] == primitive
+                 }
+          type = type ? type.first : reflective_lookup_primitive(primitive)
+
+          attrs = reflective_attributes(field)
+
+          type = if attrs[:serial] && type == Integer
+                   DataMapper::Types::Serial
+
+                 elsif type == TrueClass
+                   DataMapper::Types::Boolean
+
+                 else
+                    type
+                 end
+
+          [reflective_field_name(field).to_sym, type, attrs]
+        }
+      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 reflect
+      # all fields with reflect /.*/ for you.
+      #  e.g.
+      #       dm.auto_genclass!
+      #       # => [DataMapper::Is::Reflective::User,
+      #       #     DataMapper::Is::Reflective::SchemaInfo,
+      #       #     DataMapper::Is::Reflective::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::Is::Reflective::User]
+      def auto_genclass! opts = {}
+        opts[:scope] ||= DataMapper::Is::Reflective
+        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
+          }
+
+          reflective_genclass(mapped, opts[:scope]) if mapped.kind_of?(String)
+        }.compact
+      end
+
+      private
+      def reflective_query_storage storage
+        reflective_auto_load_adapter_extension
+        reflective_query_storage(storage) # call the overrided method
+      end
+
+      def reflective_genclass storage, scope
+        model = Class.new
+        model.__send__(:include, DataMapper::Resource)
+        model.is(:reflective)
+        model.storage_names[:default] = storage
+        model.__send__(:reflect, /.*/)
+        scope.const_set(Extlib::Inflection.classify(storage), model)
+      end
+
+      def reflective_lookup_primitive primitive
+        raise TypeError.new("#{primitive} not found for #{self.class}")
+      end
+
+      def reflective_auto_load_adapter_extension
+        require "dm-is-reflective/is/adapters/#{options['scheme']}_adapter"
+        class_name = "#{Extlib::Inflection.camelize(options['scheme'])}Adapter"
+        Adapters.const_get(class_name).__send__(:include,
+          Is::Reflective.const_get(class_name))
+      end
+    end
+  end
+end

data/lib/dm-is-reflective/is/adapters/mysql_adapter.rb

@@ -0,0 +1,62 @@
+
+require 'dm-is-reflective/is/adapters/abstract_adapter'
+
+module DataMapper
+  module Is::Reflective
+    module MysqlAdapter
+      def storages
+        query 'SHOW TABLES'
+      end
+
+      private
+      # construct needed table metadata
+      def reflective_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 reflective_field_name field
+        field.column_name
+      end
+
+      def reflective_primitive field
+        field.data_type
+      end
+
+      def reflective_attributes field, attrs = {}
+          attrs[:serial] = true if field.extra      == 'auto_increment'
+          attrs[:key]    = true if field.column_key == 'PRI'
+
+          attrs[:nullable] = field.is_nullable == 'YES'
+          attrs[:default]  = field.column_default           if
+            field.column_default
+
+          attrs[:length]   = field.character_maximum_length if
+            field.character_maximum_length
+
+          attrs
+      end
+
+      def reflective_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 Time       if p == 'TIME'
+        return DateTime   if p == 'DATETIME'
+        return DataMapper::Types::Boolean if %w[BOOL BOOLEAN].member?(p)
+        return DataMapper::Types::Text    if p =~ /\w*TEXT/
+
+        super(primitive)
+      end
+    end
+  end
+end