dm-is-reflective 1.1.0 → 1.2.0

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

@@ -0,0 +1,63 @@
+
+module DmIsReflective::MysqlAdapter
+  include DataMapper
+
+  def storages
+    select('SHOW TABLES')
+  end
+
+  private
+  # construct needed table metadata
+  def reflective_query_storage storage
+    sql = <<-SQL
+      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
+
+    # TODO: can we fix this shit in dm-mysql-adapter?
+    path = options[:path]     || options['path'] ||
+           options[:database] || options['database']
+
+    select(Ext::String.compress_lines(sql), path.sub('/', ''), 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[:allow_nil] = 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
+    case primitive.upcase
+    when 'YEAR'                           ; Integer
+    when /\w*INT(EGER)?( SIGNED| UNSIGNED)?( ZEROFILL)?/
+                                          ; Integer
+    when /(DOUBLE|FLOAT|DECIMAL)( SIGNED| UNSIGNED)?( ZEROFILL)?/
+                                          ; Property::Decimal
+    when /\w*BLOB|\w*BINARY|ENUM|SET|CHAR/; String
+    when 'TIME'                           ; Time
+    when 'DATE'                           ; Date
+    when 'DATETIME', 'TIMESTAMP'          ; DateTime
+    when 'BOOL', 'BOOLEAN'                ; Property::Boolean
+    when /\w*TEXT/                        ; Property::Text
+    end || super(primitive)
+  end
+end

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

@@ -0,0 +1,80 @@
+
+module DmIsReflective::PostgresAdapter
+  include DataMapper
+
+  def storages
+    sql = <<-SQL
+      SELECT table_name FROM "information_schema"."tables"
+      WHERE table_schema = current_schema()
+    SQL
+
+    select(Ext::String.compress_lines(sql))
+  end
+
+  private
+  def reflective_query_storage storage
+    sql = <<-SQL
+      SELECT column_name FROM "information_schema"."key_column_usage"
+      WHERE table_schema = current_schema() AND table_name = ?
+    SQL
+
+    keys = select(Ext::String.compress_lines(sql), storage).to_set
+
+    sql = <<-SQL
+      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
+
+    select(Ext::String.compress_lines(sql), storage).map{ |struct|
+      struct.instance_eval <<-RUBY
+        def key?
+          #{keys.member?(struct.column_name)}
+        end
+      RUBY
+      struct
+    }
+  end
+
+  def reflective_field_name field
+    field.column_name
+  end
+
+  def reflective_primitive field
+    field.udt_name
+  end
+
+  def reflective_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[:allow_nil] = 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] = Property::Text.length
+    end
+
+    attrs
+  end
+
+  def reflective_lookup_primitive primitive
+    case primitive.upcase
+    when /^INT\d+$/         ; Integer
+    when /^FLOAT\d+$/       ; Float
+    when 'VARCHAR', 'BPCHAR'; String
+    when 'TIMESTAMP', 'DATE'; DateTime
+    when 'TEXT'             ; Property::Text
+    when 'BOOL'             ; Property::Boolean
+    when 'NUMERIC'          ; Property::Decimal
+    end || super(primitive)
+  end
+end

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

@@ -0,0 +1,57 @@
+
+module DmIsReflective::SqliteAdapter
+  include DataMapper
+
+  def storages
+    sql = <<-SQL
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+    SQL
+
+    select(Ext::String.compress_lines(sql))
+  end
+
+  private
+  def reflective_query_storage storage
+    select('PRAGMA table_info(?)', storage)
+  end
+
+  def reflective_field_name field
+    field.name
+  end
+
+  def reflective_primitive field
+    field.type.gsub(/\(\d+\)/, '')
+  end
+
+  def reflective_attributes field, attrs = {}
+    if field.pk != 0
+      attrs[:key] = true
+      attrs[:serial] = true
+    end
+    attrs[:allow_nil] = field.notnull == 0
+    attrs[:default] = field.dflt_value[1..-2] if field.dflt_value
+
+    if field.type.upcase == 'TEXT'
+      attrs[:length] = Property::Text.length
+    else
+      ergo = field.type.match(/\((\d+)\)/)
+      size = ergo && ergo[1].to_i
+      attrs[:length] = size if size
+    end
+
+    attrs
+  end
+
+  def reflective_lookup_primitive primitive
+    case primitive.upcase
+    when 'INTEGER'        ; Integer
+    when 'REAL', 'NUMERIC'; Float
+    when 'VARCHAR'        ; String
+    when 'TIMESTAMP'      ; DateTime
+    when 'BOOLEAN'        ; Property::Boolean
+    when 'TEXT'           ; Property::Text
+    end || super(primitive)
+  end
+end

