annotaterb 4.0.0.beta.1 → 4.1.0

data/lib/annotate_rb/model_annotator/column_wrapper.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    class ColumnWrapper
+      def initialize(column)
+        @column = column
+      end
+
+      def default
+        # Note: Used to be klass.column_defaults[name], where name is the column name.
+        # Looks to be identical, but keeping note here in case there are differences.
+        _column_default = @column.default
+      end
+
+      def default_string
+        Helper.quote(@column.default)
+      end
+
+      def type
+        @column.type
+      end
+
+      def column_type_string
+        if (@column.respond_to?(:bigint?) && @column.bigint?) || /\Abigint\b/ =~ @column.sql_type
+          'bigint'
+        else
+          (@column.type || @column.sql_type).to_s
+        end
+      end
+
+      def unsigned?
+        @column.respond_to?(:unsigned?) && @column.unsigned?
+      end
+
+      def null
+        @column.null
+      end
+
+      def precision
+        @column.precision
+      end
+
+      def scale
+        @column.scale
+      end
+
+      def limit
+        @column.limit
+      end
+
+      def geometry_type?
+        @column.respond_to?(:geometry_type)
+      end
+
+      def geometry_type
+        # TODO: Check if we need to check if it responds before accessing the geometry type
+        @column.geometry_type
+      end
+
+      def geometric_type?
+        @column.respond_to?(:geometric_type)
+      end
+
+      def geometric_type
+        # TODO: Check if we need to check if it responds before accessing the geometric type
+        @column.geometric_type
+      end
+
+      def srid
+        # TODO: Check if we need to check if it responds before accessing the srid
+        @column.srid
+      end
+
+      def array?
+        @column.respond_to?(:array) && @column.array
+      end
+
+      def name
+        @column.name
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/constants.rb

@@ -1,8 +1,6 @@
 module AnnotateRb
   module ModelAnnotator
     module Constants
-      TRUE_RE = /^(true|t|yes|y|1)$/i.freeze
-
       ##
       # The set of available options to customize the behavior of Annotate.
       #
@@ -17,6 +15,8 @@ module AnnotateRb
       ALL_ANNOTATE_OPTIONS = ::AnnotateRb::Options::ALL_OPTION_KEYS
 
       SKIP_ANNOTATION_PREFIX = '# -\*- SkipSchemaAnnotations'.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
     end
   end
 end

data/lib/annotate_rb/model_annotator/file_annotator.rb

@@ -4,6 +4,10 @@ module AnnotateRb
   module ModelAnnotator
     class FileAnnotator
       class << self
+        def call_with_instructions(instruction)
+          call(instruction.file, instruction.annotation, instruction.position, instruction.options)
+        end
+
         # Add a schema block to a file. If the file already contains
         # a schema info block (a comment starting with "== Schema Information"),
         # check if it matches the block that is already there. If so, leave it be.
@@ -33,7 +37,7 @@ module AnnotateRb
 
           return false if old_columns == new_columns && !options[:force]
 
-          abort "annotate error. #{file_name} needs to be updated, but annotate was run with `--frozen`." if options[:frozen]
+          abort "AnnotateRb error. #{file_name} needs to be updated, but annotaterb was run with `--frozen`." if options[:frozen]
 
           # Replace inline the old schema info with the new schema info
           wrapper_open = options[:wrapper_open] ? "# #{options[:wrapper_open]}\n" : ""
@@ -47,7 +51,7 @@ module AnnotateRb
           # need to insert it in correct position
           if old_annotation.empty? || options[:force]
             magic_comments_block = Helper.magic_comments_as_string(old_content)
-            old_content.gsub!(Annotator::MAGIC_COMMENT_MATCHER, '')
+            old_content.gsub!(Constants::MAGIC_COMMENT_MATCHER, '')
 
             annotation_pattern = AnnotationPatternGenerator.call(options)
             old_content.sub!(annotation_pattern, '')

