godfat-dm-is-reflective 0.8.0

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.8 automatic determine model relationship

data/lib/dm-is-reflective.rb

@@ -0,0 +1,18 @@
+
+gem 'dm-core', '>=0.10.0'
+require 'dm-core'
+
+require 'extlib/hook'
+require 'extlib/inflection'
+
+module DataMapper
+  include Extlib::Hook
+  after_class_method :setup do
+    adapter_name = repository.adapter.class.to_s.split('::').last
+    require "dm-is-reflective/is/adapters/#{Extlib::Inflection.underscore(adapter_name)}"
+  end
+
+end
+
+require 'dm-is-reflective/is/reflective'
+DataMapper::Model.append_extensions DataMapper::Is::Reflective

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

@@ -0,0 +1,141 @@
+
+module DataMapper
+  module Is::Reflective
+    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, 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
+        dmm_query_storage(storage).map{ |field|
+          primitive = dmm_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 : dmm_lookup_primitive(primitive)
+
+          attrs = dmm_attributes(field)
+
+          type = if attrs[:serial] && type == Integer
+                   DataMapper::Types::Serial
+
+                 elsif type == TrueClass
+                   DataMapper::Types::Boolean
+
+                 else
+                    type
+                 end
+
+          [dmm_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 mapping
+      # all fields with mapping /.*/ 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
+          }
+
+          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.is(:reflective)
+        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
+
+module DataMapper
+  module Adapters
+    AbstractAdapter.send(:include, Is::Reflective::AbstractAdapter)
+  end
+end

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

@@ -0,0 +1,68 @@
+
+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 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 == '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 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 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
+
+module DataMapper
+  module Adapters
+    MysqlAdapter.send(:include, Is::Reflective::MysqlAdapter)
+  end
+end

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

@@ -0,0 +1,90 @@
+
+require 'dm-is-reflective/is/adapters/abstract_adapter'
+
+module DataMapper
+  module Is::Reflective
+    module PostgresAdapter
+      def storages
+        sql = <<-SQL.compress_lines
+          SELECT table_name FROM "information_schema"."tables"
+          WHERE table_schema = current_schema()
+        SQL
+
+        query(sql)
+      end
+
+      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
+
+        keys = query(sql, storage).to_set
+
+        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
+
+        query(sql, storage).map{ |struct|
+          struct.instance_eval <<-END_EVAL
+            def key?
+              #{keys.member?(struct.column_name)}
+            end
+          END_EVAL
+          struct
+        }
+      end
+
+      def dmm_field_name field
+        field.column_name
+      end
+
+      def dmm_primitive field
+        field.udt_name
+      end
+
+      def dmm_attributes field, attrs = {}
+        # strip data type
+        field.column_default.gsub!(/(.*?)::[\w\s]*/, '\1') if field.column_default
+
+        attrs[:serial] = true if field.column_default =~ /nextval\('\w+'\)/
+        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]
+
+        if field.character_maximum_length
+          attrs[:length] = field.character_maximum_length
+        elsif field.udt_name.upcase == 'TEXT'
+          attrs[:length] = DataMapper::Types::Text.size
+        end
+
+        attrs
+      end
+
+      def dmm_lookup_primitive primitive
+        p = primitive.upcase
+
+        return Integer  if p =~ /^INT\d+$/
+        return String   if p == 'VARCHAR'
+        return DateTime if p == 'TIMESTAMP'
+        return DataMapper::Types::Text    if p == 'TEXT'
+        return DataMapper::Types::Boolean if p == 'BOOL'
+
+        super(primitive)
+      end
+
+    end
+  end
+end
+
+module DataMapper
+  module Adapters
+    PostgresAdapter.send(:include, Is::Reflective::PostgresAdapter)
+  end
+end

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

@@ -0,0 +1,59 @@
+
+require 'dm-is-reflective/is/adapters/abstract_adapter'
+
+module DataMapper
+  module Is::Reflective
+    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
+# activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
+
+        query sql
+      end
+
+      private
+      # alias_method :dmm_query_storages, :query_table
+      def dmm_query_storage *args, &block
+        query_table(*args, &block)
+      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 != 1
+        attrs[:default] = field.dflt_value[1..-2] if field.dflt_value
+
+        if field.type.upcase == 'TEXT'
+          attrs[:length] = DataMapper::Types::Text.size
+        else
+          ergo = field.type.match(/\((\d+)\)/)
+          size = ergo && ergo[1].to_i
+          attrs[:length] = size if size
+        end
+
+        attrs
+      end
+    end
+  end
+end
+
+module DataMapper
+  module Adapters
+    Sqlite3Adapter.send(:include, Is::Reflective::Sqlite3Adapter)
+  end
+end

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

@@ -0,0 +1,78 @@
+
+module DataMapper
+module Is
+module Reflective
+
+  def is_reflective
+    extend ClassMethod
+  end
+
+  module ClassMethod
+    # it simply calls Migration#fields(self.storage_name)
+    #  e.g.
+    #       DataMapper.repository.adapter.fields storage_name
+    def fields repo = default_repository_name
+      DataMapper.repository(repo).adapter.fields(storage_name(repo))
+    end
+
+    # it automaticly creates mappings from storage fields to properties.
+    # i.e. you don't have to specify any property if you are connecting
+    # to an existing database.
+    # 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
+    #         # mapping all
+    #         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
+    def mapping *targets
+      targets << /.*/ if targets.empty?
+
+      fields.map{ |field|
+        name, type, attrs = field
+
+        mapped = targets.each{ |target|
+          case target
+            when Regexp;
+              break name if name.to_s =~ target
+
+            when Symbol, String;
+              break name if name == target.to_sym
+
+            when Class;
+              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 # of ClassMethod
+
+end # of Reflective
+end # of Is
+end # of DataMapper