rbhint 0.8.5.rc1

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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
+      #
+      # @example AllowNamedUnderscoreVariables: true (default)
+      #   # good
+      #   a, b, _something = foo()
+      #
+      # @example AllowNamedUnderscoreVariables: false
+      #   # bad
+      #   a, b, _something = foo()
+      #
+      class TrailingUnderscoreVariable < Cop
+        include SurroundingSpace
+        include RangeHelp
+
+        MSG = 'Do not use trailing `_`s in parallel assignment. ' \
+              'Prefer `%<code>s`.'
+        UNDERSCORE = '_'
+
+        def on_masgn(node)
+          ranges = unneeded_ranges(node)
+
+          ranges.each do |range|
+            good_code = node.source
+            offset = range.begin_pos - node.source_range.begin_pos
+            good_code[offset, range.size] = ''
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, code: good_code))
+          end
+        end
+
+        def autocorrect(node)
+          ranges = unneeded_ranges(node)
+
+          lambda do |corrector|
+            ranges.each { |range| 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|
+            break offense unless %i[lvasgn splat].include?(variable.type)
+
+            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_ranges(node)
+          node.masgn_type? ? (mlhs_node, = *node) : mlhs_node = node
+          variables = *mlhs_node
+
+          main_offense = main_node_offense(node)
+          if main_offense.nil?
+            children_offenses(variables)
+          else
+            children_offenses(variables) << main_offense
+          end
+        end
+
+        def main_node_offense(node)
+          node.masgn_type? ? (mlhs_node, right = *node) : mlhs_node = node
+
+          variables = *mlhs_node
+          first_offense = find_first_offense(variables)
+
+          return unless first_offense
+
+          if unused_variables_only?(first_offense, variables)
+            return unused_range(node.type, mlhs_node, right)
+          end
+
+          return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
+
+          range_between(first_offense.source_range.begin_pos,
+                        node.loc.operator.begin_pos)
+        end
+
+        def children_offenses(variables)
+          variables.select(&:mlhs_type?).flat_map { |v| unneeded_ranges(v) }
+        end
+
+        def unused_variables_only?(offense, variables)
+          offense.source_range == variables.first.source_range
+        end
+
+        def unused_range(node_type, mlhs_node, right)
+          start_range = mlhs_node.source_range.begin_pos
+
+          end_range = case node_type
+                      when :masgn
+                        right.source_range.begin_pos
+                      when :mlhs
+                        mlhs_node.source_range.end_pos
+                      end
+
+          range_between(start_range, end_range)
+        end
+
+        def range_for_parentheses(offense, left)
+          range_between(
+            offense.source_range.begin_pos - 1,
+            left.loc.expression.end_pos - 1
+          )
+        end
+      end
+    end
+  end
+end

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?(: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 allowed_methods
+          allowed_methods = cop_config['AllowedMethods']
+          Array(allowed_methods).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)
+          allowed_methods.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,
+                              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/unpack_first.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for accessing the first element of `String#unpack`
+      # which can be replaced with the shorter method `unpack1`.
+      #
+      # @example
+      #
+      #   # bad
+      #   'foo'.unpack('h*').first
+      #   'foo'.unpack('h*')[0]
+      #   'foo'.unpack('h*').slice(0)
+      #   'foo'.unpack('h*').at(0)
+      #
+      #   # good
+      #   'foo'.unpack1('h*')
+      #
+      class UnpackFirst < Cop
+        MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
+          '`%<receiver>s.unpack(%<format>s)%<method>s`.'
+
+        def_node_matcher :unpack_and_first_element?, <<~PATTERN
+          {
+            (send $(send (...) :unpack $(...)) :first)
+            (send $(send (...) :unpack $(...)) {:[] :slice :at} (int 0))
+          }
+        PATTERN
+
+        def on_send(node)
+          unpack_and_first_element?(node) do |unpack_call, unpack_arg|
+            range = first_element_range(node, unpack_call)
+            message = format(MSG,
+                             receiver: unpack_call.receiver.source,
+                             format: unpack_arg.source,
+                             method: range.source)
+            add_offense(node, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          unpack_and_first_element?(node) do |unpack_call, _unpack_arg|
+            lambda do |corrector|
+              corrector.remove(first_element_range(node, unpack_call))
+              corrector.replace(unpack_call.loc.selector, 'unpack1')
+            end
+          end
+        end
+
+        private
+
+        def first_element_range(node, unpack_call)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    unpack_call.loc.expression.end_pos,
+                                    node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end