rubocop 0.9.0 → 0.9.1

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

@@ -10,15 +10,25 @@ module Rubocop
         def on_send(node)
           return unless node.loc.dot
 
-          dot_line = node.loc.dot.line
-          selector_line = node.loc.selector.line
-
-          if dot_line != selector_line
+          unless proper_dot_position?(node)
             add_offence(:convention, node.loc.dot, MSG)
           end
 
           super
         end
+
+        private
+
+        def proper_dot_position?(node)
+          dot_line = node.loc.dot.line
+          selector_line = node.loc.selector.line
+
+          case DotPosition.config['Style'].downcase
+          when 'leading' then dot_line == selector_line
+          when 'trailing' then dot_line != selector_line
+          else fail 'Unknown dot position style selected.'
+          end
+        end
       end
     end
   end

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

@@ -24,57 +24,6 @@ module Rubocop
           end
         end
       end
-
-      # Checks for uses of semicolon in if statements.
-      class IfWithSemicolon < Cop
-        include IfThenElse
-
-        def offending_line(node)
-          node.loc.begin.line if node.loc.begin && node.loc.begin.is?(';')
-        end
-
-        def error_message
-          'Never use if x; Use the ternary operator instead.'
-        end
-      end
-
-      # Checks for uses of then multi-line if statements.
-      class MultilineIfThen < Cop
-        include IfThenElse
-
-        def offending_line(node)
-          condition, body = *node
-          next_thing = if body && body.loc.expression
-                         body.loc.expression.begin
-                       else
-                         node.loc.end # No body, use "end".
-                       end
-          right_after_cond =
-            Parser::Source::Range.new(next_thing.source_buffer,
-                                      condition.loc.expression.end.end_pos,
-                                      next_thing.begin_pos)
-          if right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
-            node.loc.expression.begin.line
-          end
-        end
-
-        def error_message
-          'Never use then for multi-line if/unless.'
-        end
-      end
-
-      # Checks for uses of if/then/else/end on a single line.
-      class OneLineConditional < Cop
-        include IfThenElse
-
-        def offending_line(node)
-          node.loc.expression.line unless node.loc.expression.source =~ /\n/
-        end
-
-        def error_message
-          'Favor the ternary operator (?:) over if/then/else/end constructs.'
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of semicolon in if statements.
+      class IfWithSemicolon < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          node.loc.begin.line if node.loc.begin && node.loc.begin.is?(';')
+        end
+
+        def error_message
+          'Never use if x; Use the ternary operator instead.'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of the `then` keyword in multi-line if statements.
+      #
+      # This is considered bad practice:
+      # @example
+      #
+      # if cond then
+      # end
+      #
+      # While if statements can contain `then` on the same line:
+      # @example
+      #
+      # if cond then a
+      # elsif cond then b
+      # end
+      class MultilineIfThen < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          condition, body, else_clause = *node
+          next_thing = if body && body.loc.expression
+                         body.loc.expression.begin
+                       elsif else_clause && else_clause.loc.expression
+                        else_clause.loc.expression.begin
+                       else
+                         node.loc.end # No body, use "end".
+                       end
+          right_after_cond =
+            Parser::Source::Range.new(next_thing.source_buffer,
+                                      condition.loc.expression.end.end_pos,
+                                      next_thing.begin_pos)
+          if right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
+            node.loc.expression.begin.line
+          end
+        end
+
+        def error_message
+          'Never use then for multi-line if/unless.'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of if/then/else/end on a single line.
+      class OneLineConditional < Cop
+        include IfThenElse
+
+        def offending_line(node)
+          node.loc.expression.line unless node.loc.expression.source =~ /\n/
+        end
+
+        def error_message
+          'Favor the ternary operator (?:) over if/then/else/end constructs.'
+        end
+      end
+    end
+  end
+end

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

@@ -2,25 +2,27 @@
 
 module Rubocop
   module Cop
