rbhint 0.8.5.rc1

data/lib/rubocop/cop/mixin/target_ruby_version.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking target ruby version.
+    module TargetRubyVersion
+      def required_minimum_ruby_version
+        @minimum_target_ruby_version
+      end
+
+      def minimum_target_ruby_version(version)
+        @minimum_target_ruby_version = version
+      end
+
+      def support_target_ruby_version?(version)
+        required_minimum_ruby_version <= version
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/too_many_lines.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for too many lines.
+    module TooManyLines
+      include ConfigurableMax
+      include CodeLength
+
+      MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'
+
+      private
+
+      def message(length, max_length)
+        format(MSG, label: cop_label, length: length, max: max_length)
+      end
+
+      def code_length(node)
+        body = extract_body(node)
+        lines = body&.source&.lines || []
+
+        lines.count { |line| !irrelevant_line(line) }
+      end
+
+      def extract_body(node)
+        case node.type
+        when :block, :def, :defs
+          node.body
+        else
+          node
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/trailing_body.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common methods shared by TrailingBody cops
+    module TrailingBody
+      def trailing_body?(node)
+        body = node.to_a.reverse[0]
+        body && node.multiline? &&
+          body_on_first_line?(node, body)
+      end
+
+      def body_on_first_line?(node, body)
+        node.source_range.first_line == body.source_range.first_line
+      end
+
+      def first_part_of(body)
+        if body.begin_type?
+          body.children.first.source_range
+        else
+          body.source_range
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common methods shared by Style/TrailingCommaInArguments and
+    # Style/TrailingCommaInLiteral
+    module TrailingComma
+      include ConfigurableEnforcedStyle
+      include RangeHelp
+
+      MSG = '%<command>s comma after the last %<unit>s.'
+
+      private
+
+      def style_parameter_name
+        'EnforcedStyleForMultiline'
+      end
+
+      def check(node, items, kind, begin_pos, end_pos)
+        after_last_item = range_between(begin_pos, end_pos)
+        comma_offset = comma_offset(items, after_last_item)
+
+        if comma_offset && !inside_comment?(after_last_item, comma_offset)
+          check_comma(node, kind, after_last_item.begin_pos + comma_offset)
+        elsif should_have_comma?(style, node)
+          put_comma(items, kind)
+        end
+      end
+
+      def comma_offset(items, range)
+        # If there is any heredoc in items, then match the comma succeeding
+        # any whitespace (except newlines), otherwise allow for newlines
+        comma_regex = any_heredoc?(items) ? /\A[^\S\n]*,/ : /\A\s*,/
+        range.source =~ comma_regex && range.source.index(',')
+      end
+
+      def check_comma(node, kind, comma_pos)
+        return if should_have_comma?(style, node)
+
+        avoid_comma(kind, comma_pos, extra_avoid_comma_info)
+      end
+
+      def check_literal(node, kind)
+        return if node.children.empty?
+        # A braceless hash is the last parameter of a method call and will be
+        # checked as such.
+        return unless brackets?(node)
+
+        check(node, node.children, kind,
+              node.children.last.source_range.end_pos,
+              node.loc.end.begin_pos)
+      end
+
+      def extra_avoid_comma_info
+        case style
+        when :comma
+          ', unless each item is on its own line'
+        when :consistent_comma
+          ', unless items are split onto multiple lines'
+        else
+          ''
+        end
+      end
+
+      def should_have_comma?(style, node)
+        case style
+        when :comma
+          multiline?(node) && no_elements_on_same_line?(node)
+        when :consistent_comma
+          multiline?(node) && !method_name_and_arguments_on_same_line?(node)
+        else
+          false
+        end
+      end
+
+      def inside_comment?(range, comma_offset)
+        processed_source.comments.any? do |comment|
+          comment_offset = comment.loc.expression.begin_pos - range.begin_pos
+          comment_offset >= 0 && comment_offset < comma_offset
+        end
+      end
+
+      # Returns true if the node has round/square/curly brackets.
+      def brackets?(node)
+        node.loc.end
+      end
+
+      # Returns true if the round/square/curly brackets of the given node are
+      # on different lines, each item within is on its own line, and the
+      # closing bracket is on its own line.
+      def multiline?(node)
+        node.multiline? && !allowed_multiline_argument?(node)
+      end
+
+      def method_name_and_arguments_on_same_line?(node)
+        return false unless node.call_type?
+
+        line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
+
+        line == node.last_argument.last_line &&
+          node.last_line == node.last_argument.last_line
+      end
+
+      # A single argument with the closing bracket on the same line as the end
+      # of the argument is not considered multiline, even if the argument
+      # itself might span multiple lines.
+      def allowed_multiline_argument?(node)
+        elements(node).one? && !Util.begins_its_line?(node.loc.end)
+      end
+
+      def elements(node)
+        return node.children unless %i[csend send].include?(node.type)
+
+        node.arguments.flat_map do |argument|
+          # For each argument, if it is a multi-line hash without braces,
+          # then promote the hash elements to method arguments
+          # for the purpose of determining multi-line-ness.
+          if argument.hash_type? && argument.multiline? && !argument.braces?
+            argument.children
+          else
+            argument
+          end
+        end
+      end
+
+      def no_elements_on_same_line?(node)
+        items = elements(node).map(&:source_range)
+        items << node.loc.end
+        items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
+      end
+
+      def on_same_line?(range1, range2)
+        range1.last_line == range2.line
+      end
+
+      def avoid_comma(kind, comma_begin_pos, extra_info)
+        range = range_between(comma_begin_pos, comma_begin_pos + 1)
+        article = /array/.match?(kind) ? 'an' : 'a'
+        msg = format(
+          MSG,
+          command: 'Avoid',
+          unit: format(kind, article: article) + extra_info.to_s
+        )
+
+        add_offense(range, location: range, message: msg)
+      end
+
+      def put_comma(items, kind)
+        last_item = items.last
+        return if last_item.block_pass_type?
+
+        range = autocorrect_range(last_item)
+        msg = format(
+          MSG,
+          command: 'Put a',
+          unit: format(kind, article: 'a multiline')
+        )
+
+        add_offense(range, location: range, message: msg)
+      end
+
+      def autocorrect_range(item)
+        expr = item.source_range
+        ix = expr.source.rindex("\n") || 0
+        ix += expr.source[ix..-1] =~ /\S/
+
+        range_between(expr.begin_pos + ix, expr.end_pos)
+      end
+
+      def any_heredoc?(items)
+        items.any? { |item| heredoc?(item) }
+      end
+
+      def heredoc?(node)
+        return false unless node.is_a?(RuboCop::AST::Node)
+        return true if node.loc.respond_to?(:heredoc_body)
+
+        return heredoc_send?(node) if node.send_type?
+
+        # handle hash values
+        #
+        #   some_method({
+        #     'auth' => <<-SOURCE
+        #       ...
+        #     SOURCE
+        #   })
+        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
+
+        false
+      end
+
+      def heredoc_send?(node)
+        # handle heredocs with methods
+        #
+        #   some_method(<<-CODE.strip.chomp)
+        #     ...
+        #   CODE
+        return heredoc?(node.children.first) if node.children.size == 2
+        # handle nested methods
+        #
+        #   some_method(
+        #     another_method(<<-CODE.strip.chomp)
+        #       ...
+        #     CODE
+        #   )
+        return heredoc?(node.children.last) if node.children.size > 2
+
+        false
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/uncommunicative_name.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality shared by Uncommunicative cops
+    module UncommunicativeName
+      CASE_MSG = 'Only use lowercase characters for %<name_type>s.'
+      NUM_MSG = 'Do not end %<name_type>s with a number.'
+      LENGTH_MSG = '%<name_type>s must be at least %<min>s ' \
+                   'characters long.'
+      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a ' \
+                      '%<name_type>s.'
+
+      def check(node, args)
+        args.each do |arg|
+          # Argument names might be "_" or prefixed with "_" to indicate they
+          # are unused. Trim away this prefix and only analyse the basename.
+          full_name = arg.children.first.to_s
+          next if full_name == '_'
+
+          name = full_name.gsub(/\A(_+)/, '')
+          next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
+          next if allowed_names.include?(name)
+
+          range = arg_range(arg, name.size)
+          issue_offenses(node, range, name)
+        end
+      end
+
+      private
+
+      def issue_offenses(node, range, name)
+        forbidden_offense(node, range, name) if forbidden_names.include?(name)
+        case_offense(node, range) if uppercase?(name)
+        length_offense(node, range) unless long_enough?(name)
+        return if allow_nums
+
+        num_offense(node, range) if ends_with_num?(name)
+      end
+
+      def case_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(CASE_MSG, name_type: name_type(node)))
+      end
+
+      def uppercase?(name)
+        name =~ /[[:upper:]]/
+      end
+
+      def name_type(node)
+        @name_type ||= begin
+          case node.type
+          when :block then 'block parameter'
+          when :def, :defs then 'method parameter'
+          end
+        end
+      end
+
+      def num_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(NUM_MSG, name_type: name_type(node)))
+      end
+
+      def ends_with_num?(name)
+        name[-1] =~ /\d/
+      end
+
+      def length_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(LENGTH_MSG,
+                                          name_type: name_type(node).capitalize,
+                                          min: min_length))
+      end
+
+      def long_enough?(name)
+        name.size >= min_length
+      end
+
+      def arg_range(arg, length)
+        begin_pos = arg.source_range.begin_pos
+        Parser::Source::Range.new(processed_source.buffer,
+                                  begin_pos,
+                                  begin_pos + length)
+      end
+
+      def forbidden_offense(node, range, name)
+        add_offense(
+          node,
+          location: range,
+          message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node))
+        )
+      end
+
+      def allowed_names
+        cop_config['AllowedNames']
+      end
+
+      def forbidden_names
+        cop_config['ForbiddenNames']
+      end
+
+      def allow_nums
+        cop_config['AllowNamesEndingInNumbers']
+      end
+
+      def min_length
+        cop_config['MinNameLength']
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Common functionality for cops handling unused arguments.
+      module UnusedArgument
+        extend NodePattern::Macros
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        private
+
+        def check_argument(variable)
+          return if variable.should_be_unused?
+          return if variable.referenced?
+
+          message = message(variable)
+          add_offense(variable.declaration_node, location: :name,
+                                                 message: message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that accessor methods are named properly.
+      #
+      # @example
+      #   # bad
+      #   def set_attribute(value)
+      #   end
+      #
+      #   # good
+      #   def attribute=(value)
+      #   end
+      #
+      #   # bad
+      #   def get_attribute
+      #   end
+      #
+      #   # good
+      #   def attribute
+      #   end
+      class AccessorMethodName < Cop
+        MSG_READER = 'Do not prefix reader method names with `get_`.'
+        MSG_WRITER = 'Do not prefix writer method names with `set_`.'
+
+        def on_def(node)
+          return unless bad_reader_name?(node) || bad_writer_name?(node)
+
+          add_offense(node, location: :name)
+        end
+        alias on_defs on_def
+
+        private
+
+        def message(node)
+          if bad_reader_name?(node)
+            MSG_READER
+          elsif bad_writer_name?(node)
+            MSG_WRITER
+          end
+        end
+
+        def bad_reader_name?(node)
+          node.method_name.to_s.start_with?('get_') && !node.arguments?
+        end
+
+        def bad_writer_name?(node)
+          node.method_name.to_s.start_with?('set_') && node.arguments.one?
+        end
+      end
+    end
+  end
+end