data/lib/dm-is-reflective/{is/reflective.rb → reflective.rb}

@@ -1,7 +1,8 @@
 
-module DataMapper
-module Is
-module Reflective
+module DmIsReflective
+  autoload :VERSION, 'dm-is-reflective/version'
+
+  include DataMapper
 
   def is_reflective
     extend ClassMethod
@@ -74,8 +75,18 @@ module Reflective
       finalize if respond_to?(:finalize)
       result
     end
-  end # of ClassMethod
 
-end # of Reflective
-end # of Is
-end # of DataMapper
+    def to_source scope=nil
+<<-RUBY
+class #{scope}::#{name} < #{superclass}
+  include DataMapper::Resource
+  #{
+    properties.map do |prop|
+      "property :#{prop.name}, #{prop.class.name}, #{prop.options}"
+    end.join("\n")
+  }
+end
+RUBY
+    end
+  end # of ClassMethod
+end # of DmIsReflective

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

@@ -0,0 +1,87 @@
+
+require 'dm-is-reflective'
+
+module DmIsReflective::Runner
+  module_function
+  def options
+    @options ||=
+    [['-s, --scope SCOPE'                                          ,
+      'SCOPE where the models should go (default: Object)'         ],
+     ['-o, --output DIRECTORY'                                     ,
+      'DIRECTORY where the output goes (default: dm-is-reflective)'],
+     ['-h, --help'   , 'Print this message'                        ],
+     ['-v, --version', 'Print the version'                         ]]
+  end
+
+  def run argv=ARGV
+    puts(help) and exit if argv.empty?
+    generate(*parse(argv))
+  end
+
+  def generate uri, scope, output
+    require 'fileutils'
+    FileUtils.mkdir_p(output)
+    DataMapper.setup(:default, uri).auto_genclass!(:scope => scope).
+      each do |model|
+        path = "#{output}/#{model.name.gsub(/::/, '').
+                                       gsub(/([A-Z])/, '_\1').
+                                       downcase[1..-1]}.rb"
+        File.open(path, 'w') do |file|
+          file.puts model.to_source
+        end
+      end
+  end
+
+  def parse argv
+    uri, scope, output = ['sqlite::memory:', Object, 'dm-is-reflective']
+    until argv.empty?
+      case arg = argv.shift
+      when /^-s=?(.+)?/, /^--scope=?(.+)?/
+        name  = $1 || argv.shift
+        scope = if Object.const_defined?(name)
+                  Object.const_get(name)
+                else
+                  mkconst_p(name)
+                end
+
+      when /^-o=?(.+)?/, /^--output=?(.+)?/
+        output = $1 || argv.shift
+
+      when /^-h/, '--help'
+        puts(help)
+        exit
+
+      when /^-v/, '--version'
+        puts(DmIsReflective::VERSION)
+        exit
+
+      else
+        uri = arg
+      end
+    end
+    [uri, scope, output]
+  end
+
+  def mkconst_p name
+    name.split('::').inject(Object) do |ret, mod|
+      if Object.const_defined?(mod)
+        ret.const_get(mod)
+      else
+        ret.const_set(mod, Module.new)
+      end
+    end
+  end
+
+  def help
+    maxn = options.transpose.first.map(&:size).max
+    maxd = options.transpose.last .map(&:size).max
+    "Usage: dm-is-reflective DATABASE_URI\n" +
+    options.map{ |(name, desc)|
+      if desc.empty?
+        name
+      else
+        sprintf("  %-*s  %-*s", maxn, name, maxd, desc)
+      end
+    }.join("\n")
+  end
+end

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

