table_inspector 0.5.5 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83143bbf7fb6d4ce752da10da85b265037f75fad9417f104ab761660d638db1b
-  data.tar.gz: 6268b3194f9eef7ec25c830cae63cad79d0fa29ed8b98f27c77049b450d31def
+  metadata.gz: a7b361cd6519e4f22acd13f7414daa56d361f83b2bc742679fd7413bc3a3e9d3
+  data.tar.gz: efebb7e0def5dc75c974a06d7504efaa462068d009438885c16d9a0e6ed73ba1
 SHA512:
-  metadata.gz: 5e5df809d52919113556d0048e91e633663bcba444b4d2cff13919bb0670f01a51a9460de7789ef556f661c5fc25aa213eff3fb38547a0566331300cd17dd5f4
-  data.tar.gz: a137cf1372c765da06bcfc459f4ab0d5b7f9e09f947bbaa0908c560f8cbea24e3e6ab45a5dad043527e7b6f57328d4541876f1acae10394faf2d5435888bf344
+  metadata.gz: cfb17c67a0091dbaccbad92a638bd22de4f7361458baf0bcc25902ce97709d6d15b69d7e01ec51112d5b649f2d89e1c24e762ce3dd2d536055ad9d1b8ab15fe8
+  data.tar.gz: dd4b194ebf0c45c0b76c18b447ca77460fc84cc74343673cfe250a561e381efc8bccabd4628ec46c2a42262745e7485d8861c498be8f81f2b2cff82d332bc6f4

data/README.md

@@ -1,9 +1,34 @@
 # 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-99.65-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"
 
@@ -12,7 +37,9 @@ TableInspector.scan User
 
 ![TableInspect scan table](/img/table_inspector_scan_table_3.png)
 
-It will print the all table definition and all indexes.
+It will print the scheme of table and indexes. 
+(If the table content is too long, It may be printed messy. You can adjust the scaling of the terminal window to fix it. 
+Alternatively, you can use `TableInspector.scan(User, :name)` to print a specific column)
 
 Or you can use `TableInspector.ascan` to print more colorful table(`ascan` means `awesome scan`) :
 ```ruby
@@ -29,29 +56,57 @@ 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: 
+**It is recommended to include `TableInspector::Inspectable` in `app/models/application_record.rb` and use `ti` or `ati` method to print the table definition: **
+```ruby
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+  
+  # Add this line
+  include TableInspector::Inspectable
+
+  # ...
+end
+```
+and call:
+```ruby
+# Same as TableInspector.scan User
+User.ti
 
+# Same as TableInspector.ascan User
+User.ati
+```
+The module `TableInspector::Inspectable` only defines two class methods: `ti` and `ati`, which delegate to `TableInspector.scan` and `TableInspector.ascan` respectively.
+
+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:
-
+To print comment column only for the table, use `comment_only: true` 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
+You can change the style of the table by setting the `TableInspector.style` in `config/initalizers/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.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.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,8 +18,7 @@ module TableInspector
     end
 
     def headings
-      first_column = klass.columns.first
-      extract_meta(first_column).keys.map(&:humanize)
+      ordered_keys.map(&:humanize)
     end
 
     private
@@ -48,23 +47,27 @@ module TableInspector
     end
 
     def ordered_keys
-      %w[name type limit null default precision scale comment].tap do |keys|
-        keys << "sql_type" if sql_type
+      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 colorize(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.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 = "0.6.0"
 end

data/lib/table_inspector.rb

@@ -1,70 +1,68 @@
 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/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: 0.6.0
 platform: ruby
 authors:
 - ian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-04 00:00:00.000000000 Z
+date: 2023-08-27 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,14 @@ 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_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
@@ -85,5 +87,5 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: Inspect table structure of ActiveRecord class
+summary: Print table structure of ActiveRecord class
 test_files: []