rubocop 0.12.0 → 0.13.0

data/lib/rubocop/cop/variable_inspector/variable_table.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      # A VariableTable manages the lifetime of all scopes and local variables
+      # in a program.
+      # This holds scopes as stack structure, and provides a way to add local
+      # variables to current scope and find local variables by considering
+      # variable visibility of the current scope.
+      class VariableTable
+        def initialize(hook_receiver = nil)
+          @hook_receiver = hook_receiver
+        end
+
+        def invoke_hook(hook_name, *args)
+          @hook_receiver.send(hook_name, *args) if @hook_receiver
+        end
+
+        def scope_stack
+          @scope_stack ||= []
+        end
+
+        def push_scope(scope_node)
+          scope = Scope.new(scope_node)
+          invoke_hook(:before_entering_scope, scope)
+          scope_stack.push(scope)
+          invoke_hook(:after_entering_scope, scope)
+          scope
+        end
+
+        def pop_scope
+          scope = current_scope
+          invoke_hook(:before_leaving_scope, scope)
+          scope_stack.pop
+          invoke_hook(:after_leaving_scope, scope)
+          scope
+        end
+
+        def current_scope
+          scope_stack.last
+        end
+
+        def current_scope_level
+          scope_stack.count
+        end
+
+        def declare_variable(name, node)
+          variable = Variable.new(name, node, current_scope)
+          invoke_hook(:before_declaring_variable, variable)
+          current_scope.variables[variable.name] = variable
+          invoke_hook(:after_declaring_variable, variable)
+          variable
+        end
+
+        def assign_to_variable(name, node)
+          variable = find_variable(name)
+
+          unless variable
+            fail "Assigning to undeclared local variable \"#{name}\" " +
+                 "at #{node.loc.expression}, #{node.inspect}"
+          end
+
+          variable.assign(node)
+          mark_variable_as_captured_by_block_if_so(variable)
+        end
+
+        def reference_variable(name, node)
+          variable = find_variable(name)
+
+          # In this code:
+          #
+          #   foo = 1 unless foo
+          #
+          #   (if
+          #     (lvar :foo) nil
+          #     (lvasgn :foo
+          #       (int 1)))
+          #
+          # Parser knows whether the foo is a variable or method invocation.
+          # This means that if a :lvar node is shown in AST, the variable is
+          # assumed to be already declared, even if we haven't seen any :lvasgn
+          # or :arg node before the :lvar node.
+          #
+          # We don't invoke #declare_variable here otherwise
+          # Variable#declaration_node will be :lvar node, that is actually not.
+          # So just skip.
+          return unless variable
+
+          variable.reference!(node)
+          mark_variable_as_captured_by_block_if_so(variable)
+        end
+
+        def find_variable(name)
+          name = name.to_sym
+
+          scope_stack.reverse_each do |scope|
+            variable = scope.variables[name]
+            return variable if variable
+            # Only block scope allows referencing outer scope variables.
+            return nil unless scope.node.type == :block
+          end
+
+          nil
+        end
+
+        def variable_exist?(name)
+          !find_variable(name).nil?
+        end
+
+        def accessible_variables
+          scope_stack.reverse_each.reduce([]) do |variables, scope|
+            variables.concat(scope.variables.values)
+            break variables unless scope.node.type == :block
+            variables
+          end
+        end
+
+        private
+
+        def mark_variable_as_captured_by_block_if_so(variable)
+          return unless current_scope.node.type == :block
+          return if variable.scope == current_scope
+          variable.capture_with_block!
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/json_formatter.rb

@@ -13,8 +13,8 @@ module Rubocop
         super
         @output_hash = {
           metadata: metadata_hash,
-             files: [],
-           summary: { offence_count: 0 }
+          files:    [],
+          summary:  { offence_count: 0 }
         }
       end
 
@@ -35,16 +35,16 @@ module Rubocop
       def metadata_hash
         {
           rubocop_version: Rubocop::Version::STRING,
-              ruby_engine: RUBY_ENGINE,
-             ruby_version: RUBY_VERSION,
+          ruby_engine:     RUBY_ENGINE,
+          ruby_version:    RUBY_VERSION,
           ruby_patchlevel: RUBY_PATCHLEVEL.to_s,
-            ruby_platform: RUBY_PLATFORM
+          ruby_platform:   RUBY_PLATFORM
         }
       end
 
       def hash_for_file(file, offences)
         {
-              path: relative_path(file),
+          path:     relative_path(file),
           offences: offences.map { |o| hash_for_offence(o) }
         }
       end