data/lib/annotate_rb/model_annotator/file_annotator_instruction.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    # A plain old Ruby object (PORO) that contains all necessary information for FileAnnotator
+    class FileAnnotatorInstruction
+      def initialize(file, annotation, position, options = {})
+        @file = file # Path to file
+        @annotation = annotation # Annotation string
+        @position = position # Position in the file where to write the annotation to
+        @options = options
+      end
+
+      attr_reader :file, :annotation, :position, :options
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/foreign_key_annotation_builder.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    class ForeignKeyAnnotationBuilder
+      def initialize(model, options)
+        @model = model
+        @options = options
+      end
+
+      def build
+        fk_info = if @options[:format_markdown]
+                    "#\n# ### Foreign Keys\n#\n"
+                  else
+                    "#\n# Foreign Keys\n#\n"
+                  end
+
+        return '' unless @model.connection.respond_to?(:supports_foreign_keys?) &&
+          @model.connection.supports_foreign_keys? && @model.connection.respond_to?(:foreign_keys)
+
+        foreign_keys = @model.connection.foreign_keys(@model.table_name)
+        return '' if foreign_keys.empty?
+
+        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|
+          ref_info = "#{fk.column} => #{fk.to_table}.#{fk.primary_key}"
+          constraints_info = ''
+          constraints_info += "ON DELETE => #{fk.on_delete} " if fk.on_delete
+          constraints_info += "ON UPDATE => #{fk.on_update} " if fk.on_update
+          constraints_info = constraints_info.strip
+
+          fk_info += if @options[:format_markdown]
+                       format("# * `%s`%s:\n#     * **`%s`**\n",
+                              format_name.call(fk),
+                              constraints_info.blank? ? '' : " (_#{constraints_info}_)",
+                              ref_info)
+                     else
+                       format("#  %-#{max_size}.#{max_size}s %s %s",
+                              format_name.call(fk),
+                              "(#{ref_info})",
+                              constraints_info).rstrip + "\n"
+                     end
+        end
+
+        fk_info
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/helper.rb

@@ -3,51 +3,104 @@
 module AnnotateRb
   module ModelAnnotator
     module Helper
-      MATCHED_TYPES = %w(test fixture factory serializer scaffold controller helper).freeze
+      INDEX_CLAUSES = {
+        unique: {
+          default: 'UNIQUE',
+          markdown: '_unique_'
+        },
+        where: {
+          default: 'WHERE',
+          markdown: '_where_'
+        },
+        using: {
+          default: 'USING',
+          markdown: '_using_'
+        }
+      }.freeze
 
       class << self
-        def matched_types(options)
-          types = MATCHED_TYPES.dup
-          types << 'admin' if options[:active_admin] =~ Constants::TRUE_RE && !types.include?('admin')
-          types << 'additional_file_patterns' if options[:additional_file_patterns].present?
+        def mb_chars_ljust(string, length)
+          string = string.to_s
+          padding = length - Helper.width(string)
+          if padding.positive?
+            string + (' ' * padding)
+          else
+            string[0..(length - 1)]
+          end
+        end
 
-          types
+        def index_unique_info(index, format = :default)
+          index.unique ? " #{INDEX_CLAUSES[:unique][format]}" : ''
         end
 
-        def magic_comments_as_string(content)
-          magic_comments = content.scan(Annotator::MAGIC_COMMENT_MATCHER).flatten.compact
+        def index_where_info(index, format = :default)
+          value = index.try(:where).try(:to_s)
+          if value.blank?
+            ''
+          else
+            " #{INDEX_CLAUSES[:where][format]} #{value}"
+          end
+        end
 
-          if magic_comments.any?
-            magic_comments.join
+        def index_using_info(index, format = :default)
+          value = index.try(:using) && index.using.try(:to_sym)
+          if !value.blank? && value != :btree
+            " #{INDEX_CLAUSES[:using][format]} #{value}"
           else
             ''
           end
         end
 
-        def skip_on_migration?
-          Env.read('ANNOTATE_SKIP_ON_DB_MIGRATE') =~ Constants::TRUE_RE || Env.read('skip_on_db_migrate') =~ Constants::TRUE_RE
+        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 non_ascii_length(string)
+          string.to_s.chars.reject(&:ascii_only?).length
         end
 
-        def include_routes?
-          Env.read('routes') =~ Constants::TRUE_RE
+        # Simple quoting for the default column value
+        def quote(value)
+          case value
+          when NilClass then 'NULL'
+          when TrueClass then 'TRUE'
+          when FalseClass then 'FALSE'
+          when Float, Integer then value.to_s
+          # BigDecimals need to be output in a non-normalized form and quoted.
+          when BigDecimal then value.to_s('F')
+          when Array then value.map { |v| quote(v) }
+          else
+            value.inspect
+          end
         end
 
-        def include_models?
-          Env.read('models') =~ Constants::TRUE_RE
+        def width(string)
+          string.chars.inject(0) { |acc, elem| acc + (elem.bytesize == 3 ? 2 : 1) }
         end
 
