dm-is-reflective 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4a92f58af6a1c63b6bb445e06fdc573239ef558
-  data.tar.gz: 4577c3ed73a122c4ddd09e62c8c0e64802e49540
+  metadata.gz: 9e05d37577ac7449933ee4680893d496c6ca138f
+  data.tar.gz: ff50451f50e9b1094db71272cbda92bb7476015a
 SHA512:
-  metadata.gz: f271c3864848cfb098e7f7b32887831700617668c001a56f25f0be1a0497d0e488db5f8970ad7e96ee9ab9aecb4fd333b4fa71c70de48afd435929c266751f5c
-  data.tar.gz: a139f550d6b69b36ddb824eec2ca59b4ec157d1289d39cdcc31f268a5d50a7abb90abcb1b48a05f7cdb0784edfb31b28440078adaef7f3b721ccb82d5f7e1944
+  metadata.gz: eb614bb45b425c7d5cbdbeb9cbaa8b8acb34ff4492af861c277cdfb60c116ec5560504dd10402dbb492dfa7f5adbc441588f40e0bd3fd59fef29e7535c47d858
+  data.tar.gz: 9bc150a2c0da4b77af03cca23f2f7c8148d7196689e714c4e8544e6fb38d506c2257dc5f5b25fca74b620e20893c4192eadbc8d2430f1f40ab0f2f8ecccbf5bd

data/CHANGES.md

@@ -1,5 +1,14 @@
 # CHANGES
 
+## dm-is-reflective 1.3.0, 2013-05-20
+
+* Warn instead of raising a TypeError if a datatype cannot be found.
+  We fallback to use String.
+* Now it works for multiple composite keys.
+* If there's no key defined, it would pick the first unique index as the key.
+* If a field name is conflicted, it would try to resolve it by appending a
+  underscore to the field name.
+
 ## dm-is-reflective 1.2.0, 2013-05-14
 
 * We got a bunch of internal renaming.

data/dm-is-reflective.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = "dm-is-reflective"
-  s.version = "1.2.0"
+  s.version = "1.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2013-05-14"
+  s.date = "2013-05-20"
   s.description = "DataMapper plugin that helps you manipulate an existing database.\nIt creates mappings between existing columns and model's properties."
   s.email = ["godfat (XD) godfat.org"]
   s.executables = ["dm-is-reflective"]

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

@@ -114,12 +114,12 @@ module DmIsReflective::DataObjectsAdapter
     model.storage_names[:default] = storage
     scope.const_set(Inflector.classify(storage), model)
     model.__send__(:reflect, /.*/)
-    model.finalize if model.respond_to?(:finalize)
     model
   end
 
   def reflective_lookup_primitive primitive
-    raise TypeError.new("#{primitive} not found for #{self.class}")
+    warn "#{primitive} not found for #{self.class}: #{caller.inspect}"
+    String # falling back to the universal interface
   end
 
   def reflective_auto_load_adapter_extension

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

@@ -9,18 +9,50 @@ module DmIsReflective::MysqlAdapter
   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_indices = <<-SQL
+      SELECT column_name, index_name, non_unique
+      FROM   `information_schema`.`statistics`
+      WHERE  table_schema = ? AND table_name = ?
+    SQL
+
+    sql_columns = <<-SQL
+      SELECT column_name, column_key, column_default, is_nullable,
+             data_type, character_maximum_length, extra, table_name
+      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']
+    path = (options[:path]     || options['path'] ||
+            options[:database] || options['database']).sub('/', '')
+
+    indices =
+    select(Ext::String.compress_lines(sql_indices), path, storage).
+      group_by(&:column_name)
 
-    select(Ext::String.compress_lines(sql), path.sub('/', ''), storage)
+    select(Ext::String.compress_lines(sql_columns), path, storage).
+    map do |column|
+      if idx = indices[column.column_name]
+        idx_uni, idx_com = idx.partition{ |i| i.non_unique == 0 }.map{ |i|
+          if i.empty?
+            nil
+          elsif i.size == 1
+            i.first.index_name.to_sym
+          else
+            i.map{ |ii| ii.index_name.to_sym }
+          end
+        }
+      else
+        idx_uni, idx_com = nil
+      end
+
+      column.instance_eval <<-RUBY
+        def unique_index; #{idx_uni.inspect}; end
+        def index       ; #{idx_com.inspect}; end
+      RUBY
+
+      column
+    end
   end
 
   def reflective_field_name field
