awesome_annotate 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 231c9ce46ab9f54c995580b73fc46b2f16df5531ab979b0fa9ce7273e34c5fda
-  data.tar.gz: 0752a6de349b42c1658a8a907f503f1a16392a8d894af9436877c6cb83dbe68a
+  metadata.gz: d120e2f6dba99ee06506353a609f7b68e4ad08213141762b77ca6dacacc854ce
+  data.tar.gz: 6bb8098703ec777bfc7dcc9351ca88ed4c2f9655cb122c71f25b398165aad187
 SHA512:
-  metadata.gz: 37e53bcca2c79b97e551397f0dd6c92ab0c1f2b833edb05175100b0548c00c8b3117ea4aa528ef9f37e604329805f65f98ba9ac48c6bc2661b6395777de3028e
-  data.tar.gz: c38e57f6d68825d3917fa0c9926be4ac7526c5a0154c568afc18b802363bd4af1e7e37e22581ea009a0fa5bdb1ab0f0d3c9f1f5f11f12e21dfc7ee3d89a2862a
+  metadata.gz: d04a22f78762b7fd4de71460b710b512b3c23e126ce136afa326a7aa1a32f7bc9be2c72ed7fa3a740da266ae2cea8883d0a156296089a1ed3dc8fa0b88ae02f7
+  data.tar.gz: d64c97ff823e7eb03e2f16a9e511343ef6dc9856c33e78b2e0003e8ccaf390ce7adc87dedb62a1299aa320b0293d9a148677fbc86b7d9e6886d8e3c210ee9a1a

data/.rubocop.yml

@@ -1,18 +1,50 @@
-inherit_from:
-  - .rubocop_todo.yml
-
 require:
   - rubocop-rake
   - rubocop-rspec
 
 AllCops:
+  TargetRubyVersion: 3.0
   Exclude:
     - 'vendor/**/*'
     - 'spec/fixtures/**/*'
     - 'tmp/**/*'
-    - 'spec/integration/**/*'
   NewCops: enable
 
+Style/Documentation:
+  Enabled: false
+
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*.rb'
+
+Metrics/AbcSize:
+  Exclude:
+    - 'spec/support/**/*'
+
+RSpec/VerifiedDoubles:
+  Exclude:
+    - 'spec/support/**/*'
+
+RSpec/MultipleExpectations:
+  Exclude:
+    - 'spec/**/*'
+
+RSpec/NestedGroups:
+  Exclude:
+    - 'spec/**/*'
+
+RSpec/HooksBeforeExamples:
+  Exclude:
+    - 'spec/**/*'
+
+RSpec/ExampleLength:
+  Exclude:
+    - 'spec/**/*'
+
+RSpec/DescribeClass:
+  Exclude:
+    - 'spec/integration/**/*'
+
+Lint/EmptyClass:
+  Exclude:
+    - 'spec/support/rails.rb'

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.2.0] - 2026-05-10
+
+- Added model schema annotations with column type, nullability, primary key,
+  default value, and basic index information.
+- Added duplicate-safe annotation blocks with AwesomeAnnotate start and end
+  markers.
+- Added route annotations for `config/routes.rb`.
+- Added model commands:
+  - `awesome_annotate model MODEL`
+  - `awesome_annotate models`
+  - `awesome_annotate models MODEL...`
+- Added `awesome_annotate all` to annotate all models and routes.
+- Added remove commands:
+  - `awesome_annotate remove model MODEL`
+  - `awesome_annotate remove models`
+  - `awesome_annotate remove routes`
+  - `awesome_annotate remove all`
+- Added Rails-like integration specs and GitHub Actions CI for RSpec and
+  RuboCop.
+- Documented supported Ruby and Active Record versions.
+
 ## [0.1.3] - 2024-05-05
 
 - Add a new feature

data/README.md

@@ -1,35 +1,210 @@
 # AwesomeAnnotate
 
