rubocop 0.75.1

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Access modifiers should be declared to apply to a group of methods
+      # or inline before each method, depending on configuration.
+      #
+      # @example EnforcedStyle: group (default)
+      #
+      #   # bad
+      #
+      #   class Foo
+      #
+      #     private def bar; end
+      #     private def baz; end
+      #
+      #   end
+      #
+      #   # good
+      #
+      #   class Foo
+      #
+      #     private
+      #
+      #     def bar; end
+      #     def baz; end
+      #
+      #   end
+      # @example EnforcedStyle: inline
+      #
+      #   # bad
+      #
+      #   class Foo
+      #
+      #     private
+      #
+      #     def bar; end
+      #     def baz; end
+      #
+      #   end
+      #
+      #   # good
+      #
+      #   class Foo
+      #
+      #     private def bar; end
+      #     private def baz; end
+      #
+      #   end
+      class AccessModifierDeclarations < Cop
+        include ConfigurableEnforcedStyle
+
+        GROUP_STYLE_MESSAGE = [
+          '`%<access_modifier>s` should not be',
+          'inlined in method definitions.'
+        ].join(' ')
+
+        INLINE_STYLE_MESSAGE = [
+          '`%<access_modifier>s` should be',
+          'inlined in method definitions.'
+        ].join(' ')
+
+        def on_send(node)
+          return unless node.access_modifier?
+          return if node.parent.pair_type?
+
+          if offense?(node)
+            add_offense(node, location: :selector) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def offense?(node)
+          (group_style? && access_modifier_is_inlined?(node)) ||
+            (inline_style? && access_modifier_is_not_inlined?(node))
+        end
+
+        def group_style?
+          style == :group
+        end
+
+        def inline_style?
+          style == :inline
+        end
+
+        def access_modifier_is_inlined?(node)
+          node.arguments.any?
+        end
+
+        def access_modifier_is_not_inlined?(node)
+          !access_modifier_is_inlined?(node)
+        end
+
+        def message(node)
+          access_modifier = node.loc.selector.source
+
+          if group_style?
+            format(GROUP_STYLE_MESSAGE, access_modifier: access_modifier)
+          elsif inline_style?
+            format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of either `#alias` or `#alias_method`
+      # depending on configuration.
+      # It also flags uses of `alias :symbol` rather than `alias bareword`.
+      #
+      # @example EnforcedStyle: prefer_alias (default)
+      #   # bad
+      #   alias_method :bar, :foo
+      #   alias :bar :foo
+      #
+      #   # good
+      #   alias bar foo
+      #
+      # @example EnforcedStyle: prefer_alias_method
+      #   # bad
+      #   alias :bar :foo
+      #   alias bar foo
+      #
+      #   # good
+      #   alias_method :bar, :foo
+      class Alias < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` ' \
+                           '%<current>s.'
+        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of ' \
+                           '`alias %<current>s`.'
+
+        def on_send(node)
+          return unless node.command?(:alias_method)
+          return unless style == :prefer_alias && alias_keyword_possible?(node)
+
+          msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
+          add_offense(node, location: :selector, message: msg)
+        end
+
+        def on_alias(node)
+          return unless alias_method_possible?(node)
+
+          if scope_type(node) == :dynamic || style == :prefer_alias_method
+            add_offense(node, location: :keyword, message: MSG_ALIAS)
+          elsif node.children.none? { |arg| bareword?(arg) }
+            add_offense_for_args(node)
+          end
+        end
+
+        def autocorrect(node)
+          if node.send_type?
+            correct_alias_method_to_alias(node)
+          elsif scope_type(node) == :dynamic || style == :prefer_alias_method
+            correct_alias_to_alias_method(node)
+          else
+            correct_alias_with_symbol_args(node)
+          end
+        end
+
+        private
+
+        def alias_keyword_possible?(node)
+          scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
+        end
+
+        def alias_method_possible?(node)
+          scope_type(node) != :instance_eval &&
+            node.children.none?(&:gvar_type?)
+        end
+
+        def add_offense_for_args(node)
+          existing_args  = node.children.map(&:source).join(' ')
+          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
+          arg_ranges     = node.children.map(&:source_range)
+          msg            = format(MSG_SYMBOL_ARGS,
+                                  prefer: preferred_args,
+                                  current: existing_args)
+          add_offense(node, location: arg_ranges.reduce(&:join), message: msg)
+        end
+
+        # In this expression, will `self` be the same as the innermost enclosing
+        # class or module block (:lexical)? Or will it be something else
+        # (:dynamic)? If we're in an instance_eval block, return that.
+        def scope_type(node)
+          while (parent = node.parent)
+            case parent.type
+            when :class, :module
+              return :lexical
+            when :def, :defs
+              return :dynamic
+            when :block
+              return :instance_eval if parent.method_name == :instance_eval
+
+              return :dynamic
+            end
+            node = parent
+          end
+          :lexical
+        end
+
+        def lexical_scope_type(node)
+          node.each_ancestor(:class, :module) do |ancestor|
+            return ancestor.class_type? ? 'in a class body' : 'in a module body'
+          end
+          'at the top level'
+        end
+
+        def bareword?(sym_node)
+          !sym_node.source.start_with?(':')
+        end
+
+        def correct_alias_method_to_alias(send_node)
+          lambda do |corrector|
+            new, old = *send_node.arguments
+            replacement = "alias #{identifier(new)} #{identifier(old)}"
+            corrector.replace(send_node.source_range, replacement)
+          end
+        end
+
+        def correct_alias_to_alias_method(node)
+          lambda do |corrector|
+            replacement =
+              'alias_method ' \
+              ":#{identifier(node.new_identifier)}, " \
+              ":#{identifier(node.old_identifier)}"
+            corrector.replace(node.source_range, replacement)
+          end
+        end
+
+        def correct_alias_with_symbol_args(node)
+          lambda do |corrector|
+            corrector.replace(node.new_identifier.source_range,
+                              node.new_identifier.source[1..-1])
+            corrector.replace(node.old_identifier.source_range,
+                              node.old_identifier.source[1..-1])
+          end
+        end
+
+        def_node_matcher :identifier, <<~PATTERN
+          (sym $_)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of `and` and `or`, and suggests using `&&` and
+      # `||` instead. It can be configured to check only in conditions or in
+      # all contexts.
+      #
+      # @example EnforcedStyle: always (default)
+      #   # bad
+      #   foo.save and return
+      #
+      #   # bad
+      #   if foo and bar
+      #   end
+      #
+      #   # good
+      #   foo.save && return
+      #
+      #   # good
+      #   if foo && bar
+      #   end
+      #
+      # @example EnforcedStyle: conditionals
+      #   # bad
+      #   if foo and bar
+      #   end
+      #
+      #   # good
+      #   foo.save && return
+      #
+      #   # good
+      #   foo.save and return
+      #
+      #   # good
+      #   if foo && bar
+      #   end
+      class AndOr < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        def on_and(node)
+          process_logical_operator(node) if style == :always
+        end
+        alias on_or on_and
+
+        def on_if(node)
+          on_conditionals(node) if style == :conditionals
+        end
+        alias on_while      on_if
+        alias on_while_post on_if
+        alias on_until      on_if
+        alias on_until_post on_if
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.each_child_node do |expr|
+              if expr.send_type?
+                correct_send(expr, corrector)
+              elsif expr.return_type?
+                correct_other(expr, corrector)
+              elsif expr.assignment?
+                correct_other(expr, corrector)
+              end
+            end
+
+            corrector.replace(node.loc.operator, node.alternate_operator)
+          end
+        end
+
+        private
+
+        def on_conditionals(node)
+          node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
+            process_logical_operator(operator)
+          end
+        end
+
+        def process_logical_operator(node)
+          return if node.logical_operator?
+
+          add_offense(node, location: :operator)
+        end
+
+        def message(node)
+          format(MSG, prefer: node.alternate_operator, current: node.operator)
+        end
+
+        def correct_send(node, corrector)
+          return correct_not(node, node.receiver, corrector) if node.method?(:!)
+          return correct_setter(node, corrector) if node.setter_method?
+          return correct_other(node, corrector) if node.comparison_method?
+
+          return unless correctable_send?(node)
+
+          corrector.replace(whitespace_before_arg(node), '(')
+          corrector.insert_after(node.last_argument.source_range, ')')
+        end
+
+        def correct_setter(node, corrector)
+          corrector.insert_before(node.receiver.source_range, '(')
+          corrector.insert_after(node.last_argument.source_range, ')')
+        end
+
+        # ! is a special case:
+        # 'x and !obj.method arg' can be auto-corrected if we
+        # recurse down a level and add parens to 'obj.method arg'
+        # however, 'not x' also parses as (send x :!)
+        def correct_not(node, receiver, corrector)
+          if node.prefix_bang?
+            return unless receiver.send_type?
+
+            correct_send(receiver, corrector)
+          elsif node.prefix_not?
+            correct_other(node, corrector)
+          else
+            raise 'unrecognized unary negation operator'
+          end
+        end
+
+        def correct_other(node, corrector)
+          return if node.source_range.begin.is?('(')
+
+          corrector.insert_before(node.source_range, '(')
+          corrector.insert_after(node.source_range, ')')
+        end
+
+        def correctable_send?(node)
+          !node.parenthesized? && node.arguments? && !node.method?(:[])
+        end
+
+        def whitespace_before_arg(node)
+          begin_paren = node.loc.selector.end_pos
+          end_paren = begin_paren
+          # Increment position of parenthesis, unless message is a predicate
+          # method followed by a non-whitespace char (e.g. is_a?String).
+          end_paren += 1 unless node.source =~ /\?\S/
+          range_between(begin_paren, end_paren)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of "*" as a substitute for *join*.
+      #
+      # Not all cases can reliably checked, due to Ruby's dynamic
+      # types, so we consider only cases when the first argument is an
+      # array literal or the second is a string literal.
+      #
+      # @example
+      #
+      #   # bad
+      #   %w(foo bar baz) * ","
+      #
+      #   # good
+      #   %w(foo bar baz).join(",")
+      #
+      class ArrayJoin < Cop
+        MSG = 'Favor `Array#join` over `Array#*`.'
+
+        def_node_matcher :join_candidate?, '(send $array :* $str)'
+
+        def on_send(node)
+          join_candidate?(node) { add_offense(node, location: :selector) }
+        end
+
+        def autocorrect(node)
+          array, join_arg = join_candidate?(node).map(&:source)
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "#{array}.join(#{join_arg})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/AsciiComments
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for non-ascii (non-English) characters
+      # in comments. You could set an array of allowed non-ascii chars in
+      # AllowedChars attribute (empty by default).
+      #
+      # @example
+      #   # bad
+      #   # Translates from English to 日本語。
+      #
+      #   # good
+      #   # Translates from English to Japanese
+      class AsciiComments < Cop
+        include RangeHelp
+
+        MSG = 'Use only ascii symbols in comments.'
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next if comment.text.ascii_only?
+            next if only_allowed_non_ascii_chars?(comment.text)
+
+            add_offense(comment, location: first_offense_range(comment))
+          end
+        end
+
+        private
+
+        def first_offense_range(comment)
+          expression    = comment.loc.expression
+          first_offense = first_non_ascii_chars(comment.text)
+
+          start_position = expression.begin_pos +
+                           comment.text.index(first_offense)
+          end_position   = start_position + first_offense.length
+
+          range_between(start_position, end_position)
+        end
+
+        def first_non_ascii_chars(string)
+          string.match(/[^[:ascii:]]+/).to_s
+        end
+
+        def only_allowed_non_ascii_chars?(string)
+          non_ascii = string.scan(/[^[:ascii:]]/)
+          (non_ascii - allowed_non_ascii_chars).empty?
+        end
+
+        def allowed_non_ascii_chars
+          cop_config['AllowedChars'] || []
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Style/AsciiComments