rubocop-migration 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18d15295e2b2d2cea9b6cdb58f2de2e5c2ae2931
-  data.tar.gz: d616df1b06c2c711d6f82e4eb2548a536eaff1f7
+  metadata.gz: 2f5d900885e38728ea16270cdb724f90d3b95b9e
+  data.tar.gz: e2a245aa7c577b066b2081cf73607cab961b8ada
 SHA512:
-  metadata.gz: cf93f98b7b7bfddaee4689e7dae70d267c8e4b202e480c22221ce2d9c8b4d8e3dc9cc6258581eb589228ef79c60d442a3e085781bd43c855718345e176720335
-  data.tar.gz: d88df8c695daf167df7b46f621f9cc4ce5b74a754cde2d523c97234203a0c84449a96830b933b6e450e9b369daef47df598f7004f4e7abe600ea0df9edb32d12
+  metadata.gz: cf48675fc5ac8d96584cacbe6b30eae4f0f8a289679fd9ac1cbbd1fcebe9b87cd01fee9f166727085161f40ba1d79029ee69c6801bb465725dfbcca9c7de7159
+  data.tar.gz: b30e87bf96055a935fa57f07c24d9aa6e3a47e205baf9fe4225a5ce36f1547d6fb5e1ef560ee3ae6e0e151a370d54da786e59b2a0209ffda143173da7594ae47

data/README.md

@@ -31,8 +31,3 @@ git clone --depth 1 git://github.com/bbatsov/rubocop.git vendor/rubocop
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## TODO
-
-https://www.braintreepayments.com/blog/safe-operations-for-high-volume-postgresql/
-http://leopard.in.ua/2016/09/20/safe-and-unsafe-operations-postgresql

data/lib/rubocop-migration.rb

@@ -1,9 +1,14 @@
 require "active_support"
 require "active_support/core_ext"
+require "active_record"
+# Only load a portion of strong_migrations
+require "strong_migrations/migration"
+require "strong_migrations/unsafe_migration"
 require "rubocop"
 
 require "rubocop/migration/version"
-require "rubocop/cop/migration/add_index_non_concurrently"
+require "rubocop/migration/strong_migrations_checker"
+require "rubocop/cop/migration/unsafe_migration"
 
 module RuboCop
   module Migration

data/lib/rubocop/cop/migration/unsafe_migration.rb

