dm-reflection 0.0.5

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+
+## Yard
+.yardoc
+measurements/report.txt

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2009 Martin Gamsjaeger (snusnu)
+Copyright (c) 2010 Montana State University
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,77 @@
+= dm-reflection
+
+For now, this gem only allows you to print the ruby source for any DataMapper::Model, taking all property and relationship definitions into account. However, the plan is to be able to reflect on an existing relational database schema and export the corresponding datamapper model definitions to ruby source files. Think of it as active_record and annotate_models combined to do something useful with legacy databases.
+
+  require 'rubygems'
+  require 'dm-core'
+  require 'dm-reflection'
+
+  class Project
+
+    include DataMapper::Resource
+
+    property :id, Serial
+
+    property :name, String, :required => true, :length => 200
+    property :created_at, DateTime
+    property :updated_at, DateTime
+
+    has 0..n, :project_tasks
+    has 0..n, :tasks, :through => :project_tasks
+    has 0..n, :people, :through => Resource
+
+  end
+
+  Project.to_ruby # produces this nicely formatted ruby code
+
+  <<-RUBY
+  class Project
+
+    include DataMapper::Resource
+
+    property :id, Serial
+
+    property :name, String, :required => true, :length => 200
+    property :created_at, DateTime
+    property :updated_at, DateTime
+
+    has 0..n, :project_tasks
+    has 0..n, :tasks, :through => :project_tasks
+    has 0..n, :people, :through => Resource
+
+  end
+  RUBY
+
+Also, you can create models from a repository by doing the following:
+
+  require 'dm-reflection'
+  models = DataMapper::Reflection.reflect(:default)
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Future Work
+
+* Support Associations/Relationships
+* Support Single Table Inheritance
+* Ensure Round tripping is functional
+  ** Create model M in DataMapper
+  ** Migrate M to a repository
+  ** Reflect M' from the repository
+  ** M should == M'
+
+* Having round tripping provably working is the first goal
+* Legacy reflection is something to make work after round tripping (because the assumptions DM makes won't always hold.)
+
+== Copyright
+
+See LICENSE for details.
+Copyright (c) 2009 Martin Gamsjaeger (snusnu).
+Copyright (c) 2010 Montana State University, Bozeman (The Yogo Data Management Team).

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rake'
+
+begin
+
+  gem 'jeweler', '>= 1.4'
+  require 'jeweler'
+
+  require File.expand_path('../lib/dm-reflection/version', __FILE__)
+
+  Jeweler::Tasks.new do |gem|
+
+    gem.version     = DataMapper::Reflection::VERSION
+
+    gem.name        = "dm-reflection"
+    gem.summary     = %Q{Generates datamapper models from existing database schemas}
+    gem.description = %Q{Generates datamapper models from existing database schemas and export them to files}
+    gem.email       = "irjudson@gmail.com"
+    gem.homepage    = "http://github.com/irjudson/dm-reflection"
+    gem.authors     = ["Martin Gamsjaeger (snusnu), Yogo Team"]
+
+    gem.add_dependency 'dm-core', '~> 0.10.2'
+
+    gem.add_development_dependency 'rspec', '~> 1.3'
+    gem.add_development_dependency 'yard',  '~> 0.5'
+
+  end
+
+  Jeweler::GemcutterTasks.new
+
+  FileList['tasks/**/*.rake'].each { |task| import task }
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+task :spec => :check_dependencies
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/dm-reflection.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dm-reflection}
+  s.version = "0.0.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Martin Gamsjaeger (snusnu), Yogo Team"]
+  s.date = %q{2010-05-03}
+  s.description = %q{Generates datamapper models from existing database schemas and export them to files}
+  s.email = %q{irjudson@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "dm-reflection.gemspec",
+     "lib/dm-reflection.rb",
+     "lib/dm-reflection/adapters/mysql.rb",
+     "lib/dm-reflection/adapters/persevere.rb",
+     "lib/dm-reflection/adapters/postgres.rb",
+     "lib/dm-reflection/adapters/sqlite3.rb",
+     "lib/dm-reflection/builders/source_builder.rb",
+     "lib/dm-reflection/reflection.rb",
+     "lib/dm-reflection/version.rb",
+     "spec/persevere_reflection_spec.rb",
+     "spec/rcov.opts",
+     "spec/reflection_spec.rb",
+     "spec/source_builder_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "tasks/changelog.rake",
+     "tasks/ci.rake",
+     "tasks/metrics.rake",
+     "tasks/spec.rake",
+     "tasks/yard.rake",
+     "tasks/yardstick.rake"
+  ]
+  s.homepage = %q{http://github.com/irjudson/dm-reflection}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Generates datamapper models from existing database schemas}
+  s.test_files = [
+    "spec/persevere_reflection_spec.rb",
+     "spec/reflection_spec.rb",
+     "spec/source_builder_spec.rb",
+     "spec/spec_helper.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.2"])
+      s.add_development_dependency(%q<rspec>, ["~> 1.3"])
+      s.add_development_dependency(%q<yard>, ["~> 0.5"])
+    else
+      s.add_dependency(%q<dm-core>, ["~> 0.10.2"])
+      s.add_dependency(%q<rspec>, ["~> 1.3"])
+      s.add_dependency(%q<yard>, ["~> 0.5"])
+    end
+  else
+    s.add_dependency(%q<dm-core>, ["~> 0.10.2"])
+    s.add_dependency(%q<rspec>, ["~> 1.3"])
+    s.add_dependency(%q<yard>, ["~> 0.5"])
+  end
+end
+