-TODO: Delete this and the text below, and describe your gem
+AwesomeAnnotate adds generated schema and route comments to Rails applications.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/awesome_annotate`. To experiment with that code, run `bin/console` for an interactive prompt.
+This gem is intended as a small replacement-style tool for the basic features of
+the original `annotate` gem:
+
+- annotate model files with Active Record schema information
+- annotate `config/routes.rb` with the application's route table
+- replace previous AwesomeAnnotate blocks instead of appending duplicates
+- remove generated AwesomeAnnotate blocks
+
+## Requirements
+
+- Ruby 3.0 or later, below 4.0
+- Active Record 6.1 or later, below 8.0
+- Rails application layout with `config/environment.rb`
+
+Development currently uses the Ruby version in `.ruby-version`.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Add this line to your Rails application's Gemfile:
+
+```ruby
+gem 'awesome_annotate'
+```
 
-Install the gem and add to the application's Gemfile by executing:
+Then run:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```sh
+bundle install
+```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+If you are using this repository directly before publishing the gem, use a Git
+source instead:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```ruby
+gem 'awesome_annotate', git: 'https://github.com/wisdom-plus/awesome_annotate'
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+Run commands from the root directory of a Rails application.
+
+Available commands:
+
+```sh
+bundle exec awesome_annotate model user
+bundle exec awesome_annotate models
+bundle exec awesome_annotate models user article admin/user
+bundle exec awesome_annotate routes
+bundle exec awesome_annotate all
+bundle exec awesome_annotate remove model user
+bundle exec awesome_annotate remove models
+bundle exec awesome_annotate remove routes
+bundle exec awesome_annotate remove all
+```
+
+Annotate a model:
+
+```sh
+bundle exec awesome_annotate model user
+```
+
+Annotate all models:
+
+```sh
+bundle exec awesome_annotate models
+```
+
+Annotate specific models:
+
+```sh
+bundle exec awesome_annotate models user article admin/user
+```
+
+Annotate all models and routes:
+
+```sh
+bundle exec awesome_annotate all
+```
+
+Remove generated annotations:
+
+```sh
+bundle exec awesome_annotate remove model user
+bundle exec awesome_annotate remove models
+bundle exec awesome_annotate remove routes
+bundle exec awesome_annotate remove all
+```
+
+This loads `config/environment.rb`, resolves `User`, reads its Active Record
+columns, and writes a schema block before the class definition in
+`app/models/user.rb`:
+
+```ruby
+# == AwesomeAnnotate: columns
+# == Schema Information
+#
+# Table name: users
+#
+#  id         :integer  not null, primary key
+#  name       :string
+#  email      :string   not null, default("")
+#  created_at :datetime not null
+#  updated_at :datetime not null
+#
+# Indexes
+#
+#  (email)       UNIQUE, index_users_on_email
+#  (name,email)  index_users_on_name_and_email
+#
+# == /AwesomeAnnotate: columns
+class User < ApplicationRecord
+end
+```
+
+Annotate routes:
+
+```sh
+bundle exec awesome_annotate routes
+```
+
+This writes a generated route block before `Rails.application.routes.draw do` in
+`config/routes.rb`:
+
+```ruby
+# == AwesomeAnnotate: routes
+# Prefix Verb URI Pattern Controller#Action
+# users GET /users(.:format) users#index
+# == /AwesomeAnnotate: routes
+Rails.application.routes.draw do
+end
+```
+
+Print the gem version:
+
+```sh
+bundle exec awesome_annotate --version
+```
+
+Short aliases are also available:
+
+```sh
+bundle exec awesome_annotate -m user
+bundle exec awesome_annotate -r
+bundle exec awesome_annotate -v
+```
+
+## Generated Blocks
+
+AwesomeAnnotate wraps generated comments with start and end markers:
+
+```ruby
+# == AwesomeAnnotate: columns
+# ...
+# == /AwesomeAnnotate: columns
+```
+
+When the command is run again, the existing block with the same marker is
+replaced. This prevents duplicate annotations from being appended on repeated
+runs.
+
+## Current Limitations
+
+- Only model schema blocks and routes are supported.
+- Model annotations include column type, nullability, primary key, and default
+  values, plus basic index information.
+- Model annotation currently targets files under `app/models`.
+- Model class detection expects a simple class declaration such as
+  `class User < ApplicationRecord`.
+- Existing comments generated by other annotate tools are not migrated or
+  removed automatically.
+- Ruby 4 is not currently supported.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Install dependencies:
+
+```sh
+bundle install
+```
+
+Run the test suite:
+
+```sh
+bundle exec rspec
+```
+
+Run RuboCop:
+
+```sh
+bundle exec rubocop
+```
+
+Build the gem locally:
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+```sh
+bundle exec rake build
+```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/awesome_annotate.
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/wisdom-plus/awesome_annotate.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the MIT License.

