schema_comments 0.1.0

data/lib/schema_comments/base.rb

@@ -0,0 +1,72 @@
+module SchemaComments
+  module Base
+    def self.included(mod)
+      mod.extend ClassMethods
+      mod.instance_eval do
+        alias :columns_without_schema_comments :columns
+        alias :columns :columns_with_schema_comments
+      end
+    end
+    
+    module ClassMethods
+      def table_comment
+        @table_comment ||= connection.table_comment(table_name)
+      end
+      
+      def columns_with_schema_comments
+        result = columns_without_schema_comments
+        unless @column_comments_loaded
+          column_comment_hash = connection.column_comments(table_name)
+          result.each do |column|
+            column.comment = column_comment_hash[column.name.to_s]
+          end
+          @column_comments_loaded = true
+        end
+        result
+      end
+      
+      def reset_column_comments
+        @column_comments_loaded = false
+      end
+      
+      def reset_table_comments
+        @table_comment = nil
+      end
+      
+      attr_accessor_with_default :ignore_pattern_to_export_i18n, /\[.*\]/
+      
+      def export_i18n_models
+        subclasses = ActiveRecord::Base.send(:subclasses).select do |klass|
+          (klass != SchemaComments::SchemaComment) and
+            klass.respond_to?(:table_exists?) and klass.table_exists?
+        end
+        subclasses.inject({}) do |d, m|
+          comment = m.table_comment
+          comment.gsub!(ignore_pattern_to_export_i18n, '') if ignore_pattern_to_export_i18n
+          d[m.name.underscore] = comment
+          d
+        end
+      end
+      
+      def export_i18n_attributes(connection = ActiveRecord::Base.connection)
+        subclasses = ActiveRecord::Base.send(:subclasses).select do |klass|
+          (klass != SchemaComments::SchemaComment) and
+            klass.respond_to?(:table_exists?) and klass.table_exists?
+        end
+        subclasses.inject({}) do |d, m|
+          attrs = {}
+          m.columns.each do |col|
+            next if col.name == 'id'
+            comment = (col.comment || '').dup
+            comment.gsub!(ignore_pattern_to_export_i18n, '') if ignore_pattern_to_export_i18n
+            attrs[col.name] = comment
+          end
+          d[m.name.underscore] = attrs
+          d
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/schema_comments/connection_adapters.rb

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+module SchemaComments
+  module ConnectionAdapters
+
+    module Column
+      attr_accessor :comment
+    end
+    
+    module ColumnDefinition
+      attr_accessor :comment
+    end
+    
+    module TableDefinition
+      def self.included(mod)
+        mod.module_eval do 
+          alias_method_chain(:column, :schema_comments)
+        end
+      end
+      attr_accessor :comment
+
+      def column_with_schema_comments(name, type, options = {})
+        column_without_schema_comments(name, type, options)
+        column = self[name]
+        column.comment = options[:comment]
+        self
+      end
+    end
+    
+    module Adapter
+      def column_comment(table_name, column_name, comment = nil) #:nodoc:
+        if comment
+          SchemaComment.save_column_comment(table_name, column_name, comment) unless SchemaComments.quiet
+          return comment
+        else
+          SchemaComment.column_comment(table_name, column_name)
+        end
+      end
+      
+      # Mass assignment of comments in the form of a hash.  Example:
+      #   column_comments {
+      #     :users => {:first_name => "User's given name", :last_name => "Family name"},
+      #     :tags  => {:id => "Tag IDentifier"}}
+      def column_comments(contents)
+        if contents.is_a?(Hash)
+          contents.each_pair do |table, cols|
+            cols.each_pair do |col, comment|
+              column_comment(table, col, comment) unless SchemaComments.quiet
+            end
+          end
+        else
+          SchemaComment.column_comments(contents)
+        end
+      end
+      
+      def table_comment(table_name, comment = nil) #:nodoc:
+        if comment
+          comment = (comment[:comment] || comment['comment']) if comment.is_a?(Hash)
+          SchemaComment.save_table_comment(table_name, comment) unless SchemaComments.quiet
+          return comment
+        else
+          SchemaComment.table_comment(table_name)
+        end
+      end
+      
+      def delete_schema_comments(table_name, column_name = nil)
+        SchemaComment.destroy_of(table_name, column_name) unless SchemaComments.quiet
+      end
+      
+      def update_schema_comments_table_name(table_name, new_name)
+        SchemaComment.update_table_name(table_name, new_name) unless SchemaComments.quiet
+      end
+      
+      def update_schema_comments_column_name(table_name, column_name, new_name)
+        SchemaComment.update_column_name(table_name, column_name, new_name) unless SchemaComments.quiet
+      end
+    end
+    
+    module ConcreteAdapter
+      def self.included(mod)
+        mod.module_eval do 
+          alias_method_chain :columns, :schema_comments
+          alias_method_chain :create_table, :schema_comments
+          alias_method_chain :drop_table, :schema_comments
+          alias_method_chain :rename_table, :schema_comments
+          alias_method_chain :remove_column, :schema_comments
+          alias_method_chain :add_column, :schema_comments
+          alias_method_chain :change_column, :schema_comments
+          alias_method_chain :rename_column, :schema_comments
+        end
+      end
+      
+      def columns_with_schema_comments(table_name, name = nil, &block)
+        result = columns_without_schema_comments(table_name, name, &block)
+        column_comment_hash = column_comments(table_name)
+        result.each do |column|
+          column.comment = column_comment_hash[column.name]
+        end
+        result
+      end
+      
+      def create_table_with_schema_comments(table_name, options = {}, &block)
+        table_def = nil
+        result = create_table_without_schema_comments(table_name, options) do |t|
+          table_def = t
+          yield(t)
+        end
+        table_comment(table_name, options[:comment]) unless options[:comment].blank?
+        table_def.columns.each do |col|
+          column_comment(table_name, col.name, col.comment) unless col.comment.blank?
+        end
+        result
+      end
+      
+      def drop_table_with_schema_comments(table_name, options = {}, &block)
+        result = drop_table_without_schema_comments(table_name, options)
+        delete_schema_comments(table_name) unless @ignore_drop_table
+        result
+      end
+      
+      def rename_table_with_schema_comments(table_name, new_name)
+        result = rename_table_without_schema_comments(table_name, new_name)
+        update_schema_comments_table_name(table_name, new_name)
+        result
+      end
+      
+      def remove_column_with_schema_comments(table_name, *column_names)
+        # sqlite3ではremove_columnがないので、以下のフローでスキーマ更新します。
+        # 1. CREATE TEMPORARY TABLE "altered_xxxxxx" (・・・)
+        # 2. PRAGMA index_list("xxxxxx")
+        # 3. DROP TABLE "xxxxxx"
+        # 4. CREATE TABLE "xxxxxx"
+        # 5. PRAGMA index_list("altered_xxxxxx")
+        # 6. DROP TABLE "altered_xxxxxx"
+        # 
+        # このdrop tableの際に、schema_commentsを変更しないようにフラグを立てています。
+        @ignore_drop_table = true
+        remove_column_without_schema_comments(table_name, *column_names)
+        column_names.each do |column_name|
+          delete_schema_comments(table_name, column_name)
+        end
+      ensure
+        @ignore_drop_table = false
+      end
+      
+      def add_column_with_schema_comments(table_name, column_name, type, options = {})
+        comment = options.delete(:comment)
+        result = add_column_without_schema_comments(table_name, column_name, type, options)
+        column_comment(table_name, column_name, comment) if comment
+        result
+      end
+      
+      def change_column_with_schema_comments(table_name, column_name, type, options = {})
+        comment = options.delete(:comment)
+        @ignore_drop_table = true
+        result = change_column_without_schema_comments(table_name, column_name, type, options)
+        column_comment(table_name, column_name, comment) if comment
+        result
+      ensure
+        @ignore_drop_table = false
+      end
+
+      def rename_column_with_schema_comments(table_name, column_name, new_column_name)
+        result = rename_column_without_schema_comments(table_name, column_name, new_column_name)
+        comment = update_schema_comments_column_name(table_name, column_name, new_column_name)
+        result
+      end
+
+    end
+  end
+end