@@ -52,7 +52,7 @@ module Rubocop
       def hash_for_offence(offence)
         {
           severity: offence.severity,
-           message: offence.message,
+          message:  offence.message,
           cop_name: offence.cop_name,
           location: hash_for_location(offence)
         }
@@ -61,7 +61,7 @@ module Rubocop
       # TODO: Consider better solution for Offence#real_column.
       def hash_for_location(offence)
         {
-            line: offence.line,
+          line:   offence.line,
           column: offence.real_column
         }
       end

data/lib/rubocop/formatter/progress_formatter.rb

@@ -7,11 +7,11 @@ module Rubocop
     # appends the regular report data in the clang style format.
     class ProgressFormatter < ClangStyleFormatter
       COLOR_FOR_SEVERITY = {
-          refactor: :yellow,
+        refactor:   :yellow,
         convention: :yellow,
-           warning: :magenta,
-             error: :red,
-             fatal: :red
+        warning:    :magenta,
+        error:      :red,
+        fatal:      :red
       }
 
       def started(target_files)

data/lib/rubocop/processed_source.rb

@@ -17,11 +17,32 @@ module Rubocop
     end
 
     def lines
-      @lines ||= @buffer.source.split($RS)
+      if @lines
+        @lines
+      else
+        init_lines
+        @lines
+      end
+    end
+
+    def raw_lines
+      if @raw_lines
+        @raw_lines
+      else
+        init_lines
+        @raw_lines
+      end
     end
 
     def [](*args)
       lines[*args]
     end
+
+    private
+
+    def init_lines
+      @raw_lines = @buffer.source.lines
+      @lines = @raw_lines.map(&:chomp)
+    end
   end
 end

data/lib/rubocop/version.rb

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

data/rubocop.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency('rainbow', '>= 1.1.4')
   s.add_runtime_dependency('parser', '~> 2.0.0.pre6')
   s.add_runtime_dependency('backports', '~> 3.3.3')
-  s.add_runtime_dependency('powerpack', '~> 0.0.3')
+  s.add_runtime_dependency('powerpack', '~> 0.0.6')
   s.add_development_dependency('rake', '~> 10.1')
   s.add_development_dependency('rspec', '~> 2.14')
   s.add_development_dependency('yard', '~> 0.8')

data/spec/rubocop/cli_spec.rb

@@ -8,7 +8,7 @@ module Rubocop
   describe CLI, :isolated_environment do
     include FileHelper
 
-    let(:cli) { CLI.new }
+    subject(:cli) { CLI.new }
 
     before(:each) do
       $stdout = StringIO.new
@@ -369,9 +369,6 @@ Usage: rubocop [options] [file1, file2, ...]
                                  "\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',
                       '--only', 'IfUnlessModifier', 'example.rb'])).to eq(1)
@@ -390,9 +387,6 @@ Usage: rubocop [options] [file1, file2, ...]
                                  "\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)
@@ -410,45 +404,51 @@ Usage: rubocop [options] [file1, file2, ...]
       expect($stderr.string).to eq("Unrecognized cop name: 123.\n")
     end
 
-    context '--show-cops' do
+    describe '--show-cops option' do
       let(:cops) { Cop::Cop.all }
+
       let(:global_conf) do
         config_path = Rubocop::Config.configuration_file_for(Dir.pwd.to_s)
         Rubocop::Config.configuration_from_file(config_path)
       end
+
+      let(:stdout) { $stdout.string }
+
       before do
-        cops.each do |cop_class|
-          cop_class.config = global_conf.for_cop(cop_class.cop_name)
-        end
+        expect { cli.run ['--show-cops'] }.to exit_with_code(0)
       end
 
-      subject do
-        expect { cli.run ['--show-cops'] }.to exit_with_code(0)
-        @stdout = $stdout.string
+      # Extracts the first line out of the description
+      def short_description_of_cop(cop)
+        desc = full_description_of_cop(cop)
+        desc ? desc.lines.first.strip : ''
+      end
+
+      # Gets the full description of the cop or nil if no description is set.
+      def full_description_of_cop(cop)
+        cop_config = global_conf.for_cop(cop)
+        cop_config['Description']
       end
+
       it 'prints all available cops and their description' do
-        subject
         cops.each do |cop|
-          expect(@stdout).to include cop.cop_name
-          expect(@stdout).to include cop.short_description
+          expect(stdout).to include cop.cop_name
+          expect(stdout).to include short_description_of_cop(cop)
         end
       end
 
       it 'prints all types' do
-        subject
         cops
           .types
-          .dup
-          .map!(&:to_s)
-          .map!(&:capitalize)
-          .each { |type| expect(@stdout).to include(type) }
+          .map(&:to_s)
+          .map(&:capitalize)
+          .each { |type| expect(stdout).to include(type) }
       end
 
       it 'prints all cops in their right type listing' do
