the_schema_is 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91c0bfc087833138e49b3723c6c8c7682899473ac1569b7a98d73c4aa86f62e7
-  data.tar.gz: c5e7980b3a600c1bfff051b719157c980cace74667db35517f225434e765e303
+  metadata.gz: 054c02711e49163e9600e925da6c9bab7007b276528472834e3383326284f5c9
+  data.tar.gz: 837d5d1f3910505a3ac0e2aa4ff7742ff960555ed0edd27dfa2a7f7b7f75d996
 SHA512:
-  metadata.gz: 89cff82616f4fa927e93268347d44d2d335928073912c1c4dac3f8a309d0c3fe82922bf97c6975b54a978d6d6bd23704cb30f80d4cc919896185d0d6eb0d1f9d
-  data.tar.gz: 0e6b141eb082561ea2939c131539e6d4ff58f47dd25d142f841b703ae6e3fe325ed10c4bc368a77b144c4cf817d4d7da8df361a6e877946d17a348f5253bac4f
+  metadata.gz: 2042bfe76d1813cc7ad043b4947fa885162e4630e27d4bdb30b5ff961de77ad9fd9e01ae36d348ddf25fa55d63d58157cb0256d1ebad80ec7fd9246368201d60
+  data.tar.gz: da567e5da9f013be952177ce79d2ba6f2ed1431f342723360f660b0dda909d02a120ad9bcfd6dfa5d9b039e74948f005655151280e10c1dd3509af27b6897d2e

data/Changelog.md

@@ -1,5 +1,11 @@
 # the-schema-is changes
 
+## 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

@@ -3,7 +3,7 @@
 [![Gem Version](https://badge.fury.io/rb/the_schema_is.svg)](http://badge.fury.io/rb/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`
@@ -143,12 +144,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 +159,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

@@ -11,6 +11,10 @@ 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

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'
@@ -25,9 +24,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,7 +35,7 @@ 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
@@ -50,7 +50,7 @@ module TheSchemaIs
 
     attr_reader :model
 
-    def validate
+    def register_offense(node)
       fail NotImplementedError
     end
 
@@ -63,34 +63,34 @@ module TheSchemaIs
     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" }
@@ -99,52 +99,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
 
@@ -153,14 +172,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
@@ -172,42 +196,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
 
@@ -215,7 +224,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

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

data/lib/the_schema_is/cops/parser.rb

@@ -17,64 +17,68 @@ module TheSchemaIs
 
       COLUMN_DEFS = (STANDARD_COLUMN_TYPES + POSTGRES_COLUMN_TYPES + %i[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.parse(code)
+        # TODO: Some kind of "current version" (ask Rubocop!)
+        RuboCop::AST::ProcessedSource.new(code, 2.7).ast
+      end
+
       def self.schema(path)
-        ast = Fast.ast(File.read(path))
-
-        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 = parse(File.read(path))
+
+        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,10 +87,10 @@ 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: the_schema_is
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Victor Shepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-12 00:00:00.000000000 Z
+date: 2021-08-16 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
@@ -151,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