data/lib/dm-reflection/adapters/mysql.rb

@@ -0,0 +1,95 @@
+module DataMapper
+  module Reflection
+    module MysqlAdapter
+
+      ##
+      # Convert the database type into a DataMapper type
+      #
+      # @todo This should be verified to identify all mysql primitive types
+      #       and that they map to the correct DataMapper/Ruby types.
+      #
+      # @param [String] db_type type specified by the database
+      # @return [Type] a DataMapper or Ruby type object.
+      #
+      def get_type(db_type)
+        # TODO: return a Hash with the :type, :min, :max and other
+        # options rather than just the type
+
+        db_type.match(/\A(\w+)/)
+        {
+          'tinyint'     =>  Integer    ,
+          'smallint'    =>  Integer    ,
+          'mediumint'   =>  Integer    ,
+          'int'         =>  Integer    ,
+          'bigint'      =>  Integer    ,
+          'integer'     =>  Integer    ,
+          'varchar'     =>  String     ,
+          'char'        =>  String     ,
+          'enum'        =>  String     ,
+          'decimal'     =>  BigDecimal ,
+          'double'      =>  Float      ,
+          'float'       =>  Float      ,
+          'datetime'    =>  DateTime   ,
+          'timestamp'   =>  DateTime   ,
+          'date'        =>  Date       ,
+          'boolean'     =>  Types::Boolean,
+          'tinyblob'    =>  Types::Text,
+          'blob'        =>  Types::Text,
+          'mediumblob'  =>  Types::Text,
+          'longblob'    =>  Types::Text,
+          'tinytext'    =>  Types::Text,
+          'text'        =>  Types::Text,
+          'mediumtext'  =>  Types::Text,
+          'longtext'    =>  Types::Text,
+        }[$1] || raise("unknown type: #{db_type}")
+      end
+
+      ##
+      # Get the list of table names
+      #
+      # @return [String Array] the names of the tables in the database.
+      #
+      def get_storage_names
+        # This gets all the non view tables, but has to strip column 0 out of the two column response.
+        select("SHOW FULL TABLES FROM #{options[:path][1..-1]} WHERE Table_type = 'BASE TABLE'").map { |item| item.first }
+      end
+
+      ##
+      # Get the column specifications for a specific table
+      #
+      # @todo Consider returning actual DataMapper::Properties from this.
+      #       It would probably require passing in a Model Object.
+      #
+      # @param [String] table the name of the table to get column specifications for
+      # @return [Hash] the column specs are returned in a hash keyed by `:name`, `:field`, `:type`, `:required`, `:default`, `:key`
+      #
+      def get_properties(table)
+        # TODO: use SHOW INDEXES to find out unique and non-unique indexes
+
+        select("SHOW COLUMNS FROM #{table} IN #{options[:path][1..-1]};").map do |column|
+          type           = get_type(column.type)
+          auto_increment = column.extra == 'auto_increment'
+
+          if type == Integer && auto_increment
+            type = DataMapper::Types::Serial
+          end
+
+          attribute = {
+            :name     => column.field.downcase,
+            :type     => type,
+            :required => column.null == 'NO',
+            :default  => column.default,
+            :key      => column.key == 'PRI',
+          }
+
+          # TODO: use the naming convention to compare the name vs the column name
+          unless attribute[:name] == column.field
+            attribute[:field] = column.field
+          end
+
+          attribute
+        end
+      end
+    end # module MysqlAdapter
+  end # module Reflection
+end # module DataMapper