-    # This cop makes sure that certain operator methods have their sole
-    # parameter named *other*.
-    class OpMethod < Cop
-      MSG = 'When defining the %s operator, name its argument *other*.'
+    module Style
+      # This cop makes sure that certain operator methods have their sole
+      # parameter named *other*.
+      class OpMethod < Cop
+        MSG = 'When defining the %s operator, name its argument *other*.'
 
-      BLACKLISTED = [:+@, :-@, :[], :[]=, :<<]
+        BLACKLISTED = [:+@, :-@, :[], :[]=, :<<]
 
-      TARGET_ARGS = s(:args, s(:arg, :other))
+        TARGET_ARGS = s(:args, s(:arg, :other))
 
-      def on_def(node)
-        name, args, _body = *node
+        def on_def(node)
+          name, args, _body = *node
 
-        if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
-            args.children.size == 1 && args != TARGET_ARGS
-          add_offence(:convention, args.children[0].loc.expression,
-                      sprintf(MSG, name))
-        end
+          if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
+              args.children.size == 1 && args != TARGET_ARGS
+            add_offence(:convention, args.children[0].loc.expression,
+                        sprintf(MSG, name))
+          end
 
-        super
+          super
+        end
       end
     end
   end

data/lib/rubocop/cop/util.rb

@@ -22,6 +22,10 @@ module Rubocop
       def block_length(block_node)
         block_node.loc.end.line - block_node.loc.begin.line
       end
+
+      def symbolize_keys(hash)
+        Hash[hash.map { |(k, v)| [k.to_sym, v] }] if hash
+      end
     end
   end
 end

data/lib/rubocop/cop/variable_inspector.rb

@@ -6,10 +6,10 @@ module Rubocop
     # This is intended to be used as mix-in, and the user class may override
     # some of hook methods.
     module VariableInspector
-      VARIABLE_ASSIGNMENT_TYPES = [:lvasgn].freeze
+      VARIABLE_ASSIGNMENT_TYPES = [:lvasgn, :match_with_lvasgn].freeze
       ARGUMENT_DECLARATION_TYPES = [
         :arg, :optarg, :restarg, :blockarg,
-        :kwarg, :kwoptarg, :kwsplatarg,
+        :kwarg, :kwoptarg, :kwrestarg,
         :shadowarg
       ].freeze
       VARIABLE_DECLARATION_TYPES =
@@ -25,18 +25,19 @@ module Rubocop
         attr_accessor :used
         alias_method :used?, :used
 
-        def initialize(node)
+        def initialize(node, name = nil)
           unless VARIABLE_DECLARATION_TYPES.include?(node.type)
             fail ArgumentError,
                  "Node type must be any of #{VARIABLE_DECLARATION_TYPES}, " +
                  "passed #{node.type}"
           end
           @node = node
+          @name = name.to_sym if name
           @used = false
         end
 
         def name
-          @node.children.first
+          @name || @node.children.first
         end
       end
 
@@ -100,8 +101,8 @@ module Rubocop
           scope_stack.count
         end
 
-        def add_variable_entry(variable_declaration_node)
-          entry = VariableEntry.new(variable_declaration_node)
+        def add_variable_entry(variable_declaration_node, name = nil)
+          entry = VariableEntry.new(variable_declaration_node, name)
           invoke_hook(:before_declaring_variable, entry)
           current_scope.variable_entries[entry.name] = entry
           invoke_hook(:after_declaring_variable, entry)
@@ -188,14 +189,11 @@ module Rubocop
         case node.type
         when *ARGUMENT_DECLARATION_TYPES
           variable_table.add_variable_entry(node)
-        when *VARIABLE_ASSIGNMENT_TYPES
+        when :lvasgn
           variable_name = node.children.first