-        def true?(val)
-          val.present? && Constants::TRUE_RE.match?(val)
+        def magic_comments_as_string(content)
+          magic_comments = content.scan(Constants::MAGIC_COMMENT_MATCHER).flatten.compact
+
+          if magic_comments.any?
+            magic_comments.join
+          else
+            ''
+          end
         end
 
         # TODO: Find another implementation that doesn't depend on ActiveSupport
         def fallback(*args)
           args.compact.detect(&:present?)
         end
-
-        def reset_options(options)
-          options.flatten.each { |key| Env.write(key, nil) }
-        end
       end
     end
   end

data/lib/annotate_rb/model_annotator/index_annotation_builder.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    class IndexAnnotationBuilder
+      def initialize(model, options)
+        @model = model
+        @options = options
+      end
+
+      def build
+        index_info = if @options[:format_markdown]
+                       "#\n# ### Indexes\n#\n"
+                     else
+                       "#\n# Indexes\n#\n"
+                     end
+
+        indexes = @model.retrieve_indexes_from_table
+        return '' if indexes.empty?
+
+        max_size = indexes.collect { |index| index.name.size }.max + 1
+        indexes.sort_by(&:name).each do |index|
+          index_info += if @options[:format_markdown]
+                          final_index_string_in_markdown(index)
+                        else
+                          final_index_string(index, max_size)
+                        end
+        end
+
+        index_info
+      end
+
+      private
+
+      def final_index_string_in_markdown(index)
+        details = format(
+          '%s%s%s',
+          Helper.index_unique_info(index, :markdown),
+          Helper.index_where_info(index, :markdown),
+          Helper.index_using_info(index, :markdown)
+        ).strip
+        details = " (#{details})" unless details.blank?
+
+        format(
+          "# * `%s`%s:\n#     * **`%s`**\n",
+          index.name,
+          details,
+          index_columns_info(index).join("`**\n#     * **`")
+        )
+      end
+
+      def final_index_string(index, max_size)
+        format(
+          "#  %-#{max_size}.#{max_size}s %s%s%s%s",
+          index.name,
+          "(#{index_columns_info(index).join(',')})",
+          Helper.index_unique_info(index),
+          Helper.index_where_info(index),
+          Helper.index_using_info(index)
+        ).rstrip + "\n"
+      end
+
+      def index_columns_info(index)
+        Array(index.columns).map do |col|
+          if index.try(:orders) && index.orders[col.to_s]
+            "#{col} #{index.orders[col.to_s].upcase}"
+          else
+            col.to_s.gsub("\r", '\r').gsub("\n", '\n')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/model_file_annotator.rb

@@ -2,36 +2,21 @@
 
 module AnnotateRb
   module ModelAnnotator
-    # Not sure yet what the difference is between this and FileAnnotator
+    # Annotates a model file and its related files (controllers, factories, etc)
     class ModelFileAnnotator
       class << self
-        def call(annotated, file, header, options)
+        def call(annotated, file, options)
           begin
-            return false if /#{Constants::SKIP_ANNOTATION_PREFIX}.*/ =~ (File.exist?(file) ? File.read(file) : '')
             klass = ModelClassGetter.call(file, options)
 
-            klass_is_a_class = klass.is_a?(Class)
-            klass_inherits_active_record_base = klass < ActiveRecord::Base
-            klass_is_not_abstract = !klass.abstract_class?
-            klass_table_exists = klass.table_exists?
-
-            not_sure_this_conditional = (!options[:exclude_sti_subclasses] || !(klass.superclass < ActiveRecord::Base && klass.table_name == klass.superclass.table_name))
-
-            annotate_conditions = [
-              klass_is_a_class,
-              klass_inherits_active_record_base,
-              not_sure_this_conditional,
-              klass_is_not_abstract,
-              klass_table_exists
-            ]
-
-            do_annotate = annotate_conditions.all?
-
-            if do_annotate
-              files_annotated = annotate(klass, file, header, options)
-              annotated.concat(files_annotated)
+            instructions = build_instructions(klass, file, options)
+            instructions.each do |instruction|
+              if FileAnnotator.call_with_instructions(instruction)
+                annotated << instruction.file
+              end
             end
 
+            annotated
           rescue BadModelFileError => e
             unless options[:ignore_unknown_models]
               $stderr.puts "Unable to annotate #{file}: #{e.message}"
@@ -45,72 +30,24 @@ module AnnotateRb
 
         private
 
