rubocop-highlands 1.0.0

data/lib/rubocop-highlands.rb

@@ -0,0 +1,11 @@
+require 'pathname'
+require 'yaml'
+
+# Load original rubocop gem
+require 'rubocop'
+
+require 'rubocop/highlands'
+require 'rubocop/highlands/inject'
+require 'rubocop/highlands/version'
+
+RuboCop::Highlands::Inject.defaults!

data/lib/rubocop/cop/highlands/class_name.rb

@@ -0,0 +1,47 @@
+module RuboCop
+  module Cop
+    module Highlands
+      # Cop to prevent cross-model references, which result in a cascade of autoloads. E.g.,
+      # belongs_to :user, :class_name => User.name
+      class ClassName < Cop
+        MSG = 'Use "Model" instead of Model.name at class scope to avoid cross-model references. ' \
+          'They cause a long cascade of autoloading, slowing down app startup and slowing down ' \
+          'reloading of zeus after changing a model.'.freeze
+
+        # Is this a has_many, has_one, or belongs_to with a :class_name arg? Make sure the
+        # class name is a hardcoded string. If not, add an offense and return true.
+        def on_send(node)
+          association_statement =
+            node.command?(:has_many) ||
+            node.command?(:has_one) ||
+            node.command?(:belongs_to)
+
+          return unless association_statement
+
+          class_pair = class_name_node(node)
+
+          if class_pair && !string_class_name?(class_pair)
+            add_offense(class_pair)
+          end
+        end
+
+        private
+
+        # Return the descendant node that is a hash pair (:key => value) whose key
+        # is :class_name.
+        def class_name_node(node)
+          node.descendants.detect do |e|
+            e.is_a?(Parser::AST::Node) &&
+              e.pair_type? &&
+              e.children[0].children[0] == :class_name
+          end
+        end
+
+        # Given a hash pair :class_name => value, is the value a hardcoded string?
+        def string_class_name?(class_pair)
+          class_pair.children[1].str_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/highlands/class_or_module_declared_in_wrong_file.rb

@@ -0,0 +1,138 @@
+require_relative '../../highlands/inflections'
+require_relative '../../highlands/rails_autoloading'
+
+module RuboCop
+  module Cop
+    module Highlands
+      # This cop checks for a class or module declared in a file that does not match its name.
+      # The Rails autoloader can't find such a constant, but sometimes
+      # people "get lucky" if the file happened to be loaded before the method was defined.
+      #
+      # @example
+      #   # bad
+      #
+      #   # foo/bar.rb
+      #   module Foo
+      #     class Goop
+      #     end
+      #
+      #     module Moo
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   # foo.rb
+      #
+      #   # foo/goop.rb
+      #   module Foo
+      #     class Goop
+      #     end
+      #   end
+      #
+      #   # foo/moo.rb
+      #   module Foo
+      #     module Moo
+      #     end
+      #   end
+      #
+      # Note that autoloading works fine if classes are defined in the file that defines
+      # the module. This is common usage for things like error classes, so we'll allow it.
+      # Nested classes are also allowed:
+      #
+      # @example
+      #   # good
+      #
+      #   # foo.rb
+      #   module Foo
+      #     class Bar < StandardError
+      #     end
+      #   end
+      #
+      #   # good
+      #
+      #   # foo.rb
+      #   class Foo
+      #     class Bar # nested class
+      #     end
+      #   end
+      class ClassOrModuleDeclaredInWrongFile < Cop
+        include Inflections
+        include RailsAutoloading
+
+        # class Foo or module Foo in the wrong file
+        CLASS_OR_MODULE_MSG =
+          "In order for Rails autoloading to be able to find and load this file when " \
+          "someone references this class/module, move its definition to a file that matches " \
+          "its name. %s %s should be defined in %s.".freeze
+        # class FooError < StandardError, in the wrong file
+        ERROR_CLASS_MSG =
+          "In order for Rails autoloading to be able to find and load this file when " \
+          "someone references this class, move its definition to a file that defines " \
+          "the owning module. Class %s should be defined in %s.".freeze
+
+        # module M
+        def on_module(node)
+          on_class_or_module(node)
+        end
+
+        # class C
+        def on_class(node)
+          on_class_or_module(node)
+        end
+
+        private
+
+        def on_class_or_module(node)
+          path = node.source_range.source_buffer.name
+          return unless run_rails_autoloading_cops?(path)
+
+          const_name = node.loc.name.source
+          parent_module_name = normalize_module_name(node.parent_module_name)
+          fully_qualified_const_name = full_const_name(parent_module_name, const_name)
+          expected_dir = underscore(fully_qualified_const_name)
+          allowable_paths = allowable_paths_for(expected_dir, allow_dir: true)
+          if allowable_paths.none? { |allowable_path| path =~ allowable_path }
+            add_error(const_name, fully_qualified_const_name, node)
+          end
+        rescue => e
+          puts e.backtrace
+          raise
+        end
+
+        def add_error(const_name, fully_qualified_const_name, node)
+          class_or_module = node.type.to_s.capitalize
+          error_class = error_class?(node, class_or_module, const_name)
+          if error_class
+            parent_module_names = split_modules(node.parent_module_name)
+          else
+            parent_module_names = split_modules(fully_qualified_const_name)
+          end
+          expected_file = "#{parent_module_names.map { |name| underscore(name) }.join("/")}.rb"
+          if error_class
+            add_offense(node, message: ERROR_CLASS_MSG % [const_name, expected_file])
+          else
+            add_offense(
+              node,
+              message: CLASS_OR_MODULE_MSG % [class_or_module, const_name, expected_file]
+            )
+          end
+        end
+
+        # Does this node define an Error class? (Classname or base class includes the word
+        # "Error" or "Exception".)
+        def error_class?(node, class_or_module, const_name)
+          return false unless class_or_module == "Class"
+          _, base_class, *_ = *node
+          return unless base_class
+          base_class_name = base_class.children[1].to_s
+          if const_name =~ /Error|Exception/ || base_class_name =~ /Error|Exception/
+            return true
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/highlands/const_assigned_in_wrong_file.rb