@@ -0,0 +1,279 @@
+
+require 'bacon'
+Bacon.summary_on_exit
+
+require 'dm-core'
+require 'dm-migrations'
+require 'dm-is-reflective'
+
+module Abstract
+  class User
+    include DataMapper::Resource
+    has n, :comments
+
+    property :id,         Serial
+    property :login,      String, :length => 70
+    property :sig,        Text
+    property :created_at, DateTime
+
+    is :reflective
+  end
+
+  class SuperUser
+    include DataMapper::Resource
+    property :id, Serial
+    property :bool, Boolean
+
+    is :reflective
+  end
+
+  class Comment
+    include DataMapper::Resource
+    belongs_to :user, :required => false
+
+    property :id,    Serial
+    property :title, String,  :length => 50, :default => 'default title',
+                              :allow_nil => false
+    property :body,  Text
+
+    is :reflective
+  end
+
+  Tables = ['abstract_comments', 'abstract_super_users', 'abstract_users']
+
+  AttrCommon   = {:allow_nil => true}
+  AttrCommonPK = {:serial => true, :key => true, :allow_nil => false}
+  AttrText     = {:length => 65535}.merge(AttrCommon)
+
+  def self.next_id
+    @id ||= 0
+    @id += 1
+  end
+end
+
+include Abstract
+
+shared :reflective do
+  def user_fields
+    [[:created_at, DateTime, AttrCommon],
+     [:id,         DataMapper::Property::Serial,  AttrCommonPK],
+     [:login,      String,   {:length => 70}.merge(AttrCommon)],
+     [:sig,        DataMapper::Property::Text, AttrText]]
+  end
+
+  def comment_fields
+    [[:body,    DataMapper::Property::Text,    AttrText],
+     [:id,      DataMapper::Property::Serial,  AttrCommonPK],
+     [:title,   String,   {:length => 50, :default => 'default title',
+                           :allow_nil => false}],
+     [:user_id, Integer,  AttrCommon]]
+  end
+
+  # there's differences between adapters
+  def super_user_fields
+    mysql = defined?(DataMapper::Adapters::MysqlAdapter) &&
+                     DataMapper::Adapters::MysqlAdapter
+    case DataMapper.repository.adapter
+    when mysql
+      # Mysql couldn't tell it's boolean or tinyint
+      [[:bool, Integer, AttrCommon],
+       [:id,   DataMapper::Property::Serial, AttrCommonPK]]
+
+    else
+      [[:bool, DataMapper::Property::Boolean, AttrCommon],
+       [:id,   DataMapper::Property::Serial,  AttrCommonPK]]
+    end
+  end
+
+  before do
+    @dm = setup_data_mapper
+    [User, Comment, SuperUser].each(&:auto_migrate!)
+  end
+
+  def sort_fields fields
+    fields.sort_by{ |f| f.first.to_s }
+  end
+
+  def create_fake_model
+    model = Class.new
+    model.module_eval do
+      include DataMapper::Resource
+      property :id, DataMapper::Property::Serial
+      is :reflective
+    end
+    Abstract.const_set("Model#{Abstract.next_id}", model)
+    [model, setup_data_mapper]
+  end
+
+  def new_scope
+    Abstract.const_set("Scope#{Abstract.next_id}", Module.new)
+  end
+
+  def test_create_comment
+    Comment.create(:title => 'XD')
+    Comment.first.title.should.eq 'XD'
+  end
+
+  def test_create_user
+    now = Time.now
+    User.create(:created_at => now)
+    User.first.created_at.asctime.should.eq now.asctime
+    now
+  end
+
+  should 'create comment' do
+    test_create_comment
+  end
+
+  should 'create user' do
+    test_create_user
+  end
+
+  should 'storages' do
+    @dm.storages.sort.should.eq Tables
+    sort_fields(@dm.fields('abstract_comments')).should.eq comment_fields
+  end
+
+  should 'reflect all' do
+    test_create_comment # for fixtures
+    model, local_dm = create_fake_model
+    model.storage_names[:default] = 'abstract_comments'
+
+    local_dm.storages.sort.should.eq Tables
+    model.storage_name.should.eq 'abstract_comments'
+
+    model.send :reflect
+    model.all.size           .should.eq 1
+    sort_fields(model.fields).should.eq comment_fields
+    model.first.title        .should.eq 'XD'
+  end
+
+  should 'reflect and create' do
+    model, local_dm = create_fake_model
+    model.storage_names[:default] = 'abstract_comments'
+    model.send :reflect
+
+    model.create(:title => 'orz')
+    model.first.title.should.eq 'orz'
+
+    model.create
+    model.last.title.should.eq 'default title'
+  end
+
+  should 'storages and fields' do
+    sort_fields(@dm.fields('abstract_users')).should.eq user_fields
+
+    @dm.storages_and_fields.inject({}){ |r, i|
+      key, value = i
+      r[key] = value.sort_by{ |v| v.first.to_s }
+      r
+    }.should.eq('abstract_users'       => user_fields      ,
+                'abstract_comments'    => comment_fields   ,
+                'abstract_super_users' => super_user_fields)
+  end
+
+  should 'reflect type' do
+    model, local_dm = create_fake_model
+    model.storage_names[:default] = 'abstract_comments'
+
+    model.send :reflect, DataMapper::Property::Serial
+    model.properties.map(&:name).map(&:to_s).sort.should.eq ['id']
+
+    model.send :reflect, Integer
+    model.properties.map(&:name).map(&:to_s).sort.should.eq \
+      ['id', 'user_id']
+  end
+
+  should 'reflect multiple' do
+    model, local_dm = create_fake_model
+    model.storage_names[:default] = 'abstract_users'
+    model.send :reflect, :login, DataMapper::Property::Serial
+
+    model.properties.map(&:name).map(&:to_s).sort.should.eq \
+      ['id', 'login']
+  end
+
+  should 'reflect regexp' do
+    model, local_dm = create_fake_model
+    model.storage_names[:default] = 'abstract_comments'
+    model.send :reflect, /id$/
+
+    model.properties.map(&:name).map(&:to_s).sort.should.eq \
+      ['id', 'user_id']
+  end
+
+  should 'raise ArgumentError when giving invalid argument' do
+    lambda{
+      User.send :reflect, 29
+    }.should.raise ArgumentError
+  end
+
+  should 'allow empty string' do
+    Comment.new(:title => '').save.should.eq true
+  end
+
+  should 'auto_genclasses' do
+    scope = new_scope
+    @dm.auto_genclass!(:scope => scope).map(&:to_s).sort.should.eq \
+      ["#{scope}::AbstractComment",
+       "#{scope}::AbstractSuperUser",
+       "#{scope}::AbstractUser"]
+
+    comment = scope.const_get('AbstractComment')
+
+    sort_fields(comment.fields).should.eq comment_fields
+
+    test_create_comment
+
+    comment.first.title.should.eq 'XD'
+    comment.create(:title => 'orz', :body => 'dm-reflect')
+    comment.last.body.should.eq 'dm-reflect'
+  end
+
+  should 'auto_genclass' do
+    scope = new_scope
+    @dm.auto_genclass!(:scope => scope,
+                       :storages => 'abstract_users').map(&:to_s).should.eq \
+      ["#{scope}::AbstractUser"]
+
+    user = scope.const_get('AbstractUser')
+    sort_fields(user.fields).should.eq user_fields
+
+    now = test_create_user
+
+    user.first.created_at.asctime.should.eq now.asctime
+    user.create(:login => 'godfat')
+    user.last.login.should.eq 'godfat'
+  end
+
+  should 'auto_genclass with regexp' do
+    scope = new_scope
+    @dm.auto_genclass!(:scope => scope,
+                       :storages => /_users$/).map(&:to_s).sort.should.eq \
+      ["#{scope}::AbstractSuperUser", "#{scope}::AbstractUser"]
+
+    user = scope.const_get('AbstractSuperUser')
+    sort_fields(user.fields).should.eq sort_fields(SuperUser.fields)
+  end
+
+  should 'reflect return value' do
+    model, local_dm = create_fake_model
+    model.storage_names[:default] = 'abstract_comments'
+    mapped = model.send :reflect, /.*/
+
+    mapped.map(&:object_id).sort.should.eq \
+      model.properties.map(&:object_id).sort
+  end
+end
+
+module Kernel
+  def eq? rhs
+    self == rhs
+  end
+
+  def require_adapter adapter
+    require "dm-#{adapter}-adapter"
+  rescue LoadError
+    puts "skip #{adapter} test since it's not installed"
+  end
+end