annotate 2.7.4 → 3.1.1

data/RELEASE.md

@@ -0,0 +1,19 @@
+## Prerequisite 
+
+- Install "git-flow" (`brew install git-flow`)
+- Install "bump" gem (`gem install bump`)
+
+
+## Perform a release
+
+- `git flow release start <release>`
+- Update the `CHANGELOG.md` file
+- `bump current`
+- `bump patch`
+- `rm -rf dist`
+- `rake spec`
+- `rake gem`
+- `git flow release finish <release>`
+
+- `rake gem:publish`
+

data/annotate.gemspec

@@ -7,42 +7,23 @@ Gem::Specification.new do |s|
   s.name = 'annotate'
   s.version = Annotate.version
 
-  s.required_ruby_version = '>= 2.2.0'
+  s.required_ruby_version = '>= 2.4.0'
   s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
   s.authors = ['Alex Chaffee', 'Cuong Tran', 'Marcos Piccinini', 'Turadg Aleahmad', 'Jon Frisby']
   s.description = 'Annotates Rails/ActiveRecord Models, routes, fixtures, and others based on the database schema.'
   s.email = ['alex@stinky.com', 'cuong.tran@gmail.com', 'x@nofxx.com', 'turadg@aleahmad.net', 'jon@cloudability.com']
   s.executables = ['annotate']
-  s.extra_rdoc_files = ['README.rdoc', 'CHANGELOG.rdoc', 'TODO.rdoc']
-  s.files = [
-    'AUTHORS.rdoc',
-    'CHANGELOG.rdoc',
-    'LICENSE.txt',
-    'README.rdoc',
-    'TODO.rdoc',
-    'annotate.gemspec',
-    'bin/annotate',
-    'lib/annotate.rb',
-    'lib/annotate/active_record_patch.rb',
-    'lib/annotate/annotate_models.rb',
-    'lib/annotate/annotate_routes.rb',
-    'lib/annotate/tasks.rb',
-    'lib/annotate/version.rb',
-    'lib/generators/annotate/USAGE',
-    'lib/generators/annotate/install_generator.rb',
-    'lib/generators/annotate/templates/auto_annotate_models.rake',
-    'lib/tasks/annotate_models.rake',
-    'lib/tasks/annotate_routes.rake',
-    'lib/tasks/annotate_models_migrate.rake'
-  ]
+  s.extra_rdoc_files = ['README.md', 'CHANGELOG.md']
+  s.files = `git ls-files -z LICENSE.txt *.md *.gemspec bin lib`.split("\x0")
   s.homepage = 'http://github.com/ctran/annotate_models'
   s.licenses = ['Ruby']
   s.require_paths = ['lib']
-  s.rubyforge_project = 'annotate'
   s.rubygems_version = '2.1.11'
   s.summary = 'Annotates Rails Models, routes, fixtures, and others based on the database schema.'
 
   s.specification_version = 4 if s.respond_to? :specification_version
-  s.add_runtime_dependency(%q<rake>, ['>= 10.4', '< 13.0'])
-  s.add_runtime_dependency(%q<activerecord>, ['>= 3.2', '< 6.0'])
+  s.add_runtime_dependency(%q<rake>, '>= 10.4', '< 14.0')
+  s.add_runtime_dependency(%q<activerecord>, ['>= 3.2', '< 7.0'])
+
+  s.metadata = { "github_repo" => "ssh://github.com/ctran/annotate_models" }
 end

data/bin/annotate

@@ -14,199 +14,19 @@ end
 here = File.expand_path(File.dirname __FILE__)
 $LOAD_PATH << "#{here}/../lib"
 
-require 'optparse'
 require 'annotate'