data/lib/schema_comments/migration.rb

@@ -0,0 +1,20 @@
+module SchemaComments
+  module Migration
+    def self.included(mod)
+      mod.extend(ClassMethods)
+      mod.instance_eval do
+        alias :migrate_without_schema_comments :migrate
+        alias :migrate :migrate_with_schema_comments
+      end
+    end
+    
+    module ClassMethods
+      def migrate_with_schema_comments(*args, &block)
+        SchemaComments::SchemaComment.yaml_access do
+          migrate_without_schema_comments(*args, &block)
+        end
+      end
+    end
+    
+  end
+end

data/lib/schema_comments/migrator.rb

@@ -0,0 +1,20 @@
+module SchemaComments
+  module Migrator
+    def self.included(mod)
+      mod.extend(ClassMethods)
+      mod.instance_eval do
+        alias :migrate_without_schema_comments :migrate
+        alias :migrate :migrate_with_schema_comments
+      end
+    end
+    
+    module ClassMethods
+      def migrate_with_schema_comments(*args, &block)
+        SchemaComments::SchemaComment.yaml_access do
+          migrate_without_schema_comments(*args, &block)
+        end
+      end
+    end
+    
+  end
+end

data/lib/schema_comments/schema.rb

@@ -0,0 +1,20 @@
+module SchemaComments
+  module Schema
+    def self.included(mod)
+      mod.extend(ClassMethods)
+      mod.instance_eval do
+        alias :define_without_schema_comments :define
+        alias :define :define_with_schema_comments
+      end
+    end
+    
+    module ClassMethods
+      def define_with_schema_comments(*args, &block)
+        SchemaComments::SchemaComment.yaml_access do
+          define_without_schema_comments(*args, &block)
+        end
+      end
+    end
+
+  end
+end

