table_inspector 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 501b198b975a552496604e4342afac6e837423ca04487327a9a7354c72f9ba36
-  data.tar.gz: 04d8de8b58039d17d8e5229cfab6b766776c099ce5ef0d39f22cfbba8ffab09a
+  metadata.gz: a7b361cd6519e4f22acd13f7414daa56d361f83b2bc742679fd7413bc3a3e9d3
+  data.tar.gz: efebb7e0def5dc75c974a06d7504efaa462068d009438885c16d9a0e6ed73ba1
 SHA512:
-  metadata.gz: baaf7974ceeb46d135c2d611b7397669b13081e3d29e15d5a5703b080e97f9380f29b599ab6119f6e5f7e4da3eead47201e5cd7a5532993358c8565e9afa8ec4
-  data.tar.gz: 30175fa53056aaa4716aabd45085b0f84d05cc5f68f746828dd8b06c082565799bfc1bdeec962ad77e3756de883a2d4fc9c6190b104cd2f4508d0ef43d7d60ab
+  metadata.gz: cfb17c67a0091dbaccbad92a638bd22de4f7361458baf0bcc25902ce97709d6d15b69d7e01ec51112d5b649f2d89e1c24e762ce3dd2d536055ad9d1b8ab15fe8
+  data.tar.gz: dd4b194ebf0c45c0b76c18b447ca77460fc84cc74343673cfe250a561e381efc8bccabd4628ec46c2a42262745e7485d8861c498be8f81f2b2cff82d332bc6f4

data/README.md

@@ -1,59 +1,112 @@
 # TableInspector
-This is a rails gem for print the definition of table. Sometimes we use some gems to embed the table schema to model file(like `annotate`).
-but sometimes it is hard to maintain, and it has a little noise. I want to find another way to check the schema of table instead of 
-using `annotate`, So I wrote this gem to do this.
+![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"
 
 TableInspector.scan User
 ```
 
-![TableInspect scan table](/img/table_inspector_scan_table_2.png)
+![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
 TableInspector.ascan User
 ```
-![TableInspect ascan table](/img/table_inspector_ascan_table_2.png)
+![TableInspect ascan table](/img/table_inspector_ascan_table_3.png)
 
 And to print a specific column by:
 
 ```ruby
 TableInspector.scan User, :name
 ```
-![Table Inspector scan column](/img/table_inspector_scan_column_2.png)
+![Table Inspector scan column](/img/table_inspector_scan_column_3.png)
 
 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
-TableInspector.scan User, sql_type: true
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+  
+  # Add this line
+  include TableInspector::Inspectable
+
+  # ...
+end
 ```
-![Table Inspector scan table column with sql type](/img/table_inspector_scan_table_with_sql_type_2.png)
+and call:
+```ruby
+# Same as TableInspector.scan User
+User.ti
 
-## Installation
-Add this line to your application's Gemfile:
+# 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
-gem "table_inspector"
+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)
 
-And then execute:
-```bash
-$ bundle
+To print comment column only for the table, use `comment_only: true` option:
+```ruby
+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.
 
-Or install it yourself as:
-```bash
-$ gem install table_inspector
+## 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
+
+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,36 +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
-      @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).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

@@ -3,16 +3,17 @@ module TableInspector
   class Indexes
     attr_reader :klass, :column_name
 
-    def initialize(klass, column_name = nil)
+    def initialize(klass, column_name = nil, colorize: false)
       @klass = klass
       @column_name = column_name
+      @colorize = colorize
     end
 
     def render
       render_title
 
       if column_name
-        render_indexes_with_specific_column
+        render_indexes_of_column
       else
         render_indexes
       end
@@ -21,32 +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_color(index)
+      else
+        compose_index_data_without_color(index)
+      end
+    end
+
+    def compose_index_data_with_color(index)
+      index_columns_text = index.columns.join(', ')
+      unique_text = index.unique ? "UNIQUE" : ""
+
+      [
+        index.name,
+        "[#{Text.yellow(index_columns_text)}]",
+        unique_text
+      ]
+    end
+
+    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
 
@@ -58,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) }
+    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,14 +18,13 @@ module TableInspector
     end
 
     def headings
-      first_column = klass.columns.first
-      extract_meta(first_column).keys.map(&:humanize)
+      ordered_keys.map(&:humanize)
     end
 
     private
 
     def extract_meta_with_highlight(column)
-      column_data = column.as_json.merge(column.sql_type_metadata.as_json)
+      column_data = extract_meta_without_highlight(column)
 
       # Colorize text but except "comment" field
       column_data.each do |k, v|
@@ -40,27 +39,35 @@ module TableInspector
     end
 
     def extract_meta_without_highlight(column)
-      column.as_json.merge(column.sql_type_metadata.as_json).slice(*ordered_keys)
+      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
+        end
+      end
     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,41 +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)
+      @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).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.4"
+  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.4
+  version: 0.6.0
 platform: ruby
 authors:
 - ian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-31 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
@@ -82,8 +84,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.7
+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: []