@@ -0,0 +1,74 @@
+require_relative '../../highlands/inflections'
+require_relative '../../highlands/rails_autoloading'
+
+module RuboCop
+  module Cop
+    module Highlands
+      # This cop checks for a constant assigned in a file that does not match its owning scope.
+      # The Rails autoloader can't find such a constant, but sometimes
+      # people "get lucky" if the file happened to be loaded before the method was defined.
+      #
+      # @example
+      #   # bad
+      #
+      #   # foo/bar.rb
+      #   module Foo
+      #     BAZ = 42
+      #   end
+      #
+      #   # good
+      #
+      #   # foo.rb
+      #   module Foo
+      #     BAZ = 42
+      #   end
+      class ConstAssignedInWrongFile < Cop
+        include Inflections
+        include RailsAutoloading
+
+        # FOO = 42
+        ASSIGNMENT_MSG =
+          "In order for Rails autoloading to be able to find and load this file when " \
+          "someone references this const, move the const assignment to a file that defines " \
+          "the owning module. Const %s should be defined in %s.".freeze
+        # FOO = 42 at global scope
+        GLOBAL_ASSIGNMENT =
+          "In order for Rails autoloading to be able to find and load this file when " \
+          "someone references this const, move the const assignment to a file that defines " \
+          "the owning module. Const %s should be moved into a namespace or defined in %s.".freeze
+
+        # FOO = 42
+        def on_casgn(node)
+          path = node.source_range.source_buffer.name
+          return unless run_rails_autoloading_cops?(path)
+          return unless node.parent_module_name
+
+          # Ignore assignments like Foo::Bar = 42
+          return if node.children[0]
+
+          const_name = node.children[1]
+          parent_module_name = normalize_module_name(node.parent_module_name)
+          fully_qualified_const_name = full_const_name(parent_module_name, const_name)
+          expected_dir = underscore(fully_qualified_const_name)
+          allowable_paths = allowable_paths_for(expected_dir)
+          if allowable_paths.none? { |allowable_path| path =~ allowable_path }
+            add_error(const_name, node)
+          end
+        end
+
+        private
+
+        def add_error(const_name, node)
+          parent_module_names = split_modules(node.parent_module_name)
+          expected_file = "#{parent_module_names.map { |name| underscore(name) }.join("/")}.rb"
+          if expected_file == ".rb" # global namespace
+            expected_file = "#{underscore(const_name)}.rb"
+            add_offense(node, message: GLOBAL_ASSIGNMENT % [const_name, expected_file])
+          else
+            add_offense(node, message: ASSIGNMENT_MSG % [const_name, expected_file])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/highlands/continuation_slash.rb