-          variable_entry = variable_table.find_variable_entry(variable_name)
-          if variable_entry
-            variable_entry.used = true
-          else
-            variable_table.add_variable_entry(node)
-          end
+          process_variable_assignment(node, variable_name)
+        when :match_with_lvasgn
+          process_named_captures(node)
         when *VARIABLE_USE_TYPES
           variable_name = node.children.first
           variable_entry = variable_table.find_variable_entry(variable_name)
@@ -256,6 +254,27 @@ module Rubocop
         end
       end
 
+      def process_variable_assignment(node, name)
+        entry = variable_table.find_variable_entry(name)
+        if entry
+          entry.used = true
+        else
+          variable_table.add_variable_entry(node, name)
+        end
+      end
+
+      def process_named_captures(match_with_lvasgn_node)
+        regexp_string = match_with_lvasgn_node.children[0]
+                                              .children[0]
+                                              .children[0]
+        regexp = Regexp.new(regexp_string)
+        variable_names = regexp.named_captures.keys
+
+        variable_names.each do |name|
+          process_variable_assignment(match_with_lvasgn_node, name)
+        end
+      end
+
       # Hooks
 
       def before_entering_scope(scope)

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module Rubocop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.9.0'
+    STRING = '0.9.1'
 
     MSG = '%s (using Parser %s, running on %s %s %s)'
 

data/rubocop.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |s|
   s.summary = 'Automatic Ruby code style checking tool.'
 
   s.add_runtime_dependency('rainbow', '>= 1.1.4')
-  s.add_runtime_dependency('parser', '2.0.0.beta9')
+  s.add_runtime_dependency('parser', '2.0.0.pre1')
   s.add_development_dependency('rake', '~> 10.0')
   s.add_development_dependency('rspec', '~> 2.13')
   s.add_development_dependency('yard', '~> 0.8')

data/spec/rubocop/cli_spec.rb

@@ -47,6 +47,7 @@ Usage: rubocop [options] [file1, file2, ...]
                                      if no format is specified.
     -r, --require FILE               Require Ruby file.
     -R, --rails                      Run extra Rails cops.
+    -l, --lint                       Run only lint cops.
     -a, --auto-correct               Auto-correct offences.
     -s, --silent                     Silence summary.
     -n, --no-color                   Disable color output.
@@ -252,8 +253,28 @@ Usage: rubocop [options] [file1, file2, ...]
                 ''].join("\n"))
     end
 
+    it 'runs only lint cops if --lint is passed' do
+      create_file('example.rb', ['if 0 ',
+                                 "\ty",
+                                 'end'])
+      # IfUnlessModifier depends on the configuration of LineLength.
+      # That configuration might have been set by other spec examples
+      # so we reset it to emulate a start from scratch.
+      Cop::Style::LineLength.config = nil
+
+      expect(cli.run(['--format', 'simple', '--lint', 'example.rb'])).to eq(1)
+      expect($stdout.string)
+        .to eq(['== example.rb ==',
+                'W:  1:  4: Literal 0 appeared in a condition.',
+                '',
+                '1 file inspected, 1 offence detected',
+                ''].join("\n"))
+
+    end
+
     it 'exits with error if an incorrect cop name is passed to --only' do
       expect(cli.run(%w(--only 123))).to eq(1)
+
       expect($stderr.string).to eq("Unrecognized cop name: 123.\n")
     end
 

data/spec/rubocop/cops/lint/end_alignment_spec.rb

@@ -8,10 +8,6 @@ module Rubocop
     module Lint
       describe EndAlignment do
         let(:cop) { EndAlignment.new }