data/Rakefile

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 

data/exe/awesome_annotate

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-unless File.exist?('./Rakefile') || File.exist?('./Gemfile')
-  abort 'Please run annotate from the root of the project.'
-end
+abort 'Please run annotate from the root of the project.' unless File.exist?('./Rakefile') || File.exist?('./Gemfile')
 require 'awesome_annotate'
 
 AwesomeAnnotate::CLI.start ARGV

data/lib/awesome_annotate/annotation_block.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AwesomeAnnotate
+  module AnnotationBlock
+    private
+
+    def replace_or_insert_annotation(file_path:, marker:, content:, before:)
+      path = file_path.to_s
+      file_content = File.read(path)
+      annotation = annotation_block(marker, content)
+
+      File.write(path, replace_annotation(file_content, marker, annotation, before))
+    end
+
+    def remove_annotation(file_path:, marker:)
+      path = file_path.to_s
+      file_content = File.read(path)
+      pattern = annotation_block_pattern(marker)
+
+      return false unless file_content.match?(pattern)
+
+      File.write(path, file_content.gsub(pattern, ''))
+      true
+    end
+
+    def annotation_block(marker, content)
+      body = content.end_with?("\n") ? content : "#{content}\n"
+
+      "# == AwesomeAnnotate: #{marker}\n" \
+        "#{body}" \
+        "# == /AwesomeAnnotate: #{marker}\n\n"
+    end
+
+    def annotation_block_pattern(marker)
+      escaped_marker = Regexp.escape(marker)
+      %r{^# == AwesomeAnnotate: #{escaped_marker}\n.*?^# == /AwesomeAnnotate: #{escaped_marker}\n(?:\n)*}m
+    end
+
+    def replace_annotation(file_content, marker, annotation, before)
+      pattern = annotation_block_pattern(marker)
+
+      return file_content.sub(pattern, annotation) if file_content.match?(pattern)
+
+      file_content.sub(before, "#{annotation}\\0")
+    end
+  end
+end

data/lib/awesome_annotate/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'awesome_annotate'
 require 'awesome_annotate/model'
 require 'awesome_annotate/route'
@@ -5,11 +7,34 @@ require 'awesome_annotate/version'
 require 'thor'
 
 module AwesomeAnnotate
+  class Remove < Thor
+    desc 'model [model_name]', 'remove annotation from a model'
+    def model(model_name)
+      AwesomeAnnotate::Model.new.remove(model_name)
+    end
+
+    desc 'models [model_names...]', 'remove annotations from all models or specified models'
+    def models(*model_names)
+      AwesomeAnnotate::Model.new.remove_all(model_names)
+    end
+
+    desc 'routes', 'remove annotation from `config/routes.rb`'
+    def routes
+      AwesomeAnnotate::Route.new.remove
+    end
+
+    desc 'all', 'remove annotations from all models and routes'
+    def all
+      AwesomeAnnotate::Model.new.remove_all
+      AwesomeAnnotate::Route.new.remove
+    end
+  end
+
   class CLI < Thor
     include Thor::Actions
 
     map %w[--version -v] => :print_version
-    desc "--version, -v", "print the version"
+    desc '--version, -v', 'print the version'
     def print_version
       say AwesomeAnnotate::VERSION
     end
@@ -20,13 +45,25 @@ module AwesomeAnnotate
       AwesomeAnnotate::Model.new.annotate(model_name)
     end
 
+    desc 'models [model_names...]', 'annotate all models or specified models'
+    def models(*model_names)
+      AwesomeAnnotate::Model.new.annotate_all(model_names)
+    end
+
     map %w[routes -r] => :routes
-    desc 'routes', "Writes application route information to `config/routes.rb`."
+    desc 'routes', 'Writes application route information to `config/routes.rb`.'
     def routes
       AwesomeAnnotate::Route.new.annotate
     end
 
-    private
+    desc 'all', 'annotate all models and routes'
+    def all
+      AwesomeAnnotate::Model.new.annotate_all
+      AwesomeAnnotate::Route.new.annotate
+    end
+
+    desc 'remove SUBCOMMAND', 'remove generated annotations'
+    subcommand 'remove', Remove
 
     def self.exit_on_failure?
       true

data/lib/awesome_annotate/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module AwesomeAnnotate
+  class Error < StandardError; end
+  class NotFoundError < Error; end
+end

data/lib/awesome_annotate/model.rb

@@ -1,68 +1,139 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require 'thor'
+require_relative 'annotation_block'
+require_relative 'error'
+require_relative 'rails_environment'
+require_relative 'schema_annotation'
 
 module AwesomeAnnotate
   class Model < Thor
+    include AnnotationBlock
     include Thor::Actions
+    include RailsEnvironment
+    include SchemaAnnotation
+
+    def initialize(params = {})
+      super()
+      @env_file_path = Pathname.new(params[:env_file_path] || 'config/environment.rb')
+      @model_dir = Pathname.new(params[:model_dir] || 'app/models')
+    end
 
     desc 'model [model name]', 'annotate your model'
     def annotate(model_name)
-      abort "Rails application path is required" unless env_file_path.exist?
+      raise 'Rails application path is required' unless @env_file_path.exist?
+
+      load_rails_environment
+      annotate_loaded_model(model_name)
+    end
+
+    desc 'models [model names]', 'annotate all models or specified models'
+    def annotate_all(model_names = [])
+      raise 'Rails application path is required' unless @env_file_path.exist?
+
+      load_rails_environment
+
+      if model_names.empty?
+        discover_model_names.each { |model_name| annotate_discovered_model(model_name) }
+      else
+        model_names.each { |model_name| annotate_loaded_model(model_name) }
+      end
+    end
+
+    desc 'remove [model name]', 'remove annotation from your model'
+    def remove(model_name)
+      file_path = model_file_path(model_name)
+
+      remove_model_annotation(file_path)
+    end
 
-      apply env_file_path.to_s
+    desc 'remove_all [model names]', 'remove annotations from all models or specified models'
+    def remove_all(model_names = [])
+      if model_names.empty?
+        discovered_model_file_paths.each { |file_path| remove_model_annotation(file_path, report_missing: false) }
+      else
+        model_names.each { |model_name| remove(model_name) }
+      end
+    end
 
-      klass = klass_name(model_name)
+    private
+
+    def annotate_loaded_model(model_name, report_missing: true)
+      klass = klass_name(model_name, report_missing: report_missing)
 
       return say 'This model does not inherit activerecord' unless klass < ActiveRecord::Base
 
-      column_names = column_names(klass)
       file_path = model_file_path(model_name)
 
-      insert_file_before_class(file_path, klass, "# Columns: #{column_names.join(', ')}\n")
+      insert_file_before_class(file_path, schema_annotation(klass))
 
       say "annotate #{model_name.pluralize} table columns in #{file_path}"
     end
 
-    private
+    def discover_model_names
+      discovered_model_file_paths.map { |file_path| model_name_from_file_path(file_path) }
+    end
 
-    def env_file_path
-      Pathname.new('config/environment.rb')
+    def discovered_model_file_paths
+      Dir.glob(@model_dir.join('**/*.rb')).reject { |file_path| excluded_model_file?(file_path) }
     end
 
-    def model_dir
-      Pathname.new('app/models')
+    def model_name_from_file_path(file_path)
+      Pathname.new(file_path).relative_path_from(@model_dir).sub_ext('').to_s
     end
 
-    def insert_file_before_class(file_path, klass, message)
-      insert_into_file file_path, :before => /^class\s+\w+\s+<\s+\w+/ do
-        message
+    def excluded_model_file?(file_path)
+      relative_path = Pathname.new(file_path).relative_path_from(@model_dir).to_s
+
+      relative_path == 'application_record.rb' || relative_path.start_with?('concerns/')
+    end
+
+    def annotate_discovered_model(model_name)
+      annotate_loaded_model(model_name, report_missing: false)
+    rescue AwesomeAnnotate::NotFoundError
+      nil
+    end
+
+    def remove_model_annotation(file_path, report_missing: true)
+      if remove_annotation(file_path: file_path, marker: 'columns')
+        say "remove model annotation in #{file_path}"
+      elsif report_missing
+        say "no model annotation in #{file_path}"
       end
     end
 
-    def column_names(klass)
-      klass.column_names
+    def insert_file_before_class(file_path, message)
+      replace_or_insert_annotation(
+        file_path: file_path,
+        marker: 'columns',
+        content: message,
+        before: /^class\s+\w+\s+<\s+\w+/
+      )
     end
 
     def model_file_path(model_name)
-      file_path = "#{model_dir}/#{model_name}.rb"
+      file_path = "#{@model_dir}/#{model_name}.rb"
 
       unless File.exist?(file_path)
-        return say "Model file not found"
+        say 'Model file not found'
+        raise AwesomeAnnotate::NotFoundError
       end
 
-      return file_path
+      file_path
     end
 
-    def klass_name(model_name)
+    def klass_name(model_name, report_missing: true)
       name = model_name.singularize.camelize
-      klass = Object.const_get(name)
-
+      Object.const_get(name)
     rescue NameError
-      say "Model not found"
+      say 'Model not found' if report_missing
+      raise AwesomeAnnotate::NotFoundError
     end
 
     def self.source_root
       Dir.pwd
     end
+    private_class_method :source_root
   end
 end

data/lib/awesome_annotate/rails_environment.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AwesomeAnnotate
+  module RailsEnvironment
+    private
+
+    def load_rails_environment
+      require @env_file_path.expand_path.to_s
+    end
+  end
+end

data/lib/awesome_annotate/route.rb

@@ -1,15 +1,27 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require 'thor'
+require_relative 'annotation_block'
+require_relative 'rails_environment'
 
 module AwesomeAnnotate
   class Route < Thor
+    include AnnotationBlock
     include Thor::Actions
+    include RailsEnvironment
+
+    def initialize(params = {})
+      super()
+      @env_file_path = Pathname.new(params[:env_file_path] || 'config/environment.rb')
+      @route_file_path = Pathname.new(params[:route_file_path] || 'config/routes.rb')
+    end
 
     desc 'annotate all routes', 'annotate your routes'
     def annotate
-      abort "Rails application path is required" unless env_file_path.exist?
+      raise 'Rails application path is required' unless @env_file_path.exist?
 
-      apply env_file_path.to_s
+      load_rails_environment
 
       inspector = ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes)
       formatter = ActionDispatch::Routing::ConsoleFormatter::Sheet.new