-        # 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.
-        #
-        # === Options (opts)
-        #  :position_in_class<Symbol>:: where to place the annotated section in model file
-        #  :position_in_test<Symbol>:: where to place the annotated section in test/spec file(s)
-        #  :position_in_fixture<Symbol>:: where to place the annotated section in fixture file
-        #  :position_in_factory<Symbol>:: where to place the annotated section in factory file
-        #  :position_in_serializer<Symbol>:: where to place the annotated section in serializer file
-        #  :exclude_tests<Symbol>:: whether to skip modification of test/spec files
-        #  :exclude_fixtures<Symbol>:: whether to skip modification of fixture files
-        #  :exclude_factories<Symbol>:: whether to skip modification of factory files
-        #  :exclude_serializers<Symbol>:: whether to skip modification of serializer files
-        #  :exclude_scaffolds<Symbol>:: whether to skip modification of scaffold files
-        #  :exclude_controllers<Symbol>:: whether to skip modification of controller files
-        #  :exclude_helpers<Symbol>:: whether to skip modification of helper files
-        #  :exclude_sti_subclasses<Symbol>:: whether to skip modification of files for STI subclasses
-        #
-        # == Returns:
-        # an array of file names that were annotated.
-        #
-        def annotate(klass, file, header, options = {})
-          begin
-            klass.reset_column_information
-            info = SchemaInfo.generate(klass, header, options)
-            model_name = klass.name.underscore
-            table_name = klass.table_name
-            model_file_name = File.join(file)
-            annotated = []
-
-            if FileAnnotator.call(model_file_name, info, :position_in_class, options)
-              annotated << model_file_name
-            end
-
-            Helper.matched_types(options).each do |key|
-              exclusion_key = "exclude_#{key.pluralize}".to_sym
-              position_key = "position_in_#{key}".to_sym
-
-              # Same options for active_admin models
-              if key == 'admin'
-                exclusion_key = 'exclude_class'.to_sym
-                position_key = 'position_in_class'.to_sym
-              end
+        def build_instructions(klass, file, options = {})
+          instructions = []
 
-              next if options[exclusion_key]
+          klass.reset_column_information
+          annotation = AnnotationGenerator.new(klass, options).generate
+          model_name = klass.name.underscore
+          table_name = klass.table_name
 
-              patterns = PatternGetter.call(options, key)
+          model_instruction = FileAnnotatorInstruction.new(file, annotation, :position_in_class, options)
+          instructions << model_instruction
 
-              patterns
-                .map { |f| FileNameResolver.call(f, model_name, table_name) }
-                .map { |f| Dir.glob(f) }
-                .flatten
-                .each do |f|
-                if FileAnnotator.call(f, info, position_key, options)
-                  annotated << f
-                end
-              end
-            end
-          rescue StandardError => e
-            $stderr.puts "Unable to annotate #{file}: #{e.message}"
-            $stderr.puts "\t" + e.backtrace.join("\n\t") if options[:trace]
+          related_files = RelatedFilesListBuilder.new(file, model_name, table_name, options).build
+          related_file_instructions = related_files.map do |f, position_key|
+            _instruction = FileAnnotatorInstruction.new(f, annotation, position_key, options)
           end
+          instructions.concat(related_file_instructions)
 
-          annotated
+          instructions
         end
       end
     end

data/lib/annotate_rb/model_annotator/model_files_getter.rb

@@ -11,6 +11,8 @@ module AnnotateRb
         def call(options)
           model_files = []
 
+          # Note: This is currently broken as we don't set `is_rake` anywhere.
+          # It's an artifact from the old Annotate gem and how it did control flow.
           model_files = list_model_files_from_argument(options) if !options[:is_rake]
 
           return model_files if !model_files.empty?
@@ -30,7 +32,7 @@ module AnnotateRb
         rescue SystemCallError
           $stderr.puts "No models found in directory '#{options[:model_dir].join("', '")}'."
           $stderr.puts "Either specify models on the command line, or use the --model-dir option."
-          $stderr.puts "Call 'annotate --help' for more info."
+          $stderr.puts "Call 'annotaterb --help' for more info."
           # exit 1 # TODO: Return exit code back to caller. Right now it messes up RSpec being able to run
         end
 
@@ -50,7 +52,7 @@ module AnnotateRb
 
           if model_files.size != specified_files.size
             $stderr.puts "The specified file could not be found in directory '#{options[:model_dir].join("', '")}'."
-            $stderr.puts "Call 'annotate --help' for more info."
+            $stderr.puts "Call 'annotaterb --help' for more info."
             # exit 1 # TODO: Return exit code back to caller. Right now it messes up RSpec being able to run
           end