annotato 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abbd50b99b491161e60be9f141a6e5315d56602dbf4b361f2f0a9d0fe15ad49b
-  data.tar.gz: b4f5fb6095559edb538bc3f4fe9f8b6ffd723c3e34a75c9259f2b460474aeed8
+  metadata.gz: c083f5bdc6340dbd160b2392a98776b88540333ed1ab48cb7d9cf10065d5299e
+  data.tar.gz: 415a2f70e589b162364d16b4132b58cb9899f85f1147214756e3f81fdda89cb3
 SHA512:
-  metadata.gz: 05ed566b4eba95b988ec2873588d2f6ac10d650d1807a54ca0374f2657d8f5e29dea50daf8b255f55c7ac58d6e553a1b646a1cef71f0ad31d809331f59eda612
-  data.tar.gz: 2203994c5c48cff744ad5e1d6583eec04211cd664b9d60aafbbec1cee02ff74dc1ae9a67350736655388e9d419c54c7bf46f897c6b66474805908c103bee4e97
+  metadata.gz: 0c5713da93df6b7dfa3bd4cc9524a80e503a2edc5da17268b73e5ee0de762222aa376cd26a7bed31ef9feba87b05e1e0701160987442ea55699033ff8d1341aa
+  data.tar.gz: be1a839e36ef7f8066376087108177472bab0750a912c04c687177a1a3856f6da338c8eb5c9893026fc372992325c8219a3bbbbe1bcb4deae962e59a82fb4462

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    annotato (0.1.6)
+    annotato (0.1.8)
       rails (>= 6.0)
 
 GEM

data/README.md

@@ -9,15 +9,15 @@
 
 ## Features
 
-- Annotates Rails models with:
-  - Columns and types
-  - Default values and constraints
-  - Enums with values
-  - Indexes (only if present)
-  - Triggers (only if present)
-- Skips unchanged annotations
-- Replaces legacy `annotate`/`annotate_models` blocks
-- Smart formatting with aligned columns
+* Annotates Rails models with:
+
+  * Columns and types
+  * Default values and constraints
+  * Enums with values
+  * Indexes (only if present)
+  * Triggers (only if present)
+* Skips unchanged annotations
+* Smart formatting with aligned columns
 
 Example:
 
@@ -57,23 +57,38 @@ bundle install
 
 ## Usage
 
-To annotate all models:
+### Annotate All Models
+
+To annotate all models, run:
 
 ```bash
 bundle exec rake annotato:models
 ```
 
+### Annotate Specific Models
+
+You can now pass one or multiple model names to the task.
+
+```bash
+# Annotate only the User model
+rake annotato:models[User]
+
+# Annotate multiple models (User and Admin::Account)
+rake annotato:models["User,Admin::Account"]
+```
+
 ---
 
 ## Rake Task
 
 ```bash
-rake annotato:models
+rake annotato:models[MODEL]
 ```
 
-- Automatically loads all models via `Rails.application.eager_load!`
-- Modifies model files in place
-- Existing Annotato and Annotate blocks will be replaced
+* Automatically loads all models via `Rails.application.eager_load!`
+* Modifies model files in place
+* Replace existing Annotato and legacy annotate blocks
+* **Pass `MODEL` argument (single or comma-separated) to target specific models**
 
 ---
 

data/lib/annotato/column_formatter.rb

@@ -1,76 +1,97 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module Annotato
   class ColumnFormatter
+    # Main entry: returns an array of comment lines per column, flattened.
     def self.format(model, connection)
-      table_name = model.table_name
-      primary_key = model.primary_key
-      enums = model.defined_enums
+      table_name     = model.table_name
+      primary_key    = model.primary_key
       unique_indexes = connection.indexes(table_name).select(&:unique)
-      columns = connection.columns(table_name)
+      enums          = model.defined_enums
+      columns        = connection.columns(table_name)
 
-      raw_data = columns.map do |col|
+      # 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
+
+      columns.flat_map do |col|
         name = col.name
         type = col.sql_type
-        default = col.default
-        opts = []
-
-        opts << "default(#{default.inspect})" unless default.nil?
-        opts << "not null" unless col.null
-        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)
-
-        [name, type, default, opts]
-      end
-
-      name_width = raw_data.map { |name, *_| name.length }.max
-      type_width = raw_data.map { |_, type, *_| type.length }.max
 
-      raw_data.flat_map do |name, type, default, opts|
-        base_line = "#  %-#{name_width}s :%-#{type_width}s" % [name, type]
-        indent = ' ' * (base_line.length + 1)
+        # 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.
+        indent_size = left.length + 1
+        indent_str  = " " * indent_size
+        closing_indent_str  = " " * (indent_size - 2)
 