-Annotate.bootstrap_rake
-
-has_set_position = {}
-target_action = :do_annotations
-positions = %w(before top after bottom)
-
-OptionParser.new do |opts|
-  opts.banner = 'Usage: annotate [options] [model_file]*'
-
-  opts.on('-d', '--delete', 'Remove annotations from all model files or the routes.rb file') do
-    target_action = :remove_annotations
-  end
-
-  opts.on('-p', '--position [before|top|after|bottom]', positions,
-          'Place the annotations at the top (before) or the bottom (after) of the model/test/fixture/factory/route/serializer file(s)') do |p|
-    ENV['position'] = p
-    %w(position_in_class position_in_factory position_in_fixture position_in_test position_in_routes position_in_serializer).each do |key|
-      ENV[key] = p unless has_set_position[key]
-    end
-  end
-
-  opts.on('--pc', '--position-in-class [before|top|after|bottom]', positions,
-          'Place the annotations at the top (before) or the bottom (after) of the model file') do |p|
-    ENV['position_in_class'] = p
-    has_set_position['position_in_class'] = true
-  end
-
-  opts.on('--pf', '--position-in-factory [before|top|after|bottom]', positions,
-          'Place the annotations at the top (before) or the bottom (after) of any factory files') do |p|
-    ENV['position_in_factory'] = p
-    has_set_position['position_in_factory'] = true
-  end
-
-  opts.on('--px', '--position-in-fixture [before|top|after|bottom]', positions,
-          'Place the annotations at the top (before) or the bottom (after) of any fixture files') do |p|
-    ENV['position_in_fixture'] = p
-    has_set_position['position_in_fixture'] = true
-  end
-
-  opts.on('--pt', '--position-in-test [before|top|after|bottom]', positions,
-          'Place the annotations at the top (before) or the bottom (after) of any test files') do |p|
-    ENV['position_in_test'] = p
-    has_set_position['position_in_test'] = true
-  end
-
-  opts.on('--pr', '--position-in-routes [before|top|after|bottom]', positions,
-          'Place the annotations at the top (before) or the bottom (after) of the routes.rb file') do |p|
-    ENV['position_in_routes'] = p
-    has_set_position['position_in_routes'] = true
-  end
-
-  opts.on('--ps', '--position-in-serializer [before|top|after|bottom]', positions,
-          'Place the annotations at the top (before) or the bottom (after) of the serializer files') do |p|
-    ENV['position_in_serializer'] = p
-    has_set_position['position_in_serializer'] = true
-  end
-
-  opts.on('--w', '--wrapper STR', 'Wrap annotation with the text passed as parameter.',
-          'If --w option is used, the same text will be used as opening and closing') do |p|
-    ENV['wrapper'] = p
-  end
-
-  opts.on('--wo', '--wrapper-open STR', 'Annotation wrapper opening.') do |p|
-    ENV['wrapper_open'] = p
-  end
-
-  opts.on('--wc', '--wrapper-close STR', 'Annotation wrapper closing') do |p|
-    ENV['wrapper_close'] = p
-  end
-
-  opts.on('-r', '--routes', "Annotate routes.rb with the output of 'rake routes'") do
-    ENV['routes'] = 'true'
-  end
-
-  opts.on('-a', '--active-admin', 'Annotate active_admin models') do
-    ENV['active_admin'] = 'true'
-  end
-
-  opts.on('-v', '--version', 'Show the current version of this gem') do
-    puts "annotate v#{Annotate.version}"; exit
-  end
-
-  opts.on('-m', '--show-migration', 'Include the migration version number in the annotation') do
-    ENV['include_version'] = 'yes'
-  end
-
-  opts.on('-k', '--show-foreign-keys',
-          "List the table's foreign key constraints in the annotation") do
-    ENV['show_foreign_keys'] = 'yes'
-  end
+require 'annotate/parser'
 
-  opts.on('--ck',
-          '--complete-foreign-keys', 'Complete foreign key names in the annotation') do
-    ENV['show_foreign_keys'] = 'yes'
-    ENV['show_complete_foreign_keys'] = 'yes'
-  end
-
-  opts.on('-i', '--show-indexes',
-          "List the table's database indexes in the annotation") do
-    ENV['show_indexes'] = 'yes'
-  end
-
-  opts.on('-s', '--simple-indexes',
-          "Concat the column's related indexes in the annotation") do
-    ENV['simple_indexes'] = 'yes'
-  end
-
-  opts.on('--model-dir dir',
-          "Annotate model files stored in dir rather than app/models, separate multiple dirs with commas") do |dir|
-    ENV['model_dir'] = dir
-  end
-
-  opts.on('--root-dir dir',
-          "Annotate files stored within root dir projects, separate multiple dirs with commas") do |dir|
-    ENV['root_dir'] = dir
-  end
-
-  opts.on('--ignore-model-subdirects',
-          "Ignore subdirectories of the models directory") do |dir|
-    ENV['ignore_model_sub_dir'] = 'yes'
-  end
-
-  opts.on('--sort',
-          "Sort columns alphabetically, rather than in creation order") do |dir|
-    ENV['sort'] = 'yes'
-  end
-
-  opts.on('--classified-sort',
-          "Sort columns alphabetically, but first goes id, then the rest columns, then the timestamp columns and then the association columns") do |dir|
-    ENV['classified_sort'] = 'yes'
-  end
-
-  opts.on('-R', '--require path',
-          "Additional file to require before loading models, may be used multiple times") do |path|
-    if !ENV['require'].blank?
-      ENV['require'] = ENV['require'] + ",#{path}"
-    else
-      ENV['require'] = path
-    end
-  end
-
-  opts.on('-e', '--exclude [tests,fixtures,factories,serializers]', Array, "Do not annotate fixtures, test files, factories, and/or serializers") do |exclusions|
-    exclusions ||= %w(tests fixtures factories)
-    exclusions.each { |exclusion| ENV["exclude_#{exclusion}"] = 'yes' }
-  end
-
-  opts.on('-f', '--format [bare|rdoc|markdown]', %w(bare rdoc markdown), 'Render Schema Infomation as plain/RDoc/Markdown') do |fmt|
-    ENV["format_#{fmt}"] = 'yes'
-  end
-
-  opts.on('--force', 'Force new annotations even if there are no changes.') do |force|
-    ENV['force'] = 'yes'
-  end
-
-  opts.on('--timestamp', 'Include timestamp in (routes) annotation') do
-    ENV['timestamp'] = 'true'
-  end
-
-  opts.on('--trace', 'If unable to annotate a file, print the full stack trace, not just the exception message.') do |value|
-    ENV['trace'] = 'yes'
-  end
-
-  opts.on('-I', '--ignore-columns REGEX', "don't annotate columns that match a given REGEX (i.e., `annotate -I '^(id|updated_at|created_at)'`") do |regex|
-    ENV['ignore_columns'] = regex
-  end
-
-  opts.on('--ignore-routes REGEX', "don't annotate routes that match a given REGEX (i.e., `annotate -I '(mobile|resque|pghero)'`") do |regex|
-    ENV['ignore_routes'] = regex
-  end
-
-  opts.on('--hide-limit-column-types VALUES', "don't show limit for given column types, separated by commas (i.e., `integer,boolean,text`)") do |values|
-    ENV['hide_limit_column_types'] = "#{values}"
-  end
-
-  opts.on('--hide-default-column-types VALUES', "don't show default for given column types, separated by commas (i.e., `json,jsonb,hstore`)") do |values|
-    ENV['hide_default_column_types'] = "#{values}"
-  end
+Annotate.bootstrap_rake
 
