migration_comments 0.1.1 → 0.1.2

data/.gitignore

@@ -1,5 +1,6 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
-.idea/*
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea/*
+test/db/migration_comments_test

data/README.rdoc

@@ -4,7 +4,7 @@ Comments for your migrations
 
 Tested on:
 
-Ruby 1.8.7 using Rails 3.x
+Ruby 1.8.7 using Rails 3.x.
 Ruby 1.8.6 using Rails 2.3.x.
 
 == Why?
@@ -78,7 +78,7 @@ Or you can combine these commands while modifying a table...
 
 == Requirements
 
-You must be using a DBMS that supports COMMENTing (currently only PostgreSQL and MySQL).
+You must be using a supported DBMS (currently PostgreSQL, MySQL, and SQLite).
 
 If this isn't an option for you, check out the 'schema_comments' gem:
   https://github.com/akm/schema_comments

data/lib/migration_comments/active_record/connection_adapters/column.rb

@@ -0,0 +1,9 @@
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module Column
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :comment
+      end
+    end
+  end
+end

data/lib/migration_comments/active_record/connection_adapters/mysql_adapter.rb

@@ -8,13 +8,13 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
       end
     end
 
-    def add_table_comment(table_name, comment)
-      execute "ALTER TABLE #{table_name} COMMENT #{escaped_comment(comment)}"
+    def add_table_comment(table_name, comment_text)
+      execute "ALTER TABLE #{table_name} COMMENT #{escaped_comment(comment_text)}"
     end
 
-    def add_column_comment(table_name, column_name, comment)
+    def add_column_comment(table_name, column_name, comment_text)
       column = column_for(table_name, column_name)
-      change_column table_name, column_name, column.sql_type, :comment => comment
+      change_column table_name, column_name, column.sql_type, :comment => comment_text
     end
 
     def retrieve_table_comment(table_name)
@@ -25,7 +25,8 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
     def retrieve_column_comments(table_name, *column_names)
       result = select_rows(column_comment_sql(table_name, *column_names))
       return {} if result.nil?
-      return result.inject({}){|m, row| m[row[0].to_sym] = (row[1].blank? ? nil : row[1]); m}
+      found = result.inject({}){|m, row| m[row[0].to_sym] = (row[1].blank? ? nil : row[1]); m}
+
     end
 
     def create_table_with_migration_comments(table_name, options={}, &block)

data/lib/migration_comments/active_record/connection_adapters/sqlite_adapter.rb

@@ -0,0 +1,140 @@
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module SQLiteAdapter
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :columns, :migration_comments
+        alias_method_chain :copy_table, :migration_comments
+        alias_method_chain :change_column, :migration_comments
+      end
+    end
+
+    def add_table_comment(table_name, comment_text)
+      alter_table(table_name, :comment => comment_text)
+    end
+
+    def add_column_comment(table_name, column_name, comment_text)
+      column = column_for(table_name, column_name)
+      change_column table_name, column_name, column.sql_type, :comment => comment_text
+    end
+
+    def retrieve_table_comment(table_name)
+      result = select_rows(lookup_comment_sql(table_name))
+      if result[0][0] =~ /CREATE (?:TEMPORARY )?TABLE #{quote_table_name table_name} [^\(]*\/\*(.*)\*\/ \(/
+        $1
+      end
+    end
+
+    def retrieve_column_comments(table_name, *column_names)
+      if column_names.empty?
+        return columns(table_name).inject({}) { |m, v| m[v.name.to_sym] = v.comment if v.comment.present?; m }
+      end
+      result = select_rows(lookup_comment_sql(table_name))
+      result[0][0] =~ /^CREATE (?:TEMPORARY )?TABLE "\w*" [^\(]*(?:\/\*.*\*\/ )?\((.*)\)[^\)]*$/
+      col_defs = $1
+      comment_matches = col_defs.scan(/"([^",]+)"[^,]*\/\*(.+?)\*\//)
+      comment_matches.inject({}){|m, row| m[row.first.to_sym] = row.last; m}
+    end
+
+    def create_table(table_name, options = {})
+      td = table_definition
+      td.primary_key(options[:primary_key] || ActiveRecord::Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
+      td.comment options[:comment] if options.has_key?(:comment)
+
+      yield td if block_given?
+
+      if options[:force] && table_exists?(table_name)
+        drop_table(table_name)
+      end
+
+      create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+      create_sql << "#{quote_table_name(table_name)}#{td.table_comment} ("
+      create_sql << td.columns.map do |column|
+        column.to_sql + column.comment.to_sql
+      end * ", "
+      create_sql << ") #{options[:options]}"
+      execute create_sql
+    end
+
+    def change_column_with_migration_comments(table_name, column_name, type, options = {}) #:nodoc:
+      adapter = self
+      alter_table(table_name) do |definition|
+        include_default = options_include_default?(options)
+        definition[column_name].instance_eval do
+          self.type    = type
+          self.limit   = options[:limit] if options.include?(:limit)
+          self.default = options[:default] if include_default
+          self.null    = options[:null] if options.include?(:null)
+          self.precision = options[:precision] if options.include?(:precision)
+          self.scale   = options[:scale] if options.include?(:scale)
+          self.comment = CommentDefinition.new(adapter, table_name, column_name, options[:comment]) if options.include?(:comment)
+        end
+      end
+    end
+
+    def columns_with_migration_comments(table_name, name = nil)
+      cols = columns_without_migration_comments(table_name, name)
+      comments = retrieve_column_comments(table_name, *(cols.map(&:name)))
+      cols.each do |col|
+        col.comment = comments[col.name.to_sym] if comments.has_key?(col.name.to_sym)
+      end
+      cols
+    end
+
+    def column_for(table_name, column_name)
+      columns(table_name).detect{|col| col.name == column_name.to_s}
+    end
+
+    def comment_sql(comment_definition)
+      if comment_definition.nil? || comment_definition.comment_text.blank?
+        ""
+      else
+        " /*#{escaped_comment(comment_definition.comment_text)}*/"
+      end
+
+    end
+
+    def copy_table_with_migration_comments(from, to, options = {}) #:nodoc:
+      options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
+      unless options.has_key?(:comment)
+        table_comment = retrieve_table_comment(from)
+        options = options.merge(:comment => table_comment) if table_comment
+      end
+      create_table(to, options) do |definition|
+        @definition = definition
+        columns(from).each do |column|
+          column_name = options[:rename] ?
+            (options[:rename][column.name] ||
+             options[:rename][column.name.to_sym] ||
+             column.name) : column.name
+          @definition.column(column_name, column.type,
+            :limit => column.limit, :default => column.default,
+            :precision => column.precision, :scale => column.scale,
+            :null => column.null, :comment => column.comment)
+        end
+        @definition.primary_key(primary_key(from)) if primary_key(from)
+        yield @definition if block_given?
+      end
+
+      copy_table_indexes(from, to, options[:rename] || {})
+      copy_table_contents(from, to,
+        @definition.columns.map {|column| column.name},
+        options[:rename] || {})
+    end
+
+    def add_column_options!(sql, options)
+      super(sql, options)
+      if options.keys.include?(:comment)
+        sql << CommentDefinition.new(self, nil, nil, options[:comment]).to_sql
+      end
+    end
+
+    private
+    def escaped_comment(comment)
+      comment.gsub(/\*\//, "*-/")
+    end
+
+    def lookup_comment_sql(table_name)
+      "select sql from (select * from sqlite_master where type='table' union select * from sqlite_temp_master where type='table') where tbl_name = '#{table_name}'"
+    end
+  end
+end

data/lib/migration_comments/version.rb

@@ -1,3 +1,3 @@
 module MigrationComments
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/migration_comments.rb

@@ -3,17 +3,19 @@ require "migration_comments/version"
 require 'migration_comments/active_record/schema_dumper'
 require 'migration_comments/active_record/connection_adapters/comment_definition'
 require 'migration_comments/active_record/connection_adapters/column_definition'
+require 'migration_comments/active_record/connection_adapters/column'
 require 'migration_comments/active_record/connection_adapters/table'
 require 'migration_comments/active_record/connection_adapters/table_definition'
 require 'migration_comments/active_record/connection_adapters/abstract_adapter'
 require 'migration_comments/active_record/connection_adapters/mysql_adapter'
 require 'migration_comments/active_record/connection_adapters/mysql2_adapter'
 require 'migration_comments/active_record/connection_adapters/postgresql_adapter'
+require 'migration_comments/active_record/connection_adapters/sqlite_adapter'
 
 module MigrationComments
   def self.setup
     base_names = %w(SchemaDumper) +
-      %w(ColumnDefinition Table TableDefinition AbstractAdapter).map{|name| "ConnectionAdapters::#{name}"}
+      %w(ColumnDefinition Column Table TableDefinition AbstractAdapter).map{|name| "ConnectionAdapters::#{name}"}
 
     base_names.each do |base_name|
       ar_class = "ActiveRecord::#{base_name}".constantize
@@ -23,7 +25,7 @@ module MigrationComments
       end
     end
 
-    %w(PostgreSQL Mysql Mysql2).each do |adapter|
+    %w(PostgreSQL Mysql Mysql2 SQLite).each do |adapter|
       begin
         require("active_record/connection_adapters/#{adapter.downcase}_adapter")
         adapter_class = ('ActiveRecord::ConnectionAdapters::' << "#{adapter}Adapter").constantize

data/migration_comments.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |s|
   # s.add_development_dependency 'postgres-pr'
   # s.add_development_dependency 'mysql'
   # s.add_development_dependency 'mysql2'
+  # s.add_development_dependency 'sqlite3'
 end

data/test/annotate_models_test.rb

@@ -14,15 +14,15 @@ class AnnotateModelsTest < Test::Unit::TestCase
   def test_annotate_includes_comments
     db_type = :default
     ActiveRecord::Schema.define do
-      db_type = :postgres if connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) rescue false
+      db_type = :mysql if connection.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter) rescue false
 
       add_table_comment :sample, "a table comment"
       add_column_comment :sample, :field1, "a \"comment\" \\ that ' needs; escaping''"