@@ -17,20 +29,25 @@ module AwesomeAnnotate
       routes = inspector.format(formatter, {})
       route_message = parse_routes(routes)
 
-      insert_file_before_class(route_file_path, route_message)
+      raise 'Route file not found' unless @route_file_path.exist?
 
-      say "annotate routes in #{route_file_path}"
+      insert_file_before_class(@route_file_path, route_message)
+
+      say "annotate routes in #{@route_file_path}"
     end
 
-    private
+    desc 'remove', 'remove route annotation'
+    def remove
+      raise 'Route file not found' unless @route_file_path.exist?
 
-    def env_file_path
-      Pathname.new('config/environment.rb')
+      if remove_annotation(file_path: @route_file_path, marker: 'routes')
+        say "remove route annotation in #{@route_file_path}"
+      else
+        say "no route annotation in #{@route_file_path}"
+      end
     end
 
-    def route_file_path
-      Pathname.new('config/routes.rb')
-    end
+    private
 
     def parse_routes(routes)
       split_routes = routes.split(/\r\n|\r|\n/)
@@ -43,13 +60,17 @@ module AwesomeAnnotate
     end
 
     def insert_file_before_class(file_path, message)
-      insert_into_file file_path, :before => "Rails.application.routes.draw do\n" do
-        message
-      end
+      replace_or_insert_annotation(
+        file_path: file_path,
+        marker: 'routes',
+        content: message,
+        before: "Rails.application.routes.draw do\n"
+      )
     end
 
     def self.source_root
       Dir.pwd
     end