-  opts.on('--ignore-unknown-models', "don't display warnings for bad model files") do |values|
-    ENV['ignore_unknown_models'] = 'true'
-  end
+options_result = Annotate::Parser.parse(ARGV)
 
-  opts.on('--with-comment', "include database comments in model annotations") do |values|
-    ENV['with_comment'] = 'true'
-  end
-end.parse!
+exit if options_result[:exit]
 
 options = Annotate.setup_options(
   is_rake: ENV['is_rake'] && !ENV['is_rake'].empty?
 )
-Annotate.eager_load(options) if Annotate.include_models?
+Annotate.eager_load(options) if Annotate::Helpers.include_models?
 
-AnnotateModels.send(target_action, options) if Annotate.include_models?
-AnnotateRoutes.send(target_action, options) if Annotate.include_routes?
+AnnotateModels.send(options_result[:target_action], options) if Annotate::Helpers.include_models?
+AnnotateRoutes.send(options_result[:target_action], options) if Annotate::Helpers.include_routes?

data/lib/annotate.rb

@@ -1,9 +1,9 @@
-# rubocop:disable  Metrics/ModuleLength
-
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'annotate/version'
 require 'annotate/annotate_models'
 require 'annotate/annotate_routes'
+require 'annotate/constants'
+require 'annotate/helpers'
 
 begin
   # ActiveSupport 3.x...
@@ -16,38 +16,6 @@ rescue StandardError
 end
 
 module Annotate
-  TRUE_RE = /^(true|t|yes|y|1)$/i
-
-  ##
-  # The set of available options to customize the behavior of Annotate.
-  #
-  POSITION_OPTIONS = [
-    :position_in_routes, :position_in_class, :position_in_test,
-    :position_in_fixture, :position_in_factory, :position,
-    :position_in_serializer
-  ].freeze
-  FLAG_OPTIONS = [
-    :show_indexes, :simple_indexes, :include_version, :exclude_tests,
-    :exclude_fixtures, :exclude_factories, :ignore_model_sub_dir,
-    :format_bare, :format_rdoc, :format_markdown, :sort, :force, :trace,
-    :timestamp, :exclude_serializers, :classified_sort,
-    :show_foreign_keys, :show_complete_foreign_keys,
-    :exclude_scaffolds, :exclude_controllers, :exclude_helpers,
-    :exclude_sti_subclasses, :ignore_unknown_models, :with_comment
-  ].freeze
-  OTHER_OPTIONS = [
-    :ignore_columns, :skip_on_db_migrate, :wrapper_open, :wrapper_close,
-    :wrapper, :routes, :hide_limit_column_types, :hide_default_column_types,
-    :ignore_routes, :active_admin
-  ].freeze
-  PATH_OPTIONS = [
-    :require, :model_dir, :root_dir
-  ].freeze
-
-  def self.all_options
-    [POSITION_OPTIONS, FLAG_OPTIONS, PATH_OPTIONS, OTHER_OPTIONS]
-  end
-
   ##
   # Set default values that can be overridden via environment variables.
   #
@@ -55,9 +23,9 @@ module Annotate
     return if @has_set_defaults
     @has_set_defaults = true
 
-    options = HashWithIndifferentAccess.new(options)
+    options = ActiveSupport::HashWithIndifferentAccess.new(options)
 
-    all_options.flatten.each do |key|
+    Constants::ALL_ANNOTATE_OPTIONS.flatten.each do |key|
       if options.key?(key)
         default_value = if options[key].is_a?(Array)
                           options[key].join(',')
@@ -75,68 +43,42 @@ module Annotate
   # TODO: what is the difference between this and set_defaults?
   #
   def self.setup_options(options = {})