@@ -0,0 +1,25 @@
+module RuboCop
+  module Cop
+    module Highlands
+      class ContinuationSlash < Cop
+        MSG = 'Slash continuation should be reserved for closed string continuation. ' \
+              'Many times it is used to get around other existing rules.'.freeze
+
+        def enforce_violation(node)
+          return if node.source.match(/["']\s*\\\n/)
+          return unless node.source.match(/\\\n/)
+          add_offense(node, message: message)
+        end
+
+        alias on_send enforce_violation
+        alias on_if enforce_violation
+
+        Util::ASGN_NODES.each do |type|
+          define_method("on_#{type}") do |node|
+            enforce_violation(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/highlands/default_scope.rb

@@ -0,0 +1,20 @@
+module RuboCop
+  module Cop
+    module Highlands
+      # Cop to help prevent the scorge of Default Scopes from ActiveRecord.
+      # Once in place they are almost impossible to remove.
+      class DefaultScope < Cop
+        MSG = 'Avoid `default_scope`.  Default scopes make it difficult to '\
+              'refactor data access patterns since the scope becomes part '\
+              'of every query unless explicitly excluded, even when it is '\
+              'unnecessary or incidental to the desired logic.'.freeze
+
+        def on_send(node)
+          return unless node.command?(:default_scope)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/highlands/factory_attr_references_class.rb

@@ -0,0 +1,74 @@
+module RuboCop
+  module Cop
+    module Highlands
+      # Cop to enforce "attr { CONST }" instead of "attr CONST" in factories,
+      # because the latter forces autoload, which slows down spec startup time and
+      # Zeus reload time after touching a model.
+      class FactoryAttrReferencesClass < Cop
+        MSG = "Instead of attr_name MyClass::MY_CONST, use attr_name { MyClass::MY_CONST }. " \
+          "This enables faster spec startup time and Zeus reload time.".freeze
+
+        def_node_search :factory_attributes, <<-PATTERN
+          (block (send nil {:factory :trait} ...) _ { (begin $...) $(send ...) } )
+        PATTERN
+
+        # Look for "attr CONST" expressions in factories or traits. In RuboCop, this is
+        # a `send` node, sending the attr method.
+        def on_send(node)
+          return unless in_factory_file?(node)
+          return unless in_factory_or_trait?(node)
+
+          add_const_offenses(node)
+        end
+
+        private
+
+        def in_factory_file?(node)
+          filename = node.location.expression.source_buffer.name
+
+          # For tests, the input is a string
+          filename.include?("spec/factories/") || filename == "(string)"
+        end
+
+        # Is this node in a factory or trait, but not inside a nested block in a factory or trait?
+        def in_factory_or_trait?(node)
+          return false unless node
+
+          # Bail out if this IS the factory or trait node.
+          return false unless factory_attributes(node)
+          return false unless node.parent
+
+          # Is this node in a block that was passed to the factory or trait method?
+          if node.parent.is_a?(RuboCop::AST::Node) && node.parent.block_type?
+            send_node = node.parent.children.first
+            return false unless send_node
+            return false unless send_node.send_type?
+
+            # Const is referenced in the block passed to a factory or trait.
+            return true if send_node.command?(:factory)
+            return true if send_node.command?(:trait)
+
+            # Const is a block that's nested deeper inside a factory or trait. This is what we want
+            # developers to do.
+            return false
+          end
+
+          in_factory_or_trait?(node.parent)
+        end
+
+        def add_const_offenses(node)
+          # Add an offense for any const reference
+          node.each_child_node(:const) do |const_node|
+            add_offense(const_node)
+          end
+
+          # Recurse into arrays, hashes, and method calls such as ConstName[:symbol],
+          # adding offenses for any const reference inside them.
+          node.each_child_node(:array, :hash, :pair, :send) do |array_node|
+            add_const_offenses(array_node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/highlands/factory_class_use_string.rb

@@ -0,0 +1,39 @@
+module RuboCop
+  module Cop
+    module Highlands
+      # Cop to tell developers to use :class => "MyClass" instead of :class => MyClass,
+      # because the latter slows down reloading zeus.
+      class FactoryClassUseString < Cop
+        MSG = 'Instead of :class => MyClass, use :class => "MyClass". ' \
+          "This enables faster spec startup time and faster Zeus reload time.".freeze
+
+        def on_send(node)
+          return unless node.command?(:factory)
+
+          class_pair = class_node(node)
+
+          if class_pair && !string_class_name?(class_pair)
+            add_offense(class_pair)
+          end
+        end
+
+        private
+
+        # Return the descendant node that is a hash pair (:key => value) whose key
+        # is :class.
+        def class_node(node)
+          node.descendants.detect do |e|
+            e.is_a?(Parser::AST::Node) &&
+              e.pair_type? &&
+              e.children[0].children[0] == :class
+          end
+        end
+
+        # Given a hash pair :class_name => value, is the value a hardcoded string?
+        def string_class_name?(class_pair)
+          class_pair.children[1].str_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/highlands/mass_assignment_accessible_modifier.rb

@@ -0,0 +1,18 @@
+module RuboCop
+  module Cop
+    module Highlands
+      # Modifying Mass assignment restrictions eliminates the entire point of disabling
+      # mass assignment. It's a lazy, potentially dangerous approach that should be discouraged.
+      class MassAssignmentAccessibleModifier < Cop
+        MSG = 'Do no override and objects mass assignment restrictions.'.freeze
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+
+          return unless method_name == :accessible=
+          add_offense(node, message: MSG)
+        end
+      end
+    end
+  end
+end