annotato 0.1.15 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9018e17dc7b82a75e12b7e43cf5845abf9d397512cfc987aaf40dc4c70af045
-  data.tar.gz: ba4b35b5f17dbeebe540e32bc5bbfa4b124667915072bc73d6690429b5e3777f
+  metadata.gz: ad60c697f9ee0213951d02981190dee26a8db0a2e48ab36d3118c1aaf95d4d40
+  data.tar.gz: 43a5f89b6509a636d579416c92bbbc52c63e15b8029701b46c525bd651a049a1
 SHA512:
-  metadata.gz: 2d573afafb8041a325f75eca8cf1ee9396520e380d28cd5a293b375e17b60f9bb872525c99a7cf0df7a54da402d5a89cadb36ec5cefbdd6906340f8bcae49a40
-  data.tar.gz: 0753e255496f9f03ec1d91ab54317ff435d2133d9e0dee7fa285c30bdef6a8692abe4a79a7d2412784436ec2696bed060feb30c5c0efde384ffcc75ce9c08273
+  metadata.gz: 7753fdc81bfc3568053c99f3f4f98107d0ca3b2ad1b64b127e19902e00f35a8b889b86b2219a431ea2dd673bab86000d0705b59d7a88ef1c68192be2cf012d3e
+  data.tar.gz: d05dd1bb4dd969a77555c3685ab129a9f31a479c5d2f69ef80c9ed7971677c044bc918ec2fd7e1212bc90eb49e678acd306f8afe66d7c9b743ea3b9dc3b9e650

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    annotato (0.1.15)
+    annotato (0.2.1)
       rails (>= 6.0)
 
 GEM
@@ -214,6 +214,7 @@ GEM
 
 PLATFORMS
   arm64-darwin-24
+  arm64-darwin-25
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -16,6 +16,7 @@
   * Enums with values
   * Indexes (only if present)
   * Triggers (only if present)
+  * Check Constraints (only if present)
 * Skips unchanged annotations
 * Smart formatting with aligned columns
 

data/lib/annotato/annotation_builder.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require_relative "wrap_helper"
 require_relative "column_formatter"
 require_relative "index_formatter"
 require_relative "trigger_formatter"
 require_relative "line_formatter"
 require_relative "enum_formatter"
+require_relative "check_constraint_formatter"
 
 module Annotato
   class AnnotationBuilder
@@ -20,7 +22,7 @@ module Annotato
       lines << "Columns:"
       lines += ColumnFormatter.format(model, conn)
 
-      enums = EnumFormatter.format(model)
+      enums = EnumFormatter.format(conn, conn.columns(table_name))
       unless enums.empty?
         lines << ""
         lines << "Enums:"
@@ -41,6 +43,13 @@ module Annotato
         lines += triggers
       end
 
+      check_constraints = CheckConstraintFormatter.format(conn, table_name)
+      unless check_constraints.empty?
+        lines << ""
+        lines << "Check Constraints:"
+        lines += check_constraints
+      end
+
       LineFormatter.format(lines)
     end
   end

data/lib/annotato/check_constraint_formatter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Annotato
+  class CheckConstraintFormatter
+    extend WrapHelper
+
+    def self.format(conn, table_name)
+      conn.check_constraints(table_name).map do |chk|
+        expr_clause = ""
+        if chk.expression
+          expr_clause = "\n" + wrap_sql(chk.expression, first_prefix: "#    (", cont_prefix: "#    ")
+        end
+        "#  #{chk.name}#{expr_clause}"
+      end
+    end
+  end
+end

data/lib/annotato/column_formatter.rb

@@ -9,9 +9,11 @@ module Annotato
       table_name     = model.table_name
       primary_key    = model.primary_key
       unique_indexes = connection.indexes(table_name).select(&:unique)
-      enums          = model.defined_enums
       columns        = connection.columns(table_name)
 
+      # Collect native PG enum type names once up front (avoids N+1 queries).
+      pg_enum_types = pg_enum_type_names(connection)
+
       # Compute max widths for name and sql_type so that the table lines up.
       name_width = columns.map(&:name).map(&:length).max
       type_width = columns.map(&:sql_type).map(&:length).max
@@ -20,8 +22,6 @@ module Annotato
         name = col.name
         type = col.sql_type
 
-        # require "pry" if name == "allowed_statuses"
-        # binding.pry if name == "allowed_statuses"
         # Build the left-hand side and calculate indent.
         left  = "#  %-#{name_width}s :%-#{type_width}s" % [name, type]
         # " default(" is 9 chars; +2 gives the extra gap.