-      add_column :sample, :field3, :string, :null => false, :comment => "third column comment"
+      add_column :sample, :field3, :string, :null => false, :default => '', :comment => "third column comment"
     end
 
     result = AnnotateModels.get_schema_info(Sample, TEST_PREFIX)
-    postgres_expected = <<EOS
+    default_expected = <<EOS
 # #{TEST_PREFIX}
 #
 # Table name: sample # a table comment
@@ -30,11 +30,11 @@ class AnnotateModelsTest < Test::Unit::TestCase
 #  id     :integer         not null, primary key
 #  field1 :string(255)                           # a "comment" \\ that ' needs; escaping''
 #  field2 :integer
-#  field3 :string(255)     not null              # third column comment
+#  field3 :string(255)     default(""), not null # third column comment
 #
 
 EOS
-    default_expected = <<EOS
+    mysql_expected = <<EOS
 # #{TEST_PREFIX}
 #
 # Table name: sample # a table comment
@@ -42,7 +42,7 @@ EOS
 #  id     :integer(4)      not null, primary key
 #  field1 :string(255)                           # a "comment" \\ that ' needs; escaping''
 #  field2 :integer(4)
-#  field3 :string(255)     not null              # third column comment
+#  field3 :string(255)     default(""), not null # third column comment
 #
 
 EOS

