the_schema_is 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 24d4d7e0d7d99a14a9d924af7efbbfbe4ee0fb9eef3b89537fb11378b4e5495e
+  data.tar.gz: e41ee7faf7ee3620dc655c3ec3468df3cd6d89a5eb93a6b130ceabad7554b99f
+SHA512:
+  metadata.gz: ce06ad394d6cec9c357af68eb370ec667707a7ea2c5df57c412a3b0e86d3122cc3865035f9464729b1548477aa23dc9350b5c7700f42d668cd72a90c487fdeeb
+  data.tar.gz: 745a19300e80a00177abad59d4c702a304b1eb1c6f5b94c2ed3eb3b63519c5438b4cdb762c752ac9b71ef8e8d665fb3180b729ab8fa72262131e11a287d84465

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Victor 'Zverok' Shepelev
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,176 @@
+# 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)
+
+`the_schema_is` is a model schema annotation DSL in ActiveSupport.
+
+### Why annotate?
+
+An important part of class' public interface is **what attributes objects of this class have**. In ActiveRecord, attributes are inferred from DB columns and only can be seen in `db/schema.rb`, which is unfortunate.
+
+We believe it _should_ be part _immediately available_ information of class definition. "It is drawn automatically from DB" is kinda clever, but it _does not_ helps to read the code. "Auto-deduction from DB" could be used to compare actual table content's to the definition in Ruby but **not** to skip the definition.
+
+> Fun fact: most of other languages' ORM have chosen "explictly list attributes in the model" approach, for some reason! For example, Python's [Django](https://docs.djangoproject.com/en/3.0/topics/db/models/#quick-example), Elixir's [Ecto](https://hexdocs.pm/phoenix/ecto.html#the-schema), Go's [Beego](https://beego.me/docs/mvc/model/overview.md#quickstart) and [Gorm](https://gorm.io/docs/#Quick-Start), Rust's [Diesel](https://github.com/diesel-rs/diesel/blob/v1.3.0/examples/postgres/getting_started_step_1/src/models.rs), most of popular [NodeJS's options](https://www.codediesel.com/javascript/nodejs-mysql-orms/), and PHP's [Symphony](https://symfony.com/doc/current/doctrine.html#creating-an-entity-class) (but, to be honest, not [Laravel](https://laravel.com/docs/6.x/eloquent#eloquent-model-conventions)).
+
+### Well then, why not [annotate](https://github.com/ctran/annotate_models) gem?
+
+Annotate gem provides a very powerful and configurable CLI/rake task which allows adding to your model (and factory/route/spec) files comment looking like...
+
+```ruby
+# == Schema Information
+#
+# Table name: users
+#
+#  id                             :integer          not null, primary key
+#  email                          :string           default(""), not null
+#  encrypted_password             :string           default(""), not null
+#  last_sign_in_at                :datetime
+#  last_sign_in_ip                :inet
+#  created_at                     :datetime         not null
+#  updated_at                     :datetime         not null
+# ....
+```
+
+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.
+
+### So, how your approach is different?..
+
+`the_schema_is` allows you to do this:
+
+```ruby
+class User < ApplicationRecord
+  the_schema_is "users" do |t|
+    t.string "email", default: "", null: false
+    t.string "encrypted_password", null: false
+    t.datetime "last_sign_in_at"
+    t.inet "last_sign_in_ip"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    # ...
+  end
+end
+```
+
+Idea is, it is _exactly_ the same DSL that `db/schema.rb` uses, so:
+
+* it can be just copied from there (or written by hands in usual migration syntax);
+* it is _code_, which can be supplemented with _comments_ explaining what some column does, or why the defaults are this way; it also can be structured with columns reordering and extra blank lines.
+
+So, in reality, your annotation may look like this:
+
+```ruby
+class User < ApplicationRecord
+  the_schema_is "users" do |t|
+    t.string "email", default: "", null: false
+    # We use RSA encryption currently.
+    t.string "encrypted_password", null: false
+
+    t.inet "last_sign_in_ip" # FIXME: Legacy, we don't use it anymore because GDPR
+
+    t.datetime "last_sign_in_at"
+
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    # ...
+  end
+end
+```
+
+Now, `the_schema_is` gem consists of this DSL and _custom [Rubocop](https://www.rubocop.org/) cops_ which check the correspondence of this DSL in model classes to your `db/schema.rb` (and can automatically fix discrepancies found).
+
+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;
+* 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?
+
+Nothing.
+
+**Ugh... What?**
+
+That's just how it is (at least for now) ¯\\\_(ツ)\_/¯
+
+The block isn't even evaluated at all (so potentially can contain any code, and only Rubocop's cop will complain). In the future, it _can_ do some useful things (like, on app run in development environment compare scheme of the real DB with declarations in class), but for now, it is just noop declarative schema copy-paste.
+
+## Usage
+
+1. Add to your Gemfile `gem 'the_schema_is'` and run `bundle install`.
+2. Add to your `.rubocop.yml` this:
+  ```yaml
+  require:
+    - 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
+
+To make reporting cleaner, all cops are split into:
+
+* `Presence`
+* `MissingColumn`
+* `UnknownColumn`
+* `WrongColumnDefinition`
+
+It is not advisable to selectively turn them off, but you may know better (for example, some may experiment with leaving in models just `t.<type> '<name>'` without details about defaults and limit, and therefore turn off `WrongColumnDefinition`), all of it is pretty experimental!
+
+## Setting
+
+`the_schema_is` cops support some configuration, which should be done on the namespace level in your `.rubocop.yml`, for example:
+
+```yaml
+TheSchemaIs:
+  Schema: db/other-schema-file.rb
+```
+
+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`).
+
+So, if you have your custom-named base class, you should do:
+
+```yaml
+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.
+
+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
+inherit_from: ../../../.rubocop.yml
+
+TheSchemaIs:
+  BaseClass: Users::BaseRecord
+  Schema: db/users_schema.rb
+```
+
+## 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`:
+  ```yaml
+  Metrics/BlockLength:
+    ExcludedMethods:
+      - the_schema_is
+  ```
+
+## Author and License
+
+[Victor Shepelev aka "zverok"](https://zverok.github.io), MIT.

data/lib/the_schema_is.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module TheSchemaIs
+  module DSL
+    # Just a no-op!
+    def the_schema_is(*); end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  extend TheSchemaIs::DSL
+end

data/lib/the_schema_is/cops.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'memoist'
+require 'rubocop'
+require 'fast'
+require 'backports/latest'
+
+require_relative 'cops/node_util'
+require_relative 'cops/inject'
+
+TheSchemaIs::Cops::Inject.defaults!
+
+require_relative 'cops/parser'
+
+module TheSchemaIs
+  using Cops::NodeRefinements
+
+  module Cops
+    def self.schema_cache
+      @schema_cache ||= Hash.new { |h, path| h[path] = Cops::Parser.schema(path) }
+    end
+  end
+
+  module Common
+    extend Memoist
+
+    def self.included(cls)
+      cls.define_singleton_method(:badge) {
+        RuboCop::Cop::Badge.for("TheSchemaIs::#{name.split('::').last}")
+      }
+    end
+
+    def on_class(node)
+      @model = Cops::Parser.model(node,
+                                  base_classes: cop_config.fetch('BaseClass'),
+                                  table_prefix: cop_config['TablePrefix']) or return
+
+      validate
+    end
+
+    private
+
+    attr_reader :model
+
+    def validate
+      fail NotImplementedError
+    end
+
+    memoize def schema_path
+      cop_config.fetch('Schema')
+    end
+
+    memoize def schema
+      Cops.schema_cache.dig(schema_path, model.table_name)
+    end
+
+    memoize def model_columns
+      statements = model.schema.ffast('(block (send nil :the_schema_is) (args) $...)').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] }
+    end
+  end
+
+  class Presence < RuboCop::Cop::Cop
+    include Common
+
+    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
+
+      m = model
+
+      lambda do |corrector|
+        indent = node.loc.expression.column + 2
+        code = [
+          "the_schema_is #{m.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" }
+
+        # in "class User < ActiveRecord::Base" -- second child is "ActiveRecord::Base"
+        corrector.insert_after(node.children[1].loc.expression, code)
+      end
+    end
+
+    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)
+    end
+  end
+
+  class MissingColumn < RuboCop::Cop::Cop
+    include Common
+
+    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
+      return if model.schema.nil? || schema.nil?
+
+      missing_columns.each do |_, col|
+        add_offense(model.schema, message: MSG % col.name)
+      end
+    end
+
+    def missing_columns
+      schema_columns.reject { |name,| model_columns.keys.include?(name) }
+    end
+  end
+
+  class UnknownColumn < RuboCop::Cop::Cop
+    include Common
+
+    MSG = 'Uknown column "%s"'
+
+    def autocorrect(_node)
+      lambda do |corrector|
+        extra_columns.each do |_, col|
+          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
+          }
+          range =
+            ::Parser::Source::Range.new(src_range.source_buffer, src_range.begin_pos - 2, end_pos)
+          corrector.remove(range)
+        end
+      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
+    include Common
+
+    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
+      return if model.schema.nil? || schema.nil?
+
+      wrong_columns
+        .each do |mcol, scol|
+          add_offense(mcol.source, message: MSG % scol.source.loc.expression.source)
+        end
+    end
+
+    def wrong_columns
+      model_columns
+        .map { |name, col| [col, schema_columns[name]] }
+        .reject { |mcol, scol|
+          mcol.type == scol.type && mcol.definition_source == scol.definition_source
+        }
+    end
+  end
+end