data/lib/dm-reflection/adapters/persevere.rb

@@ -0,0 +1,98 @@
+module DataMapper
+  module Reflection
+    module PersevereAdapter
+      extend Chainable
+
+      ##
+      # Convert the JSON Schema type into a DataMapper type
+      #
+      # @todo This should be verified to identify all mysql primitive types
+      #       and that they map to the correct DataMapper/Ruby types.
+      #
+      # @param [String] db_type type specified by the database
+      # @param [String] optional format format specification for string attributes
+      # @return [Type] a DataMapper or Ruby type object.
+      #
+      chainable do
+        def get_type(db_type)
+          type = db_type['type']
+          format = db_type['format']
+
+          case type
+          when Hash        then DataMapper::Types::JsonReference
+          when 'array'     then DataMapper::Types::JsonReferenceCollection
+          when 'serial'    then DataMapper::Types::Serial
+          when 'integer'   then Integer
+          # when 'number'    then BigDecimal
+          when 'number'    then Float
+          when 'boolean'   then DataMapper::Types::Boolean
+          when 'string'    then
+            case format
+              when nil         then DataMapper::Types::Text
+              when 'date-time' then DateTime
+              when 'date'      then Date
+              when 'time'      then Time
+            end
+          end
+        end
+      end
+      ##
+      # Get the list of schema names
+      #
+      # @return [String Array] the names of the schemas in the server.
+      #
+      def get_storage_names
+        @schemas = self.get_schema
+        @schemas.map { |schema| schema['id'].gsub('/', '__') }
+      end
+
+      ##
+      # Get the attribute specifications for a specific schema
+      #
+      # @todo Consider returning actual DataMapper::Properties from this.
+      #       It would probably require passing in a Model Object.
+      #
+      # @param [String] table the name of the schema to get attribute specifications for
+      # @return [Array] of hashes the column specs are returned in a hash keyed by `:name`, `:field`, `:type`, `:required`, `:default`, `:key`
+      #
+      chainable do
+        def get_properties(table)
+          results = Array.new
+          schema = self.get_schema(table.gsub('__', '/'))[0]
+          schema['properties'].each_pair do |key, value|
+            type = get_type(value)
+            property = {:name => key, :type => type }
+            property.merge!({ :required => !value.delete('optional'),
+                              :key => value.has_key?('index') && value.delete('index') }) unless property[:type] == DataMapper::Types::Serial
+                              
+            if type.kind_of?(DataMapper::Types::JsonReference)
+              property.merge!( {:reference => derive_relationship_model(value[:type]["$ref"])} )
+            end
+            
+            if type.kind_of?(DataMapper::Types::JsonReferenceCollection)
+              property.merge!( {:reference => derive_relationship_model(value[:items]["$ref"])} )
+            end
+            
+            value.delete('type')
+            value.delete('format')
+            value.delete('unique')
+            value.delete('index')
+            value.delete('items')
+            value.keys.each { |key| value[key.to_sym] = value[key]; value.delete(key) }
+            property.merge!(value)
+            results << property
+          end
+          return results
+        end
+      end
+
+      private
+      
+      # Turns 'class_path/class' into 'ClassPath::Class
+      def derive_relationship_model(input)
+        input.match(/(Class)?\/([a-z\-\/\_]+)$/)[-1].split('/').map{|i| ExtLib::Inflection.classify(i) }.join("::")
+      end
+      
+    end # module PersevereAdapter
+  end # module Reflection
+end # module DataMapper