data/lib/schema_comments/schema_comment.rb

@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+require 'yaml/store'
+
+module SchemaComments
+  # 現在はActiveRecord::Baseを継承していますが、将来移行が完全に終了した
+  # 時点で、ActiveRecord::Baseの継承をやめます。
+  #
+  # それまではDBからのロードは可能ですが、YAMLにのみ保存します。
+  class SchemaComment < ActiveRecord::Base
+    set_table_name('schema_comments')
+
+    TABLE_KEY = 'table_comments'
+    COLUMN_KEY = 'column_comments'
+
+    class << self
+      def table_comment(table_name)
+        if yaml_exist?
+          @table_names ||= yaml_access{|db| db[TABLE_KEY]}.dup
+          return @table_names[table_name.to_s]
+        end
+        return nil unless table_exists?
+        connection.select_value(sanitize_conditions("select descriptions from schema_comments where table_name = '%s' and column_name is null" % table_name))
+      end
+      
+      def column_comment(table_name, column_name)
+        if yaml_exist?
+          @column_names ||= yaml_access{|db| db[COLUMN_KEY] }.dup
+          column_hash = @column_names[table_name.to_s] || {}
+          return column_hash[column_name.to_s]
+        end
+        return nil unless table_exists?
+        connection.select_value(sanitize_conditions("select descriptions from schema_comments where table_name = '%s' and column_name = '%s'" % [table_name, column_name]))
+      end
+      
+      def column_comments(table_name)
+        if yaml_exist?
+          result = nil
+          @column_names ||= yaml_access{|db| db[COLUMN_KEY] }.dup
+          result = @column_names[table_name.to_s]
+          return result || {}
+        end
+        return {} unless table_exists?
+        hash_array = connection.select_all(sanitize_conditions("select column_name, descriptions from schema_comments where table_name = '%s' and column_name is not null" % table_name))
+        hash_array.inject({}){|dest, r| dest[r['column_name']] = r['descriptions']; dest}
+      end
+      
+      def save_table_comment(table_name, comment)
+        yaml_access do |db|
+          db[TABLE_KEY][table_name.to_s] = comment
+        end
+        @table_names = nil
+      end
+      
+      def save_column_comment(table_name, column_name, comment)
+        yaml_access do |db|
+          db[COLUMN_KEY][table_name.to_s] ||= {}
+          db[COLUMN_KEY][table_name.to_s][column_name.to_s] = comment
+        end
+        @column_names = nil
+      end
+      
+      def destroy_of(table_name, column_name)
+        yaml_access do |db|
+          column_hash = db[COLUMN_KEY][table_name.to_s]
+          column_hash.delete(column_name) if column_hash
+        end
+        @column_names = nil
+      end
+      
+      def update_table_name(table_name, new_name)
+        if yaml_exist?
+          yaml_access do |db|
+            db[TABLE_KEY][new_name.to_s] = db[TABLE_KEY].delete(table_name.to_s)
+            db[COLUMN_KEY][new_name.to_s] = db[COLUMN_KEY].delete(table_name.to_s)
+          end
+        end
+        @table_names = nil
+        @column_names = nil
+      end
+      
+      def update_column_name(table_name, column_name, new_name)
+        if yaml_exist?
+          yaml_access do |db|
+            table_cols = db[COLUMN_KEY][table_name.to_s]
+            if table_cols
+              table_cols[new_name.to_s] = table_cols.delete(column_name.to_s)
+            end
+          end
+        end
+        @table_names = nil
+        @column_names = nil
+      end
+      
+      def yaml_exist?
+        File.exist?(SchemaComments.yaml_path)
+      end
+      
+      def yaml_access(&block)
+        if @yaml_transaction
+          yield(@yaml_transaction) if block_given?
+        else
+          db = SortedStore.new(SchemaComments.yaml_path)
+          result = nil
+          # t = Time.now.to_f
+          db.transaction do
+            @yaml_transaction = db
+            begin
+              db[TABLE_KEY] ||= {}
+              db[COLUMN_KEY] ||= {}
+              result = yield(db) if block_given?
+            ensure
+              @yaml_transaction = nil
+            end
+          end
+          # puts("SchemaComment#yaml_access %fms from %s" % [Time.now.to_f - t, caller[0].gsub(/^.+:in /, '')])
+          result
+        end
+      end
+
+    end
+
+    class SortedStore < YAML::Store
+      module ColumnNamedHash
+        def each
+          @column_names.each do |column_name|
+            yield(column_name, self[column_name])
+          end
+        end
+      end
+
+      def dump(table)
+        root = nil
+        StringIO.open do |io|
+          YAML.dump(@table, io)
+          io.rewind
+          root = YAML.load(io)
+        end
+
+        table_comments = root['table_comments']
+        column_comments = root['column_comments']
+        # 大元は
+        # table_comments:
+        #   ...
+        # column_comments:
+        #   ...
+        # その他
+        #   ...
+        # の順番です。
+        root.instance_eval do
+          def each
+            yield('table_comments', self['table_comments'])
+            yield('column_comments', self['column_comments'])
+            (self.keys - ['table_comments', 'column_comments']).each do |key|
+              yield(key, self[key])
+            end
+          end
+        end
+        # table_comments はテーブル名のアルファベット順
+        table_names = ActiveRecord::Base.connection.tables.sort - ['schema_migrations']
+        table_comments.instance_variable_set(:@table_names, table_names)
+        table_comments.instance_eval do
+          def each
+            @table_names.each do |key|
+              yield(key, self[key])
+            end
+          end
+        end
+        # column_comments もテーブル名のアルファベット順
+        column_comments.instance_variable_set(:@table_names, table_names)
+        column_comments.instance_eval do
+          def each
+            @table_names.each do |key|
+              yield(key, self[key])
+            end
+          end
+        end
+        # column_comments の各値はテーブルのカラム順
+        column_comments.each do |table_name, column_hash|
+          column_names = nil
+          begin
+            columns = ActiveRecord::Base.connection.columns_without_schema_comments(table_name, "#{table_name.classify} Columns")
+            column_names = columns.map(&:name)
+          rescue ActiveRecord::ActiveRecordError
+            column_names = column_hash.keys.sort
+          end
+          column_names.delete('id')
+          column_hash.instance_variable_set(:@column_names, column_names)
+          column_hash.extend(ColumnNamedHash)
+        end
+        root.to_yaml(@opt)
+      end
+    end
+
+  end
+end