-        before do
-          # TODO: Initialize the config to a default {} value. Currently it's nil.
-          EndAlignment.config = {}
-        end
 
         it 'registers an offence for mismatched class end' do
           inspect_source(cop,
@@ -77,348 +73,259 @@ module Rubocop
           expect(cop.offences.size).to eq(1)
         end
 
-        context 'with BlockAlignSchema set to StartOfAssignment' do
-          before do
-            EndAlignment.config = { 'BlockAlignSchema' => 'StartOfAssignment' }
-          end
-
-          it 'accepts end aligned with a variable' do
-            inspect_source(cop,
-                           ['variable = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
-
-          it 'registers an offence for mismatched block end with a variable' do
-            inspect_source(cop,
-                           ['variable = test do |ala|',
-                            '  end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-
-          it 'accepts end aligned with an instance variable' do
-            inspect_source(cop,
-                           ['@variable = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
-
-          it 'registers an offence for mismatched block end with an instance variable' do
-            inspect_source(cop,
-                           ['@variable = test do |ala|',
-                            '  end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-
-          it 'accepts end aligned with a class variable' do
-            inspect_source(cop,
-                           ['@@variable = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
-
-          it 'registers an offence for mismatched block end with a class variable' do
-            inspect_source(cop,
-                           ['@@variable = test do |ala|',
-                            '  end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-
-          it 'accepts end aligned with a global variable' do
-            inspect_source(cop,
-                           ['$variable = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
-
-          it 'registers an offence for mismatched block end with a global variable' do
+        context 'when the block is a logical operand' do
+          it 'accepts a correctly aligned block end' do
             inspect_source(cop,
-                           ['$variable = test do |ala|',
-                            '  end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-
-          it 'accepts end aligned with a constant' do
-            inspect_source(cop,
-                           ['CONSTANT = test do |ala|',
-                            'end'
+                           ['(value.is_a? Array) && value.all? do |subvalue|',
+                            '  type_check_value(subvalue, array_type)',
+                            'end',
+                            'a || b do',
+                            'end',
                            ])
             expect(cop.offences).to be_empty
           end
+        end
 
-          it 'registers an offence for mismatched block end with a constant' do
-            inspect_source(cop,
-                           ['Module::CONSTANT = test do |ala|',
-                            '  end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'accepts end aligned with a variable' do
+          inspect_source(cop,
+                         ['variable = test do |ala|',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'accepts end aligned with an attribute writer method' do
+        context 'and the block is an operand' do
+          it 'accepts end aligned with a variable' do
             inspect_source(cop,
-                           ['parser.child.consumer = lambda do |token|',
-                            '  token << 1',
-                            'end'
+                           ['b = 1 + preceding_line.reduce(0) do |a, e|',
+                           '  a + e.length + newline_length',
+                           'end + 1'
                            ])
             expect(cop.offences).to be_empty
           end
+        end
 
-          it 'registers an offence for mismatched block end with an attribute writer method' do
-            inspect_source(cop,
-                           ['parser.child.consumer = lambda do |token|',
-                            '  token << 1',
-                            '  end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-
-          it 'accepts end aligned with an op-asgn (+=, -=)' do
-            inspect_source(cop,
-                           ['rb += files.select do |file|',
-                            '  file << something',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'registers an offence for mismatched block end with a variable' do
+          inspect_source(cop,
+                         ['variable = test do |ala|',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'registers an offence for mismatched block end with an op-asgn (+=, -=)' do
+        context 'when the block is defined on the next line' do
+          it 'accepts end aligned with the block expression' do
             inspect_source(cop,
-                           ['rb += files.select do |file|',
-                            '  file << something',
+                           ['variable =',
+                            '  a_long_method_that_dont_fit_on_the_line do |v|',
+                            '    v.foo',
                             '  end'
                            ])
-            expect(cop.offences.size).to eq(1)
-          end
-
-          it 'accepts end aligned with an and-asgn (&&=)' do
-            inspect_source(cop,
-                           ['variable &&= test do |ala|',
-                            'end'
-                           ])
             expect(cop.offences).to be_empty
           end
 
-          it 'registers an offence for mismatched block end with an and-asgn (&&=)' do
+          it 'registers an offences for mismatched end alignment' do
             inspect_source(cop,
-                           ['variable &&= test do |ala|',
-                            '  end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-
-          it 'accepts end aligned with an or-asgn (||=)' do
-            inspect_source(cop,
-                           ['variable ||= test do |ala|',
+                           ['variable =',
+                            '  a_long_method_that_dont_fit_on_the_line do |v|',
+                            '    v.foo',
                             'end'
                            ])
-            expect(cop.offences).to be_empty
-          end
-
-          it 'registers an offence for mismatched block end with an or-asgn (||=)' do
-            inspect_source(cop,
-                           ['variable ||= test do |ala|',
-                            '  end'
-                           ])
             expect(cop.offences.size).to eq(1)
           end
+        end
 
-          it 'accepts end aligned with a mass assignment' do
-            inspect_source(cop,
-                           ['var1, var2 = lambda do |test|',
-                            '  [1, 2]',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'accepts end aligned with an instance variable' do
+          inspect_source(cop,
+                         ['@variable = test do |ala|',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'registers an offence for mismatched block end with a mass assignment' do
-            inspect_source(cop,
-                           ['var1, var2 = lambda do |test|',
-                            '  [1, 2]',
-                            '  end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'registers an offence for mismatched block end with an instance variable' do
+          inspect_source(cop,
+                         ['@variable = test do |ala|',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
         end
 
-        context 'with BlockAlignSchema set to StartOfBlockCommand' do
-          before do
-            EndAlignment.config = { 'BlockAlignSchema' => 'StartOfBlockCommand' }
-          end
+        it 'accepts end aligned with a class variable' do
+          inspect_source(cop,
+                         ['@@variable = test do |ala|',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'accepts end aligned with the method that invokes the block' do
-            inspect_source(cop,
-                           ['variable = test do |ala|',
-                            '           end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'registers an offence for mismatched block end with a class variable' do
+          inspect_source(cop,
+                         ['@@variable = test do |ala|',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'registers an offence for mismatched block end with the method that invokes the block' do
-            inspect_source(cop,
-                           ['variable = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'accepts end aligned with a global variable' do
+          inspect_source(cop,
+                         ['$variable = test do |ala|',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'accepts end aligned with the method when return value is assigned to instance variable' do
-            inspect_source(cop,
-                           ['@variable = test do |ala|',
-                            '            end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'registers an offence for mismatched block end with a global variable' do
+          inspect_source(cop,
+                         ['$variable = test do |ala|',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned to instance variable' do
-            inspect_source(cop,
-                           ['@variable = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'accepts end aligned with a constant' do
+          inspect_source(cop,
+                         ['CONSTANT = test do |ala|',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'accepts end aligned with the method when return value is assigned to class variable' do
-            inspect_source(cop,
-                           ['@@variable = test do |ala|',
-                            '             end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'registers an offence for mismatched block end with a constant' do
+          inspect_source(cop,
+                         ['Module::CONSTANT = test do |ala|',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned to class variable' do
-            inspect_source(cop,
-                           ['@@variable = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'accepts end aligned with a method call' do
+          inspect_source(cop,
+                         ['parser.childs << lambda do |token|',
+                         '  token << 1',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'accepts end aligned with the method when return value is assigned to global variable' do
-            inspect_source(cop,
-                           ['$variable = test do |ala|',
-                            '            end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'registers an offence for mismatched block end with a method call' do
+          inspect_source(cop,
+                         ['parser.childs << lambda do |token|',
+                         '  token << 1',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned to global variable' do
-            inspect_source(cop,
-                           ['$variable = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'accepts end aligned with a method call with arguments' do
+          inspect_source(cop,
+                         ['@h[:f] = f.each_pair.map do |f, v|',
+                         '  v = 1',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'accepts end aligned with the method when return value is assigned to constant' do
-            inspect_source(cop,
-                           ['CONSTANT = test do |ala|',
-                            '           end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'registers an offence for mismatched end with a method call with arguments' do
+          inspect_source(cop,
+                         ['@h[:f] = f.each_pair.map do |f, v|',
+                         '  v = 1',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned to constant' do
-            inspect_source(cop,
-                           ['Module::CONSTANT = test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'does not raise an error for nested block in a method call' do
+          inspect_source(cop,
+                         ['expect(arr.all? { |o| o.valid? })'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'accepts end aligned with the method when return value is assigned to attribute writer method' do
-            inspect_source(cop,
-                           ['parser.child.consumer = lambda do |token|',
-                            '                          token << 1',
-                            '                        end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'accepts end aligned with the outermost method in the method chain that calls the block' do
+          inspect_source(cop,
+                         ['expect(arr.all? do |o|',
+                         '  o.valid?',
+                         'end)'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned to attribute writer method' do
-            inspect_source(cop,
-                           ['parser.child.consumer = lambda do |token|',
-                            '  token << 1',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'registers an offence for mismatched end aligned with the outermost method in the method chain that calls the block' do
+          inspect_source(cop,
+                         ['expect(arr.all? do |o|',
+                         '  o.valid?',
+                         '  end)'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'accepts end aligned with the method when return value is assigned using op-asgn (+=, -=)' do
-            inspect_source(cop,
-                           ['rb += files.select do |file|',
-                            '        file << something',
-                            '      end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'accepts end aligned with an op-asgn (+=, -=)' do
+          inspect_source(cop,
+                         ['rb += files.select do |file|',
+                         '  file << something',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned using op-asgn (+=, -=)' do
-            inspect_source(cop,
-                           ['rb += files.select do |file|',
-                            '  file << something',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'registers an offence for mismatched block end with an op-asgn (+=, -=)' do
+          inspect_source(cop,
+                         ['rb += files.select do |file|',
+                         '  file << something',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'accepts end aligned with the method when return value is assigned using and-asgn (&&=)' do
-            inspect_source(cop,
-                           ['variable &&= test do |ala|',
-                            '             end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'accepts end aligned with an and-asgn (&&=)' do
+          inspect_source(cop,
+                         ['variable &&= test do |ala|',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned using and-asgn (&&=)' do
-            inspect_source(cop,
-                           ['variable &&= test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'registers an offence for mismatched block end with an and-asgn (&&=)' do
+          inspect_source(cop,
+                         ['variable &&= test do |ala|',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'accepts end aligned with the method when return value is assigned using or-asgn (||=)' do
-            inspect_source(cop,
-                           ['variable ||= test do |ala|',
-                            '             end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'accepts end aligned with an or-asgn (||=)' do
+          inspect_source(cop,
+                         ['variable ||= test do |ala|',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned using or-asgn (||=)' do
-            inspect_source(cop,
-                           ['variable ||= test do |ala|',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'registers an offence for mismatched block end with an or-asgn (||=)' do
+          inspect_source(cop,
+                         ['variable ||= test do |ala|',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
+        end
 
-          it 'accepts end aligned with the method when return value is assigned using mass assignment' do
-            inspect_source(cop,
-                           ['var1, var2 = lambda do |test|',
-                            '               [1, 2]',
-                            '             end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+        it 'accepts end aligned with a mass assignment' do
+          inspect_source(cop,
+                         ['var1, var2 = lambda do |test|',
+                         '  [1, 2]',
+                         'end'
+                         ])
+          expect(cop.offences).to be_empty
+        end
 
-          it 'registers an offence for mismatched block end when return value is assigned using mass assignment' do
-            inspect_source(cop,
-                           ['var1, var2 = lambda do |test|',
-                            '  [1, 2]',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
+        it 'registers an offence for mismatched block end with a mass assignment' do
+          inspect_source(cop,
+                         ['var1, var2 = lambda do |test|',
+                         '  [1, 2]',
+                         '  end'
+                         ])
+          expect(cop.offences.size).to eq(1)
         end
       end
     end