data/lib/dm-reflection/adapters/postgres.rb

@@ -0,0 +1,126 @@
+module DataMapper
+  module Reflection
+    ##
+    # @todo The postgres adapter extensions have not been tested yet.
+    #
+    module PostgresAdapter
+
+      ##
+      # Convert the database type into a DataMapper type
+      #
+      # @todo This should be verified to identify all mysql primitive types
+      #       and that they map to the correct DataMapper/Ruby types.
+      #
+      # @param [String] db_type type specified by the database
+      # @return [Type] a DataMapper or Ruby type object.
+      #
+      def get_type(db_type)
+        {
+          'integer'                     =>  Integer        ,
+          'varchar'                     =>  String         ,
+          'character varying'           =>  String         ,
+          'numeric'                     =>  BigDecimal     ,
+          'double precision'            =>  Float          ,
+          'datetime'                    =>  DateTime       ,
+          'date'                        =>  Date           ,
+          'boolean'                     =>  Types::Boolean ,
+          'text'                        =>  Types::Text    ,
+          'timestamp without time zone' =>  DateTime       ,
+        }[db_type] || raise("unknown db type: #{db_type}")
+      end
+
+      ##
+      # Get the list of table names
+      #
+      # @return [String Array] the names of the tables in the database.
+      #
+      def get_storage_names
+        select(<<-SQL.compress_lines)
+          SELECT "relname"
+            FROM "pg_stat_user_tables"
+           WHERE "schemaname" = 'public'
+        SQL
+      end
+
+      # Returna list of columns in the primary key
+      #
+      # @param [String] the table name
+      #
+      # @return [Array<String>] the names of the columns in the primary key
+      #
+      def get_primary_keys(table)
+        select(<<-SQL.compress_lines, table).to_set
+              SELECT "key_column_usage"."column_name"
+                FROM "information_schema"."table_constraints"
+          INNER JOIN "information_schema"."key_column_usage" USING("constraint_schema", "constraint_name")
+               WHERE "table_constraints"."constraint_type" = 'PRIMARY KEY'
+                 AND "table_constraints"."table_name" = ?
+        SQL
+      end
+
+      ##
+      # Get the column specifications for a specific table
+      #
+      # @todo Consider returning actual DataMapper::Properties from this.
+      #       It would probably require passing in a Model Object.
+      #
+      # @param [String] table the name of the table to get column specifications for
+      # @return [Hash] the column specs are returned in a hash keyed by `:name`, `:field`, `:type`, `:required`, `:default`, `:key`
+      #
+      def get_properties(table)
+        columns = select(<<-SQL.compress_lines, schema_name, table)
+            SELECT "column_name"
+                 , "data_type"
+                 , "column_default"
+                 , "is_nullable"
+                 , "character_maximum_length"
+                 , "numeric_precision"
+              FROM "information_schema"."columns"
+             WHERE "table_schema" = ?
+               AND "table_name" = ?
+          ORDER BY "ordinal_position"
+        SQL
+
+        primary_keys = get_primary_keys(table)
+
+        columns.map do |column|
+          type     = get_type(column.data_type)
+          default  = column.column_default
+          required = column.is_nullable == 'NO'
+          key      = primary_keys.include?(column.column_name)
+          length   = column.character_maximum_length
+
+          if type == Integer && default
+            if key
+              type    = DataMapper::Types::Serial if default[/\Anextval/]
+              default = nil
+            else
+              default = default.to_i
+            end
+          end
+
+          if length
+            length = (required ? 1 : 0)..length
+          end
+
+          attribute = {
+            :name     => column.column_name.downcase,
+            :type     => type,
+            :required => required,
+            :default  => default,
+            :key      => key,
+            :length   => length,
+          }
+
+          # TODO: use the naming convention to compare the name vs the column name
+          unless attribute[:name] == column.column_name
+            attribute[:field] = column.column_name
+          end
+
+          attribute
+        end
+      end
+
+    end # module PostgresAdapter
+  end # module Reflection
+end # module DataMapper