@@ -32,17 +64,24 @@ module DmIsReflective::MysqlAdapter
   end
 
   def reflective_attributes field, attrs = {}
-      attrs[:serial] = true if field.extra      == 'auto_increment'
-      attrs[:key]    = true if field.column_key == 'PRI'
+    attrs[:serial] = true if field.extra == 'auto_increment'
+
+    if field.column_key == 'PRI'
+      attrs[:key] = true
+      attrs[:unique_index] = :"#{field.table_name}_pkey"
+    else
+      attrs[:unique_index] = field.unique_index if field.unique_index
+      attrs[       :index] = field.       index if field.       index
+    end
 
-      attrs[:allow_nil] = field.is_nullable == 'YES'
-      attrs[:default]  = field.column_default           if
-        field.column_default
+    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[:length]    = field.character_maximum_length if
+      field.character_maximum_length
 
-      attrs
+    attrs
   end
 
   def reflective_lookup_primitive primitive

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

@@ -13,28 +13,53 @@ module DmIsReflective::PostgresAdapter
 
   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_indices = <<-SQL
+      SELECT a.attname, i.relname, ix.indisprimary, ix.indisunique
+      FROM   pg_class t, pg_class i, pg_index ix, pg_attribute a
+      WHERE  t.oid      = ix.indrelid
+        AND  i.oid      = ix.indexrelid
+        AND  a.attrelid = t.oid
+        AND  a.attnum   = ANY(ix.indkey)
+        AND  t.relkind  = 'r'
+        AND  t.relname  = ?
     SQL
 
-    keys = select(Ext::String.compress_lines(sql), storage).to_set
-
-    sql = <<-SQL
+    sql_columns = <<-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 = ?
+      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
+    indices =
+    select(Ext::String.compress_lines(sql_indices), storage).
+      group_by(&:attname)
+
+    select(Ext::String.compress_lines(sql_columns), storage).map do |column|
+      if idx = indices[column.column_name]
+        is_key = !!idx.find{ |i| i.indisprimary }
+        idx_uni, idx_com = idx.partition{ |i| i.indisunique }.map{ |i|
+          if i.empty?
+            nil
+          elsif i.size == 1
+            i.first.relname.to_sym
+          else
+            i.map{ |ii| ii.relname.to_sym }
+          end
+        }
+      else
+        is_key = false
+        idx_uni, idx_com = nil
+      end
+
+      column.instance_eval <<-RUBY
+        def key?        ; #{is_key}         ; end
+        def unique_index; #{idx_uni.inspect}; end
+        def index       ; #{idx_com.inspect}; end
       RUBY
-      struct
-    }
+
+      column
+    end
   end
 
   def reflective_field_name field
@@ -47,11 +72,16 @@ module DmIsReflective::PostgresAdapter
 
   def reflective_attributes field, attrs = {}
     # strip data type
-    field.column_default.gsub!(/(.*?)::[\w\s]*/, '\1') if
-      field.column_default
+    if field.column_default
+      field.column_default.gsub!(/(.*?)::[\w\s]*/, '\1')
+    end
 
     attrs[:serial] = true if field.column_default =~ /nextval\('\w+'\)/
-    attrs[:key] = true if field.key?
+    attrs[:key]    = true if field.key?
+
+    attrs[:unique_index] = field.unique_index if field.unique_index
+    attrs[       :index] = field.       index if field.       index
+
     attrs[:allow_nil] = field.is_nullable == 'YES'
     # strip string quotation
     attrs[:default] = field.column_default.gsub(/^'(.*?)'$/, '\1') if

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

@@ -4,8 +4,7 @@ module DmIsReflective::SqliteAdapter
 
   def storages
     sql = <<-SQL
-      SELECT name
-      FROM sqlite_master
+      SELECT name FROM sqlite_master
       WHERE type = 'table' AND NOT name = 'sqlite_sequence'
     SQL
 
@@ -14,7 +13,48 @@ module DmIsReflective::SqliteAdapter
 
   private
   def reflective_query_storage storage
