table_inspector 0.5.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83143bbf7fb6d4ce752da10da85b265037f75fad9417f104ab761660d638db1b
-  data.tar.gz: 6268b3194f9eef7ec25c830cae63cad79d0fa29ed8b98f27c77049b450d31def
+  metadata.gz: ce96fede5dc61b809184ab371402e7972da49f1fc1708529bf7c38751fc1b595
+  data.tar.gz: 9318bbdcfc07d9e5af604bdcf98a1078cada3731136cd259b16ca78e5fbd22fd
 SHA512:
-  metadata.gz: 5e5df809d52919113556d0048e91e633663bcba444b4d2cff13919bb0670f01a51a9460de7789ef556f661c5fc25aa213eff3fb38547a0566331300cd17dd5f4
-  data.tar.gz: a137cf1372c765da06bcfc459f4ab0d5b7f9e09f947bbaa0908c560f8cbea24e3e6ab45a5dad043527e7b6f57328d4541876f1acae10394faf2d5435888bf344
+  metadata.gz: a127d351bc28568ceb50173324092b43d04289bfe0e3af625b304a2208697ea734437db2fc9be9bc6f296eb3db2e3f227e7eccadaef1a7850d3ed5f6c0d84a2a
+  data.tar.gz: cc0119437824fbd9be0f0ec80756ffd59339db0143167295943f109b91d0585306f7bcd192fe844176e657db5927d9bf07819f5359004d3f60dbf1238e9f65d8

data/README.md

@@ -1,20 +1,44 @@
 # TableInspector
