the_schema_is 0.0.1 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24d4d7e0d7d99a14a9d924af7efbbfbe4ee0fb9eef3b89537fb11378b4e5495e
-  data.tar.gz: e41ee7faf7ee3620dc655c3ec3468df3cd6d89a5eb93a6b130ceabad7554b99f
+  metadata.gz: 8735d476459a14d53240641bec87d03d7dbcd7bd5d3c8508135bde7739a04e80
+  data.tar.gz: 5cb9c6f68830db4c556aabe538611f448c581fd2c94efb15bf6eda0c0ce04511
 SHA512:
-  metadata.gz: ce06ad394d6cec9c357af68eb370ec667707a7ea2c5df57c412a3b0e86d3122cc3865035f9464729b1548477aa23dc9350b5c7700f42d668cd72a90c487fdeeb
-  data.tar.gz: 745a19300e80a00177abad59d4c702a304b1eb1c6f5b94c2ed3eb3b63519c5438b4cdb762c752ac9b71ef8e8d665fb3180b729ab8fa72262131e11a287d84465
+  metadata.gz: c4ad68960b63c360ec9becc3f733e157a6547d55e318b7de37ac9d9ff3f872c436a07729759eeba126613fb812a291f7b76a1b782fa83a82c85977e91f066493
+  data.tar.gz: c37d853e5dfbb790264e146cd07849e959880b46559a92e5b578036b0cb906de4a4db74d4d744c4b8013763782c67f5bb0592f8bd2bb22ed702348ab42fdb1b3

data/Changelog.md