-    select('PRAGMA table_info(?)', storage)
+    sql_indices = <<-SQL
+      SELECT name, sql FROM sqlite_master
+      WHERE type = 'index' AND tbl_name = ?
+    SQL
+
+    indices = select(sql_indices, storage).inject({}){ |r, field|
+      columns    =   field.sql[/\(.+\)/].scan(/\w+/)
+      uniqueness = !!field.sql[/CREATE UNIQUE INDEX/]
+
+      columns.each{ |c|
+        type = if uniqueness then :unique_index else :index end
+        r[c] ||= {:unique_index => [], :index => []}
+        r[c][type] << field.name
+      }
+
+      r
+    }
+
+    select('PRAGMA table_info(?)', storage).map{ |field|
+      if idx = indices[field.name]
+        idx_uni, idx_com = [:unique_index, :index].map{ |type|
+          i = idx[type]
+          if i.empty?
+            nil
+          elsif i.size == 1
+            i.first.to_sym
+          else
+            i.map(&:to_sym)
+          end
+        }
+      else
+        idx_uni, idx_com = nil
+      end
+
+      field.instance_eval <<-RUBY
+        def table_name  ; '#{storage}'      ; end
+        def index       ; #{idx_com.inspect}; end
+        def unique_index; #{idx_uni.inspect}; end
+      RUBY
+
+      field
+    }
   end
 
   def reflective_field_name field
@@ -27,9 +67,14 @@ module DmIsReflective::SqliteAdapter
 
   def reflective_attributes field, attrs = {}
     if field.pk != 0
-      attrs[:key] = true
-      attrs[:serial] = true
+      attrs[:key]          = true
+      attrs[:serial]       = true
+      attrs[:unique_index] = :"#{field.table_name}_pkey"
     end
+
+    attrs[:unique_index]   = field.unique_index if field.unique_index
+    attrs[       :index]   = field.       index if field.       index
+
     attrs[:allow_nil] = field.notnull == 0
     attrs[:default] = field.dflt_value[1..-2] if field.dflt_value
 

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

@@ -55,27 +55,41 @@ module DmIsReflective
 
         reflected = targets.each{ |target|
           case target
-            when Regexp;
-              break name if name.to_s =~ target
+          when Regexp;
+            break name if name.to_s =~ target
 
-            when Symbol, String;
-              break name if name == target.to_sym
+          when Symbol, String;
+            break name if name == target.to_sym
 
-            when Class;
-              break name if type == target
+          when Class;
+            break name if type == target
 
-            else
-              raise ArgumentError.new("invalid argument: #{target.inspect}")
+          else
+            raise ArgumentError.new("invalid argument: #{target.inspect}")
           end
         }
 
-        property(reflected, type, attrs) if reflected.kind_of?(Symbol)
+        reflect_property(reflected, type, attrs) if
+          reflected.kind_of?(Symbol)
       }.compact
 
+      if key.empty? && k = properties.find{ |p| p.unique_index }
+        property k.name, k.primitive, :key => true
+      end
+
       finalize if respond_to?(:finalize)
       result
     end
 
+    def reflect_property reflected, type, attrs
+      property reflected, type, attrs
+    rescue ArgumentError => e
+      if e.message =~ /cannot be used as a property name/
+        reflect_property "#{reflected}_", type,
+          {:field => reflected.to_s}.merge(attrs)
+      end
+    end
+
     def to_source scope=nil
 <<-RUBY
 class #{scope}::#{name} < #{superclass}

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

@@ -7,6 +7,32 @@ require 'dm-migrations'
 require 'dm-is-reflective'
 
 module Abstract
+  class Cat
+    include DataMapper::Resource
+    property :id, Serial
+
+    belongs_to :user
+    belongs_to :super_user
+
+    property :user_id      , Integer,
+      :unique_index => [:usu, :u]
+    property :super_user_id, Integer,
+      :unique_index => [:usu],
+             :index => [:su]
+  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
+
   class User
     include DataMapper::Resource
     has n, :comments
@@ -27,19 +53,8 @@ module Abstract
     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']
+  Tables = %w[abstract_cats        abstract_comments
+              abstract_super_users abstract_users]
 
   AttrCommon   = {:allow_nil => true}
   AttrCommonPK = {:serial => true, :key => true, :allow_nil => false}