-This is a Rails gem that allows you to print the definition of a table. While some gems (like [annotate_models](https://github.com/ctran/annotate_models)) are used to embed the table schema in the model file, they can be difficult to maintain and add unnecessary noise. This gem provides an alternative way to check the schema of a table without using `annotate_models`.
+![Test coverage](https://img.shields.io/badge/Test_coverage-96.71%25-green)
+![Release version](https://img.shields.io/badge/Release-v0.6.0-green)
+![Workflow badge](https://github.com/otorain/table_inspector/actions/workflows/run_test.yml/badge.svg)
+
+This is a Rails gem that allows you to print the structure of a database table by providing a model class.
+It functions similar to [annotate_models](https://github.com/ctran/annotate_models), but offers an alternative way to checking the table schema.
+The print function is based on [terminal-table](https://github.com/tj/terminal-table)
+
+This doc is about version 0.6.0. For version 0.5.0, please see [here](https://github.com/otorain/table_inspector/tree/v0.5.5)
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "table_inspector", "~> 0.6.0"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install table_inspector
+```
 
 ## Usage
 Assuming there is a model call `User` which has `id` and `name` column, and has a unique index for `name`.
-For print the definition of User, we can use: 
+For print the table structure of User, we can use: 
 ```ruby
-require "table_inspector"
-
 TableInspector.scan User
 ```
 
 ![TableInspect scan table](/img/table_inspector_scan_table_3.png)
 
-It will print the all table definition and all indexes.
+This will print the scheme of table and indexes. 
+If the table content is too long and appears messy, you can adjust the scaling of the terminal window or use the `TableInspector.scan(User, :name)` syntax to print a specific column. 
 
-Or you can use `TableInspector.ascan` to print more colorful table(`ascan` means `awesome scan`) :
+Alternatively, you can use `TableInspector.ascan` to print a more colorful table(`ascan` means `awesome scan`) :
 ```ruby
 TableInspector.ascan User
 ```
@@ -29,29 +53,62 @@ TableInspector.scan User, :name
 
 It will print the column definition and which indexes that contains this column.
 
-Also, you can print `sql_type` which type of column in database by provide `sql_type: true` option: 
+If you are using Ruby version 2.7.0 or later, you can define a helper method directly in the model itself by editing the `app/models/application_record.rb` file and adding the code provided below:
+```ruby
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+  # ...
+
+  def self.ti(...)
+    TableInspector.scan(self, ...) if const_defined?("TableInspector")
+  end
+
+  def self.ati(...)
+    TableInspector.ascan(self, ...) if const_defined?("TableInspector")
+  end
+  
+  # ...
+end
+```
+Then you will be able to achieve the same effect as `scan` and `ascan` do by invoking `ti` and `ati` on the model class:
 
 ```ruby
+# Same as TableInspector.scan User
+User.ti
+
+# Same as TableInspector.ascan User
+User.ati
+```
+
+You can print the database column type by providing the `sql_type: true` option:
+```ruby
+User.ti sql_type: true
+# or 
 TableInspector.scan User, sql_type: true
 ```
 ![Table Inspector scan table column with sql type](/img/table_inspector_scan_table_with_sql_type_3.png)
 
-## Installation
-Add this line to your application's Gemfile:
-
+Additionally, if you want to print the comments associated with the columns of the table, you can use the `comment_only` option:
 ```ruby
-gem "table_inspector"
+User.ti comment_only: true
+# or
+TableInspector.scan User, comment_only: true
 ```
+![Table Inspector scan table comment only](/img/table_inspector_scan_table_comment_only.png)
+If the `sql_type: true` option is also provided, the sql_type option will be omitted.
 
-And then execute:
-```bash
-$ bundle
-```
+## Style
+To change the style of the table by setting the `TableInspector.style` in `config/initializers/table_inspector.rb`(create it if not exists): 
+```ruby
+# config/initializers/table_inspector.rb
 
-Or install it yourself as:
-```bash
-$ gem install table_inspector
+TableInspector.style = { border: :unicode }
+# TableInspector.style = { border: :ascii } # default border style
+# TableInspector.style = { border: :unicode_round }
+# TableInspector.style = { border: :unicode_thick_edge } 
+# TableInspector.style = { border: :markdown }
 ```
+You can use other options available in `TerminalTable#style` of the [terminal-table](https://github.com/tj/terminal-table) 
 
 ## Contributing
 Contribution directions go here.

data/lib/table_inspector/column.rb

@@ -1,37 +1,42 @@
 
 module TableInspector
   class Column
-    attr_reader :column, :klass, :sql_type, :presenter
+    attr_reader :column, :klass, :presenter
+    delegate :break_line, :bold, to: TableInspector::Text
 
-    def initialize(klass, column_name, sql_type: false, colorize: false )
-      @column = klass.columns.find {|column| column.name == column_name.to_s}
+    def initialize(klass, column_name, presenter_option)
+      @column = klass.columns.find { |column| column.name == column_name.to_s }
       @klass = klass
-      @sql_type = sql_type
-      @colorize = colorize
-      @presenter = Presenter.new(klass, sql_type: sql_type, colorize: colorize)
+      @presenter = Presenter.current.new(klass, presenter_option)
     end
 
     def render
-      Text.break_line
+      break_line # empty line
       render_title
       render_body
-      Text.break_line
-      Indexes.new(klass, column.name, colorize: @colorize).render
-      Text.break_line
+      break_line # empty line
+      render_indexes
+      break_line # empty line
     end
 
     private
 
     def render_title
-      Grid.new do |grid|
-        grid.add_row(["#{Text.bold('Table')}: #{klass.table_name}", "#{Text.bold('Column')}: #{column.name}"])
+      TerminalTable.new do |terminal_table|
+        table_name = bold('Table') + ": " + klass.table_name
+        column_name = bold('Column') + ": " + column.name
+        terminal_table.add_row([table_name, column_name])
       end.render
     end
 
     def render_body
-      Grid.new(headings: presenter.headings) do |grid|
-        grid.add_row(@presenter.extract_meta(column).values)
+      TerminalTable.new(headings: presenter.headings) do |terminal_table|
+        terminal_table.add_row(@presenter.extract_meta(column).values)
       end.render
     end
+
+    def render_indexes
+      Indexes.new(klass, column.name, colorize: presenter.option.colorize).render
+    end
   end
 end

data/lib/table_inspector/column_validator.rb

@@ -22,7 +22,7 @@ module TableInspector
     end
 
     def column_is_not_exists_hint
-      puts "Column '#{column_name}' doesn't exists in table '#{klass.table_name}'!"
+      puts "Column '#{column_name}' doesn't exist in table '#{klass.table_name}'!"
     end
   end
 end

data/lib/table_inspector/indexes.rb

@@ -13,7 +13,7 @@ module TableInspector
       render_title
 
       if column_name
-        render_indexes_with_specific_column
+        render_indexes_of_column
       else
         render_indexes
       end
@@ -22,48 +22,53 @@ module TableInspector
     private
 
     def render_title
-      Grid.new do |grid|
-        grid.add_row([Text.bold("Indexes")])
+      TerminalTable.new do |terminal_table|
+        terminal_table.add_row([Text.bold("Indexes")])
       end.render
     end
 
-    def render_indexes_with_specific_column
-      Grid.new(headings: headings) do |grid|
-        indexes_with_specific_column.each do |index|
-          grid.add_row(compose_index_data(index))
+    def render_indexes_of_column
+      TerminalTable.new(headings: headings) do |terminal_table|
+        indexes_of_column.each do |index|
+          terminal_table.add_row(compose_index_data(index))
         end
       end.render
     end
 
     def render_indexes
-      Grid.new(headings: headings) do |grid|
+      TerminalTable.new(headings: headings) do |terminal_table|
         indexes.each do |index|
-          grid.add_row(compose_index_data(index))
+          terminal_table.add_row(compose_index_data(index))
         end
       end.render
     end
 
     def compose_index_data(index)
       if @colorize
-        compose_index_data_with_highlight(index)
+        compose_index_data_with_color(index)
       else
-        compose_index_data_without_highlight(index)
+        compose_index_data_without_color(index)
       end
     end
 
-    def compose_index_data_with_highlight(index)
+    def compose_index_data_with_color(index)
+      index_columns_text = index.columns.join(', ')
+      unique_text = index.unique ? "UNIQUE" : ""
+
       [
         index.name,
-        "[#{Text.yellow(index.columns.join(', '))}]",
-        index.unique ? "UNIQUE" : ""
+        "[#{Text.yellow(index_columns_text)}]",
+        unique_text
       ]
     end
 
-    def compose_index_data_without_highlight(index)
+    def compose_index_data_without_color(index)
+      index_columns_text = index.columns.join(', ')
+      unique_text = index.unique ? "UNIQUE" : ""
       [
         index.name,
-        "[#{index.columns.join(', ')}]",
-        index.unique ? "UNIQUE" : ""
+        "[#{index_columns_text}]",
+        unique_text
       ]
     end
 
@@ -75,8 +80,8 @@ module TableInspector
       @indexes ||= connection.indexes(klass.table_name)
     end
 
-    def indexes_with_specific_column
-      indexes.select{|index| index.columns.include?(column_name.to_s) }
+    def indexes_of_column
+      indexes.select{ |index| index.columns.include?(column_name.to_s) }
     end
 
     def connection

data/lib/table_inspector/inspectable.rb

@@ -0,0 +1,16 @@
+
+module TableInspector
+  module Inspectable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def ti(*args, **kwargs, &block)
+        TableInspector.scan(self, *args, **kwargs, &block)
+      end
+
+      def ati(*args, **kwargs, &block)
+        TableInspector.ascan(self, *args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/table_inspector/presenter/mysql2.rb

@@ -0,0 +1,14 @@
+class TableInspector::Presenter::Mysql2 < TableInspector::Presenter
+  def extract_meta_without_highlight(column)
+    column.as_json.merge(column.sql_type_metadata.as_json).slice(*ordered_keys).tap do |column_data|
+      column_data["default"] = case column_data["type"]
+                               when "string"
+                                 column_data["default"]&.inspect
+                               when "boolean"
+                                 { "1" => true, "0" => false }[column_data["default"]]
+                               else
+                                 column_data["default"]
+                               end
+    end
+  end
+end

data/lib/table_inspector/presenter/postgresql.rb

@@ -0,0 +1,15 @@
+
+class TableInspector::Presenter::Postgresql < TableInspector::Presenter
+  def extract_meta_without_highlight(column)
+    column.as_json.merge(column.sql_type_metadata.as_json).slice(*ordered_keys).tap do |column_data|
+      column_data["default"] = case column_data["type"]
+                               when "string"
+                                 column_data["default"]&.inspect
+                               when "boolean"
+                                 { "true" => true, "false" => false }[column_data["default"]]
+                               else
+                                 column_data["default"]
+                               end
+    end
+  end
+end

data/lib/table_inspector/presenter/sqlite3.rb

@@ -0,0 +1,15 @@
+class TableInspector::Presenter::Sqlite3 < TableInspector::Presenter
+
+  def extract_meta_without_highlight(column)
+    column.as_json.merge(column.sql_type_metadata.as_json).slice(*ordered_keys).tap do |column_data|
+      column_data["default"] = case column_data["type"]
+                               when "string"
+                                 column_data["default"]&.inspect
+                               when "boolean"
+                                 { "1" => true, "0" => false }[column_data["default"]]
+                               else
+                                 column_data["default"]
+                               end
+    end
+  end
+end

data/lib/table_inspector/presenter.rb

@@ -1,16 +1,16 @@
 
 module TableInspector
   class Presenter
-    attr_reader :klass, :sql_type
+    attr_reader :klass, :option
+    delegate :green, :yellow, :red, :blue, :cyan, to: Text
 
-    def initialize(klass, sql_type:, colorize: false)
+    def initialize(klass, option)
       @klass = klass
-      @sql_type = sql_type
-      @colorize = colorize
+      @option = option
     end
 
     def extract_meta(column)
-      if @colorize
+      if option.colorize
         extract_meta_with_highlight(column)
       else
         extract_meta_without_highlight(column)
@@ -18,53 +18,92 @@ module TableInspector
     end
 
     def headings
-      first_column = klass.columns.first
-      extract_meta(first_column).keys.map(&:humanize)
+      ordered_keys.map(&:humanize)
+    end
+
+    def self.current
+      adapter = ApplicationRecord.connection_db_config.adapter.camelize
+      available_presenter = %w[Mysql2 Postgresql Sqlite3]
+
+      if available_presenter.include?(adapter)
+        "TableInspector::Presenter::#{adapter}".constantize
+      else
+        TableInspector::Presenter
+      end
     end
 
     private
 
+    def extract_meta_without_highlight(column)
+      column.as_json.merge(column.sql_type_metadata.as_json).slice(*ordered_keys).tap do |column_data|
+        column_data["default"] = if column_data["type"] == "string"
+                                   column_data["default"]&.inspect
+                                 else
+                                   column_data["default"]
+                                 end
+      end
+    end
+
     def extract_meta_with_highlight(column)
       column_data = extract_meta_without_highlight(column)
 
-      # Colorize text but except "comment" field
-      column_data.each do |k, v|
-        if k != "comment"
-          column_data[k] = colorize(v)
+      # Colorize text except comment
+      column_data.except("comment").each do |k, v|
+        if k == "default"
+          column_data[k] = colorize(v, column.type)
         else
-          column_data[k]
+          column_data[k] = colorize(v)
         end
       end
 
       column_data.slice(*ordered_keys)
     end
 
-    def extract_meta_without_highlight(column)
-      column.as_json.merge(column.sql_type_metadata.as_json).slice(*ordered_keys).tap do |column_data|
-        if column_data["default"] == ""
-          column_data["default"] = column_data["default"].inspect
+    def ordered_keys
+      if option.comment_only
+        %w[name comment]
+      else
+        %w[name type limit null default precision scale comment].tap do |keys|
+          keys << "sql_type" if option.sql_type
         end
       end
     end
 
-    def ordered_keys
-      %w[name type limit null default precision scale comment].tap do |keys|
-        keys << "sql_type" if sql_type
+    def colorize(value, type = nil)
+      if type
+        colorize_by_type(value, type)
+      else
+        colorize_by_value(value)
+      end
+    end
+
+    def colorize_by_type(value, type)
+      case type
+      when :datetime
+        green(value)
+      when :boolean
+        value ? green(value) : red(value)
+      when :integer, :decimal
+        blue(value)
+      when :string, :json, :jsonb
+        yellow(value)
+      else
+        value
       end
     end
 
-    def colorize(value)
+    def colorize_by_value(value)
       case value
       when TrueClass, DateTime, 'datetime'
-        Text.green(value)
+        green(value)
       when FalseClass
-        Text.red(value)
+        red(value)
       when Numeric, 'integer', 'decimal'
-        Text.blue(value)
+        blue(value)
       when 'boolean'
-        Text.cyan(value)
+        cyan(value)
       when String
-        Text.yellow(value)
+        yellow(value)
       else
         value
       end

data/lib/table_inspector/presenter_option.rb

@@ -0,0 +1,12 @@
+
+module TableInspector
+  class PresenterOption
+    attr_accessor :sql_type, :comment_only, :colorize
+
+    def initialize(options = {})
+      @sql_type = options.fetch(:sql_type, false)
+      @comment_only = options.fetch(:comment_only, false)
+      @colorize = options.fetch(:colorize, false)
+    end
+  end
+end

data/lib/table_inspector/table.rb

@@ -1,42 +1,43 @@
 
 module TableInspector
   class Table
-    attr_reader :klass, :sql_type, :presenter
+    attr_reader :klass, :presenter, :presenter_option
+    delegate :break_line, :bold, to: TableInspector::Text
 
-    def initialize(klass, sql_type: false, colorize: false)
+    def initialize(klass, presenter_option)
       @klass = klass
-      @sql_type = sql_type
-      @presenter = Presenter.new(klass, sql_type: sql_type, colorize: colorize)
-      @colorize = colorize
+      @presenter = Presenter.current.new(klass, presenter_option)
+      @presenter_option = presenter_option
     end
 
     def render
-      Text.break_line
+      break_line # empty line
       render_title
       render_body
-      Text.break_line
+      break_line # empty line
       render_indexes
-      Text.break_line
+      break_line # empty line
     end
 
     private
 
     def render_title
-      Grid.new do |grid|
-        grid.add_row(["#{Text.bold('Table')}: #{klass.table_name}"])
+      TerminalTable.new do |terminal_table|
+        table_name = bold('Table') + ": " + klass.table_name
+        terminal_table.add_row([table_name])
       end.render
     end
 
     def render_body
-      Grid.new(headings: presenter.headings) do |grid|
+      TerminalTable.new(headings: presenter.headings) do |terminal_table|
         klass.columns.each do |column|
-          grid.add_row(presenter.extract_meta(column).values)
+          terminal_table.add_row(presenter.extract_meta(column).values)
         end
       end.render
     end
 
     def render_indexes
-      Indexes.new(klass, colorize: @colorize).render
+      Indexes.new(klass, colorize: presenter.option.colorize).render
     end
   end
 end

data/lib/table_inspector/{grid.rb → terminal_table.rb}

@@ -1,6 +1,6 @@
 
 module TableInspector
-  class Grid
+  class TerminalTable
     attr_reader :terminal_table
 
     delegate :add_row,
@@ -9,13 +9,15 @@ module TableInspector
 
     def initialize(**options, &block)
       @terminal_table = ::Terminal::Table.new(**options)
+      style = TableInspector.style || { border: :ascii }
+      @terminal_table.style = style
       yield self if block_given?
     end
 
     def render
       if rows.empty?
         Text.break_line
-        puts "  Empty."
+        puts " Empty."
       else
         puts self
       end

data/lib/table_inspector/version.rb

@@ -1,3 +1,3 @@
 module TableInspector
-  VERSION = "0.5.5"
+  VERSION = "1.0.0"
 end

data/lib/table_inspector.rb

@@ -1,70 +1,71 @@
 require "table_inspector/version"
 require "table_inspector/railtie"
 require "terminal-table"
+require "table_inspector/text"
 require "table_inspector/table"
-require "table_inspector/grid"
+require "table_inspector/terminal_table"
 require "table_inspector/indexes"
-require "table_inspector/text"
 require "table_inspector/column"
 require "table_inspector/presenter"
+require "table_inspector/presenter/sqlite3"
+require "table_inspector/presenter/postgresql"
+require "table_inspector/presenter/mysql2"
 require "table_inspector/model_validator"
 require "table_inspector/column_validator"
+require "table_inspector/presenter_option"
+require "table_inspector/inspectable"
 
 module TableInspector
   extend self
+  mattr_accessor :style
 
-  def ascan(klass, column_name = nil, sql_type: false)
-    klass = classify!(klass)
-
-    return unless klass
-    return unless validate!(klass, column_name)
-
-    render(klass, column_name, sql_type, colorize: true)
+  # options:
+  #   - sql_type: pass "true" print sql type, pass "false" not print sql type, default is false
+  #   - comment_only: pass "true" print comment only, pass "false" will print all column info, default is false
+  def ascan(klass, column_name = nil, **options)
+    scan(klass, column_name, colorize: true, **options)
   end
 
-  def scan(klass, column_name = nil, sql_type: false)
+  # options:
+  #   - sql_type: pass "true" print sql type, pass "false" not print sql type, default is false
+  #   - comment_only: pass "true" print comment only, pass "false" will print all column info, default is false
+  #   - colorize: pass "true" print colorful scheme, pass "false" will print scheme without color, default is false
+  def scan(klass, column_name = nil, colorize: false, **options)
     klass = classify!(klass)
 
     return unless klass
     return unless validate!(klass, column_name)
 
-    render(klass, column_name, sql_type)
+    presenter_options = PresenterOption.new({ **options, colorize: colorize })
+    render(klass, column_name, presenter_options)
   end
 
   private
 
   def classify!(klass)
-    begin
-      unless klass.is_a?(Class)
-        klass = klass.to_s.classify.constantize
-      end
-    rescue NameError
-      puts invalid_model_name_hint(klass.inspect)
-      return
-    end
-
-    klass
+    return klass if klass.is_a?(Class)
+    klass.to_s.classify.constantize
+  rescue NameError
+    puts invalid_model_name_hint(klass.inspect)
   end
 
   def validate!(klass, column_name)
     model_validator = ModelValidator.new(klass)
-    unless column_name
-      return model_validator.validate!
-    end
+    return model_validator.validate! unless column_name
 
     column_validator = ColumnValidator.new(klass, column_name)
     model_validator.validate! && column_validator.validate!
   end
 
-  def render(klass, column_name, sql_type, colorize: false)
+  def render(klass, column_name, presenter_option)
     if column_name
-      Column.new(klass, column_name, sql_type: sql_type, colorize: colorize).render
+      Column.new(klass, column_name, presenter_option).render
     else
-      Table.new(klass, sql_type: sql_type, colorize: colorize).render
+      Table.new(klass, presenter_option).render
     end
   end
 
   def invalid_model_name_hint(klass)
-    "'#{klass}' can be transform to a model class."
+    "'#{klass}' cannot be transformed to a valid model class."
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_inspector
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 1.0.0
 platform: ruby
 authors:
 - ian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-04 00:00:00.000000000 Z
+date: 2024-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,7 +38,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.2
-description: Inspect table structure of ActiveRecord class
+description: Print table structure of ActiveRecord class
 email:
 - ianlynxk@gmail.com
 executables: []
@@ -51,12 +51,17 @@ files:
 - lib/table_inspector.rb
 - lib/table_inspector/column.rb
 - lib/table_inspector/column_validator.rb
-- lib/table_inspector/grid.rb
 - lib/table_inspector/indexes.rb
+- lib/table_inspector/inspectable.rb
 - lib/table_inspector/model_validator.rb
 - lib/table_inspector/presenter.rb
+- lib/table_inspector/presenter/mysql2.rb
+- lib/table_inspector/presenter/postgresql.rb
+- lib/table_inspector/presenter/sqlite3.rb
+- lib/table_inspector/presenter_option.rb
 - lib/table_inspector/railtie.rb
 - lib/table_inspector/table.rb
+- lib/table_inspector/terminal_table.rb
 - lib/table_inspector/text.rb
 - lib/table_inspector/version.rb
 - lib/tasks/table_inspector_tasks.rake
@@ -82,8 +87,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
-summary: Inspect table structure of ActiveRecord class
+summary: Print table structure of ActiveRecord class
 test_files: []