+    private_class_method :source_root
   end
 end

data/lib/awesome_annotate/schema_annotation.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module AwesomeAnnotate
+  module SchemaAnnotation
+    private
+
+    def schema_annotation(klass)
+      columns = klass.columns
+      column_name_width = columns.map { |column| column.name.length }.max || 0
+      column_type_width = columns.map { |column| column_type(column).length }.max || 0
+
+      [
+        schema_header(klass),
+        columns.map { |column| column_annotation(klass, column, column_name_width, column_type_width) }.join,
+        index_annotations(klass),
+        "#\n"
+      ].join
+    end
+
+    def schema_header(klass)
+      [
+        "# == Schema Information\n",
+        "#\n",
+        "# Table name: #{klass.table_name}\n",
+        "#\n"
+      ].join
+    end
+
+    def column_annotation(klass, column, column_name_width, column_type_width)
+      column_name = column.name.ljust(column_name_width)
+      type = column_type(column).ljust(column_type_width)
+      details = column_details(klass, column)
+      line = "#  #{column_name} :#{type}"
+
+      line = "#{line} #{details.join(', ')}" if details.any?
+      "#{line}\n"
+    end
+
+    def column_type(column)
+      column.type.to_s
+    end
+
+    def column_details(klass, column)
+      details = []
+      details << 'not null' if column.null == false
+      details << 'primary key' if column.name == klass.primary_key
+      details << "default(#{column.default.inspect})" unless column.default.nil?
+      details
+    end
+
+    def index_annotations(klass)
+      indexes = klass.connection.indexes(klass.table_name)
+      return '' if indexes.empty?
+
+      index_column_width = indexes.map { |index| index_columns(index).length }.max || 0
+
+      [
+        "#\n",
+        "# Indexes\n",
+        "#\n",
+        indexes.map { |index| index_annotation(index, index_column_width) }.join
+      ].join
+    end
+
+    def index_annotation(index, index_column_width)
+      columns = index_columns(index).ljust(index_column_width)
+      details = index_details(index)
+
+      "#  #{columns}  #{details.join(', ')}\n"
+    end
+
+    def index_columns(index)
+      "(#{index.columns.join(',')})"
+    end
+
+    def index_details(index)
+      details = []
+      details << 'UNIQUE' if index.unique
+      details << index.name
+      details
+    end
+  end
+end

