rubocop 0.42.0 → 0.52.1

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

@@ -1,256 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Here we check if the keys, separators, and values of a multi-line hash
-      # literal are aligned.
-      class AlignHash < Cop
-        # Handles calculation of deltas (deviations from correct alignment)
-        # when the enforced style is 'key'.
-        class KeyAlignment
-          def checkable_layout(_node)
-            true
-          end
-
-          def deltas_for_first_pair(*)
-            {} # The first pair is always considered correct.
-          end
-
-          def deltas(first_pair, current_pair)
-            if Util.begins_its_line?(current_pair.source_range)
-              { key: first_pair.loc.column - current_pair.loc.column }
-            else
-              {}
-            end
-          end
-        end
-
-        # Common functionality for the styles where not only keys, but also
-        # values are aligned.
-        class AlignmentOfValues
-          include HashNode # any_pairs_on_the_same_line?
-
-          def checkable_layout(node)
-            !any_pairs_on_the_same_line?(node) && all_have_same_separator?(node)
-          end
-
-          def deltas(first_pair, current_pair)
-            key_delta = key_delta(first_pair, current_pair)
-            current_separator = current_pair.loc.operator
-            separator_delta = separator_delta(first_pair, current_separator,
-                                              key_delta)
-            value_delta = value_delta(first_pair, current_pair) -
-                          key_delta - separator_delta
-
-            { key: key_delta, separator: separator_delta, value: value_delta }
-          end
-
-          private
-
-          def separator_delta(first_pair, current_separator, key_delta)
-            if current_separator.is?(':')
-              0 # Colon follows directly after key
-            else
-              hash_rocket_delta(first_pair, current_separator) - key_delta
-            end
-          end
-
-          def all_have_same_separator?(node)
-            first_separator = node.children.first.loc.operator.source
-            node.children.butfirst.all? do |pair|
-              pair.loc.operator.is?(first_separator)
-            end
-          end
-        end
-
-        # Handles calculation of deltas when the enforced style is 'table'.
-        class TableAlignment < AlignmentOfValues
-          # The table style is the only one where the first key-value pair can
-          # be considered to have bad alignment.
-          def deltas_for_first_pair(first_pair, node)
-            key_widths = node.children.map do |pair|
-              key, _value = *pair
-              key.source.length
-            end
-            @max_key_width = key_widths.max
-
-            separator_delta = separator_delta(first_pair,
-                                              first_pair.loc.operator, 0)
-            {
-              separator: separator_delta,
-              value:     value_delta(first_pair, first_pair) - separator_delta
-            }
-          end
-
-          private
-
-          def key_delta(first_pair, current_pair)
-            first_pair.loc.column - current_pair.loc.column
-          end
-
-          def hash_rocket_delta(first_pair, current_separator)
-            first_pair.loc.column + @max_key_width + 1 -
-              current_separator.column
-          end
-
-          def value_delta(first_pair, current_pair)
-            first_key, = *first_pair
-            _, current_value = *current_pair
-            correct_value_column = first_key.loc.column +
-                                   spaced_separator(current_pair).length +
-                                   @max_key_width
-            correct_value_column - current_value.loc.column
-          end
-
-          def spaced_separator(node)
-            node.loc.operator.is?('=>') ? ' => ' : ': '
-          end
-        end
-
-        # Handles calculation of deltas when the enforced style is 'separator'.
-        class SeparatorAlignment < AlignmentOfValues
-          def deltas_for_first_pair(*)
-            {} # The first pair is always considered correct.
-          end
-
-          private
-
-          def key_delta(first_pair, current_pair)
-            key_end_column(first_pair) - key_end_column(current_pair)
-          end
-
-          def key_end_column(pair)
-            key, _value = *pair
-            key.loc.column + key.source.length
-          end
-
-          def hash_rocket_delta(first_pair, current_separator)
-            first_pair.loc.operator.column - current_separator.column
-          end
-
-          def value_delta(first_pair, current_pair)
-            _, first_value = *first_pair
-            _, current_value = *current_pair
-            first_value.loc.column - current_value.loc.column
-          end
-        end
-
-        MSG = 'Align the elements of a hash literal if they span more than ' \
-              'one line.'.freeze
-
-        def on_send(node)
-          return unless (last_child = node.children.last) &&
-                        hash?(last_child) &&
-                        ignore_last_argument_hash?(last_child)
-
-          ignore_node(last_child)
-        end
-
-        def on_hash(node)
-          return if ignored_node?(node)
-          return if node.children.empty?
-          return unless node.multiline?
-
-          @alignment_for_hash_rockets ||=
-            new_alignment('EnforcedHashRocketStyle')
-          @alignment_for_colons ||= new_alignment('EnforcedColonStyle')
-
-          unless @alignment_for_hash_rockets.checkable_layout(node) &&
-                 @alignment_for_colons.checkable_layout(node)
-            return
-          end
-
-          check_pairs(node)
-        end
-
-        private
-
-        def check_pairs(node)
-          first_pair = node.children.first
-          @column_deltas = alignment_for(first_pair)
-                           .deltas_for_first_pair(first_pair, node)
-          add_offense(first_pair, :expression) unless good_alignment?
-
-          node.children.each do |current|
-            @column_deltas = alignment_for(current).deltas(first_pair, current)
-            add_offense(current, :expression) unless good_alignment?
-          end
-        end
-
-        def ignore_last_argument_hash?(node)
-          case cop_config['EnforcedLastArgumentHashStyle']
-          when 'always_inspect'  then false
-          when 'always_ignore'   then true
-          when 'ignore_explicit' then explicit_hash?(node)
-          when 'ignore_implicit' then !explicit_hash?(node)
-          end
-        end
-
-        def hash?(node)
-          node.respond_to?(:type) && node.type == :hash
-        end
-
-        def explicit_hash?(node)
-          node.loc.begin
-        end
-
-        def alignment_for(pair)
-          if pair.loc.operator.is?('=>')
-            @alignment_for_hash_rockets
-          else
-            @alignment_for_colons
-          end
-        end
-
-        def autocorrect(node)
-          # We can't use the instance variable inside the lambda. That would
-          # just give each lambda the same reference and they would all get the
-          # last value of each. Some local variables fix the problem.
-          key_delta       = @column_deltas[:key] || 0
-          separator_delta = @column_deltas[:separator] || 0
-          value_delta     = @column_deltas[:value] || 0
-
-          key, value = *node
-          key_column = key.source_range.column
-          key_delta = -key_column if key_delta < -key_column
-
-          lambda do |corrector|
-            if value.nil?
-              adjust(corrector, key_delta, node.source_range)
-            else
-              adjust(corrector, key_delta, key.source_range)
-              adjust(corrector, separator_delta, node.loc.operator)
-              adjust(corrector, value_delta, value.source_range)
-            end
-          end
-        end
-
-        def new_alignment(key)
-          case cop_config[key]
-          when 'key'       then KeyAlignment.new
-          when 'table'     then TableAlignment.new
-          when 'separator' then SeparatorAlignment.new
-          else raise "Unknown #{key}: #{cop_config[key]}"
-          end
-        end
-
-        def adjust(corrector, delta, range)
-          if delta > 0
-            corrector.insert_before(range, ' ' * delta)
-          elsif delta < 0
-            range = Parser::Source::Range.new(range.source_buffer,
-                                              range.begin_pos - delta.abs,
-                                              range.begin_pos)
-            corrector.remove(range)
-          end
-        end
-
-        def good_alignment?
-          @column_deltas.values.compact.all?(&:zero?)
-        end
-      end
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks how the *when*s of a *case* expression
-      # are indented in relation to its *case* or *end* keyword.
-      #
-      # It will register a separate offense for each misaligned *when*.
-      class CaseIndentation < Cop
-        include AutocorrectAlignment
-        include ConfigurableEnforcedStyle
-
-        def on_case(case_node)
-          _condition, *whens, _else = *case_node
-
-          base = style
-          indent = cop_config['IndentOneStep']
-          base_column = base_column(case_node, base)
-
-          whens.each do |when_node|
-            check_when(when_node, case_node, base, indent, base_column)
-          end
-        end
-
-        private
-
-        def check_when(when_node, case_node, base, indent, base_column)
-          pos = when_node.loc.keyword
-          expected_column = base_column +
-                            (indent ? configured_indentation_width : 0)
-          if pos.column == expected_column
-            correct_style_detected
-          else
-            incorrect_style(when_node, case_node, base, pos, indent)
-          end
-        end
-
-        def incorrect_style(when_node, case_node, base, pos, indent)
-          msg = 'Indent `when` ' + if indent
-                                     "one step more than `#{base}`."
-                                   else
-                                     "as deep as `#{base}`."
-                                   end
-          add_offense(when_node, pos, msg) do
-            if pos.column == base_column(case_node, alternative_style)
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
-          end
-        end
-
-        def parameter_name
-          'IndentWhenRelativeTo'
-        end
-
-        def base_column(case_node, base)
-          case base
-          when :case then case_node.location.keyword.column
-          when :end  then case_node.location.end.column
-          end
-        end
-
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-          return false unless whitespace.source.strip.empty?
-
-          ->(corrector) { corrector.replace(whitespace, replacement(node)) }
-        end
-
-        def whitespace_range(node)
-          when_column = node.location.keyword.column
-          begin_pos = node.loc.keyword.begin_pos
-
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    begin_pos - when_column,
-                                    begin_pos)
-        end
-
-        def replacement(node)
-          case_node = node.each_ancestor(:case).first
-          base_type = cop_config[parameter_name] == 'end' ? :end : :case
-          column = base_column(case_node, base_type)
-          column += configured_indentation_width if cop_config['IndentOneStep']
-          ' ' * column
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cops checks for class and module names with
-      # an underscore in them.
-      class ClassAndModuleCamelCase < Cop
-        MSG = 'Use CamelCase for classes and modules.'.freeze
-
-        def on_class(node)
-          check_name(node)
-        end
-
-        def on_module(node)
-          check_name(node)
-        end
-
-        private
-
-        def check_name(node)
-          name = node.loc.name.source
-
-          add_offense(node, :name) if name =~ /_/
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks whether constant names are written using
-      # SCREAMING_SNAKE_CASE.
-      #
-      # To avoid false positives, it ignores cases in which we cannot know
-      # for certain the type of value that would be assigned to a constant.
-      class ConstantName < Cop
-        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'.freeze
-        SNAKE_CASE = /^[\dA-Z_]+$/
-
-        def on_casgn(node)
-          _scope, const_name, value = *node
-
-          # We cannot know the result of method calls like
-          # NewClass = something_that_returns_a_class
-          # It's also ok to assign a class constant another class constant
-          # SomeClass = SomeOtherClass
-          return if value && [:send, :block, :const].include?(value.type)
-
-          add_offense(node, :name) if const_name !~ SNAKE_CASE
-        end
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks whether method definitions are
-      # separated by empty lines.
-      class EmptyLineBetweenDefs < Cop
-        MSG = 'Use empty lines between method definitions.'.freeze
-
-        # We operate on `begin` nodes, instead of using `OnMethodDef`,
-        # so that we can walk over pairs of consecutive nodes and
-        # efficiently access a node's predecessor; #prev_node ends up
-        # doing a linear scan over siblings, so we don't want to call
-        # it on each def.
-        def on_begin(node)
-          node.children.each_cons(2) do |prev, n|
-            nodes = [prev, n]
-            check_defs(nodes) if nodes.all?(&method(:def_node?))
-          end
-        end
-
-        def check_defs(nodes)
-          return if blank_lines_between?(*nodes)
-          return if nodes.all?(&:single_line?) &&
-                    cop_config['AllowAdjacentOneLineDefs']
-
-          add_offense(nodes.last, :keyword)
-        end
-
-        private
-
-        def def_node?(node)
-          return unless node
-          node.def_type? || node.defs_type?
-        end
-
-        def blank_lines_between?(first_def_node, second_def_node)
-          lines_between_defs(first_def_node, second_def_node).any?(&:blank?)
-        end
-
-        def prev_node(node)
-          return nil unless node.sibling_index > 0
-
-          node.parent.children[node.sibling_index - 1]
-        end
-
-        def lines_between_defs(first_def_node, second_def_node)
-          line_range = def_end(first_def_node)..(def_start(second_def_node) - 2)
-
-          processed_source.lines[line_range]
-        end
-
-        def def_start(node)
-          node.loc.keyword.line
-        end
-
-        def def_end(node)
-          node.loc.end.line
-        end
-
-        def autocorrect(node)
-          prev_def = prev_node(node)
-          end_pos = prev_def.loc.end.end_pos
-          source_buffer = prev_def.loc.end.source_buffer
-          newline_pos = source_buffer.source.index("\n", end_pos)
-          newline = Parser::Source::Range.new(source_buffer,
-                                              newline_pos,
-                                              newline_pos + 1)
-          ->(corrector) { corrector.insert_after(newline, "\n") }
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cops checks if empty lines around the bodies of classes match
-      # the configuration.
-      #
-      # @example
-      #
-      #   EnforcedStyle: empty_lines
-      #
-      #   # good
-      #
-      #   class Foo
-      #
-      #      def bar
-      #        ...
-      #      end
-      #
-      #   end
-      class EmptyLinesAroundClassBody < Cop
-        include EmptyLinesAroundBody
-
-        KIND = 'class'.freeze
-
-        def on_class(node)
-          _name, _superclass, body = *node
-          check(node, body)
-        end
-
-        def on_sclass(node)
-          _obj, body = *node
-          check(node, body)
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for Windows-style line endings in the source code.
-      class EndOfLine < Cop
-        MSG = 'Carriage return character detected.'.freeze
-
-        def investigate(processed_source)
-          last_token = processed_source.tokens.last
-          last_line =
-            last_token ? last_token.pos.line : processed_source.lines.length
-
-          processed_source.raw_source.each_line.with_index do |line, index|
-            break if index >= last_line
-            next unless line =~ /\r$/
-
-            range =
-              source_range(processed_source.buffer, index + 1, 0, line.length)
-            add_offense(nil, range, MSG)
-            # Usually there will be carriage return characters on all or none
-            # of the lines in a file, so we report only one offense.
-            break
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cops checks for indentation of the first non-blank non-comment
-      # line in a file.
-      class InitialIndentation < Cop
-        MSG = 'Indentation of first line in file detected.'.freeze
-
-        def investigate(processed_source)
-          first_token = processed_source.tokens.find do |t|
-            !t.text.start_with?('#')
-          end
-          return unless first_token
-          return if first_token.pos.column.zero?
-
-          with_space = range_with_surrounding_space(first_token.pos, :left,
-                                                    !:with_newline)
-          # If the file starts with a byte order mark (BOM), the column can be
-          # non-zero, but then we find out here if there's no space to the left
-          # of the first token.
-          return if with_space == first_token.pos
-
-          space = Parser::Source::Range.new(processed_source.buffer,
-                                            with_space.begin_pos,
-                                            first_token.pos.begin_pos)
-          add_offense(space, first_token.pos)
-        end
-
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks whether comments have a leading space
-      # after the # denoting the start of the comment. The
-      # leading space is not required for some RDoc special syntax,
-      # like #++, #--, #:nodoc, etc. Neither is it required for
-      # =begin/=end comments.
-      class LeadingCommentSpace < Cop
-        MSG = 'Missing space after #.'.freeze
-
-        def investigate(processed_source)
-          processed_source.comments.each do |comment|
-            next unless comment.text =~ /\A#+[^#\s=:+-]/
-            next if comment.text.start_with?('#!') && comment.loc.line == 1
-
-            add_offense(comment, :expression)
-          end
-        end
-
-        def autocorrect(comment)
-          expr = comment.loc.expression
-          b = expr.begin_pos
-          hash_mark = Parser::Source::Range.new(expr.source_buffer, b, b + 1)
-          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that all methods use the configured style,
-      # snake_case or camelCase, for their names. Some special arrangements
-      # have to be made for operator methods.
-      class MethodName < Cop
-        include ConfigurableNaming
-
-        def on_def(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_defs(node)
-          _object, name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def message(style)
-          format('Use %s for method names.', style)
-        end
-      end
-    end
-  end
-end