rubbycop 0.49.0

data/lib/rubbycop/cop/style/trailing_underscore_variable.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for extra underscores in variable assignment.
+      #
+      # @example
+      #   # bad
+      #   a, b, _ = foo()
+      #   a, b, _, = foo()
+      #   a, _, _ = foo()
+      #   a, _, _, = foo()
+      #
+      #   # good
+      #   a, b, = foo()
+      #   a, = foo()
+      #   *a, b, _ = foo()  => We need to know to not include 2 variables in a
+      #   a, *b, _ = foo()  => The correction `a, *b, = foo()` is a syntax error
+      #
+      #   # good if AllowNamedUnderscoreVariables is true
+      #   a, b, _something = foo()
+      class TrailingUnderscoreVariable < Cop
+        include SurroundingSpace
+
+        MSG = 'Do not use trailing `_`s in parallel assignment. ' \
+              'Prefer `%s`.'.freeze
+        UNDERSCORE = '_'.freeze
+
+        def on_masgn(node)
+          range = unneeded_range(node)
+
+          return unless range
+
+          good_code = node.source
+          offset = range.begin_pos - node.source_range.begin_pos
+          good_code[offset, range.size] = ''
+
+          add_offense(node, range, format(MSG, good_code))
+        end
+
+        def autocorrect(node)
+          range = unneeded_range(node)
+
+          lambda do |corrector|
+            corrector.remove(range) if range
+          end
+        end
+
+        private
+
+        def find_first_offense(variables)
+          first_offense = find_first_possible_offense(variables.reverse)
+
+          return unless first_offense
+          return if splat_variable_before?(first_offense, variables)
+
+          first_offense
+        end
+
+        def find_first_possible_offense(variables)
+          variables.reduce(nil) do |offense, variable|
+            var, = *variable
+            var, = *var
+            if allow_named_underscore_variables
+              break offense unless var == :_
+            else
+              break offense unless var.to_s.start_with?(UNDERSCORE)
+            end
+
+            variable
+          end
+        end
+
+        def splat_variable_before?(first_offense, variables)
+          # Account for cases like `_, *rest, _`, where we would otherwise get
+          # the index of the first underscore.
+          first_offense_index = reverse_index(variables, first_offense)
+
+          variables[0...first_offense_index].any?(&:splat_type?)
+        end
+
+        def reverse_index(collection, item)
+          collection.size - 1 - collection.reverse.index(item)
+        end
+
+        def allow_named_underscore_variables
+          @allow_named_underscore_variables ||=
+            cop_config['AllowNamedUnderscoreVariables']
+        end
+
+        def unneeded_range(node)
+          left, right = *node
+          variables = *left
+          first_offense = find_first_offense(variables)
+
+          return unless first_offense
+
+          end_position =
+            if first_offense.source_range == variables.first.source_range
+              right.source_range.begin_pos
+            else
+              node.loc.operator.begin_pos
+            end
+
+          range = range_between(first_offense.source_range.begin_pos,
+                                end_position)
+          range_with_surrounding_space(range, :right)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/trivial_accessors.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop looks for trivial reader/writer methods, that could
+      # have been created with the attr_* family of functions automatically.
+      class TrivialAccessors < Cop
+        MSG = 'Use `attr_%s` to define trivial %s methods.'.freeze
+
+        def on_def(node)
+          return if in_module_or_instance_eval?(node)
+          method_name, args, body = *node
+          on_method_def(node, method_name, args, body)
+        end
+
+        def on_defs(node)
+          return if in_module_or_instance_eval?(node)
+          return if ignore_class_methods?
+          _scope, method_name, args, body = *node
+          on_method_def(node, method_name, args, body)
+        end
+
+        private
+
+        def in_module_or_instance_eval?(node)
+          node.each_ancestor(:block, :class, :sclass, :module).each do |pnode|
+            case pnode.type
+            when :class, :sclass
+              return false
+            when :module
+              return true
+            else
+              return true if pnode.method_name == :instance_eval
+            end
+          end
+          false
+        end
+
+        def on_method_def(node, method_name, args, body)
+          kind = if trivial_reader?(method_name, args, body)
+                   'reader'
+                 elsif trivial_writer?(method_name, args, body)
+                   'writer'
+                 end
+          return unless kind
+
+          add_offense(node, :keyword, format(MSG, kind, kind))
+        end
+
+        def exact_name_match?
+          cop_config['ExactNameMatch']
+        end
+
+        def allow_predicates?
+          cop_config['AllowPredicates']
+        end
+
+        def allow_dsl_writers?
+          cop_config['AllowDSLWriters']
+        end
+
+        def ignore_class_methods?
+          cop_config['IgnoreClassMethods']
+        end
+
+        def whitelist
+          whitelist = cop_config['Whitelist']
+          Array(whitelist).map(&:to_sym) + [:initialize]
+        end
+
+        def predicate?(method_name)
+          method_name[-1] == '?'
+        end
+
+        def dsl_writer?(method_name)
+          !method_name.to_s.end_with?('=')
+        end
+
+        def trivial_reader?(method_name, args, body)
+          looks_like_trivial_reader?(args, body) &&
+            !allowed_method?(method_name, body) &&
+            !allowed_reader?(method_name)
+        end
+
+        def looks_like_trivial_reader?(args, body)
+          args.children.empty? && body && body.ivar_type?
+        end
+
+        def trivial_writer?(method_name, args, body)
+          looks_like_trivial_writer?(args, body) &&
+            !allowed_method?(method_name, body) &&
+            !allowed_writer?(method_name)
+        end
+
+        def looks_like_trivial_writer?(args, body)
+          args.children.one? &&
+            !%i[restarg blockarg].include?(args.children[0].type) &&
+            body && body.ivasgn_type? &&
+            body.children[1] && body.children[1].lvar_type?
+        end
+
+        def allowed_method?(method_name, body)
+          whitelist.include?(method_name) ||
+            exact_name_match? && !names_match?(method_name, body)
+        end
+
+        def allowed_writer?(method_name)
+          allow_dsl_writers? && dsl_writer?(method_name)
+        end
+
+        def allowed_reader?(method_name)
+          allow_predicates? && predicate?(method_name)
+        end
+
+        def names_match?(method_name, body)
+          ivar_name, = *body
+
+          method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
+        end
+
+        def trivial_accessor_kind(method_name, args, body)
+          if trivial_writer?(method_name, args, body) &&
+             !dsl_writer?(method_name)
+            'writer'
+          elsif trivial_reader?(method_name, args, body)
+            'reader'
+          end
+        end
+
+        def accessor(kind, method_name)
+          "attr_#{kind} :#{method_name.to_s.chomp('=')}"
+        end
+
+        def autocorrect(node)
+          if node.def_type?
+            autocorrect_instance(node)
+          elsif node.defs_type? && node.children.first.self_type?
+            autocorrect_class(node)
+          end
+        end
+
+        def autocorrect_instance(node)
+          method_name, args, body = *node
+          unless names_match?(method_name, body) &&
+                 !predicate?(method_name) &&
+                 (kind = trivial_accessor_kind(method_name, args, body))
+            return
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, accessor(kind, method_name))
+          end
+        end
+
+        def autocorrect_class(node)
+          _, method_name, args, body = *node
+          unless names_match?(method_name, body) &&
+                 (kind = trivial_accessor_kind(method_name, args, body))
+            return
+          end
+
+          lambda do |corrector|
+            indent = ' ' * node.loc.column
+            corrector.replace(
+              node.source_range,
+              ['class << self',
+               "#{indent}  #{accessor(kind, method_name)}",
+               "#{indent}end"].join("\n")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/unless_else.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop looks for *unless* expressions with *else* clauses.
+      class UnlessElse < Cop
+        MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
+              'positive case first.'.freeze
+
+        def on_if(node)
+          return unless node.unless? && node.else?
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          condition, = *node
+          body_range = range_between_condition_and_else(node, condition)
+          else_range = range_between_else_and_end(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, 'if'.freeze)
+            corrector.replace(body_range, else_range.source)
+            corrector.replace(else_range, body_range.source)
+          end
+        end
+
+        def range_between_condition_and_else(node, condition)
+          range_between(condition.source_range.end_pos, node.loc.else.begin_pos)
+        end
+
+        def range_between_else_and_end(node)
+          range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/unneeded_capital_w.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for usage of the %W() syntax when %w() would do.
+      class UnneededCapitalW < Cop
+        include PercentLiteral
+
+        MSG = 'Do not use `%W` unless interpolation is needed. ' \
+              'If not, use `%w`.'.freeze
+
+        def on_array(node)
+          process(node, '%W')
+        end
+
+        private
+
+        def on_percent_literal(node)
+          return if requires_interpolation?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def requires_interpolation?(node)
+          node.child_nodes.any? do |string|
+            string.dstr_type? ||
+              double_quotes_required?(string.source)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/unneeded_interpolation.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for strings that are just an interpolated expression.
+      #
+      # @example
+      #
+      #   # bad
+      #   "#{@var}"
+      #
+      #   # good
+      #   @var.to_s
+      #
+      #   # good if @var is already a String
+      #   @var
+      class UnneededInterpolation < Cop
+        include PercentLiteral
+
+        MSG = 'Prefer `to_s` over string interpolation.'.freeze
+
+        def on_dstr(node)
+          add_offense(node, :expression, MSG) if single_interpolation?(node)
+        end
+
+        private
+
+        def single_interpolation?(node)
+          single_child?(node) &&
+            interpolation?(node.children.first) &&
+            !implicit_concatenation?(node) &&
+            !embedded_in_percent_array?(node)
+        end
+
+        def single_variable_interpolation?(node)
+          single_child?(node) && variable_interpolation?(node.children.first)
+        end
+
+        def single_child?(node)
+          node.children.one?
+        end
+
+        def interpolation?(node)
+          variable_interpolation?(node) || node.begin_type?
+        end
+
+        def variable_interpolation?(node)
+          node.variable? || node.reference?
+        end
+
+        def implicit_concatenation?(node)
+          node.parent && node.parent.dstr_type?
+        end
+
+        def embedded_in_percent_array?(node)
+          node.parent && node.parent.array_type? &&
+            percent_literal?(node.parent)
+        end
+
+        def autocorrect(node)
+          embedded_node = node.children.first
+
+          if variable_interpolation?(embedded_node)
+            autocorrect_variable_interpolation(embedded_node, node)
+          elsif single_variable_interpolation?(embedded_node)
+            autocorrect_single_variable_interpolation(embedded_node, node)
+          else
+            autocorrect_other(embedded_node, node)
+          end
+        end
+
+        def autocorrect_variable_interpolation(embedded_node, node)
+          replacement = "#{embedded_node.loc.expression.source}.to_s"
+          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+        end
+
+        def autocorrect_single_variable_interpolation(embedded_node, node)
+          variable_loc = embedded_node.children.first.loc
+          replacement = "#{variable_loc.expression.source}.to_s"
+          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+        end
+
+        def autocorrect_other(embedded_node, node)
+          loc = node.loc
+          embedded_loc = embedded_node.loc
+
+          lambda do |corrector|
+            corrector.replace(loc.begin, '')
+            corrector.replace(loc.end, '')
+            corrector.replace(embedded_loc.begin, '(')
+            corrector.replace(embedded_loc.end, ').to_s')
+          end
+        end
+      end
+    end
+  end
+end