-        subject
-        lines = @stdout.lines
+        lines = stdout.lines
         lines.slice_before(/Type /).each do |slice|
-          types = cops.types.dup.map!(&:to_s).map!(&:capitalize)
+          types = cops.types.map(&:to_s).map(&:capitalize)
           current = types.delete(slice.shift[/Type '(?<c>[^'']+)'/, 'c'])
           # all cops in their type listing
           cops.with_type(current).each do |cop|
@@ -465,14 +465,13 @@ Usage: rubocop [options] [file1, file2, ...]
       end
 
       it 'prints the current configuration' do
-        subject
-        out = @stdout.lines.to_a
+        out = stdout.lines.to_a
         cops.each do |cop|
           conf = global_conf[cop.cop_name].dup
           confstrt = out.find_index { |i| i.include?("- #{cop.cop_name}") } + 1
           c = out[confstrt, conf.keys.size].to_s
           conf.delete('Description')
-          expect(c).to include(cop.short_description)
+          expect(c).to include(short_description_of_cop(cop))
           conf.each do |k, v|
             # ugly hack to get hash/array content tested
             if v.kind_of?(Hash) || v.kind_of?(Array)
@@ -480,7 +479,6 @@ Usage: rubocop [options] [file1, file2, ...]
             else
               expect(c).to include "#{k}: #{v}"
             end
-
           end
         end
       end
@@ -792,12 +790,16 @@ Usage: rubocop [options] [file1, file2, ...]
     it 'registers an offence for Parser warnings' do
       create_file('example.rb', [
                                  '# encoding: utf-8',
-                                 'puts *test'
+                                 'puts *test',
+                                 'if a then b else c end'
                                 ])
       expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
       expect($stdout.string)
         .to eq(["#{abs('example.rb')}:2:6: W: " +
                 "`*' interpreted as argument prefix",
+                "#{abs('example.rb')}:3:1: C: " +
+                'Favor the ternary operator (?:) over if/then/else/end ' +
+                'constructs.',
                 ''].join("\n"))
     end
 

data/spec/rubocop/config_spec.rb

@@ -296,9 +296,8 @@ describe Rubocop::Config do
       end
 
       it 'raises validation error' do
-        expect do
-          configuration.validate
-        end.to raise_error(Rubocop::Config::ValidationError) do |error|
+        e = Rubocop::Config::ValidationError
+        expect { configuration.validate }.to raise_error(e) do |error|
           expect(error.message).to start_with('unrecognized cop LyneLenth')
         end
       end
@@ -314,9 +313,8 @@ describe Rubocop::Config do
       end
 
       it 'raises validation error' do
-        expect do
-          configuration.validate
-        end.to raise_error(Rubocop::Config::ValidationError) do |error|
+        e = Rubocop::Config::ValidationError
+        expect { configuration.validate }.to raise_error(e) do |error|
           expect(error.message).to
             start_with('unrecognized parameter LineLength:Min')
         end

data/spec/rubocop/cop/commissioner_spec.rb

@@ -7,8 +7,11 @@ module Rubocop
   module Cop
     describe Commissioner do
       describe '#investigate' do
+        let(:cop) { double(Cop, offences: []).as_null_object }
+
         it 'returns all offences found by the cops' do
-          cop = double(Cop, offences: [1])
+          cop.stub(:offences).and_return([1])
+
           commissioner = Commissioner.new([cop])
           source = []
           processed_source = parse_source(source)
@@ -17,7 +20,6 @@ module Rubocop
         end
 
         it 'traverses the AST and invoke cops specific callbacks' do
-          cop = double(Cop, offences: [])
           cop.should_receive(:on_def)
 
           commissioner = Commissioner.new([cop])
@@ -30,7 +32,6 @@ module Rubocop
         it 'passes the input params to all cops that implement their own #investigate method' do
           source = []
           processed_source = parse_source(source)
-          cop = double(Cop, offences: [])
           cop.should_receive(:investigate).with(processed_source)
 
           commissioner = Commissioner.new([cop])
@@ -39,7 +40,6 @@ module Rubocop
         end
 
         it 'stores all errors raised by the cops' do
-          cop = double(Cop, offences: [])
           cop.stub(:on_def) { raise RuntimeError }
 
           commissioner = Commissioner.new([cop])
@@ -54,7 +54,6 @@ module Rubocop
 
         context 'when passed :raise_error option' do
           it 're-raises the exception received while processing' do
-            cop = double(Cop, offences: [])
             cop.stub(:on_def) { raise RuntimeError }
 
             commissioner = Commissioner.new([cop], raise_error: true)