activerecord-comments 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e72374f3910386b8d9db461607ac65df0eb162f9
+  data.tar.gz: c662619926513774697a3b2cfad8d6546a14ac22
+SHA512:
+  metadata.gz: d1f359c48d85d25e8bcd5823e619b221f71878ae95ec9a4bff7dc4b81d155dcf21a60cfbe6d48444ba3606c0a3214d55ef503501170ba8bfd2bbff1148fac3c2
+  data.tar.gz: d0d79995bc495bf4f8e28501ec04415f3dad0904ded665de73b7b1f6668177d9be531cb38b9fb4aed6f845120ea942050a14ec2ffbcd4db609d3e559e2a4e7e1

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-comments.gemspec
+gemspec
+
+group :development do
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Marton Somogyi
+
+MIT License
+
+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.md

@@ -0,0 +1,26 @@
+# ActiveRecord::Comments
+
+Manage comments for SQL schemas. Set, get and remove comments on tables and columns. ActiveRecord bindings and executable with CLI.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activerecord-comments'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-comments
+
+## Executable usage
+
+    Set the DB environment variable to select from database configurations. Current value: "postgres"
+        -a, --action ACTION              Action to perform: set, retrieve, remove
+        -t, --table TABLE                Select table
+        -c, --column COLUMN              Select column
+        -m, --comment COMMENT            Comment to save
+            --conf DBCONF                Database config YAML (default: /Users/<user>/activerecord_comments/config/database.yml)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/activerecord-comments.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+require File.expand_path('../lib/active_record/comments/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'activerecord-comments'
+  spec.version       = ActiveRecord::Comments::VERSION
+  spec.authors       = ['Marton Somogyi']
+  spec.email         = ['msomogyi@whitepages.com']
+  spec.summary       = %q{Comments for SQL schemas}
+  spec.description   = %q{Manage comments for SQL tables and columns}
+  spec.homepage      = 'https://github.com/mcbuddha/activerecord-comments'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10'
+  spec.add_development_dependency 'rspec', '~> 3'
+
+  spec.add_development_dependency 'pg', '~> 0.17'
+  spec.add_development_dependency 'mysql2', '~> 0'
+  spec.add_development_dependency 'sqlite3', '~> 0'
+
+  spec.add_runtime_dependency 'activerecord', '~> 3'
+end

data/bin/activerecord-comments

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require 'pry'
+require 'yaml'
+require 'optparse'
+
+require 'active_record/comments'
+
+ENV['DB'] ||= 'postgres'
+
+TYPES = %w(table column)
+ACTIONS = %w(set retrieve remove)
+
+options = {dbconf: File.expand_path('./config/database.yml', Dir.pwd)}
+OptionParser.new do |opts|
+  opts.banner = <<USAGE
+Set the DB environment variable to select from database configurations. Current value: "#{ENV['DB']}"
+USAGE
+
+  opts.on('-a', '--action ACTION', ACTIONS, "Action to perform: #{ACTIONS.join(', ')}") { |action| options[:action] = action }
+  opts.on('-t', '--table TABLE', 'Select table') { |table| options[:table] = table }
+  opts.on('-c', '--column COLUMN', 'Select column') { |column| options[:column] = column }
+  opts.on('-m', '--comment COMMENT', 'Comment to save') { |comment| options[:comment] = comment }
+  opts.on('--conf DBCONF', "Database config YAML (default: #{options[:dbconf]})") { |dbconf| options[:dbconf] = dbconf }
+end.parse!
+
+abort 'You must specify a table' unless options[:table]
+abort 'You must specify an action' unless options[:action]
+abort 'You must specify a comment' if options[:action] == 'set' && options[:comment].nil?
+
+DBCONF = YAML::load IO.read options[:dbconf] rescue abort "Error reading #{options[:dbconf]}: #{$!}"
+
+ActiveRecord::Base.establish_connection(DBCONF[ENV['DB']]).connection rescue abort "Couldn't connect to #{options[:dbconf]}[#{ENV['DB']}]: #{$!}"
+
+command = "#{options[:action]}_#{options[:column] ? 'column':'table'}_comment"
+args = [options[:table].to_sym]
+args << options[:column].to_sym if options[:column]
+args << options[:comment] if options[:comment] and options[:action] != 'retrieve'
+
+begin
+  result = ActiveRecord::Base.connection.send command, *args
+  puts result if options[:action] == 'retrieve'
+rescue
+  abort "Error while executing query: #{$!}"
+end

data/lib/active_record/comments.rb

@@ -0,0 +1,42 @@
+require 'active_record'
+require 'active_support/inflector'
+
+require 'active_record/comments/version'
+
+module ActiveRecord::Comments; end
+
+require 'active_record/comments/connection_adapters/comment_definition'
+require 'active_record/comments/connection_adapters/abstract_adapter'
+require 'active_record/comments/connection_adapters/postgresql_adapter'
+require 'active_record/comments/connection_adapters/abstract_sqlite_adapter'
+require 'active_record/comments/connection_adapters/sqlite_adapter'
+require 'active_record/comments/connection_adapters/sqlite3_adapter'
+require 'active_record/comments/connection_adapters/mysql_adapter'
+require 'active_record/comments/connection_adapters/mysql2_adapter'
+
+module ActiveRecord::Comments
+  def self.setup
+    _cls = ->(l) { l.join('::').constantize }
+
+    ar_names = %w(ActiveRecord ConnectionAdapters AbstractAdapter)
+    ar_class = _cls.(ar_names)
+    arc_class = _cls.([self.name, *ar_names[1..-1]])
+    ar_class.send :include, arc_class unless ar_class.ancestors.include? arc_class
+
+    adapters = %w(PostgreSQL Mysql Mysql2)
+    adapters << (::ActiveRecord::VERSION::MAJOR <= 3 ? 'SQLite' : 'SQLite3')
+    adapters.each do |adapter|
+      begin require "active_record/connection_adapters/#{adapter.downcase}_adapter"
+      rescue LoadError => err; next; end
+
+      to_inject = "#{adapter}Adapter"
+      ar_class = _cls.([*ar_names[0..-2], to_inject])
+      arc_class = _cls.([self.name, *ar_names[1..-2], to_inject])
+      ar_class.module_eval do
+        ar_class.send :include, arc_class unless ar_class.ancestors.include?(arc_class)
+      end
+    end
+  end
+end
+
+ActiveRecord::Comments.setup

data/lib/active_record/comments/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,43 @@
+module ActiveRecord::Comments::ConnectionAdapters
+  module AbstractAdapter
+    def set_table_comment(table_name, comment_text)
+    end
+
+    def set_column_comment(table_name, column_name, comment_text)
+    end
+
+    def comments_supported?
+      false
+    end
+
+    # SQLite style - embedded comments
+    def inline_comments?
+      false
+    end
+
+    # PostgreSQL style - comment specific commands
+    def independent_comments?
+      false
+    end
+
+    def remove_table_comment(table_name)
+      set_table_comment(table_name, nil)
+    end
+
+    def remove_column_comment(table_name, column_name)
+      set_column_comment(table_name, column_name, nil)
+    end
+
+    def retrieve_table_comment(table_name)
+      nil
+    end
+
+    def retrieve_column_comments(table_name, *column_names)
+      {}
+    end
+
+    def retrieve_column_comment(table_name, column_name)
+      retrieve_column_comments(table_name, column_name)[column_name]
+    end
+  end
+end

data/lib/active_record/comments/connection_adapters/abstract_sqlite_adapter.rb

@@ -0,0 +1,70 @@
+module ActiveRecord::Comments::ConnectionAdapters
+  module AbstractSQLiteAdapter
+    def comments_supported?
+      true
+    end
+
+    def inline_comments?
+      true
+    end
+
+    def set_table_comment(table_name, comment_text)
+      alter_table(table_name, :comment => comment_text)
+    end
+
+    def set_column_comment(table_name, column_name, comment_text)
+      sql_type = primary_key(table_name) == column_name.to_s ?
+          :primary_key :
+          column_for(table_name, column_name).sql_type
+      change_column table_name, column_name, 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 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 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/active_record/comments/connection_adapters/comment_definition.rb

@@ -0,0 +1,24 @@
+module ActiveRecord::Comments::ConnectionAdapters
+  class CommentDefinition < Struct.new(:adapter, :table, :column_name, :comment_text)
+    def to_dump
+      if table_comment?
+        "set_table_comment :#{table_name}, %{#{comment_text}}"
+      else
+        "set_column_comment :#{table_name}, :#{column_name}, %{#{comment_text}}"
+      end
+    end
+
+    def to_sql
+      adapter.comment_sql(self)
+    end
+    alias to_s :to_sql
+
+    def table_comment?
+      column_name.blank?
+    end
+
+    def table_name
+      table.respond_to?(:name) ? table.name : table
+    end
+  end
+end

data/lib/active_record/comments/connection_adapters/mysql2_adapter.rb

@@ -0,0 +1,9 @@
+module ActiveRecord::Comments::ConnectionAdapters
+  module Mysql2Adapter
+    def self.included(base)
+      base.class_eval do
+        include ActiveRecord::Comments::ConnectionAdapters::MysqlAdapter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module ActiveRecord::Comments::ConnectionAdapters
+  module MysqlAdapter
+    def comments_supported?
+      true
+    end
+
+    def set_table_comment(table_name, comment_text)
+      execute "ALTER TABLE #{quote_table_name table_name} COMMENT #{escaped_comment(comment_text)}"
+    end
+
+    def set_column_comment(table_name, column_name, comment_text)
+      pk_info = pk_and_sequence_for(table_name)
+      if pk_info && pk_info.first == column_name.to_s             # change_column broken for :primary_key
+        primary_col_def = native_database_types[:primary_key].sub(/ PRIMARY KEY/i, '')
+        execute "ALTER TABLE #{quote_table_name table_name} CHANGE #{quote_column_name column_name} #{quote_column_name column_name} #{primary_col_def} COMMENT #{escaped_comment(comment_text)};"
+      else
+        column = column_for(table_name, column_name)
+        change_column table_name, column_name, column.sql_type, :comment => comment_text
+      end
+    end
+
+    def retrieve_table_comment(table_name)
+      result = select_rows(table_comment_sql(table_name))
+      result[0].nil? || result[0][0].blank? ? nil : result[0][0]
+    end
+
+    def retrieve_column_comments(table_name, *column_names)
+      result = select_rows(column_comment_sql(table_name, *column_names))
+      return {} if result.nil?
+      result.inject({}){|m, row| m[row[0].to_sym] = (row[1].blank? ? nil : row[1]); m}
+    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
+
+    def comment_sql(comment_definition)
+      " COMMENT #{escaped_comment(comment_definition.comment_text)}"
+    end
+
+    def execute_comment(comment_definition)
+      if comment_definition.table_comment?
+        set_table_comment comment_definition.table_name, comment_definition.comment_text
+      else
+        set_column_comment comment_definition.table_name, comment_definition.column_name, comment_definition.comment_text
+      end
+    end
+
+    private
+    def escaped_comment(comment)
+      comment.nil? ? "''" : "'#{comment.gsub("'", "''").gsub("\\", "\\\\\\\\")}'"
+    end
+
+    def table_comment_sql(table_name)
+      <<SQL
+SELECT table_comment FROM INFORMATION_SCHEMA.TABLES
+  WHERE table_schema = '#{database_name}'
+  AND table_name = '#{table_name}'
+SQL
+    end
+
+    def column_comment_sql(table_name, *column_names)
+      col_matcher_sql = column_names.empty? ? "" : " AND column_name IN (#{column_names.map{|c_name| "'#{c_name}'"}.join(',')})"
+      <<SQL
+SELECT column_name, column_comment FROM INFORMATION_SCHEMA.COLUMNS
+  WHERE table_schema = '#{database_name}'
+  AND table_name = '#{table_name}' #{col_matcher_sql}
+SQL
+    end
+
+    def database_name
+      @database_name ||= select_rows("SELECT DATABASE()")[0][0]
+    end
+
+  end
+end

data/lib/active_record/comments/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,77 @@
+module ActiveRecord::Comments::ConnectionAdapters
+  module PostgreSQLAdapter
+    def comments_supported?
+      true
+    end
+
+    def independent_comments?
+      true
+    end
+
+    def set_table_comment(table_name, comment_text)
+      execute CommentDefinition.new(self, table_name, nil, comment_text).to_sql
+    end
+
+    def set_column_comment(table_name, column_name, comment_text)
+      execute CommentDefinition.new(self, table_name, column_name, comment_text).to_sql
+    end
+
+    def retrieve_table_comment(table_name)
+      result = select_rows(table_comment_sql(table_name))
+      result[0].nil? ? nil : result[0][0]
+    end
+
+    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]; m}
+    end
+
+    def comment_sql(comment_definition)
+      "COMMENT ON #{comment_target(comment_definition)} IS #{escaped_comment(comment_definition.comment_text)}"
+    end
+
+    private
+
+    def comment_target(comment_definition)
+      comment_definition.table_comment? ?
+          "TABLE #{quote_table_name(comment_definition.table_name)}" :
+          "COLUMN #{quote_table_name(comment_definition.table_name)}.#{quote_column_name(comment_definition.column_name)}"
+    end
+
+    def escaped_comment(comment)
+      comment.nil? ? 'NULL' : "'#{comment.gsub("'", "''")}'"
+    end
+
+    def table_comment_sql(table_name)
+      <<SQL
+SELECT d.description FROM (
+#{table_oids(table_name)}) tt
+JOIN pg_catalog.pg_description d
+  ON tt.oid = d.objoid AND tt.tableoid = d.classoid AND d.objsubid = 0;
+SQL
+    end
+
+    def column_comment_sql(table_name, *column_names)
+      col_matcher_sql = column_names.empty? ? "" : " a.attname IN (#{column_names.map{|c_name| "'#{c_name}'"}.join(',')}) AND "
+      <<SQL
+SELECT a.attname, pg_catalog.col_description(a.attrelid, a.attnum)
+FROM pg_catalog.pg_attribute a
+JOIN (
+#{table_oids(table_name)}) tt
+  ON tt.oid = a.attrelid
+WHERE #{col_matcher_sql} a.attnum > 0 AND NOT a.attisdropped;
+SQL
+    end
+
+    def table_oids(table_name)
+      <<SQL
+SELECT c.oid, c.tableoid
+FROM pg_catalog.pg_class c
+WHERE c.relname = '#{table_name}'
+  AND c.relkind = 'r'
+  AND pg_catalog.pg_table_is_visible(c.oid)
+SQL
+    end
+  end
+end

data/lib/active_record/comments/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,28 @@
+module ActiveRecord::Comments::ConnectionAdapters
+  module SQLite3Adapter
+    include ActiveRecord::Comments::ConnectionAdapters::AbstractSQLiteAdapter
+
+    def create_table(table_name, options = {})
+      td = create_table_definition table_name, options[:temporary], options[:options]
+      td.base = self
+
+      unless options[:id] == false
+        pk = options.fetch(:primary_key) {
+          ActiveRecord::Base.get_primary_key table_name.to_s.singularize
+        }
+
+        td.primary_key pk, options.fetch(:id, :primary_key), options
+      end
+      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, options)
+      end
+
+      execute schema_creation.accept td
+      td.indexes.each_pair { |c,o| add_index table_name, c, o }
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ActiveRecord::Comments::ConnectionAdapters
+  module SQLiteAdapter
+    include ActiveRecord::Comments::ConnectionAdapters::AbstractSQLiteAdapter
+
+    def create_table(table_name, options = {})
+      td = ::ActiveRecord::ConnectionAdapters::TableDefinition.new(self)
+      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)
+      td.base = self
+
+      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_s
+      end * ", "
+      create_sql << ") #{options[:options]}"
+      execute create_sql
+    end
+  end
+end

data/lib/active_record/comments/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Comments
+    VERSION = '0.0.3'
+  end
+end

data/spec/activerecord_comments_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+TEST_COMMENTS =
+  [
+   %q{some "comment" with 'quotes'},
+   %q{other ; special \\ characters \' \"},
+  ]
+
+describe ActiveRecord::Comments do
+  subject { ActiveRecord::Base.connection }
+  let(:table) { :test }
+  describe '#setup' do
+    context 'should define' do
+      it('set_table_comment') { expect(subject).to respond_to(:set_table_comment) }
+      it('retrieve_table_comment') { expect(subject).to respond_to(:retrieve_table_comment) }
+      it('remove_table_comment') { expect(subject).to respond_to(:remove_table_comment) }
+
+      it('set_column_comment') { expect(subject).to respond_to(:set_column_comment) }
+      it('retrieve_column_comment') { expect(subject).to respond_to(:retrieve_column_comment) }
+      it('retrieve_column_comments') { expect(subject).to respond_to(:retrieve_column_comments) }
+      it('remove_column_comment') { expect(subject).to respond_to(:remove_column_comment) }
+    end
+  end
+
+  describe 'table comments' do
+    let(:comment) { 'test comment' }
+    let(:comment2) { 'other test comment' }
+
+    before { subject.set_table_comment table, comment }
+
+    it 'should read same comment' do
+      expect(subject.retrieve_table_comment table).to eq(comment)
+    end
+
+    it 'should read last version' do
+      expect(subject.retrieve_table_comment table).to eq(comment)
+      subject.set_table_comment table, comment2
+      expect(subject.retrieve_table_comment table).to eq(comment2)
+    end
+
+    it 'should read nil after remove' do
+      subject.remove_table_comment table
+      expect(subject.retrieve_table_comment table).to be_nil
+    end
+  end
+
+  describe 'test_comments' do
+    TEST_COMMENTS.each do |comment|
+      it do
+        subject.set_table_comment table, comment
+        expect(subject.retrieve_table_comment table).to eq(comment)
+      end
+    end
+  end
+
+  describe 'column comments' do
+    let(:comment) { 'some comment' }
+    let(:comment2) { 'some other comment' }
+    let(:comment3) { 'another comment' }
+
+    let(:col) { :field1 }
+    let(:col2) { :field2 }
+
+    context 'should read' do
+      it do
+        subject.set_column_comment table, col, comment
+        expect(subject.retrieve_column_comment table, col).to eq(comment)
+      end
+
+      it do
+        subject.set_column_comment table, col2, comment2
+        expect(subject.retrieve_column_comment table, col2).to eq(comment2)
+      end
+
+      it do
+        subject.set_column_comment table, col, comment
+        subject.set_column_comment table, col2, comment2
+        expect(subject.retrieve_column_comments table, col, col2).to eq(col => comment, col2 => comment2)
+      end
+
+      it do
+        subject.set_column_comment table, col, comment
+        expect(subject.retrieve_column_comment table, col).to eq(comment)
+        subject.remove_column_comment table, col
+        expect(subject.retrieve_column_comment table, col).to be_nil
+      end
+    end
+
+    describe 'test_comments' do
+      TEST_COMMENTS.each do |comment|
+        it do
+          subject.set_column_comment table, col, comment
+          expect(subject.retrieve_column_comment table, col).to eq(comment)
+        end
+      end
+    end
+  end
+end

data/spec/config/database.yml

@@ -0,0 +1,18 @@
+postgres:
+  adapter: postgresql
+  database: activerecord_comments_test
+  host: 127.0.0.1
+  username: postgres
+  password: postgres
+
+mysql:
+  adapter: mysql2
+  database: activerecord_comments_test
+  user: root
+  password: password
+
+sqlite:
+  adapter: sqlite3
+  database: test/db/activerecord_comments_test
+  pool: 5
+  timeout: 5000

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+$: << File.expand_path('../lib', __FILE__)
+
+require 'yaml'
+require 'pry'
+
+require 'active_record/comments'
+
+DBCONF = YAML::load(IO.read(File.expand_path('../config/database.yml', __FILE__)))
+ENV['DB'] ||= 'postgres'
+ActiveRecord::Base.establish_connection DBCONF[ENV['DB']]
+
+RSpec.configure do |c|
+  c.around(:each) do |ex|
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Schema.define do
+        create_table :test do |t|
+          t.string :field1
+          t.integer :field2
+        end
+      end
+    end
+    ex.run
+    ActiveRecord::Migration.suppress_messages { ActiveRecord::Schema.define { drop_table :test } }
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-comments
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Marton Somogyi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Manage comments for SQL tables and columns
+email:
+- msomogyi@whitepages.com
+executables:
+- activerecord-comments
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-comments.gemspec
+- bin/activerecord-comments
+- lib/active_record/comments.rb
+- lib/active_record/comments/connection_adapters/abstract_adapter.rb
+- lib/active_record/comments/connection_adapters/abstract_sqlite_adapter.rb
+- lib/active_record/comments/connection_adapters/comment_definition.rb
+- lib/active_record/comments/connection_adapters/mysql2_adapter.rb
+- lib/active_record/comments/connection_adapters/mysql_adapter.rb
+- lib/active_record/comments/connection_adapters/postgresql_adapter.rb
+- lib/active_record/comments/connection_adapters/sqlite3_adapter.rb
+- lib/active_record/comments/connection_adapters/sqlite_adapter.rb
+- lib/active_record/comments/version.rb
+- spec/activerecord_comments_spec.rb
+- spec/config/database.yml
+- spec/spec_helper.rb
+homepage: https://github.com/mcbuddha/activerecord-comments
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Comments for SQL schemas
+test_files:
+- spec/activerecord_comments_spec.rb
+- spec/config/database.yml
+- spec/spec_helper.rb