@@ -0,0 +1,69 @@
+module RuboCop
+  module Cop
+    module Migration
+      class UnsafeMigration < Cop
+        # List of all public methods that can be used within a migration method,
+        # like `add_index`, `rename_table`, etc.
+        SCHEMA_STATEMENTS = ActiveRecord::ConnectionAdapters::SchemaStatements
+          .public_instance_methods
+          .freeze
+        SCHEMA_STATEMENTS_PATTERN = SCHEMA_STATEMENTS.map { |s| ":#{s}" }.join(" ")
+
+        ERROR_NOTICE = "Ignore this warning by inserting `# rubocop:disable UnsafeMigration`\nabove your code and `# rubocop:enable UnsafeMigration` below code.".freeze
+
+        # Match `ActiveRecord::Migration` and `ActiveRecord::Migration[5.0]`
+        def_node_matcher :migration_class?, <<-PATTERN
+          {
+            (class
+              (const nil _)
+              (const
+                (const nil :ActiveRecord) :Migration) ...)
+
+            (class
+              (const nil _)
+              (send
+                (const
+                  (const nil :ActiveRecord) :Migration) :[] _) ...)
+          }
+        PATTERN
+
+        # `down` migrations can be ignored as they should not be run in
+        # production environments per:
+        # https://github.com/ankane/strong_migrations/commit/fcfbcb4b1bef6a1ed9ec4808268ed0e684ec4389
+        def_node_matcher :migration_method_match, <<-PATTERN
+          (def {:change :up} args $...)
+        PATTERN
+
+        def_node_search :schema_statement_match, <<-PATTERN
+          $(send nil ${#{SCHEMA_STATEMENTS_PATTERN}} $...)
+        PATTERN
+
+        def investigate(processed_source)
+          ast = processed_source.ast
+          return if !ast || !migration_class?(ast)
+          ast.each_child_node do |child_node|
+            migration_methods = migration_method_match(child_node)
+            migration_methods&.each { |method_node| investigate_migration_method(method_node) }
+          end
+        end
+
+        private
+
+        def investigate_migration_method(method_node)
+          schema_statement_match(method_node) do |statement_node, method_name, args_nodes|
+            # TODO: Better/safer way to do this?
+            args_source = "[#{args_nodes.map(&:source).join(', ')}]"
+            args = eval(args_source)
+
+            checker = RuboCop::Migration::StrongMigrationsChecker.new
+            error = checker.check_operation(method_name, *args)
+            if error
+              error += "\n#{ERROR_NOTICE}"
+              add_offense(statement_node, :expression, error)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/migration/strong_migrations_checker.rb

@@ -0,0 +1,47 @@
+module RuboCop
+  module Migration
+    class StrongMigrationsChecker
+      include StrongMigrations::Migration
+
+      # StrongMigrations raises errors for potentially unsafe code, and relies
+      # on the user to add a `safety_assured { }` block to supress this warning.
+      # These warnings are unsupported by rubocop-migration for now.
+      SAFETY_ASSURED_WARNINGS = [
+        :add_column_json,
+        :add_index_columns,
+        :change_table,
+        :execute,
+        :remove_column,
+      ].freeze
+
+      def version_safe?
+        false
+      end
+
+      def postgresql?
+        true
+      end
+
+      def check_operation(method_name, *args)
+        send(method_name, *args)
+      rescue StrongMigrations::UnsafeMigration => e
+        strip_wait_message(e.message)
+      rescue NoMethodError
+        # Do nothing, this method is unrecognized by StrongMigrations unsafe
+        # operations and is likely safe.
+      end
+
+      private
+
+      def raise_error(message_key)
+        return if SAFETY_ASSURED_WARNINGS.include?(message_key)
+        super(message_key)
+      end
+
+      # Strip large "WAIT!" ASCII art from the StrongMigrations error message.
+      def strip_wait_message(error_message)
+        error_message.split("\n\n", 2).last
+      end
+    end
+  end
+end

data/lib/rubocop/migration/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module Migration
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/rubocop-migration.gemspec

@@ -24,6 +24,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.3.0"
 
   spec.add_dependency "activesupport", ">= 4"
+  spec.add_dependency "activerecord", ">= 4"
+  spec.add_dependency "strong_migrations", "~> 0.1"
   spec.add_dependency "rubocop", ">= 0.48.0"
 
   spec.add_development_dependency "bundler", "~> 1.14"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-migration
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Peter Graham
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-07 00:00:00.000000000 Z
+date: 2017-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: strong_migrations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -152,7 +180,8 @@ files:
 - bin/setup
 - circle.yml
 - lib/rubocop-migration.rb
-- lib/rubocop/cop/migration/add_index_non_concurrently.rb
+- lib/rubocop/cop/migration/unsafe_migration.rb
+- lib/rubocop/migration/strong_migrations_checker.rb
 - lib/rubocop/migration/version.rb
 - rubocop-migration.gemspec
 - vendor/.gitkeep

data/lib/rubocop/cop/migration/add_index_non_concurrently.rb

@@ -1,66 +0,0 @@
-module RuboCop
-  module Cop
-    module Migration
-      class AddIndexNonConcurrently < Cop
-        MSG = 'Use `algorithm: :concurrently` to avoid locking table.'.freeze
-
-        def_node_matcher :add_index_match, <<-PATTERN
-          (send nil :add_index _ _ (hash $...))
-        PATTERN
-
-        def_node_matcher :add_reference_match, <<-PATTERN
-          (send nil {:add_reference :add_belongs_to} _ _ (hash $...))
-        PATTERN
-
-        def_node_matcher :add_reference_index_options?, <<-PATTERN
-          (pair (sym :index) !({:nil false}))
-        PATTERN
-
-        def on_send(node)
-          if node.method_name == :add_index
-            check_add_index(node)
-          elsif [:add_reference, :add_belongs_to].include?(node.method_name)
-            check_add_reference(node)
-          end
-        end
-
-        private
-
-        def check_add_index(node)
-          pairs = add_index_match(node)
-          if !pairs_contains_algorithm_concurrently?(pairs)
-            add_offense(node, :expression, MSG)
-          end
-        end
-
-        def check_add_reference(node)
-          pairs = add_reference_match(node)
-          index_options = pairs&.find { |pair| add_reference_index_options?(pair) }&.value
-          return unless index_options
-
-          valid = true
-          if index_options.true_type?
-            # `index: true` is always invalid
-            valid = false
-          elsif index_options.hash_type?
-            # check for `algorithm: :concurrently`
-            valid = pairs_contains_algorithm_concurrently?(index_options.pairs)
-          end
-          add_offense(node, :expression, MSG) if !valid
-        end
-
-        def pairs_contains_algorithm_concurrently?(pairs)
-          return false unless pairs.is_a?(Array)
-          pairs.each do |pair|
-            next unless pair.pair_type?
-            key = pair.key
-            value = pair.value
-            next unless (key.sym_type? || key.str_type?) && key.children.first.to_s == "algorithm"
-            return true if value.children.first.to_s == "concurrently"
-          end
-          false
-        end
-      end
-    end
-  end
-end