dm-is-reflective 1.1.0 → 1.2.0

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

@@ -1,64 +0,0 @@
-
-module DataMapper
-  module Is::Reflective
-    module 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
-
-        select(Ext::String.compress_lines(sql),
-          options[: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)?/
-                                              ; BigDecimal
-        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
-  end
-end

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

@@ -1,82 +0,0 @@
-
-module DataMapper
-  module Is::Reflective
-    module 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 <<-END_EVAL
-            def key?
-              #{keys.member?(struct.column_name)}
-            end
-          END_EVAL
-          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
-        end || super(primitive)
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-
-module DataMapper
-  module Is::Reflective
-    module 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 if supports_serial?
-        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
-  end
-end

data/test/abstract.rb

@@ -1,252 +0,0 @@
-
-require 'dm-core'
-require 'dm-migrations'
-require 'dm-is-reflective'
-
-module Abstract
-  def self.next_id
-    @id ||= 0
-    @id += 1
-  end
-
-  AttrCommon   = {:allow_nil => true}
-  AttrCommonPK = {:serial => true, :key => true, :allow_nil => false}
-  AttrText     = {:length => 65535}.merge(AttrCommon)
-
-  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
-    Object.const_set(:MysqlTest, Class.new) unless defined?(MysqlTest) # dummy
-    case self
-      when MysqlTest # 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
-
-  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']
-
-  def sort_fields fields
-    fields.sort_by{ |field|
-      field.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, self.class.setup_data_mapper]
-  end
-
-  attr_reader :dm
-  def setup
-    @dm = self.class.setup_data_mapper
-    [User, Comment, SuperUser].each(&:auto_migrate!)
-  end
-
-  def new_scope
-    self.class.const_set("Scope#{object_id.object_id}", Module.new)
-  end
-
-  def test_storages
-    assert_equal Tables, dm.storages.sort
-    assert_equal comment_fields, sort_fields(dm.fields('abstract_comments'))
-  end
-
-  def test_create_comment
-    Comment.create(:title => 'XD')
-    assert_equal 'XD', Comment.first.title
-  end
-
-  def test_create_user
-    now = Time.now
-    User.create(:created_at => now)
-    assert_equal now.asctime, User.first.created_at.asctime
-
-    return now
-  end
-
-  def test_reflect_all
-    test_create_comment # for fixtures
-    model, local_dm = create_fake_model
-    model.storage_names[:default] = 'abstract_comments'
-
-    assert_equal Tables, local_dm.storages.sort
-    assert_equal 'abstract_comments', model.storage_name
-
-    model.send :reflect
-    assert_equal 1, model.all.size
-    assert_equal comment_fields, sort_fields(model.fields)
-
-    assert_equal 'XD', model.first.title
-  end
-
-  def test_reflect_and_create
-    model, local_dm = create_fake_model
-    model.storage_names[:default] = 'abstract_comments'
-    model.send :reflect
-
-    model.create(:title => 'orz')
-    assert_equal 'orz', model.first.title
-
-    model.create
-    assert_equal 'default title', model.last.title
-  end
-
-  def test_storages_and_fields
-    assert_equal user_fields, sort_fields(dm.fields('abstract_users'))
-    assert_equal( {'abstract_users' => user_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_by{ |v| v.first.to_s }
-                    r
-                  } )
-  end
-
-  def test_reflect_type
-    model, local_dm = create_fake_model
-    model.storage_names[:default] = 'abstract_comments'
-
-    model.send :reflect, DataMapper::Property::Serial
-    assert_equal ['id'], model.properties.map(&:name).map(&:to_s).sort
-
-    model.send :reflect, Integer
-    assert_equal ['id', 'user_id'], model.properties.map(&:name).map(&:to_s).sort
-  end
-
-  def test_reflect_multiple
-    model, local_dm = create_fake_model
-    model.storage_names[:default] = 'abstract_users'
-    model.send :reflect, :login, DataMapper::Property::Serial
-
-    assert_equal ['id', 'login'], model.properties.map(&:name).map(&:to_s).sort
-  end
-
-  def test_reflect_regexp
-    model, local_dm = create_fake_model
-    model.storage_names[:default] = 'abstract_comments'
-    model.send :reflect, /id$/
-
-    assert_equal ['id', 'user_id'], model.properties.map(&:name).map(&:to_s).sort
-  end
-
-  def test_invalid_argument
-    assert_raises(ArgumentError){
-      User.send :reflect, 29
-    }
-  end
-
-  def test_allow_empty_string
-    assert Comment.new(:title => '').save
-  end
-
-  def test_auto_genclasses
-    scope = new_scope
-    assert_equal ["#{scope == Object ? '' : "#{scope}::"}AbstractComment",
-                  "#{scope}::AbstractSuperUser",
-                  "#{scope}::AbstractUser"],
-                 dm.auto_genclass!(:scope => scope).map(&:to_s).sort
-
-    comment = scope.const_get('AbstractComment')
-
-    assert_equal comment_fields, sort_fields(comment.fields)
-
-    test_create_comment
-
-    assert_equal 'XD', comment.first.title
-    comment.create(:title => 'orz', :body => 'dm-reflect')
-    assert_equal 'dm-reflect', comment.last.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.last.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_reflect_return_value
-    model, local_dm = create_fake_model
-    model.storage_names[:default] = 'abstract_comments'
-    mapped = model.send :reflect, /.*/
-
-    assert_equal model.properties.map(&:object_id).sort, mapped.map(&:object_id).sort
-  end
-end