rubocop 0.75.1

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for trivial reader/writer methods, that could
+      # have been created with the attr_* family of functions automatically.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     @foo
+      #   end
+      #
+      #   def bar=(val)
+      #     @bar = val
+      #   end
+      #
+      #   def self.baz
+      #     @baz
+      #   end
+      #
+      #   # good
+      #   attr_reader :foo
+      #   attr_writer :bar
+      #
+      #   class << self
+      #     attr_reader :baz
+      #   end
+      class TrivialAccessors < Cop
+        MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'
+
+        def on_def(node)
+          return if top_level_node?(node)
+          return if in_module_or_instance_eval?(node)
+          return if ignore_class_methods? && node.defs_type?
+
+          on_method_def(node)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          parent = node.parent
+          return if parent&.send_type?
+
+          if node.def_type?
+            autocorrect_instance(node)
+          elsif node.defs_type? && node.children.first.self_type?
+            autocorrect_class(node)
+          end
+        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)
+          kind = if trivial_reader?(node)
+                   'reader'
+                 elsif trivial_writer?(node)
+                   'writer'
+                 end
+          return unless kind
+
+          add_offense(node,
+                      location: :keyword,
+                      message: 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 dsl_writer?(method_name)
+          !method_name.to_s.end_with?('=')
+        end
+
+        def trivial_reader?(node)
+          looks_like_trivial_reader?(node) &&
+            !allowed_method?(node) && !allowed_reader?(node)
+        end
+
+        def looks_like_trivial_reader?(node)
+          !node.arguments? && node.body && node.body.ivar_type?
+        end
+
+        def trivial_writer?(node)
+          looks_like_trivial_writer?(node) &&
+            !allowed_method?(node) && !allowed_writer?(node.method_name)
+        end
+
+        def_node_matcher :looks_like_trivial_writer?, <<~PATTERN
+          {(def    _ (args (arg ...)) (ivasgn _ (lvar _)))
+           (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
+        PATTERN
+
+        def allowed_method?(node)
+          whitelist.include?(node.method_name) ||
+            exact_name_match? && !names_match?(node)
+        end
+
+        def allowed_writer?(method_name)
+          allow_dsl_writers? && dsl_writer?(method_name)
+        end
+
+        def allowed_reader?(node)
+          allow_predicates? && node.predicate_method?
+        end
+
+        def names_match?(node)
+          ivar_name, = *node.body
+
+          node.method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
+        end
+
+        def trivial_accessor_kind(node)
+          if trivial_writer?(node) &&
+             !dsl_writer?(node.method_name)
+            'writer'
+          elsif trivial_reader?(node)
+            'reader'
+          end
+        end
+
+        def accessor(kind, method_name)
+          "attr_#{kind} :#{method_name.to_s.chomp('=')}"
+        end
+
+        def autocorrect_instance(node)
+          kind = trivial_accessor_kind(node)
+
+          return unless names_match?(node) && !node.predicate_method? && kind
+
+          lambda do |corrector|
+            corrector.replace(node.source_range,
+                              accessor(kind, node.method_name))
+          end
+        end
+
+        def autocorrect_class(node)
+          kind = trivial_accessor_kind(node)
+
+          return unless names_match?(node) && kind
+
+          lambda do |corrector|
+            indent = ' ' * node.loc.column
+            corrector.replace(
+              node.source_range,
+              ['class << self',
+               "#{indent}  #{accessor(kind, node.method_name)}",
+               "#{indent}end"].join("\n")
+            )
+          end
+        end
+
+        def top_level_node?(node)
+          node.parent.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for *unless* expressions with *else* clauses.
+      #
+      # @example
+      #   # bad
+      #   unless foo_bar.nil?
+      #     # do something...
+      #   else
+      #     # do a different thing...
+      #   end
+      #
+      #   # good
+      #   if foo_bar.present?
+      #     # do something...
+      #   else
+      #     # do a different thing...
+      #   end
+      class UnlessElse < Cop
+        include RangeHelp
+
+        MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
+              'positive case first.'
+
+        def on_if(node)
+          return unless node.unless? && node.else?
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          body_range = range_between_condition_and_else(node, node.condition)
+          else_range = range_between_else_and_end(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, 'if')
+            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/rubocop/cop/style/unneeded_capital_w.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usage of the %W() syntax when %w() would do.
+      #
+      # @example
+      #   # bad
+      #   %W(cat dog pig)
+      #   %W[door wall floor]
+      #
+      #   # good
+      #   %w/swim run bike/
+      #   %w[shirt pants shoes]
+      #   %W(apple #{fruit} grape)
+      class UnneededCapitalW < Cop
+        include PercentLiteral
+
+        MSG = 'Do not use `%W` unless interpolation is needed. ' \
+              'If not, use `%w`.'
+
+        def on_array(node)
+          process(node, '%W')
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+          end
+        end
+
+        private
+
+        def on_percent_literal(node)
+          return if requires_interpolation?(node)
+
+          add_offense(node)
+        end
+
+        def requires_interpolation?(node)
+          node.child_nodes.any? do |string|
+            string.dstr_type? ||
+              double_quotes_required?(string.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unnecessary conditional expressions.
+      #
+      # @example
+      #   # bad
+      #   a = b ? b : c
+      #
+      #   # good
+      #   a = b || c
+      #
+      # @example
+      #   # bad
+      #   if b
+      #     b
+      #   else
+      #     c
+      #   end
+      #
+      #   # good
+      #   b || c
+      #
+      #   # good
+      #   if b
+      #     b
+      #   elsif cond
+      #     c
+      #   end
+      #
+      class UnneededCondition < Cop
+        include RangeHelp
+
+        MSG = 'Use double pipes `||` instead.'
+        UNNEEDED_CONDITION = 'This condition is not needed.'
+
+        def on_if(node)
+          return if node.elsif_conditional?
+          return unless offense?(node)
+
+          add_offense(node, location: range_of_offense(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.ternary?
+              corrector.replace(range_of_offense(node), '||')
+            elsif node.modifier_form? || !node.else_branch
+              corrector.replace(node.source_range, node.if_branch.source)
+            else
+              corrected = make_ternary_form(node)
+
+              corrector.replace(node.source_range, corrected)
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.modifier_form? || !node.else_branch
+            UNNEEDED_CONDITION
+          else
+            MSG
+          end
+        end
+
+        def range_of_offense(node)
+          return :expression unless node.ternary?
+
+          range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
+        end
+
+        def offense?(node)
+          condition, if_branch, else_branch = *node
+
+          return false if use_if_branch?(else_branch)
+
+          condition == if_branch && !node.elsif? && (
+            node.ternary? ||
+            !else_branch.instance_of?(AST::Node) ||
+            else_branch.single_line?
+          )
+        end
+
+        def use_if_branch?(else_branch)
+          else_branch&.if_type?
+        end
+
+        def else_source(else_branch)
+          wrap_else =
+            else_branch.basic_conditional? && else_branch.modifier_form?
+          wrap_else ? "(#{else_branch.source})" : else_branch.source
+        end
+
+        def make_ternary_form(node)
+          _condition, if_branch, else_branch = *node
+          ternary_form = [if_branch.source,
+                          else_source(else_branch)].join(' || ')
+
+          if node.parent&.send_type?
+            "(#{ternary_form})"
+          else
+            ternary_form
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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.'
+
+        def self.autocorrect_incompatible_with
+          [Style::LineEndConcatenation]
+        end
+
+        def on_dstr(node)
+          add_offense(node) if single_interpolation?(node)
+        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
+
+        private
+
+        def single_interpolation?(node)
+          node.children.one? &&
+            interpolation?(node.children.first) &&
+            !implicit_concatenation?(node) &&
+            !embedded_in_percent_array?(node)
+        end
+
+        def single_variable_interpolation?(node)
+          node.children.one? && variable_interpolation?(node.children.first)
+        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&.dstr_type?
+        end
+
+        def embedded_in_percent_array?(node)
+          node.parent&.array_type? &&
+            percent_literal?(node.parent)
+        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