data/lib/dm-reflection/adapters/sqlite3.rb

@@ -0,0 +1,85 @@
+module DataMapper
+  module Reflection
+    module Sqlite3Adapter
+
+      ##
+      # Convert the database type into a DataMapper type
+      #
+      # @todo This should be verified to identify all sqlite3 primitive types
+      #       and that they map to the correct DataMapper/Ruby types.
+      #
+      # @param [String] db_type type specified by the database
+      # @return [Type] a DataMapper or Ruby type object.
+      #
+      def get_type(db_type)
+        db_type.match(/\A(\w+)/)
+        {
+           'INTEGER'     =>  Integer      ,
+           'VARCHAR'     =>  String       ,
+           'DECIMAL'     =>  BigDecimal   ,
+           'FLOAT'       =>  Float        ,
+           'TIMESTAMP'   =>  DateTime     ,
+           'DATE'        =>  Date         ,
+           'BOOLEAN'     =>  Types::Boolean,
+           'TEXT'        =>  Types::Text
+          }[$1] || raise("unknown db type: #{db_type}")
+      end
+
+      ##
+      # Get the list of table names
+      #
+      # @return [String Array] the names of the tables in the database.
+      #
+      def get_storage_names
+        select(<<-SQL.compress_lines)
+            SELECT name
+              FROM (SELECT * FROM sqlite_master UNION SELECT * FROM sqlite_temp_master)
+             WHERE type IN('table', 'view')
+               AND name NOT LIKE 'sqlite_%'
+          ORDER BY name
+        SQL
+      end
+
+      ##
+      # Get the column specifications for a specific table
+      #
+      # @todo Consider returning actual DataMapper::Properties from this.
+      #       It would probably require passing in a Model Object.
+      #
+      # @param [String] table the name of the table to get column specifications for
+      # @return [Hash] the column specs are returned in a hash keyed by `:name`, `:field`, `:type`, `:required`, `:default`, `:key`
+      #
+      def get_properties(table)
+        # TODO: consider using "SELECT sql FROM sqlite_master WHERE tbl_name = ?"
+        # and parsing the create table statement since it will provide
+        # more information like if a column is auto-incrementing, and what
+        # indexes are used.
+
+        select('PRAGMA table_info(%s)' % table).map do |column|
+          type    = get_type(column.type)
+          default = column.dflt_value
+
+          if type == Integer && default
+            default = default.to_i
+          end
+
+          attribute = {
+            :name     => column.name.downcase,
+            :type     => type,
+            :required => column.notnull == 1,
+            :default  => default,
+            :key      => column.pk == 1,
+          }
+
+          # TODO: use the naming convention to compare the name vs the column name
+          unless attribute[:name] == column.name
+            attribute[:field] = column.name
+          end
+
+          attribute
+        end
+      end
+
+    end # module Sqlite3Adapter
+  end # module Reflection
+end # module DataMapper