@@ -41,7 +41,8 @@ module Annotato
         opts << "primary key"    if name == primary_key
         opts << "is an Array"    if type.end_with?("[]")
         opts << "unique"         if unique_indexes.any? { |idx| idx.columns == [name] }
-        opts << "enum"           if enums.key?(name)
+        opts << "enum"           if pg_enum_types.include?(type.delete_suffix("[]"))
+        opts << "comment: #{col.comment.inspect}" if col.respond_to?(:comment) && col.comment && !col.comment.empty?
 
         # Emit either a multiline block or a single line.
         if default_block
@@ -64,9 +65,8 @@ module Annotato
       end
     end
 
-    # Returns nil (no default) or an Array of un-indented lines:
-    #   ["[", "\"A\",", "\"B\"", "]"]   or   ["{", "\"k\":v,", ... , "}"]
-    # If the value is empty array or hash, returns ["[]"] or ["{}"].
+    # Returns nil for non-JSON/empty values, or an Array of un-indented inner lines
+    # for multiline formatting: e.g. ["\"A\",", "\"B\""] for a JSON array.
     def self.build_default_block(value)
       return nil if value.nil? || !value.is_a?(String)
       s = value.strip
@@ -76,15 +76,15 @@ module Annotato
       return nil unless parsed.is_a?(Array) || parsed.is_a?(Hash)
 
       if parsed.is_a?(Array)
-        return if parsed.empty? # empty array → ["[]"]
+        return nil if parsed.empty?
 