@@ -54,40 +69,58 @@ end
 include Abstract
 
 shared :reflective do
+  def cat_fields
+    @cat_fields ||=
+    [[:id,         DataMapper::Property::Serial,
+        {:unique_index => :abstract_cats_pkey}.merge(AttrCommonPK)],
+     [:super_user_id, Integer,
+        {:unique_index =>  :unique_abstract_cats_usu,
+                :index =>  :index_abstract_cats_su }.merge(AttrCommon)],
+     [:user_id      , Integer,
+        {:unique_index => [:unique_abstract_cats_usu,
+                           :unique_abstract_cats_u]}.merge(AttrCommon)]]
+  end
+
+  def comment_fields
+    @comment_fields ||= begin
+      [[:body   , DataMapper::Property::Text  , AttrText],
+       [:id     , DataMapper::Property::Serial,
+          {:unique_index => :abstract_comments_pkey}.merge(AttrCommonPK)],
+
+       [:title  , String                      ,
+          {:length => 50, :default => 'default title', :allow_nil => false}],
+
+       [:user_id, Integer                     ,
+          {:index => :index_abstract_comments_user}.merge(AttrCommon)]]
+    end
+  end
+
   def user_fields
+    @user_fields ||=
     [[:created_at, DateTime, AttrCommon],
-     [:id,         DataMapper::Property::Serial,  AttrCommonPK],
+     [:id,         DataMapper::Property::Serial,
+        {:unique_index => :abstract_users_pkey}.merge(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]]
+    @super_user_fields ||= begin
+      type = case DataMapper.repository.adapter.class.name
+             when 'DataMapper::Adapters::MysqlAdapter'
+               Integer
+             else
+               DataMapper::Property::Boolean
+             end
+      [[:bool, type, AttrCommon],
+       [:id  , DataMapper::Property::Serial,
+        {:unique_index => :abstract_super_users_pkey}.merge(AttrCommonPK)]]
     end
   end
 
   before do
     @dm = setup_data_mapper
-    [User, Comment, SuperUser].each(&:auto_migrate!)
+    [Cat, Comment, User, SuperUser].each(&:auto_migrate!)
   end
 
   def sort_fields fields
@@ -167,8 +200,9 @@ shared :reflective do
       key, value = i
       r[key] = value.sort_by{ |v| v.first.to_s }
       r
-    }.should.eq('abstract_users'       => user_fields      ,
-                'abstract_comments'    => comment_fields   ,
+    }.should.eq('abstract_cats'        =>        cat_fields,
+                'abstract_comments'    =>    comment_fields,
+                'abstract_users'       =>       user_fields,
                 'abstract_super_users' => super_user_fields)
   end
 
@@ -215,7 +249,8 @@ shared :reflective do
   should 'auto_genclasses' do
     scope = new_scope
     @dm.auto_genclass!(:scope => scope).map(&:to_s).sort.should.eq \
-      ["#{scope}::AbstractComment",
+      ["#{scope}::AbstractCat"      ,
+       "#{scope}::AbstractComment"  ,
        "#{scope}::AbstractSuperUser",
        "#{scope}::AbstractUser"]
 

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

@@ -1,4 +1,4 @@
 
 module DmIsReflective
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

data/test/test_mysql.rb

@@ -19,5 +19,6 @@ describe 'mysql' do
                                  :database => 'dm_is_reflective')
     end
   end
+
   behaves_like :reflective
 end if defined?(DataMapper::Adapters::MysqlAdapter)

data/test/test_postgres.rb

@@ -19,5 +19,6 @@ describe 'postgres' do
                                  :database => 'dm_is_reflective')
     end
   end
+
   behaves_like :reflective
 end if defined?(DataMapper::Adapters::PostgresAdapter)

data/test/test_sqlite.rb

@@ -6,5 +6,6 @@ describe 'sqlite' do
   def setup_data_mapper
     DataMapper.setup(:default, :adapter => 'sqlite', :database => ':memory:')
   end
+
   behaves_like :reflective
 end if defined?(DataMapper::Adapters::SqliteAdapter)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dm-is-reflective
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-14 00:00:00.000000000 Z
+date: 2013-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dm-core