rubocop 0.75.1

data/lib/rubocop/cop/style/braces_around_hash_parameters.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for braces around the last parameter in a method call
+      # if the last parameter is a hash.
+      # It supports `braces`, `no_braces` and `context_dependent` styles.
+      #
+      # @example EnforcedStyle: braces
+      #   # The `braces` style enforces braces around all method
+      #   # parameters that are hashes.
+      #
+      #   # bad
+      #   some_method(x, y, a: 1, b: 2)
+      #
+      #   # good
+      #   some_method(x, y, {a: 1, b: 2})
+      #
+      # @example EnforcedStyle: no_braces (default)
+      #   # The `no_braces` style checks that the last parameter doesn't
+      #   # have braces around it.
+      #
+      #   # bad
+      #   some_method(x, y, {a: 1, b: 2})
+      #
+      #   # good
+      #   some_method(x, y, a: 1, b: 2)
+      #
+      # @example EnforcedStyle: context_dependent
+      #   # The `context_dependent` style checks that the last parameter
+      #   # doesn't have braces around it, but requires braces if the
+      #   # second to last parameter is also a hash literal.
+      #
+      #   # bad
+      #   some_method(x, y, {a: 1, b: 2})
+      #   some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
+      #
+      #   # good
+      #   some_method(x, y, a: 1, b: 2)
+      #   some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
+      class BracesAroundHashParameters < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = '%<type>s curly braces around a hash parameter.'
+
+        def on_send(node)
+          return if node.assignment_method? || node.operator_method?
+
+          return unless node.arguments? && node.last_argument.hash_type? &&
+                        !node.last_argument.empty?
+
+          check(node.last_argument, node.arguments)
+        end
+        alias on_csend on_send
+
+        def autocorrect(send_node)
+          hash_node = send_node.last_argument
+
+          lambda do |corrector|
+            if hash_node.braces?
+              remove_braces_with_whitespace(corrector,
+                                            hash_node,
+                                            extra_space(hash_node))
+            else
+              add_braces(corrector, hash_node)
+            end
+          end
+        end
+
+        private
+
+        def check(arg, args)
+          case style
+          when :braces
+            check_braces(arg)
+          when :no_braces
+            check_no_braces(arg)
+          when :context_dependent
+            check_context_dependent(arg, args)
+          end
+        end
+
+        def check_braces(arg)
+          add_arg_offense(arg, :missing) unless arg.braces?
+        end
+
+        def check_no_braces(arg)
+          return unless arg.braces? && !braces_needed_for_semantics?(arg)
+
+          add_arg_offense(arg, :redundant)
+        end
+
+        def check_context_dependent(arg, args)
+          braces_around_second_from_end = args.size > 1 && args[-2].hash_type?
+
+          if arg.braces?
+            unless braces_around_second_from_end ||
+                   braces_needed_for_semantics?(arg)
+              add_arg_offense(arg, :redundant)
+            end
+          elsif braces_around_second_from_end
+            add_arg_offense(arg, :missing)
+          end
+        end
+
+        # Returns true if there's block inside the braces of the given hash arg
+        # and that block uses do..end. The reason for wanting to check this is
+        # that the do..end could bind to a different method invocation if the
+        # hash braces were removed.
+        def braces_needed_for_semantics?(arg)
+          arg.each_pair do |_key, value|
+            return true if value.block_type? && !value.braces?
+          end
+          false
+        end
+
+        def add_arg_offense(arg, type)
+          add_offense(arg.parent, location: arg.source_range,
+                                  message: format(MSG,
+                                                  type: type.to_s.capitalize))
+        end
+
+        def extra_space(hash_node)
+          {
+            newlines: extra_left_space?(hash_node) &&
+              extra_right_space?(hash_node),
+            left: extra_left_space?(hash_node),
+            right: extra_right_space?(hash_node)
+          }
+        end
+
+        def extra_left_space?(hash_node)
+          @extra_left_space ||= begin
+            top_line = hash_node.source_range.source_line
+            top_line.delete(' ') == '{'
+          end
+        end
+
+        def extra_right_space?(hash_node)
+          @extra_right_space ||= begin
+            bottom_line_number = hash_node.source_range.last_line
+            bottom_line = processed_source.lines[bottom_line_number - 1]
+            bottom_line.delete(' ') == '}'
+          end
+        end
+
+        def remove_braces_with_whitespace(corrector, node, space)
+          if node.multiline?
+            remove_braces_with_range(corrector,
+                                     left_whole_line_range(node.loc.begin),
+                                     right_whole_line_range(node.loc.end))
+          else
+            right_brace_and_space = right_brace_and_space(node.loc.end, space)
+            left_brace_and_space = left_brace_and_space(node.loc.begin, space)
+            remove_braces_with_range(corrector,
+                                     left_brace_and_space,
+                                     right_brace_and_space)
+          end
+        end
+
+        def remove_braces_with_range(corrector, left_range, right_range)
+          corrector.remove(left_range)
+          corrector.remove(right_range)
+        end
+
+        def left_whole_line_range(loc_begin)
+          if range_by_whole_lines(loc_begin).source.strip == '{'
+            range_by_whole_lines(loc_begin, include_final_newline: true)
+          else
+            loc_begin
+          end
+        end
+
+        def right_whole_line_range(loc_end)
+          if range_by_whole_lines(loc_end).source.strip =~ /\A}\s*,?\z/
+            range_by_whole_lines(loc_end, include_final_newline: true)
+          else
+            loc_end
+          end
+        end
+
+        def left_brace_and_space(loc_begin, space)
+          range_with_surrounding_space(range: loc_begin,
+                                       side: :right,
+                                       newlines: space[:newlines],
+                                       whitespace: space[:left])
+        end
+
+        def right_brace_and_space(loc_end, space)
+          brace_and_space =
+            range_with_surrounding_space(
+              range: loc_end,
+              side: :left,
+              newlines: space[:newlines],
+              whitespace: space[:right]
+            )
+          range_with_surrounding_comma(brace_and_space, :left)
+        end
+
+        def add_braces(corrector, node)
+          corrector.insert_before(node.source_range, '{')
+          corrector.insert_after(node.source_range, '}')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/case_equality.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of the case equality operator(===).
+      #
+      # @example
+      #   # bad
+      #   Array === something
+      #   (1..100) === 7
+      #   /something/ === some_string
+      #
+      #   # good
+      #   something.is_a?(Array)
+      #   (1..100).include?(7)
+      #   some_string =~ /something/
+      #
+      class CaseEquality < Cop
+        MSG = 'Avoid the use of the case equality operator `===`.'
+
+        def_node_matcher :case_equality?, '(send _ :=== _)'
+
+        def on_send(node)
+          case_equality?(node) { add_offense(node, location: :selector) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/character_literal.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of the character literal ?x.
+      #
+      # @example
+      #   # bad
+      #   ?x
+      #
+      #   # good
+      #   'x'
+      #
+      #   # good
+      #   ?\C-\M-d
+      class CharacterLiteral < Cop
+        include StringHelp
+
+        MSG = 'Do not use the character literal - ' \
+              'use string literal instead.'
+
+        def offense?(node)
+          # we don't register an offense for things like ?\C-\M-d
+          node.loc.begin.is?('?') &&
+            node.source.size.between?(2, 3)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            string = node.source[1..-1]
+
+            # special character like \n
+            # or ' which needs to use "" or be escaped.
+            if string.length == 2 || string == "'"
+              corrector.replace(node.source_range, %("#{string}"))
+            elsif string.length == 1 # normal character
+              corrector.replace(node.source_range, "'#{string}'")
+            end
+          end
+        end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def opposite_style_detected; end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def correct_style_detected; end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the style of children definitions at classes and
+      # modules. Basically there are two different styles:
+      #
+      # @example EnforcedStyle: nested (default)
+      #   # good
+      #   # have each child on its own line
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: compact
+      #   # good
+      #   # combine definitions as much as possible
+      #   class Foo::Bar
+      #   end
+      #
+      # The compact style is only forced for classes/modules with one child.
+      class ClassAndModuleChildren < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        NESTED_MSG = 'Use nested module/class definitions instead of ' \
+                     'compact style.'
+        COMPACT_MSG = 'Use compact module/class definition instead of ' \
+                      'nested style.'
+
+        def on_class(node)
+          return if node.parent_class && style != :nested
+
+          check_style(node, node.body)
+        end
+
+        def on_module(node)
+          check_style(node, node.body)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            return if node.class_type? && node.parent_class && style != :nested
+
+            nest_or_compact(corrector, node)
+          end
+        end
+
+        private
+
+        def nest_or_compact(corrector, node)
+          if style == :nested
+            nest_definition(corrector, node)
+          else
+            compact_definition(corrector, node)
+          end
+        end
+
+        def nest_definition(corrector, node)
+          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
+
+          replace_keyword_with_module(corrector, node)
+          split_on_double_colon(corrector, node, padding)
+          add_trailing_end(corrector, node, padding_for_trailing_end)
+        end
+
+        def replace_keyword_with_module(corrector, node)
+          corrector.replace(node.loc.keyword, 'module')
+        end
+
+        def split_on_double_colon(corrector, node, padding)
+          children_definition = node.children.first
+          range = range_between(children_definition.loc.double_colon.begin_pos,
+                                children_definition.loc.double_colon.end_pos)
+          replacement = "\n#{padding}#{node.loc.keyword.source} "
+
+          corrector.replace(range, replacement)
+        end
+
+        def add_trailing_end(corrector, node, padding)
+          replacement = "#{padding}end\n#{leading_spaces(node)}end"
+          corrector.replace(node.loc.end, replacement)
+        end
+
+        def compact_definition(corrector, node)
+          compact_node(corrector, node)
+          remove_end(corrector, node.body)
+        end
+
+        def compact_node(corrector, node)
+          replacement = "#{node.body.type} #{compact_identifier_name(node)}"
+          range = range_between(node.loc.keyword.begin_pos,
+                                node.body.loc.name.end_pos)
+          corrector.replace(range, replacement)
+        end
+
+        def compact_identifier_name(node)
+          "#{node.identifier.const_name}::" \
+            "#{node.body.children.first.const_name}"
+        end
+
+        def remove_end(corrector, body)
+          range = range_between(
+            body.loc.end.begin_pos - leading_spaces(body).size,
+            body.loc.end.end_pos + 1
+          )
+          corrector.remove(range)
+        end
+
+        def leading_spaces(node)
+          node.source_range.source_line[/\A\s*/]
+        end
+
+        def indent_width
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+        end
+
+        def check_style(node, body)
+          if style == :nested
+            check_nested_style(node)
+          else
+            check_compact_style(node, body)
+          end
+        end
+
+        def check_nested_style(node)
+          return unless compact_node_name?(node)
+
+          add_offense(node, location: :name, message: NESTED_MSG)
+        end
+
+        def check_compact_style(node, body)
+          return unless one_child?(body) && !compact_node_name?(node)
+
+          add_offense(node, location: :name, message: COMPACT_MSG)
+        end
+
+        def one_child?(body)
+          body && %i[module class].include?(body.type)
+        end
+
+        def compact_node_name?(node)
+          node.loc.name.source =~ /::/
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/class_check.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
+      #
+      # @example EnforcedStyle: is_a? (default)
+      #   # bad
+      #   var.kind_of?(Date)
+      #   var.kind_of?(Integer)
+      #
+      #   # good
+      #   var.is_a?(Date)
+      #   var.is_a?(Integer)
+      #
+      # @example EnforcedStyle: kind_of?
+      #   # bad
+      #   var.is_a?(Time)
+      #   var.is_a?(String)
+      #
+      #   # good
+      #   var.kind_of?(Time)
+      #   var.kind_of?(String)
+      #
+      class ClassCheck < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'
+
+        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
+
+        def on_send(node)
+          class_check?(node) do |method_name|
+            return if style == method_name
+
+            add_offense(node, location: :selector)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
+
+            corrector.replace(node.loc.selector, replacement)
+          end
+        end
+
+        def message(node)
+          if node.method?(:is_a?)
+            format(MSG, prefer: 'kind_of?', current: 'is_a?')
+          else
+            format(MSG, prefer: 'is_a?', current: 'kind_of?')
+          end
+        end
+      end
+    end
+  end
+end