-        # Only a JSON array of strings?
+        # JSON array of strings
         parsed.map.with_index do |e, i|
           comma = i == parsed.size - 1 ? "" : ","
           %Q{"#{e}"#{comma}}
         end
       else
-        return if parsed.empty? # empty hash → ["{}"]
+        return nil if parsed.empty?
 
         # JSON hash → key/value pairs
         parsed.map.with_index do |(k, v), i|
@@ -93,5 +93,16 @@ module Annotato
         end
       end
     end
+
+    # Fetches all native PostgreSQL enum type names in one query.
+    # Returns a Set for O(1) membership checks.
+    def self.pg_enum_type_names(connection)
+      rows = connection.exec_query(
+        "SELECT typname FROM pg_type WHERE typtype = 'e'",
+        "SQL"
+      )
+      rows.map { |r| r["typname"] }.to_set
+    end
+    private_class_method :pg_enum_type_names
   end
 end

data/lib/annotato/enum_formatter.rb

@@ -1,26 +1,50 @@
 # frozen_string_literal: true
 
 module Annotato
+  # Formats PostgreSQL native enum type definitions for columns whose sql_type
+  # refers to a custom DB enum (e.g. `access_link_category`). Queries pg_enum
+  # directly so the output reflects the actual database definition, not the
+  # ActiveRecord-level enum mapping already visible in the model source.
   class EnumFormatter
-    def self.format(model)
-      return [] if model.defined_enums.empty?
+    def self.format(conn, columns)
+      # Collect columns backed by a native PG enum type.
+      # A native enum type is one that exists in pg_type with typtype = 'e'.
+      enum_columns = columns.select { |col| pg_enum_type?(conn, col.sql_type) }
+      return [] if enum_columns.empty?
 
-      model.defined_enums.map do |attr, values|
-        lines = ["#  #{attr}: {"]
-
-        formatted_values = values.map do |key, val|
-          if key.to_s == val.to_s
-            "#{key}"
-          else
-            "#{key} (#{val})"
-          end
-        end
-
-        lines += formatted_values.map { |v| "#    #{v}," }
-        lines[-1] = lines[-1].chomp(',') # remove trailing comma from last line
-        lines << "#  }"
+      enum_columns.map do |col|
+        labels = pg_enum_labels(conn, col.sql_type)
+        lines = ["#  #{col.name} (#{col.sql_type}): ["]
+        lines += labels.map.with_index { |label, i|
+          comma = i == labels.size - 1 ? "" : ","
+          "#    #{label}#{comma}"
+        }
+        lines << "#  ]"
         lines.join("\n")
       end
     end
+
+    private_class_method def self.pg_enum_type?(conn, sql_type)
+      # Strip array suffix (e.g. "my_enum[]") before checking.
+      type_name = sql_type.delete_suffix("[]")
+      result = conn.exec_query(
+        "SELECT 1 FROM pg_type WHERE typname = $1 AND typtype = 'e' LIMIT 1",
+        "SQL",
+        [type_name]
+      )
+      result.any?
+    end
+
+    private_class_method def self.pg_enum_labels(conn, sql_type)
+      type_name = sql_type.delete_suffix("[]")
+      conn.exec_query(
+        "SELECT e.enumlabel FROM pg_enum e " \
+        "JOIN pg_type t ON e.enumtypid = t.oid " \
+        "WHERE t.typname = $1 " \
+        "ORDER BY e.enumsortorder",
+        "SQL",
+        [type_name]
+      ).map { |r| r["enumlabel"] }
+    end
   end
 end

data/lib/annotato/index_formatter.rb

@@ -2,7 +2,7 @@
 
 module Annotato
   class IndexFormatter
-    MAX_LINE = 100
+    extend WrapHelper
 
     def self.format(conn, table_name)
       conn.indexes(table_name).map do |idx|
@@ -11,75 +11,11 @@ module Annotato
 
         where_clause = ""
         if idx.where
-          where_clause = "\n" + wrap_where(idx.where, max_len: MAX_LINE)
+          where_clause = "\n" + wrap_sql(idx.where, first_prefix: "#    where (", cont_prefix: "#          ")
         end
 
         "#  #{idx.name} (#{cols_list})#{unique_clause}#{where_clause}"
       end
     end
-
-    # Produces one or more lines, each already prefixed with "#    "
-    # First line: "#    where (..."
-    # Next lines:  "#          ..." (aligned under the "(")
-    def self.wrap_where(where_sql, max_len:)
-      first_prefix = "#    where ("
-      cont_prefix  = "#          " # aligns under the "(" after "where "
-
-      text = where_sql.to_s
-      lines = []
-
-      # If it already fits, keep it one-liner
-      if (first_prefix.length + text.length + 1) <= max_len
-        return "#{first_prefix}#{text})"
-      end
-
-      remaining = text.dup
-      current_prefix = first_prefix
-
-      while remaining.length > 0
-        available = max_len - current_prefix.length - 1 # -1 for closing ")" on last line (or just safety)
-        available = 20 if available < 20
-
-        if remaining.length <= available
-          lines << "#{current_prefix}#{remaining}"
-          remaining = ""
-          break
-        end
-
-        # Prefer breaking on logical operators within the window
-        window = remaining[0, available]
-        cut =
-          window.rindex(" AND ") ||
-          window.rindex(" OR ")  ||
-          window.rindex(", ")    ||
-          window.rindex(") ")    ||
-          window.rindex(" ")     # last resort: whitespace
-
-        # If we found a breakpoint, include it in the line (so operators stay visible)
-        if cut
-          # If we’re cutting on AND/OR/comma, keep that token at the end of the line when possible
-          if window[cut, 5] == " AND " || window[cut, 4] == " OR "
-            cut += (window[cut, 5] == " AND " ? 5 : 4)
-          elsif window[cut, 2] == ", "
-            cut += 2
-          elsif window[cut, 2] == ") "
-            cut += 2
-          else
-            cut += 1
-          end
-        else
-          cut = available
-        end
-
-        lines << "#{current_prefix}#{remaining[0, cut].rstrip}"
-        remaining = remaining[cut..].to_s.lstrip
-        current_prefix = cont_prefix
-      end
-
-      # Close the paren on the last line
-      lines[-1] = "#{lines[-1]})"
-
-      lines.join("\n")
-    end
   end
 end

data/lib/annotato/model_annotator.rb

@@ -19,7 +19,6 @@ module Annotato
         annotation = AnnotationBuilder.build(model)
         write_annotation(model, annotation)
       end
-      @output.puts "✅ Annotato completed"
     end
 
     private
@@ -46,7 +45,13 @@ module Annotato
         file = model_file(model)
         return unless file && File.exist?(file)
 
-        content = File.read(file).dup   # <--- duplicate string to avoid FrozenError
+        content = File.read(file).dup
+
+        # Verify the class definition exists before doing anything else.
+        unless content.match?(/class\s+\w+/)
+          @output.puts "⚠️  Skipped #{model.name} — class not found in file"
+          return
+        end
 
         # Extract the old Annotato annotation block if it exists
         old_annotation = content[/^# == Annotato Schema Info.*?(?=^class|\z)/m]
@@ -57,17 +62,11 @@ module Annotato
           return
         end
 
-        # Remove old Annotato blocks
+        # Remove old Annotato blocks and legacy annotate-gem blocks
         content.gsub!(/^# == Annotato Schema Info.*?(?=^class|\z)/m, "")
         content.gsub!(/^# == Schema Information.*?(?=^class|\z)/m, "")
         content.rstrip!
 
-        # Verify the class definition exists before appending annotation
-        unless content.match?(/class\s+\w+/)
-          @output.puts "⚠️  Skipped #{model.name} — class not found in file"
-          return
-        end
-
         # Append the new annotation at the end of the file
         content += "\n\n#{annotation}\n"
         File.write(file, content)

data/lib/annotato/trigger_formatter.rb

@@ -3,11 +3,11 @@
 module Annotato
   class TriggerFormatter
     def self.format(conn, table_name)
-      conn.exec_query(<<~SQL).map { |r| "#  #{r['tgname']}" }
-        SELECT tgname FROM pg_trigger
-        WHERE tgrelid = '#{table_name}'::regclass
-          AND NOT tgisinternal;
-      SQL
+      conn.exec_query(
+        "SELECT tgname FROM pg_trigger WHERE tgrelid = $1::regclass AND NOT tgisinternal",
+        "SQL",
+        [table_name]
+      ).map { |r| "#  #{r['tgname']}" }
     end
   end
 end

data/lib/annotato/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Annotato
-  VERSION = "0.1.15"
+  VERSION = "0.2.1"
 end

data/lib/annotato/wrap_helper.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Annotato
+  module WrapHelper
+    MAX_LINE = 100
+
+    # Produces one or more lines, each already prefixed with "#    "
+    # First line: "#    where (..."
+    # Next lines: "#          ..." (aligned under the "(")
+    def wrap_sql(sql, first_prefix:, cont_prefix:, max_len: MAX_LINE)
+      text = sql.to_s
+      lines = []
+
+      # If it already fits, keep it one-liner
+      if (first_prefix.length + text.length + 1) <= max_len
+        return "#{first_prefix}#{text})"
+      end
+
+      remaining = text.dup
+      current_prefix = first_prefix
+
+      while remaining.length > 0
+        available = max_len - current_prefix.length - 1 # -1 for closing ")" on last line (or just safety)
+        available = 20 if available < 20
+
+        if remaining.length <= available
+          lines << "#{current_prefix}#{remaining}"
+          remaining = ""
+          break
+        end
+
+        # Prefer breaking on logical operators within the window
+        window = remaining[0, available]
+        cut =
+          window.rindex(" AND ") ||
+          window.rindex(" OR ")  ||
+          window.rindex(", ")    ||
+          window.rindex(") ")    ||
+          window.rindex(" ")     # last resort: whitespace
+
+        # If we found a breakpoint, include it in the line (so operators stay visible)
+        if cut
+          # If we’re cutting on AND/OR/comma, keep that token at the end of the line when possible
+          if window[cut, 5] == " AND " || window[cut, 4] == " OR "
+            cut += (window[cut, 5] == " AND " ? 5 : 4)
+          elsif window[cut, 2] == ", "
+            cut += 2
+          elsif window[cut, 2] == ") "
+            cut += 2
+          else
+            cut += 1
+          end
+        else
+          cut = available
+        end
+
+        lines << "#{current_prefix}#{remaining[0, cut].rstrip}"
+        remaining = remaining[cut..].to_s.lstrip
+        current_prefix = cont_prefix
+      end
+
+      # Close the paren on the last line
+      lines[-1] = "#{lines[-1]})"
+
+      lines.join("\n")
+    end
+  end
+end

data/lib/tasks/annotato.rake

@@ -19,5 +19,7 @@ namespace :annotato do
       # No MODEL passed → annotate all models
       annotator.run
     end
+
+    puts "✅ Annotato completed"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: annotato
 version: !ruby/object:Gem::Version
-  version: 0.1.15
+  version: 0.2.1
 platform: ruby
 authors:
 - Serhii Bodnaruk
 bindir: exe
 cert_chain: []
-date: 2025-12-19 00:00:00.000000000 Z
+date: 2026-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -45,6 +45,7 @@ files:
 - bin/setup
 - lib/annotato.rb
 - lib/annotato/annotation_builder.rb
+- lib/annotato/check_constraint_formatter.rb
 - lib/annotato/column_formatter.rb
 - lib/annotato/enum_formatter.rb
 - lib/annotato/index_formatter.rb
@@ -53,6 +54,7 @@ files:
 - lib/annotato/railtie.rb
 - lib/annotato/trigger_formatter.rb
 - lib/annotato/version.rb
+- lib/annotato/wrap_helper.rb
 - lib/tasks/annotato.rake
 - sig/annotato.rbs
 homepage: https://github.com/boserh/annotato