data/lib/the_schema_is/cops/inject.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# copy-paste from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+# ...and other projects in rubocop-hq :shrug:
+module TheSchemaIs
+  module Cops
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      def self.defaults!
+        path = File.expand_path('../../../config/defaults.yml', __dir__)
+        hash = RuboCop::ConfigLoader.send(:load_yaml_configuration, path)
+        config = RuboCop::Config.new(hash, path)
+        puts "configuration from #{path}" if RuboCop::ConfigLoader.debug?
+        config = RuboCop::ConfigLoader.merge_with_default(config, path)
+        RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/the_schema_is/cops/node_util.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TheSchemaIs
+  module Cops
+    module NodeRefinements
+      refine ::Parser::AST::Node do
+        def ffast(expr)
+          Fast.search(expr, self)
+        end
+
+        def ffast_match?(expr)
+          Fast.match?(expr, self)
+        end
+
+        def arraify
+          type == :begin ? children : [self]
+        end
+
+        def next_sibling
+          return unless parent
+
+          parent.children.index(self).then { |i| parent.children[i + 1] }
+        end
+
+        def find_parent(type)
+          Enumerator.produce(parent, &:parent).slice_after { |n| n && n.type == type }.first.last
+        end
+      end
+    end
+  end
+end

data/lib/the_schema_is/cops/parser.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module TheSchemaIs
+  module Cops
+    module Parser
+      using NodeRefinements
+
+      # See https://github.com/rails/rails/blob/f33d52c95217212cbacc8d5e44b5a8e3cdc6f5b3/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L217
+      # TODO: numeric is just an alias for decimal
+      # TODO: different adapters can add another types
+      # https://edgeguides.rubyonrails.org/active_record_postgresql.html
+      STANDARD_COLUMN_TYPES = %i[bigint binary boolean date datetime decimal numeric
+                                 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
+
+      Model = Struct.new(:class_name, :table_name, :source, :schema, 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
+        end
+      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?..
+      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)
+           .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?
+
+        # 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) }
+
+        class_name = name_node.first.loc.expression.source
+
+        schema = definition_node.ffast('$(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
+
+        Model.new(
+          class_name: class_name,
+          table_name: table_name ||
+            table_prefix.+(ActiveSupport::Inflector.tableize(class_name)),
+          source: definition_node,
+          schema: schema
+        )
+      end
+
+      def self.base_classes_query(classes)
+        classes
+          .map { |cls| cls.split('::').inject('nil') { |res, str| "(const #{res} :#{str})" } }
+          .join(' ')
+          .then { |str| "{#{str}}" }
+      end
+
+      def self.columns(ast)
+        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 $_) $...'))
+            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))
+            Column.new(name: name, type: type, source: node) if COLUMN_DEFS.include?(type)
+          end
+        }.compact
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: the_schema_is
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Victor Shepelev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: backports
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.16.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      Annotating ActiveRecord models with lists of columns defined through DSL and checked with
+      custom Rubocop's cop.
+email: zverok.offline@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/the_schema_is.rb
+- lib/the_schema_is/cops.rb
+- lib/the_schema_is/cops/inject.rb
+- lib/the_schema_is/cops/node_util.rb
+- lib/the_schema_is/cops/parser.rb
+homepage: https://github.com/zverok/the_schema_is
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: ActiveRecord model annotations done right
+test_files: []