data/lib/awesome_annotate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AwesomeAnnotate
-  VERSION = "0.1.4"
+  VERSION = '0.2.0'
 end

data/lib/awesome_annotate.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "awesome_annotate/version"
-require_relative "awesome_annotate/cli"
-
-module AwesomeAnnotate
-  class Error < StandardError; end
-end
+require_relative 'awesome_annotate/version'
+require_relative 'awesome_annotate/error'
+require_relative 'awesome_annotate/cli'

metadata

@@ -1,46 +1,52 @@
 --- !ruby/object:Gem::Specification
 name: awesome_annotate
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - wisdom-plus
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-07 00:00:00.000000000 Z
+date: 2026-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: '1.3'
 description: annotate your code with comments (e.g. model schema, routes, etc.)
 email:
-- wisdom.plus.264.dev@gmail.com
+- wisdom-plus@users.noreply.github.com
 executables:
 - awesome_annotate
 extensions: []
@@ -48,16 +54,20 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
-- awesome_annotate.gemspec
 - exe/awesome_annotate
 - lib/awesome_annotate.rb
+- lib/awesome_annotate/annotation_block.rb
 - lib/awesome_annotate/cli.rb
+- lib/awesome_annotate/error.rb
 - lib/awesome_annotate/model.rb
+- lib/awesome_annotate/rails_environment.rb
 - lib/awesome_annotate/route.rb
+- lib/awesome_annotate/schema_annotation.rb
 - lib/awesome_annotate/version.rb
 - sig/awesome_annotate.rbs
 homepage: https://github.com/wisdom-plus/awesome_annotate
@@ -68,6 +78,7 @@ metadata:
   homepage_uri: https://github.com/wisdom-plus/awesome_annotate
   source_code_uri: https://github.com/wisdom-plus/awesome_annotate
   changelog_uri: https://github.com/wisdom-plus/awesome_annotate/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -76,14 +87,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: annotate your code with comments

data/awesome_annotate.gemspec

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/awesome_annotate/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "awesome_annotate"
-  spec.version = AwesomeAnnotate::VERSION
-  spec.authors = ["wisdom-plus"]
-  spec.email = ["wisdom.plus.264.dev@gmail.com"]
-
-  spec.summary = "annotate your code with comments"
-  spec.description = "annotate your code with comments (e.g. model schema, routes, etc.)"
-  spec.homepage = "https://github.com/wisdom-plus/awesome_annotate"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0.0"
-
-  spec.metadata["allowed_push_host"] = "https://rubygems.org"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = spec.homepage + "/blob/main/CHANGELOG.md"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  spec.add_dependency "thor"
-  spec.add_dependency "activerecord", ">= 6.1.0"
-end