annotaterb 4.10.1 → 4.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3439937ec29e9b23e7902464eab521443e5171b74cfa386bfc0f4a163eaf2ea3
-  data.tar.gz: de7e55a701dc842603467c64576f005c93dee653c3876baa0603906c380efaf7
+  metadata.gz: a5dbaac7f2e0a75991b8d45ab6fdc6cd3de88493e045c9fdc166b86154d99054
+  data.tar.gz: 9902039f9f2a7a19e77201de2a197eb3f015effb9a7b59a108601d4d355227e6
 SHA512:
-  metadata.gz: 69243cd57c5c6f284cf06a12465cdfd5fc1bf98c5802e89e7bc44a1e9a7f1e3bc63f2af96dab36aae68406d97a4978e16213c7a63c72e902b33ada3a284a512d
-  data.tar.gz: 96680dd592b3d95825d657af8393b740119920907804f363b179f0199010ed11b03f89461720c099292ca70b71d85acca0005e8c913a8ce88b47e58667c3ca78
+  metadata.gz: 4e7d023754cdc71278b597fcd8010deb199c776835953c0bcf39fb5371088cf38b565da58ff6942fc51a88a218512bbe7297aeb9dfe32776fa2fc36ac8b44601
+  data.tar.gz: 4c14de66314768ac83dcbd275e56f8627c5ecd82f10da63595c23bbd31c7a5cdb4318a6075f3f98787edf3a319ed7d22dc260b8b5aa70527de93fb7e62b9d53f

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [v4.10.1](https://github.com/drwl/annotaterb/tree/v4.10.1) (2024-07-07)
+
+[Full Changelog](https://github.com/drwl/annotaterb/compare/v4.10.0...v4.10.1)
+
+**Merged pull requests:**
+
+- Bump version to v4.10.1 [\#132](https://github.com/drwl/annotaterb/pull/132) ([drwl](https://github.com/drwl))
+- Correct uses of `respond_to` in AnnotationDecider [\#131](https://github.com/drwl/annotaterb/pull/131) ([andreccosta](https://github.com/andreccosta))
+- Generate changelog for v4.10.0 [\#129](https://github.com/drwl/annotaterb/pull/129) ([drwl](https://github.com/drwl))
+
 ## [v4.10.0](https://github.com/drwl/annotaterb/tree/v4.10.0) (2024-06-28)
 
 [Full Changelog](https://github.com/drwl/annotaterb/compare/v4.9.0...v4.10.0)

data/VERSION

@@ -1 +1 @@
-4.10.1
+4.10.2

data/lib/annotate_rb/model_annotator/annotation/annotation_builder.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module Annotation
+      class AnnotationBuilder
+        class Annotation < Components::Base
+          attr_reader :version, :table_name, :table_comment, :max_size
+
+          def initialize(options, **input)
+            @options = options
+
+            @version = input[:version]
+            @table_name = input[:table_name]
+            @table_comment = input[:table_comment]
+            @max_size = input[:max_size]
+            @model = input[:model]
+          end
+
+          def body
+            [
+              MainHeader.new(version, @options[:include_version]),
+              SchemaHeader.new(table_name, table_comment, @options),
+              MarkdownHeader.new(max_size),
+              *columns,
+              IndexAnnotation::AnnotationBuilder.new(@model, @options).build,
+              ForeignKeyAnnotation::AnnotationBuilder.new(@model, @options).build,
+              CheckConstraintAnnotation::AnnotationBuilder.new(@model, @options).build,
+              SchemaFooter.new
+            ]
+          end
+
+          def build
+            components = body.flatten
+
+            if @options[:format_rdoc]
+              components.map(&:to_rdoc).compact.join("\n")
+            elsif @options[:format_yard]
+              components.map(&:to_yard).compact.join("\n")
+            elsif @options[:format_markdown]
+              components.map(&:to_markdown).compact.join("\n")
+            else
+              components.map(&:to_default).compact.join("\n")
+            end
+          end
+
+          private
+
+          def columns
+            @model.columns.map do |col|
+              _component = ColumnAnnotation::AnnotationBuilder.new(col, @model, max_size, @options).build
+            end
+          end
+        end
+
+        def initialize(klass, options)
+          @model = ModelWrapper.new(klass, options)
+          @options = options
+        end
+
+        def build
+          if @options.get_state(:current_version).nil?
+            migration_version = begin
+              ActiveRecord::Migrator.current_version
+            rescue
+              0
+            end
+
+            @options.set_state(:current_version, migration_version)
+          end
+
+          version = @options.get_state(:current_version)
+          table_name = @model.table_name
+          table_comment = @model.connection.try(:table_comment, @model.table_name)
+          max_size = @model.max_schema_info_width
+
+          _annotation = Annotation.new(@options,
+            version: version, table_name: table_name, table_comment: table_comment,
+            max_size: max_size, model: @model).build
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/annotation/main_header.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module Annotation
+      class MainHeader < Components::Base
+        # Annotate Models plugin use this header
+        PREFIX = "== Schema Information"
+        PREFIX_MD = "## Schema Information"
+
+        attr_reader :version
+
+        def initialize(version, include_version)
+          @version = version
+          @include_version = include_version
+        end
+
+        def to_markdown
+          header = "# #{PREFIX_MD}"
+          if @include_version && version > 0
+            header += "\n# Schema version: #{version}"
+          end
+
+          header
+        end
+
+        def to_default
+          header = "# #{PREFIX}"
+          if @include_version && version > 0
+            header += "\n# Schema version: #{version}"
+          end
+
+          header
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/annotation/markdown_header.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module Annotation
+      class MarkdownHeader < Components::Base
+        MD_NAMES_OVERHEAD = 6
+        MD_TYPE_ALLOWANCE = 18
+
+        attr_reader :max_size
+
+        def initialize(max_size)
+          @max_size = max_size
+        end
+
+        def to_markdown
+          name_padding = max_size + MD_NAMES_OVERHEAD
+          # standard:disable Lint/FormatParameterMismatch
+          formatted_headers = format("# %-#{name_padding}.#{name_padding}s | %-#{MD_TYPE_ALLOWANCE}.#{MD_TYPE_ALLOWANCE}s | %s",
+            "Name",
+            "Type",
+            "Attributes")
+          # standard:enable Lint/FormatParameterMismatch
+
+          <<~HEADER.strip
+            # ### Columns
+            #
+            #{formatted_headers}
+            # #{"-" * name_padding} | #{"-" * MD_TYPE_ALLOWANCE} | #{"-" * 27}
+          HEADER
+        end
+
+        def to_default
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/annotation/schema_footer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module Annotation
+      class SchemaFooter < Components::Base
+        def to_rdoc
+          <<~OUTPUT
+            #--
+            # == Schema Information End
+            #++
+          OUTPUT
+        end
+
+        def to_default
+          <<~OUTPUT
+            #
+          OUTPUT
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/annotation/schema_header.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module Annotation
+      class SchemaHeader < Components::Base
+        class TableName < Components::Base
+          attr_reader :name
+
+          def initialize(name)
+            @name = name
+          end
+
+          def to_default
+            "# Table name: #{name}"
+          end
+
+          def to_markdown
+            "# Table name: `#{name}`"
+          end
+        end
+
+        attr_reader :table_name, :table_comment
+
+        def initialize(table_name, table_comment, options)
+          @table_name = table_name
+          @table_comment = table_comment
+          @options = options
+        end
+
+        def body
+          [
+            Components::BlankCommentLine.new,
+            TableName.new(name),
+            Components::BlankCommentLine.new
+          ]
+        end
+
+        def to_default
+          body.map(&:to_default).join("\n")
+        end
+
+        def to_markdown
+          body.map(&:to_markdown).join("\n")
+        end
+
+        private
+
+        def display_table_comments?
+          @options[:with_comment] && @options[:with_table_comments]
+        end
+
+        def name
+          if display_table_comments? && table_comment
+            formatted_comment = "(#{table_comment.gsub(/\n/, "\\n")})"
+
+            "#{table_name}#{formatted_comment}"
+          else
+            table_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/annotation.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module Annotation
+      autoload :AnnotationBuilder, "annotate_rb/model_annotator/annotation/annotation_builder"
+      autoload :MainHeader, "annotate_rb/model_annotator/annotation/main_header"
+      autoload :SchemaHeader, "annotate_rb/model_annotator/annotation/schema_header"
+      autoload :MarkdownHeader, "annotate_rb/model_annotator/annotation/markdown_header"
+      autoload :SchemaFooter, "annotate_rb/model_annotator/annotation/schema_footer"
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/check_constraint_annotation/annotation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module CheckConstraintAnnotation
+      class Annotation
+        HEADER_TEXT = "Check Constraints"
+
+        def initialize(constraints)
+          @constraints = constraints
+        end
+
+        def body
+          [
+            Components::BlankCommentLine.new,
+            Components::Header.new(HEADER_TEXT),
+            Components::BlankCommentLine.new,
+            *@constraints
+          ]
+        end
+
+        def to_markdown
+          body.map(&:to_markdown).join("\n")
+        end
+
+        def to_default
+          body.map(&:to_default).join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/check_constraint_annotation/annotation_builder.rb

@@ -10,52 +10,28 @@ module AnnotateRb
         end
 
         def build
-          constraint_info = if @options[:format_markdown]
-            "#\n# ### Check Constraints\n#\n"
-          else
-            "#\n# Check Constraints\n#\n"
-          end
-
-          return "" unless @model.connection.respond_to?(:supports_check_constraints?) &&
+          return Components::NilComponent.new if !@options[:show_check_constraints]
+          return Components::NilComponent.new unless @model.connection.respond_to?(:supports_check_constraints?) &&
             @model.connection.supports_check_constraints? && @model.connection.respond_to?(:check_constraints)
 
           check_constraints = @model.connection.check_constraints(@model.table_name)
-          return "" if check_constraints.empty?
+          return Components::NilComponent.new if check_constraints.empty?
 
           max_size = check_constraints.map { |check_constraint| check_constraint.name.size }.max + 1
-          check_constraints.sort_by(&:name).each do |check_constraint|
+
+          constraints = check_constraints.sort_by(&:name).map do |check_constraint|
             expression = if check_constraint.expression
-              not_validated = if !check_constraint.validated?
-                "NOT VALID"
+              if check_constraint.validated?
+                "(#{check_constraint.expression.squish})"
+              else
+                "(#{check_constraint.expression.squish}) NOT VALID".squish
               end
-
-              "(#{check_constraint.expression.squish}) #{not_validated}".squish
             end
 
-            constraint_info += if @options[:format_markdown]
-              cc_info_in_markdown(check_constraint.name, expression)
-            else
-              cc_info_string(check_constraint.name, expression, max_size)
-            end
+            CheckConstraintComponent.new(check_constraint.name, expression, max_size)
           end
 
-          constraint_info
-        end
-
-        private
-
-        def cc_info_in_markdown(name, expression)
-          cc_info_markdown = sprintf("# * `%s`", name)
-          cc_info_markdown += sprintf(": `%s`", expression) if expression
-          cc_info_markdown += "\n"
-
-          cc_info_markdown
-        end
-
-        def cc_info_string(name, expression, max_size)
-          # standard:disable Lint/FormatParameterMismatch
-          sprintf("#  %-#{max_size}.#{max_size}s %s", name, expression).rstrip + "\n"
-          # standard:enable Lint/FormatParameterMismatch
+          _annotation = Annotation.new(constraints)
         end
       end
     end

data/lib/annotate_rb/model_annotator/check_constraint_annotation/check_constraint_component.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module CheckConstraintAnnotation
+      class CheckConstraintComponent < Components::Base
+        attr_reader :name, :expression, :max_size
+
+        def initialize(name, expression, max_size)
+          @name = name
+          @expression = expression
+          @max_size = max_size
+        end
+
+        def to_default
+          # standard:disable Lint/FormatParameterMismatch
+          sprintf("#  %-#{max_size}.#{max_size}s %s", name, expression).rstrip
+          # standard:enable Lint/FormatParameterMismatch
+        end
+
+        def to_markdown
+          if expression
+            sprintf("# * `%s`: `%s`", name, expression)
+          else
+            sprintf("# * `%s`", name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/check_constraint_annotation.rb

@@ -4,6 +4,8 @@ module AnnotateRb
   module ModelAnnotator
     module CheckConstraintAnnotation
       autoload :AnnotationBuilder, "annotate_rb/model_annotator/check_constraint_annotation/annotation_builder"
+      autoload :Annotation, "annotate_rb/model_annotator/check_constraint_annotation/annotation"
+      autoload :CheckConstraintComponent, "annotate_rb/model_annotator/check_constraint_annotation/check_constraint_component"
     end
   end
 end

data/lib/annotate_rb/model_annotator/column_annotation/annotation_builder.rb

@@ -4,9 +4,6 @@ module AnnotateRb
   module ModelAnnotator
     module ColumnAnnotation
       class AnnotationBuilder
-        BARE_TYPE_ALLOWANCE = 16
-        MD_TYPE_ALLOWANCE = 18
-
         def initialize(column, model, max_size, options)
           @column = column
           @model = model
@@ -15,8 +12,6 @@ module AnnotateRb
         end
 
         def build
-          result = ""
-
           is_primary_key = is_column_primary_key?(@model, @column.name)
 
           table_indices = @model.retrieve_indexes_from_table
@@ -33,88 +28,11 @@ module AnnotateRb
             @column.name
           end
 
-          result += if @options[:format_rdoc]
-            format_rdoc(col_name, @max_size, formatted_column_type, column_attributes)
-          elsif @options[:format_yard]
-            format_yard(col_name, @max_size, formatted_column_type, column_attributes)
-          elsif @options[:format_markdown]
-            format_markdown(col_name, @max_size, formatted_column_type, column_attributes)
-          else
-            format_default(col_name, @max_size, formatted_column_type, column_attributes)
-          end
-
-          result
+          _component = ColumnComponent.new(col_name, @max_size, formatted_column_type, column_attributes)
         end
 
         private
 
-        def non_ascii_length(string)
-          string.to_s.chars.count { |element| !element.ascii_only? }
-        end
-
-        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 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 format_rdoc(col_name, max_size, formatted_column_type, column_attributes)
-          format("# %-#{max_size}.#{max_size}s<tt>%s</tt>",
-            "*#{col_name}*::",
-            column_attributes.unshift(formatted_column_type).join(", ")).rstrip + "\n"
-        end
-
-        def format_yard(col_name, _max_size, formatted_column_type, _column_attributes)
-          res = ""
-          res += sprintf("# @!attribute #{col_name}") + "\n"
-
-          ruby_class = if @column.respond_to?(:array) && @column.array
-            "Array<#{map_col_type_to_ruby_classes(formatted_column_type)}>"
-          else
-            map_col_type_to_ruby_classes(formatted_column_type)
-          end
-
-          res += sprintf("#   @return [#{ruby_class}]") + "\n"
-
-          res
-        end
-
-        def format_markdown(col_name, max_size, formatted_column_type, column_attributes)
-          name_remainder = max_size - col_name.length - non_ascii_length(col_name)
-          type_remainder = (MD_TYPE_ALLOWANCE - 2) - formatted_column_type.length
-
-          format("# **`%s`**%#{name_remainder}s | `%s`%#{type_remainder}s | `%s`",
-            col_name,
-            " ",
-            formatted_column_type,
-            " ",
-            column_attributes.join(", ").rstrip).gsub("``", "  ").rstrip + "\n"
-        end
-
-        def format_default(col_name, max_size, formatted_column_type, column_attributes)
-          format("#  %s:%s %s",
-            mb_chars_ljust(col_name, max_size),
-            mb_chars_ljust(formatted_column_type, BARE_TYPE_ALLOWANCE),
-            column_attributes.join(", ")).rstrip + "\n"
-        end
-
         # TODO: Simplify this conditional
         def is_column_primary_key?(model, column_name)
           if model.primary_key

data/lib/annotate_rb/model_annotator/column_annotation/attributes_builder.rb

@@ -88,6 +88,8 @@ module AnnotateRb
           _sorted_indices = sorted_indices.reject { |ind| ind.columns.is_a?(String) }
         end
 
+        # Historically, the old gem looked for the option being set to "skip"
+        # e.g. hide_default_column_types: "skip"
         def hide_default?
           excludes =
             if @options[:hide_default_column_types].blank?

data/lib/annotate_rb/model_annotator/column_annotation/column_component.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module ColumnAnnotation
+      class ColumnComponent < Components::Base
+        MD_TYPE_ALLOWANCE = 18
+        BARE_TYPE_ALLOWANCE = 16
+
+        attr_reader :name, :max_size, :type, :attributes
+
+        def initialize(name, max_size, type, attributes)
+          @name = name
+          @max_size = max_size
+          @type = type
+          @attributes = attributes
+        end
+
+        def to_rdoc
+          # standard:disable Lint/FormatParameterMismatch
+          format("# %-#{max_size}.#{max_size}s<tt>%s</tt>",
+            "*#{name}*::",
+            attributes.unshift(type).join(", ")).rstrip
+          # standard:enable Lint/FormatParameterMismatch
+        end
+
+        def to_yard
+          res = ""
+          res += sprintf("# @!attribute #{name}") + "\n"
+
+          ruby_class = if @column.respond_to?(:array) && @column.array
+            "Array<#{map_col_type_to_ruby_classes(type)}>"
+          else
+            map_col_type_to_ruby_classes(type)
+          end
+
+          res += sprintf("#   @return [#{ruby_class}]")
+
+          res
+        end
+
+        def to_markdown
+          name_remainder = max_size - name.length - non_ascii_length(name)
+          type_remainder = (MD_TYPE_ALLOWANCE - 2) - type.length
+
+          # standard:disable Lint/FormatParameterMismatch
+          format("# **`%s`**%#{name_remainder}s | `%s`%#{type_remainder}s | `%s`",
+            name,
+            " ",
+            type,
+            " ",
+            attributes.join(", ").rstrip).gsub("``", "  ").rstrip
+          # standard:enable Lint/FormatParameterMismatch
+        end
+
+        def to_default
+          format("#  %s:%s %s",
+            mb_chars_ljust(name, max_size),
+            mb_chars_ljust(type, BARE_TYPE_ALLOWANCE),
+            attributes.join(", ")).rstrip
+        end
+
+        private
+
+        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 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.count { |element| !element.ascii_only? }
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/column_annotation.rb

@@ -8,6 +8,7 @@ module AnnotateRb
       autoload :ColumnWrapper, "annotate_rb/model_annotator/column_annotation/column_wrapper"
       autoload :AnnotationBuilder, "annotate_rb/model_annotator/column_annotation/annotation_builder"
       autoload :DefaultValueBuilder, "annotate_rb/model_annotator/column_annotation/default_value_builder"
+      autoload :ColumnComponent, "annotate_rb/model_annotator/column_annotation/column_component"
     end
   end
 end