-    POSITION_OPTIONS.each do |key|
-      options[key] = fallback(ENV[key.to_s], ENV['position'], 'before')
+    Constants::POSITION_OPTIONS.each do |key|
+      options[key] = Annotate::Helpers.fallback(ENV[key.to_s], ENV['position'], 'before')
     end
-    FLAG_OPTIONS.each do |key|
-      options[key] = true?(ENV[key.to_s])
+    Constants::FLAG_OPTIONS.each do |key|
+      options[key] = Annotate::Helpers.true?(ENV[key.to_s])
     end
-    OTHER_OPTIONS.each do |key|
+    Constants::OTHER_OPTIONS.each do |key|
       options[key] = !ENV[key.to_s].blank? ? ENV[key.to_s] : nil
     end
-    PATH_OPTIONS.each do |key|
+    Constants::PATH_OPTIONS.each do |key|
       options[key] = !ENV[key.to_s].blank? ? ENV[key.to_s].split(',') : []
     end
 
+    options[:additional_file_patterns] ||= []
+    options[:additional_file_patterns] = options[:additional_file_patterns].split(',') if options[:additional_file_patterns].is_a?(String)
     options[:model_dir] = ['app/models'] if options[:model_dir].empty?
 
     options[:wrapper_open] ||= options[:wrapper]
     options[:wrapper_close] ||= options[:wrapper]
 
     # These were added in 2.7.0 but so this is to revert to old behavior by default
-    options[:exclude_scaffolds] = Annotate.true?(ENV.fetch('exclude_scaffolds', 'true'))
-    options[:exclude_controllers] = Annotate.true?(ENV.fetch('exclude_controllers', 'true'))
-    options[:exclude_helpers] = Annotate.true?(ENV.fetch('exclude_helpers', 'true'))
+    options[:exclude_scaffolds] = Annotate::Helpers.true?(ENV.fetch('exclude_scaffolds', 'true'))
+    options[:exclude_controllers] = Annotate::Helpers.true?(ENV.fetch('exclude_controllers', 'true'))
+    options[:exclude_helpers] = Annotate::Helpers.true?(ENV.fetch('exclude_helpers', 'true'))
 
     options
   end
 
-  def self.reset_options
-    all_options.flatten.each { |key| ENV[key.to_s] = nil }
-  end
-
-  def self.skip_on_migration?
-    ENV['ANNOTATE_SKIP_ON_DB_MIGRATE'] =~ TRUE_RE || ENV['skip_on_db_migrate'] =~ TRUE_RE
-  end
-
-  def self.include_routes?
-    ENV['routes'] =~ TRUE_RE
-  end
-
-  def self.include_models?
-    ENV['routes'] !~ TRUE_RE
-  end
-
-  def self.loaded_tasks=(val)
-    @loaded_tasks = val
-  end
-
-  def self.loaded_tasks
-    @loaded_tasks
-  end
-
   def self.load_tasks
-    return if loaded_tasks
-    self.loaded_tasks = true
+    return if @tasks_loaded
 
     Dir[File.join(File.dirname(__FILE__), 'tasks', '**/*.rake')].each do |rake|
       load rake
     end
-  end
 
-  def self.load_requires(options)
-    options[:require].count > 0 &&
-      options[:require].each { |path| require path }
+    @tasks_loaded = true
   end
 
   def self.eager_load(options)
@@ -192,13 +134,12 @@ module Annotate
     Rake::Task[:set_annotation_options].invoke
   end
 
-  def self.fallback(*args)
-    args.detect { |arg| !arg.blank? }
-  end
+  class << self
+    private
 
-  def self.true?(val)
-    return false if val.blank?
-    return false unless val =~ TRUE_RE
-    true
+    def load_requires(options)
+      options[:require].count > 0 &&
+        options[:require].each { |path| require path }
+    end
   end
 end

data/lib/annotate/annotate_models.rb

@@ -2,9 +2,9 @@
 
 require 'bigdecimal'
 
-module AnnotateModels
-  TRUE_RE = /^(true|t|yes|y|1)$/i
+require 'annotate/constants'
 
+module AnnotateModels
   # Annotate Models plugin use this header
   COMPAT_PREFIX    = '== Schema Info'.freeze
   COMPAT_PREFIX_MD = '## Schema Info'.freeze
@@ -38,9 +38,9 @@ module AnnotateModels
   BLUEPRINTS_TEST_DIR   = File.join('test', "blueprints")
   BLUEPRINTS_SPEC_DIR   = File.join('spec', "blueprints")
 
-  # Factory Girl http://github.com/thoughtbot/factory_girl
-  FACTORY_GIRL_TEST_DIR = File.join('test', "factories")
-  FACTORY_GIRL_SPEC_DIR = File.join('spec', "factories")
+  # Factory Bot https://github.com/thoughtbot/factory_bot
+  FACTORY_BOT_TEST_DIR = File.join('test', "factories")
+  FACTORY_BOT_SPEC_DIR = File.join('spec', "factories")
 
   # Fabrication https://github.com/paulelliott/fabrication.git
   FABRICATORS_TEST_DIR  = File.join('test', "fabricators")