-        if multiline_default?(default)
-          formatted_defaults = format_multiline_default(default)
-          remaining_opts = opts.reject { |o| o.start_with?("default(") }
+        # Gather all options, pulling out default_lines if multiline.
+        opts         = []
+        default_block = build_default_block(col.default)
+        if default_block
+          opts << "__MULTILINE__"  # placeholder
+        elsif col.default
+          opts << "default(#{col.default.inspect})"
+        end
+        opts << "not null"       unless col.null
+        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)
 
-          lines = []
-          lines << "#{base_line} default(["
-          formatted_defaults.each do |v|
-            lines << "#{'#' + indent}#{v}"
-          end
-          closing = "#{'#' + indent}]),"
-          closing += " #{remaining_opts.join(', ')}" unless remaining_opts.empty?
-          lines << closing.rstrip
+        # Emit either a multiline block or a single line.
+        if default_block
+          # 1) opening line
+          lines = ["#{left} default(#{col.default[0]}"]
+          # 2) each interior line, prefixed by "# " + indent_str
+          lines += default_block.map { |l| "# #{indent_str}#{l}" }
+          # 3) closing line with trailing options
+          closing = "# #{closing_indent_str}#{col.default[-1]})"
+          trailing = opts.reject { |o| o == "__MULTILINE__" }
+          closing += ", #{trailing.join(', ')}" unless trailing.empty?
+          lines << closing
           lines
         else
-          line = base_line
+          # single-line comment
+          line = left
           line += " #{opts.join(', ')}" unless opts.empty?
-          line.rstrip
+          [line.rstrip]
         end
       end
     end
 
-    def self.multiline_default?(value)
-      value.is_a?(String) && value.strip.start_with?("[") && value.strip.end_with?("]") && value.include?(",")
-    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 ["{}"].
+    def self.build_default_block(value)
+      return nil if value.nil?
+      s = value.strip
+      return nil unless s.start_with?("[") || s.start_with?("{")
 
-    def self.format_multiline_default(value)
-      parsed = JSON.parse(value)
-      return [value] unless parsed.is_a?(Array)
+      parsed = JSON.parse(s) rescue nil
+      return nil unless parsed.is_a?(Array) || parsed.is_a?(Hash)
 
-      items = parsed.is_a?(Array) && parsed[0].is_a?(Array) ? parsed[0] : parsed
+      if parsed.is_a?(Array)
+        return if parsed.empty? # empty array → ["[]"]
 
-      items.map.with_index do |item, idx|
-        comma = idx == items.size - 1 ? "" : ","
-        "#{item.to_json}#{comma}"
+        # Only a 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 → ["{}"]
+
+        # JSON hash → key/value pairs
+        parsed.map.with_index do |(k, v), i|
+          comma = i == parsed.size - 1 ? "" : ","
+          %Q{"#{k}": #{v.inspect}#{comma}}
+        end
       end
-    rescue JSON::ParserError
-      [value]
     end
   end
 end

data/lib/annotato/model_annotator.rb

@@ -10,8 +10,9 @@ module Annotato
       @output = output
     end
 
-    def run
-      models.each do |model|
+    def run(one_model = nil)
+      mtd = one_model ? [one_model] : models
+      mtd.each do |model|
         next unless model.table_exists?
 
         annotation = AnnotationBuilder.build(model)

data/lib/annotato/version.rb

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

data/lib/tasks/annotato.rake

@@ -1,8 +1,23 @@
+# lib/tasks/annotato.rake
+
 require "annotato/model_annotator"
 
 namespace :annotato do
-  desc "Annotate models with schema info"
-  task models: :environment do
-    Annotato::ModelAnnotator.new.run
+  desc "Annotate models with schema info. Pass MODEL=name or comma-separated list"
+  task :models, [:MODEL] => :environment do |t, args|
+    # Parse MODEL argument into an array of model names, if given
+    model_list = args[:MODEL]&.split(",")&.map(&:strip)
+
+    annotator = Annotato::ModelAnnotator.new
+
+    if model_list && model_list.any?
+      # Constantize each name and annotate only those classes
+      model_list.map(&:constantize).each do |klass|
+        annotator.run(klass)
+      end
+    else
+      # No MODEL passed → annotate all models
+      annotator.run
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: annotato
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Serhii Bodnaruk
 bindir: exe
 cert_chain: []
-date: 2025-05-16 00:00:00.000000000 Z
+date: 2025-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails