schema_comments 0.4.3 → 0.5.0

data/VERSION

@@ -1 +0,0 @@
-0.2.0

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "schema_comments"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start

data/bin/setup

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-IFS=$'\n\t'
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/init.rb

@@ -1,4 +0,0 @@
-unless ENV['SCHEMA_COMMENTS_DISABLED']
-  require 'schema_comments'
-  SchemaComments.setup
-end

data/lib/annotate_models.rb

@@ -1,234 +0,0 @@
-
-# fork from
-# http://github.com/rotuka/annotate_models/blob/d2afee82020dbc592b147d92f9beeadbf665a9e0/lib/annotate_models.rb
-
-require 'rails'
-
-require "config/environment" if File.exist?("config/environment")
-
-MODEL_DIR         = Rails.root.join("app/models" )
-UNIT_TEST_DIR     = Rails.root.join("test/unit"  )
-SPEC_MODEL_DIR    = Rails.root.join("spec/models")
-FIXTURES_DIR      = Rails.root.join("test/fixtures")
-SPEC_FIXTURES_DIR = Rails.root.join("spec/fixtures")
-
-module AnnotateModels
-
-  PREFIX_AT_BOTTOM = "== Schema Info"
-  SUFFIX_AT_BOTTOM = ""
-  PREFIX_ON_TOP = "== Schema Info =="
-  SUFFIX_ON_TOP = "=================\n# "
-
-  # ENV options
-  {:position => 'top', :model_dir => MODEL_DIR}.each do |name, default_value|
-    mattr_accessor name.to_sym
-    self.send("#{name}=", ENV[name.to_s.upcase] || default_value)
-  end
-
-  def self.models
-    (ENV['MODELS'] || '').split(',')
-  end
-
-  def self.sort_columns
-    ENV['SORT'] =~ /yes|on|true/i
-  end
-
-  def self.output_prefix
-    bottom? ? PREFIX_AT_BOTTOM : PREFIX_ON_TOP
-  end
-
-  def self.output_suffix
-    bottom? ? SUFFIX_AT_BOTTOM : SUFFIX_ON_TOP
-  end
-
-  def self.bottom?
-    self.position =~ /bottom/i
-  end
-
-  def self.separate?
-    ENV['SEPARATE'] =~ /yes|on|true/i
-  end
-
-
-  # Simple quoting for the default column value
-  def self.quote(value)
-    case value
-    when NilClass                 then "NULL"
-    when TrueClass                then "TRUE"
-    when FalseClass               then "FALSE"
-    when Float, Fixnum, Bignum    then value.to_s.inspect
-      # BigDecimals need to be output in a non-normalized form and quoted.
-    when BigDecimal               then value.to_s('F')
-    else
-      value.inspect
-    end
-  end
-
-  # Use the column information in an ActiveRecord class
-  # to create a comment block containing a line for
-  # each column. The line contains the column name,
-  # the type (and length), and any optional attributes
-  def self.get_schema_info(klass)
-    table_info = "# Table name: #{klass.table_name}"
-    table_info << " # #{klass.table_comment}" unless klass.table_comment.blank?
-    table_info << "\n#\n"
-    max_size = klass.column_names.collect{|name| name.size}.max + 1
-
-    columns = klass.columns
-
-    cols = if self.sort_columns
-             pk    = columns.find_all { |col| col.name == klass.primary_key }.flatten
-             assoc = columns.find_all { |col| col.name.match(/_id$/) }.sort_by(&:name)
-             dates = columns.find_all { |col| col.name.match(/_on$/) }.sort_by(&:name)
-             times = columns.find_all { |col| col.name.match(/_at$/) }.sort_by(&:name)
-             pk + assoc + (columns - pk - assoc - times - dates).compact.sort_by(&:name) + dates + times
-           else
-             columns
-           end
-
-    col_lines = append_comments(cols.map{|col| [col, annotate_column(col, klass, max_size)]})
-    cols_text = col_lines.join("\n")
-
-    result = "# #{self.output_prefix}\n# \n# Schema version: #{get_schema_version}\n#\n"
-    result << table_info
-    result << cols_text
-    result << "\n# \n# #{self.output_suffix}" unless self.output_suffix.blank?
-    result << "\n"
-    result
-  end
-
-  def self.annotate_column(col, klass, max_size)
-    col_type = col.type.to_s
-    attrs = []
-    attrs << "not null" unless col.null
-    if col.default
-      default_value =
-        case col_type
-        when "decimal" then col.default.to_s.sub(/\.0+\z/, '.0')
-        else col.default
-        end
-      attrs << "default(#{quote(default_value)})"
-    end
-    attrs << "primary key" if col.name == klass.primary_key
-
-    case col_type
-    when "decimal" then
-      col_type << "(#{col.precision}, #{col.scale})"
-    else
-      col_type << "(#{col.limit})" if col.limit
-    end
-    sprintf("#  %-#{max_size}s:%-15s %s", col.name, col_type, attrs.join(", ")).rstrip
-  end
-
-  def self.append_comments(col_and_lines)
-    max_length = col_and_lines.map{|(col, line)| line.length}.max
-    col_and_lines.map do |(col, line)|
-      if col.comment.blank?
-        line
-      else
-        "%-#{max_length}s # %s" % [line, col.comment]
-      end
-    end
-  end
-
-  # Add a schema block to a file. If the file already contains
-  # a schema info block (a comment starting
-  # with "Schema as of ..."), remove it first.
-  # Mod to write to the end of the file
-  def self.annotate_one_file(file_name, info_block)
-    if File.exist?(file_name)
-      content = File.read(file_name)
-
-      encoding_comment = content.scan(/^\#\s*-\*-(.+?)-\*-/).flatten.first
-      content.sub!(/^\#\s*-\*-(.+?)-\*-/, '')
-
-      # Remove old schema info
-      content.sub!(/(\n)*^# #{PREFIX_ON_TOP}.*?\n(#.*\n)*# #{SUFFIX_ON_TOP}/, '')
-      content.sub!(/(\n)*^# #{PREFIX_AT_BOTTOM}.*?\n(#.*\n)*#.*(\n)*/, '')
-      content.sub!(/^[\n\s]*/, '')
-
-      # Write it back
-      File.open(file_name, "w") do |f|
-        f.print "# -*- #{encoding_comment.strip} -*-\n\n" unless encoding_comment.blank?
-        if self.bottom?
-          f.print content
-          f.print "\n\n"
-          f.print info_block
-        else
-          f.print info_block
-          f.print "\n" if self.separate?
-          f.print content
-        end
-      end
-    end
-  end
-
-
-  # Given the name of an ActiveRecord class, create a schema
-  # info block (basically a comment containing information
-  # on the columns and their types) and put it at the front
-  # of the model and fixture source files.
-  def self.annotate(klass)
-    info = get_schema_info(klass)
-    model_name = klass.name.underscore
-    fixtures_name = "#{klass.table_name}.yml"
-
-    [
-      File.join(self.model_dir,     "#{model_name}.rb"),      # model
-      File.join(UNIT_TEST_DIR,      "#{model_name}_test.rb"), # test
-      File.join(FIXTURES_DIR,       fixtures_name),           # fixture
-      File.join(SPEC_MODEL_DIR,     "#{model_name}_spec.rb"), # spec
-      File.join(SPEC_FIXTURES_DIR,  fixtures_name),           # spec fixture
-      Rails.root.join(        'test', 'factories.rb'),  # factories file
-      Rails.root.join(        'spec', 'factories.rb'),  # factories file
-    ].each { |file| annotate_one_file(file, info) }
-  end
-
-  # Return a list of the model files to annotate. If we have
-  # command line arguments, they're assumed to be either
-  # the underscore or CamelCase versions of model names.
-  # Otherwise we take all the model files in the
-  # app/models directory.
-  def self.get_model_names
-    result = nil
-    if self.models.empty?
-      Dir.chdir(self.model_dir) do
-        result = Dir["**/*.rb"].map do |filename|
-          filename.sub(/\.rb$/, '').camelize
-        end
-      end
-    else
-      result = self.models.dup
-    end
-    result
-  end
-
-  # We're passed a name of things that might be
-  # ActiveRecord models. If we can find the class, and
-  # if its a subclass of ActiveRecord::Base,
-  # then pas it to the associated block
-  def self.do_annotations
-    annotated = self.get_model_names.inject([]) do |list, class_name|
-      begin
-        # klass = class_name.split('::').inject(Object){ |klass,part| klass.const_get(part) }
-        klass = class_name.constantize
-        if klass < ActiveRecord::Base && !klass.abstract_class?
-          list << class_name
-          self.annotate(klass)
-        end
-      rescue Exception => e
-        puts "Unable to annotate #{class_name}: #{e.message}"
-      end
-      list
-    end
-    puts "Annotated #{annotated.join(', ')}"
-  end
-
-  def self.get_schema_version
-    unless @schema_version
-      version = ActiveRecord::Migrator.current_version rescue 0
-      @schema_version = version > 0 ? version : ''
-    end
-    @schema_version
-  end
-end

data/lib/schema_comments/base.rb

@@ -1,69 +0,0 @@
-module SchemaComments
-  module Base
-    def self.prepended(mod)
-      mod.singleton_class.prepend ClassMethods
-      mod.ignore_pattern_to_export_i18n = /\[.*\]/
-    end
-
-    module ClassMethods
-      def table_comment
-        @table_comment ||= connection.table_comment(table_name)
-      end
-
-      def columns
-        result = super
-        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 :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/migration.rb

@@ -1,16 +0,0 @@
-module SchemaComments
-  module Migration
-    def self.prepended(mod)
-      mod.singleton_class.prepend(ClassMethods)
-    end
-
-    module ClassMethods
-      def migrate(*args, &block)
-        SchemaComments::SchemaComment.yaml_access do
-          super(*args, &block)
-        end
-      end
-    end
-
-  end
-end

data/lib/schema_comments/migrator.rb

@@ -1,16 +0,0 @@
-module SchemaComments
-  module Migrator
-    def self.prepend(mod)
-      mod.singleton_class.prepend(ClassMethods)
-    end
-
-    module ClassMethods
-      def migrate(*args, &block)
-        SchemaComments::SchemaComment.yaml_access do
-          super(*args, &block)
-        end
-      end
-    end
-
-  end
-end

data/lib/schema_comments/tasks/alter_comments.rake

@@ -1,53 +0,0 @@
-namespace :db do
-  namespace :schema do
-    namespace :comments do
-
-      desc "update #{SchemaComments.yaml_path} from mysql comments of tables and columns"
-      task :dump => :environment do
-        conn = ActiveRecord::Base.connection
-        db_table_comments = conn.select_all("SHOW TABLE STATUS").each_with_object({}){|row, d| d[row["Name"]] = row["Comment"]}
-        column_comments = {}
-        db_table_comments.keys.each do |t|
-          column_comments[t] = conn.select_all("SHOW FULL COLUMNS FROM #{t}").each_with_object({}){|row, d| d[row["Field"]] = row["Comment"]}
-        end
-        root = {"table_comments" => db_table_comments, "column_comments" => column_comments}
-        SchemaComments::SchemaComment::SortedStore.sort_yaml_content!(root)
-        open(SchemaComments.yaml_path, "w"){|f| f.puts root.to_yaml }
-      end
-
-      desc "load #{SchemaComments.yaml_path} and alter table for mysql comments"
-      task :load => :environment do
-        conn = ActiveRecord::Base.connection
-        creation = ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation.new(conn)
-
-        db_tables = conn.tables
-        db_table_comments = conn.select_all("SHOW TABLE STATUS").each_with_object({}){|row, d| d[row["Name"]] = row["Comment"]}
-        root = YAML.load_file(SchemaComments.yaml_path)
-        column_comments_root = root["column_comments"]
-        root["table_comments"].each do |t, t_comment|
-          unless db_tables.include?(t)
-            $stderr.puts "\e[33mtable #{t.inspect} doesn't exist\e[0m"
-            next
-          end
-          unless t_comment == db_table_comments[t]
-            conn.execute("ALTER TABLE #{t} COMMENT '#{t_comment}'")
-          end
-
-          column_hash = conn.columns(t).each_with_object({}){|c, d| d[c.name] = c}
-          db_column_comments = conn.select_all("SHOW FULL COLUMNS FROM #{t}").each_with_object({}){|row, d| d[row["Field"]] = row["Comment"]}
-          column_comments = column_comments_root[t]
-          column_comments.each do |c, c_comment|
-            unless c_comment == db_column_comments[t]
-              if col = column_hash[c]
-                opts = col.sql_type.dup
-                creation.send(:add_column_options!, opts, column: col, null: col.null, default: col.default, auto_increment: (col.extra == "auto_increment"))
-                conn.execute("ALTER TABLE #{t} MODIFY #{c} #{opts} COMMENT '#{c_comment}'")
-              end
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/schema_comments/tasks/annotate_models_tasks.rake

@@ -1,12 +0,0 @@
-# Original file
-# http://github.com/rotuka/annotate_models/blob/d2afee82020dbc592b147d92f9beeadbf665a9e0/tasks/annotate_models_tasks.rake
-namespace :db do
-  desc "Add schema information (as comments) to model files"
-  task :annotate => :environment do
-    require File.join(File.dirname(__FILE__), "../lib/annotate_models.rb")
-    AnnotateModels.do_annotations
-  end
- 
-  desc "Updates database (migrate and annotate models)"
-  task :update => %w(migrate annotate)
-end