@@ -0,0 +1,16 @@
+# the-schema-is changes
+
+## 2021-11-04 - 0.0.5
+
+* Support `enum` column type;
+* Add `RemoveDefinitions` config key for leaner `the_schema_is` definitions (avoiding huge index descriptions in models).
+
+## 2021-09-15 - 0.0.4
+
+* Get rid of [Fast](https://jonatas.github.io/fast/) dependency. It is cool, but we switched to use Rubocop's own `NodePattern` to lessen the dependency burden (Fast was depending on [astrolabe](https://github.com/yujinakayama/astrolabe) which wasn't updated in 6 years, locking parser dependency to old version and making Fast incompatible with newer Rubocop);
+* Introduce mandatory table name in the `the_schema_is` DSL (and the `WrongTableName` cop to check it);
+* Internally, change cop classes to comply to newer (> 1.0) Rubocop API.
+
+## 2020-05-07 - 0.0.3
+
+First really working release.

data/README.md

@@ -1,9 +1,9 @@
 # The schema is ...
 
 [![Gem Version](https://badge.fury.io/rb/the_schema_is.svg)](http://badge.fury.io/rb/the_schema_is)
-[![Build Status](https://travis-ci.org/zverok/the_schema_is.svg?branch=master)](https://travis-ci.org/zverok/the_schema_is)
+![Build Status](https://github.com/zverok/the_schema_is/workflows/CI/badge.svg?branch=master)
 
-`the_schema_is` is a model schema annotation DSL in ActiveSupport.
+`the_schema_is` is a model schema annotation DSL for ActiveSupport models, enforced by Rubocop. [Jump to detailed description →](#so-how-your-approach-is-different).
 
 ### Why annotate?
 
@@ -34,10 +34,10 @@ Annotate gem provides a very powerful and configurable CLI/rake task which allow
 
 It kinda achieves the goal, but in our experience, it also brings some problems:
 
-* annotation regeneration is disruptive, just replacing the whole block with a new one, which produces a lot of "false changes" (e.g. one field with a bit longer name was added → spacing of all fields were changed);
-* if on different developer's machines column order or defaults is different on dev. DB, annotate also decides to rewrite all the annotations, sometimes adding tens files "changed" to PR;
-* regeneration makes it hard to use schema annotation for commenting/explaining some fields: because regeneration will lose them, and because comments-between-comments will be hard to distinguish;
-* the syntax of annotations is kinda ad-hoc, which makes it harder to add them by hand, so regeneration becomes the _only_ way to add them.
+* annotation **regeneration is disruptive**, just replacing the whole block with a new one, which produces a lot of "false changes" (e.g. one field with a bit longer name was added → spacing of all fields were changed);
+* if on different developer's machines **column order or defaults is different** in dev. DB, annotate also decides to rewrite all the annotations, sometimes adding tens files "changed" to PR;
+* regeneration makes it **hard to use schema annotation for commenting/explaining** some fields: because regeneration will lose them, and because comments-between-comments will be hard to distinguish;
+* the **syntax of annotations is kinda ad-hoc**, which makes it harder to add them by hand, so regeneration becomes the _only_ way to add them.
 
 ### So, how your approach is different?..
 
@@ -88,7 +88,7 @@ Using existing Rubocop's infrastructure brings several great benefits:
 
 * you can include checking "if all annotations are actual" in your CI/pre-commit hooks easily;
 * you can preview problems found, and then fix them automatically (with `rubocop -a`) or manually however you see suitable;
-* the changes made with auto-fix is very local (just add/remove/change line related to relevant column), so your custom structuring, like separating groups of related columns with empty lines and comments, will be preserved;
+* the changes made with auto-correct is very local (just add/remove/change line related to relevant column), so your custom structuring, like separating groups of related columns with empty lines and comments, will be preserved;
 * rubocop is easy to run on some sub-folder or one file, or files corresponding to some pattern; or exclude permanently for some file or folder.
 
 ### But what the block itself does?
@@ -110,11 +110,12 @@ The block isn't even evaluated at all (so potentially can contain any code, and
     - the_schema_is/cops
   ```
 3. Run `rubocop` and see what it now says about your models.
-4. Now you can add schema definitions manually, or allow `rubocop --auto-fix` (or `-a`) to do its job! NB: you can always use `rubocop --auto-fix --only TheSchemaIs` to auto-fix ONLY this schema thing
+4. Now you can add schema definitions manually, or allow `rubocop --auto-correct` (or `-a`) to do its job! NB: you can always use `rubocop --auto-correct --only TheSchemaIs` to auto-correct ONLY this schema thing
 
 To make reporting cleaner, all cops are split into:
 
 * `Presence`
+* `WrongTableName`
 * `MissingColumn`
 * `UnknownColumn`
 * `WrongColumnDefinition`
@@ -133,8 +134,9 @@ TheSchemaIs:
 Currently available settings are:
 
 * `TablePrefix` to help `the_schema_is` deduce table name from class name;
-* `Schema` to set path to schema (by default `db/schema.rb`)
-* `BaseClass` to help `the_schema_is` guess what is a model class (by default `ApplicationRecord` and `ActiveRecord::Base`).
+* `Schema` to set path to schema (by default `db/schema.rb`);
+* `BaseClass` to help `the_schema_is` guess what is a model class (by default `ApplicationRecord` and `ActiveRecord::Base`);
+* `RemoveDefinitions`: list of definition keys to remove (for example, `[index, foreign_key, limit]`) when copying definitions into models; this might be desirable for leaner `the_schema_is` statements, displaying only field types/names.
 
 So, if you have your custom-named base class, you should do:
 
@@ -143,12 +145,12 @@ TheSchemaIs:
   BaseClass: OurOwnBase
 ```
 
-Note that Rubocop allows per-folder settings out of the box, which allows TheSchemaIs even at the tender version of 0.0.1, support complicated configurations with multiple databases and engines.
+Note that Rubocop allows per-folder settings out of the box, which allows TheSchemaIs to support complicated configurations with multiple databases and engines.
 
 For example, consider your models are split into `app/models/users/` and `app/models/products` which are stored in the different databases, then you probably have different schemas and base classes for them. So, to configure it properly, you might want to do in `app/models/users/.rubocop.yml`:
 
 ```yaml
-# Don't forget this for all other cops to not be ignored
+# Don't forget this for all other cop settings to not be ignored
 inherit_from: ../../../.rubocop.yml
 
 TheSchemaIs:
@@ -158,13 +160,18 @@ TheSchemaIs:
 
 ## Some Q&A
 
-* **Q: It doesn't check the actual DB?** A: No, it does not! At the current moment, our belief is that in a healthy Rails codebase `schema.rb` is always corresponding to DB state, so checking against it is enough. This approach makes the tooling much easier (with existing Rubocop's ecosystem of parsers/offenses/configurations).
-* **Q: What if I don't use Rubocop?** A: You may want to try, at least? Do you know that you may disable or configure most of its checks to your liking? And auto-correct any code to your preferences?.. Or automatically create "TODO" config-file (which disables all the cops currently raising offenses, and allows to review them and later setup one-by-one)?.. It is much more than "linter making your code to complain about some rigid style guide".
-* **Q: Cool, but I still don't want to.** ...OK, then you can disable all cops _except_ for `TheSchemaIs` namespace :)
-* **How do I annotate my fabrics, model specs, routes, controllers, ... (which `annotate` allows)?** You don't. The same way you don't copy-paste the whole definition of the class into spec file which tests this class: Definition is in one place, tests and other code using this definition is another. DRY!
-* **Rubocop is unhappy with the code `TheSchemaIs` generated**. There are two known things in generated `the_schema_is` blocks that Rubocop may complain about:
-  * Usage of double quotes for strings, if your config insists on single quotes: that's because we just copy code objects from `schema.rb`. Rubocop's auto-fix will fix it :) (Even in one run: "fixing TheSchemaIs, then fixing quotes");
-  * Too long blocks (if you have tables with dozens of columns, God forbid... as we do). It can be fixed by adding this to `.rubocop.yml`:
+* **Q: It doesn't check the actual DB?**
+  * A: No, it does not! At the current moment, our belief is that in a healthy Rails codebase `schema.rb` is always corresponding to DB state, so checking against it is enough. This approach makes the tooling much easier (with existing Rubocop's ecosystem of parsers/offenses/configurations).
+* **Q: What if I don't use Rubocop?**
+  * A: You may want to try, at least? Do you know that you may disable or configure most of its checks to your liking? And auto-correct any code to your preferences?.. Or automatically create "TODO" config-file (which disables all the cops currently raising offenses, and allows to review them and later setup one-by-one)?.. It is much more than "linter making your code to complain about some rigid style guide".
+* **Q: Cool, but I still don't want to.**
+  * A: ...OK, then you can disable all cops _except_ for `TheSchemaIs` namespace :)
+* **How do I annotate my fabrics, model specs, routes, controllers, ... (which `annotate` allows)?**
+  * A: You don't. The same way you don't copy-paste the whole definition of the class into spec file which tests this class: Definition is in one place, tests and other code using this definition is another. DRY!
+* **Rubocop is unhappy with the code `TheSchemaIs` generated**.
+  * A: There are two known things in generated `the_schema_is` blocks that Rubocop may complain about:
+    * Usage of double quotes for strings, if your config insists on single quotes: that's because we just copy code objects from `schema.rb`. Rubocop's auto-correct will fix it :) (Even in one run: "fixing TheSchemaIs, then fixing quotes");
+    * Too long blocks (if you have tables with dozens of columns, God forbid... as we do). It can be fixed by adding this to `.rubocop.yml`:
   ```yaml
   Metrics/BlockLength:
     ExcludedMethods:

data/config/defaults.yml

@@ -0,0 +1,29 @@
+---
+# For all TheSchemaIs cops the settings are the same.
+# But note that Rubocop's behavior is slightly weird with --show-cops (it will not show that
+# cop has those three setting)
+TheSchemaIs:
+  Schema: db/schema.rb
+  BaseClass: ['ActiveRecord::Base', 'ApplicationRecord']
+  TablePrefix: ''
+  RemoveDefinitions: []
+
+TheSchemaIs/Presence:
+   Description: "Check presence of the_schema_is statement in ActiveRecord models"
+   Enabled: true
+
+TheSchemaIs/WrongTableName:
+   Description: "Check table name define by the_schema_is statement against one in schema.rb"
+   Enabled: true
+
+TheSchemaIs/MissingColumn:
+  Description: "Check columns missing in the_schema_is definition (but present in schema.rb)"
+  Enabled: true
+
+TheSchemaIs/UnknownColumn:
+  Description: "Check unknown column in the_schema_is definition (not defined in schema.rb)"
+  Enabled: true
+
+TheSchemaIs/WrongColumnDefinition:
+  Description: "Check column definition in the_schema_is statement against schema.rb"
+  Enabled: true

data/lib/the_schema_is/cops/node_util.rb

@@ -1,15 +1,58 @@
 # frozen_string_literal: true
 
+require 'singleton'
+
 module TheSchemaIs
   module Cops
+    # This module mitigates usage of RuboCop's NodePattern in a more flexible manner. NodePattern
+    # (targeting RuboCop's goals) was only available as a metaprogramming macro, requiring to
+    # `def_node_search :some_method, pattern` before the pattern can be used, while we wanted to
+    # just do `ast.ast_search(some_pattern)`; so this method defines a method for each used pattern
+    # on the fly and hides this discrepancy. Used by NodeRefinements (mixed into parser's node) to
+    # provide `Node#ast_search` and `Node#ast_match`.
+    class Patterns
+      include Singleton
+      extend RuboCop::AST::NodePattern::Macros
+
+      class << self
+        extend Memoist
+
+        def search(pattern, node)
+          search_methods[pattern].then { |m| instance.send(m, node) }
+        end
+
+        def match(pattern, node)
+          match_methods[pattern].then { |m| instance.send(m, node) }
+        end
+
+        private
+
+        memoize def search_methods
+          Hash.new { |h, pattern|
+            method_name = "search_#{h.size}"
+            def_node_search method_name, pattern
+            h[pattern] = method_name
+          }
+        end
+
+        memoize def match_methods
+          Hash.new { |h, pattern|
+            method_name = "match_#{h.size}"
+            def_node_search method_name, pattern
+            h[pattern] = method_name
+          }
+        end
+      end
+    end
+
     module NodeRefinements
       refine ::Parser::AST::Node do
-        def ffast(expr)
-          Fast.search(expr, self)
+        def ast_search(expr)
+          Patterns.search(expr, self).to_a
         end
 
-        def ffast_match?(expr)
-          Fast.match?(expr, self)
+        def ast_match(expr)
+          Patterns.match(expr, self).to_a.first
         end
 
         def arraify
@@ -23,7 +66,7 @@ module TheSchemaIs
         end
 
         def find_parent(type)
-          Enumerator.produce(parent, &:parent).slice_after { |n| n && n.type == type }.first.last
+          Enumerator.produce(parent, &:parent).find { |n| n && n.type == type }
         end
       end
     end

data/lib/the_schema_is/cops/parser.rb

@@ -15,66 +15,72 @@ module TheSchemaIs
                                  float integer json string text time timestamp virtual].freeze
       POSTGRES_COLUMN_TYPES = %i[jsonb inet cidr macaddr hstore uuid].freeze
 
-      COLUMN_DEFS = (STANDARD_COLUMN_TYPES + POSTGRES_COLUMN_TYPES + %i[column]).freeze
+      COLUMN_DEFS = (STANDARD_COLUMN_TYPES + POSTGRES_COLUMN_TYPES + %i[enum column]).freeze
 
-      Model = Struct.new(:class_name, :table_name, :source, :schema, keyword_init: true)
+      Model = Struct.new(:class_name, :table_name, :source, :schema, :table_name_node,
+                         keyword_init: true)
 
       Column = Struct.new(:name, :type, :definition, :source, keyword_init: true) do
         def definition_source
           return unless definition
 
-          eval('{' + definition.loc.expression.source + '}') # rubocop:disable Security/Eval
+          eval('{' + definition.loc.expression.source + '}') # rubocop:disable Security/Eval,Style/StringConcatenation
         end
       end
 
-      def self.schema(path)
-        ast = Fast.ast(File.read(path))
+      def self.parse(code)
+        # TODO: Some kind of "current version" (ask Rubocop!)
+        RuboCop::AST::ProcessedSource.new(code, 2.7).ast
+      end
+
+      def self.schema(path, remove_definition_attrs: [])
+        ast = parse(File.read(path))
+
+        ast = remove_attributes(ast, remove_definition_attrs) unless remove_definition_attrs.empty?
 
-        content = Fast.search(
-          '(block (send (const (const nil :ActiveRecord) :Schema) :define) _ $_)',
-          ast
-        ).last.first
-        Fast.search('(block (send nil :create_table (str $_)) _ _)', content)
-            .each_slice(2).to_h { |t, name| [Array(name).first, t] } # FIXME: Why it sometimes makes arrays, and sometimes not?..
+        ast.ast_search('(block (send nil? :create_table (str $_) _) _ $_)').to_h
       end
 
       def self.model(ast, base_classes: %w[ActiveRecord::Base ApplicationRecord], table_prefix: nil)
         base = base_classes_query(base_classes)
-        ast.ffast("(class $_ #{base})").each_slice(2)
+        ast.ast_search("$(class $_ #{base} _)")
            .map { |node, name| node2model(name, node, table_prefix.to_s) }
            .compact
            .first
       end
 
-      def self.node2model(name_node, definition_node, table_prefix)
-        return if definition_node.ffast('(send self abstract_class= true)').any?
+      def self.node2model(name_node, definition_node, table_prefix) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        return if definition_node.ast_search('(send self :abstract_class= true)')&.any?
 
         # If all children are classes/modules -- model is here only as a namespace, shouldn't be
         # parsed/have the_schema_is
-        return if definition_node
-                  .children[2]&.arraify&.all? { |n| %i[class module].include?(n.type) }
+        if definition_node.children&.dig(2)&.arraify&.all? { |n| %i[class module].include?(n.type) }
+          return
+        end
 
-        class_name = name_node.first.loc.expression.source
+        class_name = name_node.loc.expression.source
 
-        schema = definition_node.ffast('$(block (send nil :the_schema_is) _ ...')&.last
+        schema_node, name_node =
+          definition_node.ast_search('$(block (send nil? :the_schema_is $_?) _ ...)')&.last
 
         # TODO: https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema/ClassMethods.html#method-i-table_name
         # * consider table_prefix/table_suffix settings
         # * also, consider engines!
-        table_name = definition_node.ffast('(send self table_name= (str $_)')&.last
+        table_name = definition_node.ast_search('(send self :table_name= (str $_))')&.last
 
         Model.new(
           class_name: class_name,
           table_name: table_name ||
             table_prefix.+(ActiveSupport::Inflector.tableize(class_name)),
           source: definition_node,
-          schema: schema
+          schema: schema_node,
+          table_name_node: name_node&.first
         )
       end
 
       def self.base_classes_query(classes)
         classes
-          .map { |cls| cls.split('::').inject('nil') { |res, str| "(const #{res} :#{str})" } }
+          .map { |cls| cls.split('::').inject('nil?') { |res, str| "(const #{res} :#{str})" } }
           .join(' ')
           .then { |str| "{#{str}}" }
       end
@@ -83,14 +89,37 @@ module TheSchemaIs
         ast.arraify.map { |node|
           # FIXME: Of course it should be easier to say "optional additional params"
           if (type, name, defs =
-                node.ffast_match?('(send {(send nil t) (lvar t)} $_ (str $_) $...'))
+                node.ast_match('(send {(send nil? :t) (lvar :t)} $_ (str $_) $_)'))
             Column.new(name: name, type: type, definition: defs, source: node) \
               if COLUMN_DEFS.include?(type)
-          elsif (type, name = Fast.match?('(send {(send nil t) (lvar t)} $_ (str $_)', node))
+          elsif (type, name = node.ast_match('(send {(send nil? :t) (lvar :t)} $_ (str $_))'))
             Column.new(name: name, type: type, source: node) if COLUMN_DEFS.include?(type)
           end
         }.compact
       end
+
+      # Removes unnecessary column definitions from further comparison, using schema source tree editing
+      def self.remove_attributes(ast, attrs_to_remove)
+        buf = ast.loc.expression.source_buffer
+        src = buf.source
+        rewriter = ::Parser::Source::TreeRewriter.new(buf)
+
+        # FIXME: Two nested cycles can be simplifid to just look for column definition, probably
+        ast.ast_search('(block (send nil? :create_table (str _) _) _ $_)').each do |table_def|
+          table_def.children.each do |col|
+            dfn = col.children[3] or next
+            dfn.children
+               .select { |c| attrs_to_remove.include?(c.children[0].children[0]) }
+               .each do |c|
+              prev_comma = c.source_range.begin_pos.step(by: -1).find { |pos| src[pos] == ',' }
+              range = ::Parser::Source::Range.new(buf, prev_comma, c.source_range.end_pos)
+              rewriter.remove(range)
+            end
+          end
+        end
+
+        RuboCop::AST::ProcessedSource.new(rewriter.process, 2.7).ast
+      end
     end
   end
 end

data/lib/the_schema_is/cops.rb

@@ -2,7 +2,6 @@
 
 require 'memoist'
 require 'rubocop'
-require 'fast'
 require 'backports/latest'
 
 require_relative 'cops/node_util'
@@ -16,8 +15,12 @@ module TheSchemaIs
   using Cops::NodeRefinements
 
   module Cops
-    def self.schema_cache
-      @schema_cache ||= Hash.new { |h, path| h[path] = Cops::Parser.schema(path) }
+    class << self
+      extend Memoist
+
+      memoize def fetch_schema(path, remove_definition_attrs: [])
+        Cops::Parser.schema(path, remove_definition_attrs: remove_definition_attrs)
+      end
     end
   end
 
@@ -25,9 +28,10 @@ module TheSchemaIs
     extend Memoist
 
     def self.included(cls)
-      cls.define_singleton_method(:badge) {
+      cls.define_singleton_method(:badge) do
         RuboCop::Cop::Badge.for("TheSchemaIs::#{name.split('::').last}")
-      }
+      end
+      super
     end
 
     def on_class(node)
@@ -35,14 +39,22 @@ module TheSchemaIs
                                   base_classes: cop_config.fetch('BaseClass'),
                                   table_prefix: cop_config['TablePrefix']) or return
 
-      validate
+      register_offense(node)
+    end
+
+    # We need this method to tell Rubocop that EVEN if app/models/user.rb haven't changed, and
+    # .rubocop.yml haven't changed, we STILL may need to rerun the cop if schema.rb have changed.
+    def external_dependency_checksum
+      return unless schema_path
+
+      Digest::SHA1.hexdigest(File.read(schema_path))
     end
 
     private
 
     attr_reader :model
 
-    def validate
+    def register_offense(node)
       fail NotImplementedError
     end
 
@@ -51,38 +63,40 @@ module TheSchemaIs
     end
 
     memoize def schema
-      Cops.schema_cache.dig(schema_path, model.table_name)
+      attrs_to_remove = cop_config['RemoveDefinitions']&.map(&:to_sym) || []
+      # It is OK if it returns Nil, just will be handled by "schema is absent" cop
+      Cops.fetch_schema(schema_path, remove_definition_attrs: attrs_to_remove)[model.table_name]
     end
 
     memoize def model_columns
-      statements = model.schema.ffast('(block (send nil :the_schema_is) (args) $...)').last.last
+      statements = model.schema.ast_search('(block (send nil? :the_schema_is _?) _ $...)')
+                        .last.last
 
       Cops::Parser.columns(statements).to_h { |col| [col.name, col] }
     end
 
     memoize def schema_columns
-      # FIXME: should be already done in Parser.schema, probably!
-      statements = schema.ffast('(block (send nil :create_table) (args) $...)').last.last
-
-      Cops::Parser.columns(statements).to_h { |col| [col.name, col] }
+      Cops::Parser.columns(schema).to_h { |col| [col.name, col] }
     end
   end
 
-  class Presence < RuboCop::Cop::Cop
+  class Presence < RuboCop::Cop::Base
     include Common
+    extend RuboCop::Cop::AutoCorrector
 
     MSG_NO_MODEL_SCHEMA = 'The schema is not specified in the model (use the_schema_is statement)'
     MSG_NO_DB_SCHEMA = 'Table "%s" is not defined in %s'
 
-    def autocorrect(node)
-      return unless schema
+    private
 
-      m = model
+    def register_offense(node)
+      schema.nil? and
+        add_offense(model.source, message: MSG_NO_DB_SCHEMA % [model.table_name, schema_path])
 
-      lambda do |corrector|
+      model.schema.nil? and add_offense(model.source, message: MSG_NO_MODEL_SCHEMA) do |corrector|
         indent = node.loc.expression.column + 2
         code = [
-          "the_schema_is #{m.table_name.to_s.inspect} do |t|",
+          "the_schema_is #{model.table_name.to_s.inspect} do |t|",
           *schema_columns.map { |_, col| "  #{col.source.loc.expression.source}" },
           'end'
         ].map { |s| ' ' * indent + s }.join("\n").then { |s| "\n#{s}\n" }
@@ -91,52 +105,71 @@ module TheSchemaIs
         corrector.insert_after(node.children[1].loc.expression, code)
       end
     end
+  end
+
+  class WrongTableName < RuboCop::Cop::Base
+    include Common
+    extend RuboCop::Cop::AutoCorrector
+
+    MSG_WRONG_TABLE_NAME = 'The real table name should be %p'
+    MSG_NO_TABLE_NAME = 'Table name is not specified'
 
     private
 
-    def validate
-      schema.nil? and
-        add_offense(model.source, message: MSG_NO_DB_SCHEMA % [model.table_name, schema_path])
-      model.schema.nil? and add_offense(model.source, message: MSG_NO_MODEL_SCHEMA)
+    def register_offense(_node)
+      return if model.schema.nil? || schema.nil?
+
+      pp
+
+      if model.table_name_node.nil?
+        add_offense(model.schema, message: MSG_NO_TABLE_NAME) do |corrector|
+          corrector.insert_after(model.schema.children[0].loc.expression, " #{model.table_name.to_s.inspect}")
+        end
+      elsif model.table_name_node.children[0] != model.table_name
+        add_offense(model.table_name_node,
+                    message: MSG_WRONG_TABLE_NAME % model.table_name) do |corrector|
+          corrector.replace(model.table_name_node.loc.expression, model.table_name.to_s.inspect)
+        end
+      end
     end
   end
 
-  class MissingColumn < RuboCop::Cop::Cop
+  class MissingColumn < RuboCop::Cop::Base
     include Common
+    extend RuboCop::Cop::AutoCorrector
 
     MSG = 'Column "%s" definition is missing'
 
-    def autocorrect(_node)
-      lambda do |corrector|
-        missing_columns.each { |name, col|
-          prev_statement = model_columns
-                           .slice(*schema_columns.keys[0...schema_columns.keys.index(name)])
-                           .values.last&.source
-          if prev_statement
-            indent = prev_statement.loc.expression.column
-            corrector.insert_after(
-              prev_statement.loc.expression,
-              "\n#{' ' * indent}#{col.source.loc.expression.source}"
-            )
-          else
-            indent = model.schema.loc.expression.column + 2
-            corrector.insert_after(
-              # of "the_schema_is do |t|" -- children[1] is "|t|""
-              model.schema.children[1].loc.expression,
-              "\n#{' ' * indent}#{col.source.loc.expression.source}"
-            )
-          end
-        }
-      end
-    end
-
     private
 
-    def validate
+    def register_offense(_node)
       return if model.schema.nil? || schema.nil?
 
-      missing_columns.each do |_, col|
-        add_offense(model.schema, message: MSG % col.name)
+      missing_columns.each do |name, col|
+        add_offense(model.schema, message: MSG % col.name) do |corrector|
+          insert_column(corrector, name, col)
+        end
+      end
+    end
+
+    def insert_column(corrector, name, col)
+      prev_statement = model_columns
+                       .slice(*schema_columns.keys[0...schema_columns.keys.index(name)])
+                       .values.last&.source
+
+      if prev_statement
+        indent = prev_statement.loc.expression.column
+        corrector.insert_after(
+          prev_statement.loc.expression,
+          "\n#{' ' * indent}#{col.source.loc.expression.source}"
+        )
+      else
+        indent = model.schema.loc.expression.column + 2
+        corrector.insert_after(
+          # of "the_schema_is do |t|" -- children[1] is "|t|""
+          model.schema.children[1].loc.expression,
+          "\n#{' ' * indent}#{col.source.loc.expression.source}"
+        )
       end
     end
 
@@ -145,14 +178,19 @@ module TheSchemaIs
     end
   end
 
-  class UnknownColumn < RuboCop::Cop::Cop
+  class UnknownColumn < RuboCop::Cop::Base
     include Common
+    extend RuboCop::Cop::AutoCorrector
 
     MSG = 'Uknown column "%s"'
 
-    def autocorrect(_node)
-      lambda do |corrector|
-        extra_columns.each do |_, col|
+    private
+
+    def register_offense(_node)
+      return if model.schema.nil? || schema.nil?
+
+      extra_columns.each do |_, col|
+        add_offense(col.source, message: MSG % col.name) do |corrector|
           src_range = col.source.loc.expression
           end_pos = col.source.next_sibling.then { |n|
             n ? n.loc.expression.begin_pos - 2 : col.source.find_parent(:block).loc.end.begin_pos
@@ -164,42 +202,27 @@ module TheSchemaIs
       end
     end
 
-    private
-
-    def validate
-      return if model.schema.nil? || schema.nil?
-
-      extra_columns.each do |_, col|
-        add_offense(col.source, message: MSG % col.name)
-      end
-    end
-
     def extra_columns
       model_columns.reject { |name,| schema_columns.keys.include?(name) }
     end
   end
 
-  class WrongColumnDefinition < RuboCop::Cop::Cop
+  class WrongColumnDefinition < RuboCop::Cop::Base
     include Common
+    extend RuboCop::Cop::AutoCorrector
 
     MSG = 'Wrong column definition: expected `%s`'
 
-    def autocorrect(_node)
-      lambda do |corrector|
-        wrong_columns.each do |mcol, scol|
-          corrector.replace(mcol.source.loc.expression, scol.source.loc.expression.source)
-        end
-      end
-    end
-
     private
 
-    def validate
+    def register_offense(_node)
       return if model.schema.nil? || schema.nil?
 
       wrong_columns
         .each do |mcol, scol|
-          add_offense(mcol.source, message: MSG % scol.source.loc.expression.source)
+          add_offense(mcol.source, message: MSG % scol.source.loc.expression.source) do |corrector|
+            corrector.replace(mcol.source.loc.expression, scol.source.loc.expression.source)
+          end
         end
     end
 
@@ -207,7 +230,9 @@ module TheSchemaIs
       model_columns
         .map { |name, col| [col, schema_columns[name]] }
         .reject { |mcol, scol|
-          mcol.type == scol.type && mcol.definition_source == scol.definition_source
+          # When column is not in schema, we shouldn't try to check it: UnknownColumn cop will
+          # handle.
+          !scol || mcol.type == scol.type && mcol.definition_source == scol.definition_source
         }
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: the_schema_is
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.5
 platform: ruby
 authors:
 - Victor Shepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-22 00:00:00.000000000 Z
+date: 2021-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backports
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: ffast
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.8
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.8
 - !ruby/object:Gem::Dependency
   name: memoist
   requirement: !ruby/object:Gem::Requirement
@@ -130,8 +116,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Changelog.md
 - LICENSE.txt
 - README.md
+- config/defaults.yml
 - lib/the_schema_is.rb
 - lib/the_schema_is/cops.rb
 - lib/the_schema_is/cops/inject.rb
@@ -149,14 +137,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: ActiveRecord model annotations done right