rubocop-airbnb 1.0.0

data/lib/rubocop-airbnb.rb

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

data/lib/rubocop/airbnb.rb

@@ -0,0 +1,16 @@
+require 'pathname'
+require 'psych'
+
+Dir.glob(File.expand_path('cop/**/*.rb', File.dirname(__FILE__))).map(&method(:require))
+
+module RuboCop
+  # RuboCop Airbnb project namespace
+  module Airbnb
+    PROJECT_ROOT =
+      Pathname.new(__FILE__).parent.parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG = Psych.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(*constants(false))
+  end
+end

data/lib/rubocop/airbnb/inflections.rb

@@ -0,0 +1,14 @@
+# String inflections copied over from ActiveSupport
+module Inflections
+  # Convert Foo::BarBaz to foo/bar_baz.
+  # Copied from ActiveSupport.
+  def underscore(camel_cased_word)
+    word = camel_cased_word.to_s.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end

data/lib/rubocop/airbnb/inject.rb

@@ -0,0 +1,20 @@
+# Straight up ripped from the custom Rspec rubocop
+# https://github.com/nevir/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+require 'yaml'
+
+module RuboCop
+  module Airbnb
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.load_file(path).to_hash
+        config = Config.new(hash, path)
+        puts "configuration from #{path}" if ConfigLoader.debug?
+        config = ConfigLoader.merge_with_default(config, path)
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/airbnb/rails_autoloading.rb

@@ -0,0 +1,55 @@
+# These methods are useful for Rubocop rules related to Rails autoloading.
+module RailsAutoloading
+  def run_rails_autoloading_cops?(path)
+    return false unless config["Rails".freeze]
+    return false unless config["Rails".freeze]["Enabled".freeze]
+
+    # Ignore rake tasks
+    return false unless path.end_with?(".rb")
+
+    true
+  end
+
+  # Given "foo/bar/baz", return:
+  # [
+  #   %r{/foo.rb$},
+  #   %r{/foo/bar.rb$},
+  #   %r{/foo/bar/baz.rb$},
+  #   %r{/foo/bar/baz/}, # <= only if allow_dir = true
+  # ]
+  def allowable_paths_for(expected_dir, options = {})
+    options = { allow_dir: false }.merge(options)
+    allowable_paths = []
+    next_slash = expected_dir.index("/")
+    while next_slash
+      allowable_paths << %r{/#{expected_dir[0...next_slash]}.rb$}
+      next_slash = expected_dir.index("/", next_slash + 1)
+    end
+    allowable_paths << %r{#{expected_dir}.rb$}
+    allowable_paths << %r{/#{expected_dir}/} if options[:allow_dir]
+    allowable_paths
+  end
+
+  def normalize_module_name(module_name)
+    return '' if module_name.nil?
+    normalized_name = module_name.gsub(/#<Class:|>/, "")
+    normalized_name = "" if normalized_name == "Object"
+    normalized_name
+  end
+
+  # module_name looks like one of these:
+  #   Foo::Bar for an instance method
+  #   #<Class:Foo::Bar> for a class method.
+  # For either case we return ["Foo", "Bar"]
+  def split_modules(module_name)
+    normalize_module_name(module_name).split("::")
+  end
+
+  def full_const_name(parent_module_name, const_name)
+    if parent_module_name == "".freeze
+      "#{const_name}"
+    else
+      "#{parent_module_name}::#{const_name}"
+    end
+  end
+end

data/lib/rubocop/airbnb/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Airbnb
+    # Version information for the the Airbnb RuboCop plugin.
+    VERSION = '1.0.0'.freeze
+  end
+end

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

@@ -0,0 +1,47 @@
+module RuboCop
+  module Cop
+    module Airbnb
+      # 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/airbnb/class_or_module_declared_in_wrong_file.rb

@@ -0,0 +1,138 @@
+require_relative '../../airbnb/inflections'
+require_relative '../../airbnb/rails_autoloading'
+
+module RuboCop
+  module Cop
+    module Airbnb
+      # 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/airbnb/const_assigned_in_wrong_file.rb

@@ -0,0 +1,74 @@
+require_relative '../../airbnb/inflections'
+require_relative '../../airbnb/rails_autoloading'
+
+module RuboCop
+  module Cop
+    module Airbnb
+      # 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/airbnb/continuation_slash.rb

@@ -0,0 +1,25 @@
+module RuboCop
+  module Cop
+    module Airbnb
+      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/airbnb/default_scope.rb

@@ -0,0 +1,20 @@
+module RuboCop
+  module Cop
+    module Airbnb
+      # 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/airbnb/factory_attr_references_class.rb

@@ -0,0 +1,74 @@
+module RuboCop
+  module Cop
+    module Airbnb
+      # 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