@@ -62,7 +62,7 @@ module AnnotateModels
 
   # Don't show limit (#) on these column types
   # Example: show "integer" instead of "integer(4)"
-  NO_LIMIT_COL_TYPES = %w(integer boolean).freeze
+  NO_LIMIT_COL_TYPES = %w(integer bigint boolean).freeze
 
   # Don't show default value for these column types
   NO_DEFAULT_COL_TYPES = %w(json jsonb hstore).freeze
@@ -82,6 +82,8 @@ module AnnotateModels
     }
   }.freeze
 
+  MAGIC_COMMENT_MATCHER = Regexp.new(/(^#\s*encoding:.*(?:\n|r\n))|(^# coding:.*(?:\n|\r\n))|(^# -\*- coding:.*(?:\n|\r\n))|(^# -\*- encoding\s?:.*(?:\n|\r\n))|(^#\s*frozen_string_literal:.+(?:\n|\r\n))|(^# -\*- frozen_string_literal\s*:.+-\*-(?:\n|\r\n))/).freeze
+
   class << self
     def annotate_pattern(options = {})
       if options[:wrapper_open]
@@ -140,12 +142,12 @@ module AnnotateModels
         File.join(root_directory, EXEMPLARS_SPEC_DIR,     "%MODEL_NAME%_exemplar.rb"),
         File.join(root_directory, BLUEPRINTS_TEST_DIR,    "%MODEL_NAME%_blueprint.rb"),
         File.join(root_directory, BLUEPRINTS_SPEC_DIR,    "%MODEL_NAME%_blueprint.rb"),
-        File.join(root_directory, FACTORY_GIRL_TEST_DIR,  "%MODEL_NAME%_factory.rb"),    # (old style)
-        File.join(root_directory, FACTORY_GIRL_SPEC_DIR,  "%MODEL_NAME%_factory.rb"),    # (old style)
-        File.join(root_directory, FACTORY_GIRL_TEST_DIR,  "%TABLE_NAME%.rb"),            # (new style)
-        File.join(root_directory, FACTORY_GIRL_SPEC_DIR,  "%TABLE_NAME%.rb"),            # (new style)
-        File.join(root_directory, FACTORY_GIRL_TEST_DIR,  "%PLURALIZED_MODEL_NAME%.rb"), # (new style)
-        File.join(root_directory, FACTORY_GIRL_SPEC_DIR,  "%PLURALIZED_MODEL_NAME%.rb"), # (new style)
+        File.join(root_directory, FACTORY_BOT_TEST_DIR,  "%MODEL_NAME%_factory.rb"),    # (old style)
+        File.join(root_directory, FACTORY_BOT_SPEC_DIR,  "%MODEL_NAME%_factory.rb"),    # (old style)
+        File.join(root_directory, FACTORY_BOT_TEST_DIR,  "%TABLE_NAME%.rb"),            # (new style)
+        File.join(root_directory, FACTORY_BOT_SPEC_DIR,  "%TABLE_NAME%.rb"),            # (new style)
+        File.join(root_directory, FACTORY_BOT_TEST_DIR,  "%PLURALIZED_MODEL_NAME%.rb"), # (new style)
+        File.join(root_directory, FACTORY_BOT_SPEC_DIR,  "%PLURALIZED_MODEL_NAME%.rb"), # (new style)
         File.join(root_directory, FABRICATORS_TEST_DIR,   "%MODEL_NAME%_fabricator.rb"),
         File.join(root_directory, FABRICATORS_SPEC_DIR,   "%MODEL_NAME%_fabricator.rb")
       ]
@@ -154,18 +156,20 @@ module AnnotateModels
     def serialize_files(root_directory)
       [
         File.join(root_directory, SERIALIZERS_DIR,       "%MODEL_NAME%_serializer.rb"),
-        File.join(root_directory, SERIALIZERS_TEST_DIR,  "%MODEL_NAME%_serializer_spec.rb"),
+        File.join(root_directory, SERIALIZERS_TEST_DIR,  "%MODEL_NAME%_serializer_test.rb"),
         File.join(root_directory, SERIALIZERS_SPEC_DIR,  "%MODEL_NAME%_serializer_spec.rb")
       ]
     end
 
-    def files_by_pattern(root_directory, pattern_type)
+    def files_by_pattern(root_directory, pattern_type, options)
       case pattern_type
       when 'test'       then test_files(root_directory)
       when 'fixture'    then fixture_files(root_directory)
       when 'scaffold'   then scaffold_files(root_directory)
       when 'factory'    then factory_files(root_directory)
       when 'serializer' then serialize_files(root_directory)
+      when 'additional_file_patterns'
+        [options[:additional_file_patterns] || []].flatten
       when 'controller'
         [File.join(root_directory, CONTROLLER_DIR, "%PLURALIZED_MODEL_NAME%_controller.rb")]
       when 'admin'
@@ -177,14 +181,20 @@ module AnnotateModels
       end
     end
 
-    def get_patterns(pattern_types = [])
+    def get_patterns(options, pattern_types = [])
       current_patterns = []
       root_dir.each do |root_directory|
         Array(pattern_types).each do |pattern_type|
-          current_patterns += files_by_pattern(root_directory, pattern_type)
+          patterns = files_by_pattern(root_directory, pattern_type, options)
+
+          current_patterns += if pattern_type.to_sym == :additional_file_patterns
+                                patterns
+                              else
+                                patterns.map { |p| p.sub(/^[\/]*/, '') }
+                              end
         end
       end
-      current_patterns.map { |p| p.sub(/^[\/]*/, '') }
+      current_patterns
     end
 
     # Simple quoting for the default column value
@@ -236,16 +246,7 @@ module AnnotateModels
         info << "# #{ '-' * ( max_size + md_names_overhead ) } | #{'-' * md_type_allowance} | #{ '-' * 27 }\n"
       end
 
-      cols = if ignore_columns = options[:ignore_columns]
-               klass.columns.reject do |col|
-                 col.name.match(/#{ignore_columns}/)
-               end
-             else
-               klass.columns
-             end
-
-      cols = cols.sort_by(&:name) if options[:sort]
-      cols = classified_sort(cols) if options[:classified_sort]
+      cols = columns(klass, options)
       cols.each do |col|
         col_type = get_col_type(col)
         attrs = []
@@ -256,8 +257,8 @@ module AnnotateModels
 
         if col_type == 'decimal'
           col_type << "(#{col.precision}, #{col.scale})"
-        elsif col_type != 'spatial'
-          if col.limit
+        elsif !%w[spatial geometry geography].include?(col_type)
+          if col.limit && !options[:format_yard]
             if col.limit.is_a? Array
               attrs << "(#{col.limit.join(', ')})"
             else
@@ -296,12 +297,16 @@ module AnnotateModels
                    end
         if options[:format_rdoc]
           info << sprintf("# %-#{max_size}.#{max_size}s<tt>%s</tt>", "*#{col_name}*::", attrs.unshift(col_type).join(", ")).rstrip + "\n"
+        elsif options[:format_yard]
+          info << sprintf("# @!attribute #{col_name}") + "\n"
+          ruby_class = col.respond_to?(:array) && col.array ? "Array<#{map_col_type_to_ruby_classes(col_type)}>": map_col_type_to_ruby_classes(col_type)
+          info << sprintf("#   @return [#{ruby_class}]") + "\n"
         elsif options[:format_markdown]
-          name_remainder = max_size - col_name.length
+          name_remainder = max_size - col_name.length - non_ascii_length(col_name)
           type_remainder = (md_type_allowance - 2) - col_type.length
           info << (sprintf("# **`%s`**%#{name_remainder}s | `%s`%#{type_remainder}s | `%s`", col_name, " ", col_type, " ", attrs.join(", ").rstrip)).gsub('``', '  ').rstrip + "\n"
         else
-          info << sprintf("#  %-#{max_size}.#{max_size}s:%-#{bare_type_allowance}.#{bare_type_allowance}s %s", col_name, col_type, attrs.join(", ")).rstrip + "\n"
+          info << format_default(col_name, max_size, col_type, bare_type_allowance, attrs)
         end
       end
 
@@ -362,7 +367,7 @@ module AnnotateModels
     end
 
     def get_col_type(col)
-      if col.respond_to?(:bigint?) && col.bigint?
+      if (col.respond_to?(:bigint?) && col.bigint?) || /\Abigint\b/ =~ col.sql_type
         'bigint'
       else
         (col.type || col.sql_type).to_s
@@ -464,7 +469,10 @@ module AnnotateModels
       foreign_keys = klass.connection.foreign_keys(klass.table_name)
       return '' if foreign_keys.empty?
 
-      format_name = ->(fk) { options[:show_complete_foreign_keys] ? fk.name : fk.name.gsub(/(?<=^fk_rails_)[0-9a-f]{10}$/, '...') }
+      format_name = lambda do |fk|
+        return fk.options[:column] if fk.name.blank?
+        options[:show_complete_foreign_keys] ? fk.name : fk.name.gsub(/(?<=^fk_rails_)[0-9a-f]{10}$/, '...')
+      end
 
       max_size = foreign_keys.map(&format_name).map(&:size).max + 1
       foreign_keys.sort_by {|fk| [format_name.call(fk), fk.column]}.each do |fk|
@@ -498,64 +506,63 @@ module AnnotateModels
     #                           :before, :top, :after or :bottom. Default is :before.
     #
     def annotate_one_file(file_name, info_block, position, options = {})
-      if File.exist?(file_name)
-        old_content = File.read(file_name)
-        return false if old_content =~ /#{SKIP_ANNOTATION_PREFIX}.*\n/
+      return false unless File.exist?(file_name)
+      old_content = File.read(file_name)
+      return false if old_content =~ /#{SKIP_ANNOTATION_PREFIX}.*\n/
 
-        # Ignore the Schema version line because it changes with each migration
-        header_pattern = /(^# Table name:.*?\n(#.*[\r]?\n)*[\r]?)/
-        old_header = old_content.match(header_pattern).to_s
-        new_header = info_block.match(header_pattern).to_s
+      # Ignore the Schema version line because it changes with each migration
+      header_pattern = /(^# Table name:.*?\n(#.*[\r]?\n)*[\r]?)/
+      old_header = old_content.match(header_pattern).to_s
+      new_header = info_block.match(header_pattern).to_s
 
-        column_pattern = /^#[\t ]+[\w\*`]+[\t ]+.+$/
-        old_columns = old_header && old_header.scan(column_pattern).sort
-        new_columns = new_header && new_header.scan(column_pattern).sort
+      column_pattern = /^#[\t ]+[\w\*\.`]+[\t ]+.+$/
+      old_columns = old_header && old_header.scan(column_pattern).sort
+      new_columns = new_header && new_header.scan(column_pattern).sort
 
-        magic_comments_block = magic_comments_as_string(old_content)
+      return false if old_columns == new_columns && !options[:force]
 
-        if old_columns == new_columns && !options[:force]
-          return false
-        else
-          # Replace inline the old schema info with the new schema info
-          new_content = old_content.sub(annotate_pattern(options), info_block + "\n")
+      abort "annotate error. #{file_name} needs to be updated, but annotate was run with `--frozen`." if options[:frozen]
 
-          if new_content.end_with?(info_block + "\n")
-            new_content = old_content.sub(annotate_pattern(options), "\n" + info_block)
-          end
+      # Replace inline the old schema info with the new schema info
+      wrapper_open = options[:wrapper_open] ? "# #{options[:wrapper_open]}\n" : ""
+      wrapper_close = options[:wrapper_close] ? "# #{options[:wrapper_close]}\n" : ""
+      wrapped_info_block = "#{wrapper_open}#{info_block}#{wrapper_close}"
 
-          wrapper_open = options[:wrapper_open] ? "# #{options[:wrapper_open]}\n" : ""
-          wrapper_close = options[:wrapper_close] ? "# #{options[:wrapper_close]}\n" : ""
-          wrapped_info_block = "#{wrapper_open}#{info_block}#{wrapper_close}"
-          # if there *was* no old schema info (no substitution happened) or :force was passed,
-          # we simply need to insert it in correct position
-          if new_content == old_content || options[:force]
-            old_content.gsub!(magic_comment_matcher, '')
-            old_content.sub!(annotate_pattern(options), '')
-
-            new_content = if %w(after bottom).include?(options[position].to_s)
-                            magic_comments_block + (old_content.rstrip + "\n\n" + wrapped_info_block)
-                          else
-                            magic_comments_block + wrapped_info_block + "\n" + old_content
-                          end
-          end
+      old_annotation = old_content.match(annotate_pattern(options)).to_s
 
-          File.open(file_name, 'wb') { |f| f.puts new_content }
-          return true
-        end
+      # if there *was* no old schema info or :force was passed, we simply
+      # need to insert it in correct position
+      if old_annotation.empty? || options[:force]
+        magic_comments_block = magic_comments_as_string(old_content)
+        old_content.gsub!(MAGIC_COMMENT_MATCHER, '')
+        old_content.sub!(annotate_pattern(options), '')
+
+        new_content = if %w(after bottom).include?(options[position].to_s)
+                        magic_comments_block + (old_content.rstrip + "\n\n" + wrapped_info_block)
+                      elsif magic_comments_block.empty?
+                        magic_comments_block + wrapped_info_block + old_content.lstrip
+                      else
+                        magic_comments_block + "\n" + wrapped_info_block + old_content.lstrip
+                      end
       else
-        false
+        # replace the old annotation with the new one
+
+        # keep the surrounding whitespace the same
+        space_match = old_annotation.match(/\A(?<start>\s*).*?\n(?<end>\s*)\z/m)
+        new_annotation = space_match[:start] + wrapped_info_block + space_match[:end]
+
+        new_content = old_content.sub(annotate_pattern(options), new_annotation)
       end
-    end
 
-    def magic_comment_matcher
-      Regexp.new(/(^#\s*encoding:.*(?:\n|r\n))|(^# coding:.*(?:\n|\r\n))|(^# -\*- coding:.*(?:\n|\r\n))|(^# -\*- encoding\s?:.*(?:\n|\r\n))|(^#\s*frozen_string_literal:.+(?:\n|\r\n))|(^# -\*- frozen_string_literal\s*:.+-\*-(?:\n|\r\n))/)
+      File.open(file_name, 'wb') { |f| f.puts new_content }
+      true
     end
 
     def magic_comments_as_string(content)
-      magic_comments = content.scan(magic_comment_matcher).flatten.compact
+      magic_comments = content.scan(MAGIC_COMMENT_MATCHER).flatten.compact
 
       if magic_comments.any?
-        magic_comments.join + "\n"
+        magic_comments.join
       else
         ''
       end
@@ -578,8 +585,9 @@ module AnnotateModels
     end
 
     def matched_types(options)
-      types = MATCHED_TYPES
-      types << 'admin' if options[:active_admin] =~ TRUE_RE && !types.include?('admin')
+      types = MATCHED_TYPES.dup
+      types << 'admin' if options[:active_admin] =~ Annotate::Constants::TRUE_RE && !types.include?('admin')
+      types << 'additional_file_patterns' if options[:additional_file_patterns].present?
 
       types
     end
@@ -631,8 +639,11 @@ module AnnotateModels
           end
 
           next if options[exclusion_key]
-          get_patterns(key)
+
+          get_patterns(options, key)
             .map { |f| resolve_filename(f, model_name, table_name) }
+            .map { |f| expand_glob_into_files(f) }
+            .flatten
             .each do |f|
               if annotate_one_file(f, info, position_key, options_with_position(options, position_key))
                 annotated << f
@@ -790,6 +801,10 @@ module AnnotateModels
       end
     end
 
+    def expand_glob_into_files(glob)
+      Dir.glob(glob)
+    end
+
     def annotate_model_file(annotated, file, header, options)
       begin
         return false if /#{SKIP_ANNOTATION_PREFIX}.*/ =~ (File.exist?(file) ? File.read(file) : '')
@@ -827,7 +842,7 @@ module AnnotateModels
             model_file_name = file
             deannotated_klass = true if remove_annotation_of_file(model_file_name, options)
 
-            get_patterns(matched_types(options))
+            get_patterns(options, matched_types(options))
               .map { |f| resolve_filename(f, model_name, table_name) }
               .each do |f|
                 if File.exist?(f)
@@ -883,18 +898,104 @@ module AnnotateModels
     end
 
     def max_schema_info_width(klass, options)
+      cols = columns(klass, options)
+
       if with_comments?(klass, options)
-        max_size = klass.columns.map do |column|
-          column.name.size + (column.comment ? column.comment.size : 0)
+        max_size = cols.map do |column|
+          column.name.size + (column.comment ? width(column.comment) : 0)
         end.max || 0
         max_size += 2
       else
-        max_size = klass.column_names.map(&:size).max
+        max_size = cols.map(&:name).map(&:size).max
       end
       max_size += options[:format_rdoc] ? 5 : 1
 
       max_size
     end
+
+    def format_default(col_name, max_size, col_type, bare_type_allowance, attrs)
+      sprintf("#  %s:%s %s", mb_chars_ljust(col_name, max_size), mb_chars_ljust(col_type, bare_type_allowance),  attrs.join(", ")).rstrip + "\n"
+    end
+
+    def width(string)
+      string.chars.inject(0) { |acc, elem| acc + (elem.bytesize == 3 ? 2 : 1) }
+    end
+
+    def mb_chars_ljust(string, length)
+      string = string.to_s
+      padding = length - width(string)
+      if padding > 0
+        string + (' ' * padding)
+      else
+        string[0..length-1]
+      end
+    end
+
+    def non_ascii_length(string)
+      string.to_s.chars.reject(&:ascii_only?).length
+    end
+
+    def map_col_type_to_ruby_classes(col_type)
+      case col_type
+      when 'integer'                                       then Integer.to_s
+      when 'float'                                         then Float.to_s
+      when 'decimal'                                       then BigDecimal.to_s
+      when 'datetime', 'timestamp', 'time'                 then Time.to_s
+      when 'date'                                          then Date.to_s
+      when 'text', 'string', 'binary', 'inet', 'uuid'      then String.to_s
+      when 'json', 'jsonb'                                 then Hash.to_s
+      when 'boolean'                                       then 'Boolean'
+      end
+    end
+
+    def columns(klass, options)
+      cols = klass.columns
+      cols += translated_columns(klass)
+
+      if ignore_columns = options[:ignore_columns]
+        cols = cols.reject do |col|
+          col.name.match(/#{ignore_columns}/)
+        end
+      end
+
+      cols = cols.sort_by(&:name) if options[:sort]
+      cols = classified_sort(cols) if options[:classified_sort]
+
+      cols
+    end
+
+    ##
+    # Add columns managed by the globalize gem if this gem is being used.
+    def translated_columns(klass)
+      return [] unless klass.respond_to? :translation_class
+
+      ignored_cols = ignored_translation_table_colums(klass)
+      klass.translation_class.columns.reject do |col|
+        ignored_cols.include? col.name.to_sym
+      end
+    end
+
+    ##
+    # These are the columns that the globalize gem needs to work but
+    # are not necessary for the models to be displayed as annotations.
+    def ignored_translation_table_colums(klass)
+      # Construct the foreign column name in the translations table
+      # eg. Model: Car, foreign column name: car_id
+      foreign_column_name = [
+        klass.translation_class.to_s
+             .gsub('::Translation', '').gsub('::', '_')
+             .downcase,
+        '_id'
+      ].join.to_sym
+
+      [
+        :id,
+        :created_at,
+        :updated_at,
+        :locale,
+        foreign_column_name
+      ]
+    end
   end
 
   class BadModelFileError < LoadError