data/test/config/database.yml

@@ -9,4 +9,10 @@ mysql:
   adapter: mysql # mysql2
   database: migration_comments_test
   user: root
-  password: password
+  password: password
+
+sqlite:
+  adapter: sqlite3
+  database: db/migration_comments_test
+  pool: 5
+  timeout: 5000

data/test/schema_dumper_test.rb

@@ -4,10 +4,13 @@ class SchemaDumperTest < Test::Unit::TestCase
   include TestHelper
 
   def test_dump
+    db_type = :default
     ActiveRecord::Schema.define do
+      db_type = :sqlite if connection.is_a?(ActiveRecord::ConnectionAdapters::SQLiteAdapter) rescue false
+
       add_table_comment :sample, "a table comment"
       add_column_comment :sample, :field1, "a \"comment\" \\ that ' needs; escaping''"
-      add_column :sample, :field3, :string, :null => false, :comment => "third column comment"
+      add_column :sample, :field3, :string, :null => false, :default => "", :comment => "third column comment"
     end
     dest = StringIO.new
     ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, dest)
@@ -17,13 +20,14 @@ class SchemaDumperTest < Test::Unit::TestCase
 ActiveRecord::Schema.define(:version => 1) do
 
   create_table "sample", :force => true, :comment => "a table comment" do |t|
-    t.string  "field1",                 :comment => "a \"comment\" \\ that ' needs; escaping''"
+    t.string  "field1",                                 :comment => "a \"comment\" \\ that ' needs; escaping''"
     t.integer "field2"
-    t.string  "field3", :null => false, :comment => "third column comment"
+    t.string  "field3", :default => "", :null => false, :comment => "third column comment"
   end
 
 end
 EOS
+
     assert_match /#{Regexp.escape expected}/, result
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: migration_comments
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Pinny
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-13 00:00:00 -05:00
+date: 2012-02-22 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,11 +78,13 @@ files:
 - Rakefile
 - lib/migration_comments.rb
 - lib/migration_comments/active_record/connection_adapters/abstract_adapter.rb
+- lib/migration_comments/active_record/connection_adapters/column.rb
 - lib/migration_comments/active_record/connection_adapters/column_definition.rb
 - lib/migration_comments/active_record/connection_adapters/comment_definition.rb
 - lib/migration_comments/active_record/connection_adapters/mysql2_adapter.rb
 - lib/migration_comments/active_record/connection_adapters/mysql_adapter.rb
 - lib/migration_comments/active_record/connection_adapters/postgresql_adapter.rb
+- lib/migration_comments/active_record/connection_adapters/sqlite_adapter.rb
 - lib/migration_comments/active_record/connection_adapters/table.rb
 - lib/migration_comments/active_record/connection_adapters/table_definition.rb
 - lib/migration_comments/active_record/schema_dumper.rb