annotaterb 4.1.1 → 4.2.0

data/lib/annotate_rb/model_annotator/column_wrapper.rb

@@ -1,84 +0,0 @@
-# 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,22 +0,0 @@
-module AnnotateRb
-  module ModelAnnotator
-    module Constants
-      ##
-      # The set of available options to customize the behavior of Annotate.
-      #
-      POSITION_OPTIONS = ::AnnotateRb::Options::POSITION_OPTION_KEYS
-
-      FLAG_OPTIONS = ::AnnotateRb::Options::FLAG_OPTION_KEYS
-
-      OTHER_OPTIONS = ::AnnotateRb::Options::OTHER_OPTION_KEYS
-
-      PATH_OPTIONS = ::AnnotateRb::Options::PATH_OPTION_KEYS
-
-      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_annotation_remover.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module AnnotateRb
-  module ModelAnnotator
-    class FileAnnotationRemover
-      class << self
-        def call(file_name, options = Options.from({}))
-          if File.exist?(file_name)
-            content = File.read(file_name)
-            return false if content =~ /#{Constants::SKIP_ANNOTATION_PREFIX}.*\n/
-
-            wrapper_open = options[:wrapper_open] ? "# #{options[:wrapper_open]}\n" : ''
-            content.sub!(/(#{wrapper_open})?#{AnnotationPatternGenerator.call(options)}/, '')
-
-            File.open(file_name, 'wb') { |f| f.puts content }
-
-            true
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/annotate_rb/model_annotator/file_annotator.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-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.
-        # If not, remove the old info block and write a new one.
-        #
-        # == Returns:
-        # true or false depending on whether the file was modified.
-        #
-        # === Options (opts)
-        #  :force<Symbol>:: whether to update the file even if it doesn't seem to need it.
-        #  :position_in_*<Symbol>:: where to place the annotated section in fixture or model file,
-        #                           :before, :top, :after or :bottom. Default is :before.
-        #
-        def call(file_name, info_block, position, options = {})
-          return false unless File.exist?(file_name)
-          old_content = File.read(file_name)
-
-          return false if old_content =~ /#{Constants::SKIP_ANNOTATION_PREFIX}.*\n/
-
-          diff = AnnotationDiffGenerator.new(old_content, info_block).generate
-
-          return false if !diff.changed? && !options[:force]
-
-          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" : ""
-          wrapper_close = options[:wrapper_close] ? "# #{options[:wrapper_close]}\n" : ""
-          wrapped_info_block = "#{wrapper_open}#{info_block}#{wrapper_close}"
-
-          annotation_pattern = AnnotationPatternGenerator.call(options)
-          old_annotation = old_content.match(annotation_pattern).to_s
-
-          # 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 = Helper.magic_comments_as_string(old_content)
-            old_content.gsub!(Constants::MAGIC_COMMENT_MATCHER, '')
-
-            annotation_pattern = AnnotationPatternGenerator.call(options)
-            old_content.sub!(annotation_pattern, '')
-
-            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
-            # 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]
-
-            annotation_pattern = AnnotationPatternGenerator.call(options)
-            new_content = old_content.sub(annotation_pattern, new_annotation)
-          end
-
-          File.open(file_name, 'wb') { |f| f.puts new_content }
-          true
-        end
-      end
-    end
-  end
-end

data/lib/annotate_rb/model_annotator/file_patterns.rb

@@ -1,129 +0,0 @@
-module AnnotateRb
-  module ModelAnnotator
-    # This module provides module method to get file paths.
-    module FilePatterns
-      # Controller files
-      CONTROLLER_DIR       = File.join('app', 'controllers')
-
-      # Active admin registry files
-      ACTIVEADMIN_DIR      = File.join('app', 'admin')
-
-      # Helper files
-      HELPER_DIR           = File.join('app', 'helpers')
-
-      # File.join for windows reverse bar compat?
-      # I dont use windows, can`t test
-      UNIT_TEST_DIR        = File.join('test', 'unit')
-      MODEL_TEST_DIR       = File.join('test', 'models') # since rails 4.0
-      SPEC_MODEL_DIR       = File.join('spec', 'models')
-
-      FIXTURE_TEST_DIR     = File.join('test', 'fixtures')
-      FIXTURE_SPEC_DIR     = File.join('spec', 'fixtures')
-
-      # Other test files
-      CONTROLLER_TEST_DIR  = File.join('test', 'controllers')
-      CONTROLLER_SPEC_DIR  = File.join('spec', 'controllers')
-      REQUEST_SPEC_DIR     = File.join('spec', 'requests')
-      ROUTING_SPEC_DIR     = File.join('spec', 'routing')
-
-      # Object Daddy http://github.com/flogic/object_daddy/tree/master
-      EXEMPLARS_TEST_DIR   = File.join('test', 'exemplars')
-      EXEMPLARS_SPEC_DIR   = File.join('spec', 'exemplars')
-
-      # Machinist http://github.com/notahat/machinist
-      BLUEPRINTS_TEST_DIR  = File.join('test', 'blueprints')
-      BLUEPRINTS_SPEC_DIR  = File.join('spec', 'blueprints')
-
-      # 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')
-      FABRICATORS_SPEC_DIR = File.join('spec', 'fabricators')
-
-      # Serializers https://github.com/rails-api/active_model_serializers
-      SERIALIZERS_DIR      = File.join('app',  'serializers')
-      SERIALIZERS_TEST_DIR = File.join('test', 'serializers')
-      SERIALIZERS_SPEC_DIR = File.join('spec', 'serializers')
-
-      class << self
-        def generate(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'
-            [
-              File.join(root_directory, ACTIVEADMIN_DIR, '%MODEL_NAME%.rb'),
-              File.join(root_directory, ACTIVEADMIN_DIR, '%PLURALIZED_MODEL_NAME%.rb')
-            ]
-          when 'helper'
-            [File.join(root_directory, HELPER_DIR, '%PLURALIZED_MODEL_NAME%_helper.rb')]
-          else
-            []
-          end
-        end
-
-        private
-
-        def test_files(root_directory)
-          [
-            File.join(root_directory, UNIT_TEST_DIR,  '%MODEL_NAME%_test.rb'),
-            File.join(root_directory, MODEL_TEST_DIR, '%MODEL_NAME%_test.rb'),
-            File.join(root_directory, SPEC_MODEL_DIR, '%MODEL_NAME%_spec.rb')
-          ]
-        end
-
-        def fixture_files(root_directory)
-          [
-            File.join(root_directory, FIXTURE_TEST_DIR, '%TABLE_NAME%.yml'),
-            File.join(root_directory, FIXTURE_SPEC_DIR, '%TABLE_NAME%.yml'),
-            File.join(root_directory, FIXTURE_TEST_DIR, '%PLURALIZED_MODEL_NAME%.yml'),
-            File.join(root_directory, FIXTURE_SPEC_DIR, '%PLURALIZED_MODEL_NAME%.yml')
-          ]
-        end
-
-        def scaffold_files(root_directory)
-          [
-            File.join(root_directory, CONTROLLER_TEST_DIR, '%PLURALIZED_MODEL_NAME%_controller_test.rb'),
-            File.join(root_directory, CONTROLLER_SPEC_DIR, '%PLURALIZED_MODEL_NAME%_controller_spec.rb'),
-            File.join(root_directory, REQUEST_SPEC_DIR,    '%PLURALIZED_MODEL_NAME%_spec.rb'),
-            File.join(root_directory, ROUTING_SPEC_DIR,    '%PLURALIZED_MODEL_NAME%_routing_spec.rb')
-          ]
-        end
-
-        def factory_files(root_directory)
-          [
-            File.join(root_directory, EXEMPLARS_TEST_DIR,   '%MODEL_NAME%_exemplar.rb'),
-            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_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')
-          ]
-        end
-
-        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_test.rb'),
-            File.join(root_directory, SERIALIZERS_SPEC_DIR, '%MODEL_NAME%_serializer_spec.rb')
-          ]
-        end
-      end
-    end
-  end
-end

data/lib/annotate_rb/model_annotator/foreign_key_annotation_builder.rb

@@ -1,55 +0,0 @@
-# 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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module AnnotateRb
-  module ModelAnnotator
-    module Helper
-      INDEX_CLAUSES = {
-        unique: {
-          default: 'UNIQUE',
-          markdown: '_unique_'
-        },
-        where: {
-          default: 'WHERE',
-          markdown: '_where_'
-        },
-        using: {
-          default: 'USING',
-          markdown: '_using_'
-        }
-      }.freeze
-
-      class << self
-        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
-
-        def index_unique_info(index, format = :default)
-          index.unique ? " #{INDEX_CLAUSES[:unique][format]}" : ''
-        end
-
-        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
-
-        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 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
-
-        # 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 width(string)
-          string.chars.inject(0) { |acc, elem| acc + (elem.bytesize == 3 ? 2 : 1) }
-        end
-
-        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
-      end
-    end
-  end
-end

data/lib/annotate_rb/model_annotator/index_annotation_builder.rb

@@ -1,74 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module AnnotateRb
-  module ModelAnnotator
-    # Annotates a model file and its related files (controllers, factories, etc)
-    class ModelFileAnnotator
-      class << self
-        def call(annotated, file, options)
-          begin
-            klass = ModelClassGetter.call(file, options)
-
-            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}"
-              $stderr.puts "\t" + e.backtrace.join("\n\t") if options[:trace]
-            end
-          rescue StandardError => e
-            $stderr.puts "Unable to annotate #{file}: #{e.message}"
-            $stderr.puts "\t" + e.backtrace.join("\n\t") if options[:trace]
-          end
-        end
-
-        private
-
-        def build_instructions(klass, file, options = {})
-          instructions = []
-
-          klass.reset_column_information
-          annotation = AnnotationGenerator.new(klass, options).generate
-          model_name = klass.name.underscore
-          table_name = klass.table_name
-
-          model_instruction = FileAnnotatorInstruction.new(file, annotation, :position_in_class, options)
-          instructions << model_instruction
-
-          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)
-
-          instructions
-        end
-      end
-    end
-  end
-end