annotato 0.1.16 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53d8c10c79ec7a147fde40ed706fa11b77e62a65f1afbb87a204b8f2153d6f29
-  data.tar.gz: 488da6fb4970e359d266cc6e817502a72cdfc29a2d7ab59f10219c1e73978ef6
+  metadata.gz: ad60c697f9ee0213951d02981190dee26a8db0a2e48ab36d3118c1aaf95d4d40
+  data.tar.gz: 43a5f89b6509a636d579416c92bbbc52c63e15b8029701b46c525bd651a049a1
 SHA512:
-  metadata.gz: 6dd785f4e27b78b9a2084d2f846e531aba53774be945e5534386a179165c9509028bb8010f97fbab57c31693ed33aeda2fc2ec7f3ee807b711f7ad4086270048
-  data.tar.gz: 52d70e99d63296a518007970d09f20c209b15b5bb993b1c4f114c0912ba143c28d79e091491b74c7585898fef9c0c1140486db61df1a9782deefe935849720aa
+  metadata.gz: 7753fdc81bfc3568053c99f3f4f98107d0ca3b2ad1b64b127e19902e00f35a8b889b86b2219a431ea2dd673bab86000d0705b59d7a88ef1c68192be2cf012d3e
+  data.tar.gz: d05dd1bb4dd969a77555c3685ab129a9f31a479c5d2f69ef80c9ed7971677c044bc918ec2fd7e1212bc90eb49e678acd306f8afe66d7c9b743ea3b9dc3b9e650

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    annotato (0.1.16)
+    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/lib/annotato/annotation_builder.rb

@@ -22,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:"

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/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.16"
+  VERSION = "0.2.1"
 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.16
+  version: 0.2.1
 platform: ruby
 authors:
 - Serhii Bodnaruk
 bindir: exe
 cert_chain: []
-date: 2026-01-23 00:00:00.000000000 Z
+date: 2026-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails