rubocop 0.14.0 → 0.14.1

data/lib/rubocop/config_store.rb

@@ -20,20 +20,20 @@ module Rubocop
     end
 
     def set_options_config(options_config)
-      loaded_config = Config.load_file(options_config)
-      @options_config = Config.merge_with_default(loaded_config,
-                                                  options_config)
+      loaded_config = ConfigLoader.load_file(options_config)
+      @options_config = ConfigLoader.merge_with_default(loaded_config,
+                                                        options_config)
     end
 
     def for(file)
       return @options_config if @options_config
 
       dir = File.dirname(file)
-      @path_cache[dir] ||= Config.configuration_file_for(dir)
+      @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
       path = @path_cache[dir]
       @object_cache[path] ||= begin
-                                print "For #{dir}: " if Config.debug?
-                                Config.configuration_from_file(path)
+                                print "For #{dir}: " if ConfigLoader.debug?
+                                ConfigLoader.configuration_from_file(path)
                               end
     end
   end

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

@@ -12,24 +12,20 @@ module Rubocop
         def on_hash(node)
           first_pair = node.children.first
 
-          if [cop_config['EnforcedHashRocketStyle'],
-              cop_config['EnforcedColonStyle']].include?('table')
+          styles = [cop_config['EnforcedHashRocketStyle'],
+                    cop_config['EnforcedColonStyle']]
 
-            lines_of_the_children = node.children.map do |pair|
-              key, _value = *pair
-              key.loc.line
-            end
-            on_the_same_line = lines_of_the_children.uniq.size == 1
-            return if on_the_same_line
+          if styles.include?('table') || styles.include?('separator')
+            return if any_pairs_on_the_same_line?(node)
+          end
 
+          if styles.include?('table')
             key_widths = node.children.map do |pair|
               key, _value = *pair
               key.loc.expression.source.length
             end
             @max_key_width = key_widths.max
-            if first_pair && !on_the_same_line &&
-              value_delta(nil, first_pair, @max_key_width) != 0
-
+            if first_pair && value_delta(nil, first_pair, @max_key_width) != 0
               @column_deltas = {}
               convention(first_pair, :expression)
             end
@@ -41,6 +37,14 @@ module Rubocop
           end
         end
 
+        def any_pairs_on_the_same_line?(node)
+          lines_of_the_children = node.children.map do |pair|
+            key, _value = *pair
+            key.loc.line
+          end
+          lines_of_the_children.uniq.size < lines_of_the_children.size
+        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

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for braces in method calls with hash parameters.
+      class BracesAroundHashParameters < Cop
+        def on_send(node)
+          _receiver, method_name, *args = *node
+
+          return unless args.size == 1
+          # discard attr writer methods.
+          return if method_name.to_s.end_with?('=')
+          # discard operator methods
+          return if OPERATOR_METHODS.include?(method_name)
+
+          # we care only for the first argument
+          arg = args.first
+          return unless arg && arg.type == :hash && arg.children.any?
+
+          has_braces = !arg.loc.begin.nil?
+
+          if style == :no_braces && has_braces
+            convention(arg,
+                       :expression,
+                       'Redundant curly braces around a hash parameter.')
+          elsif style == :braces && !has_braces
+            convention(arg,
+                       :expression,
+                       'Missing curly braces around a hash parameter.')
+          end
+        end
+
+        private
+
+        def style
+          case cop_config['EnforcedStyle']
+          when 'braces' then :braces
+          when 'no_braces' then :no_braces
+          else fail 'Unknown style selected!'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,8 @@ module Rubocop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class ClassLength < Cop
+        include Util
+
         MSG = 'Class definition is too long. [%d/%d]'
 
         def on_class(node)
@@ -24,14 +26,35 @@ module Rubocop
         private
 
         def check(node)
-          method_length = Util.source_length(node.loc.expression.source,
-                                             count_comments?)
+          class_body_line_numbers = line_range(node).to_a[1...-1]
+
+          target_line_numbers = class_body_line_numbers -
+                                  line_numbers_of_inner_classes(node)
 
-          if method_length > max_length
-            message = sprintf(MSG, method_length, max_length)
+          class_length = target_line_numbers.reduce(0) do |length, line_number|
+            source_line = processed_source[line_number]
+            next length if source_line.blank?
+            next length if !count_comments? && comment_line?(source_line)
+            length + 1
+          end
+
+          if class_length > max_length
+            message = sprintf(MSG, class_length, max_length)
             convention(node, :keyword, message)
           end
         end
+
+        def line_numbers_of_inner_classes(node)
+          line_numbers = Set.new
+
+          on_node([:class, :module], node) do |inner_node|
+            next if inner_node.eql?(node)
+            line_range = line_range(inner_node)
+            line_numbers.merge(line_range)
+          end
+
+          line_numbers.to_a
+        end
       end
     end
   end

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

@@ -19,41 +19,39 @@ module Rubocop
             processed_source.comments
           )
 
-          check_classes(ast, ast_with_comments)
-          check_modules(ast, ast_with_comments)
+          check(ast, ast_with_comments)
         end
 
         private
 
-        def check_classes(ast, ast_with_comments)
-          on_node(:class, ast) do |node|
-            _name, _superclass, body = *node
-
-            if body && ast_with_comments[node].empty?
-              convention(node, :keyword, format(MSG, 'class'))
+        def check(ast, ast_with_comments)
+          on_node([:class, :module], ast) do |node|
+            case node.type
+            when :class
+              _name, _superclass, body = *node
+            when :module
+              _name, body = *node
             end
+
+            next if node.type == :class && !body
+            next if namespace?(body)
+            next unless ast_with_comments[node].empty?
+            convention(node, :keyword, format(MSG, node.type.to_s))
           end
         end
 
-        def check_modules(ast, ast_with_comments)
-          on_node(:module, ast) do |node|
-            _name, body = *node
-
-            if body.nil?
-              namespace = false
-            elsif body.type == :begin
-              namespace = body.children.all? do |n|
-                [:class, :module].include?(n.type)
-              end
-            elsif body.type == :class || body.type == :module
-              namespace = true
-            else
-              namespace = false
-            end
+        def namespace?(body_node)
+          return false unless body_node
 
-            if !namespace && ast_with_comments[node].empty?
-              convention(node, :keyword, format(MSG, 'module'))
+          case body_node.type
+          when :begin
+            body_node.children.all? do |node|
+              [:class, :module].include?(node.type)
             end
+          when :class, :module
+            true
+          else
+            false
           end
         end
       end

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

@@ -34,7 +34,12 @@ module Rubocop
           arg, = *args
 
           if arg.type == :send && arg.loc.selector.is?('new')
-            convention(node, :expression, message(selector))
+            _receiver, _selector, *constructor_args = *arg
+
+            # Allow code like `raise Ex.new(arg1, arg2)`.
+            unless constructor_args.size > 1
+              convention(node, :expression, message(selector))
+            end
           end
         end
 

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for space after `!`.
+      #
+      # @example
+      #   # bad
+      #   ! something
+      #
+      #   # good
+      #   !something
+      class SpaceAfterNot < Cop
+        MSG = 'Do not leave space between `!` and its argument.'
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+
+          return unless method_name == :!
+
+          if node.loc.expression.source =~ /^!\s+\w+/
+            # TODO: Improve source range to highlight the redundant whitespace.
+            convention(node, :selector)
+          end
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.expression,
+                              node.loc.expression.source.gsub(/\A!\s+/, '!'))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/util.rb

@@ -30,11 +30,28 @@ module Rubocop
 
         lines.reject!(&:blank?)
 
-        lines.reject! { |line| line =~ /^\s*#/ } unless count_comments
+        lines.reject! { |line| comment_line?(line) } unless count_comments
 
         lines.size
       end
 
+      def comment_line?(line_source)
+        line_source =~ /^\s*#/
+      end
+
+      def line_range(arg)
+        source_range = case arg
+                       when Parser::Source::Range
+                         arg
+                       when Parser::AST::Node
+                         arg.loc.expression
+                       else
+                         fail ArgumentError, "Invalid argument #{arg}"
+                       end
+
+        source_range.begin.line..source_range.end.line
+      end
+
       def const_name(node)
         return nil if node.nil? || node.type != :const
 

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -16,11 +16,20 @@ module Rubocop
 
           unless source_line.blank?
             output.puts(source_line)
-            output.puts(' ' * o.location.column +
-                        '^' * o.location.column_range.count)
+            output.puts(highlight_line(o.location))
           end
         end
       end
+
+      def highlight_line(location)
+        column_length = if location.begin.line == location.end.line
+                          location.column_range.count
+                        else
+                          location.source_line.length - location.column
+                        end
+
+        ' ' * location.column + '^' * column_length
+      end
     end
   end
 end

data/lib/rubocop/options.rb

@@ -38,7 +38,7 @@ module Rubocop
           @options[:formatters] = [
                                    [DEFAULT_FORMATTER],
                                    [Formatter::DisabledConfigFormatter,
-                                    Config::AUTO_GENERATED_FILE]
+                                    ConfigLoader::AUTO_GENERATED_FILE]
                                   ]
           validate_auto_gen_config_option(args)
         end
@@ -148,8 +148,8 @@ module Rubocop
       target_finder.find(args).each do |file|
         config = @config_store.for(file)
         if @options[:auto_gen_config] && config.contains_auto_generated_config
-          fail "Remove #{Config::AUTO_GENERATED_FILE} from the current " +
-            'configuration before generating it again.'
+          fail "Remove #{ConfigLoader::AUTO_GENERATED_FILE} from the " +
+            'current configuration before generating it again.'
         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.14.0'
+    STRING = '0.14.1'
 
     MSG = '%s (using Parser %s, running on %s %s %s)'
 

data/spec/project_spec.rb

@@ -6,12 +6,12 @@ describe 'RuboCop Project' do
   describe 'default configuration file' do
     it 'has configuration for all cops' do
       cop_names = Rubocop::Cop::Cop.all.map(&:cop_name)
-      expect(Rubocop::Config.load_file('config/default.yml').keys.sort)
+      expect(Rubocop::ConfigLoader.load_file('config/default.yml').keys.sort)
         .to eq((['AllCops'] + cop_names).sort)
     end
     it 'has a description for all cops' do
       cop_names = Rubocop::Cop::Cop.all.map(&:cop_name)
-      conf = Rubocop::Config.load_file('config/default.yml')
+      conf = Rubocop::ConfigLoader.load_file('config/default.yml')
       cop_names.each do |name|
         expect(conf[name]['Description']).not_to be_nil
       end

data/spec/rubocop/cli_spec.rb

@@ -12,7 +12,7 @@ describe Rubocop::CLI, :isolated_environment do
   before(:each) do
     $stdout = StringIO.new
     $stderr = StringIO.new
-    Rubocop::Config.debug = false
+    Rubocop::ConfigLoader.debug = false
   end
 
   after(:each) do

data/spec/rubocop/config_loader_spec.rb

@@ -0,0 +1,314 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+DEFAULT_CONFIG = Rubocop::ConfigLoader.load_file('config/default.yml')
+
+describe Rubocop::ConfigLoader do
+  include FileHelper
+
+  describe '.configuration_file_for', :isolated_environment do
+    subject(:configuration_file_for) do
+      described_class.configuration_file_for(dir_path)
+    end
+
+    context 'when no config file exists in ancestor directories' do
+      let(:dir_path) { 'dir' }
+      before { create_file('dir/example.rb', '') }
+
+      context 'but a config file exists in home directory' do
+        before { create_file('~/.rubocop.yml', '') }
+
+        it 'returns the path to the file in home directory' do
+          expect(configuration_file_for).to end_with('home/.rubocop.yml')
+        end
+      end
+
+      context 'and no config file exists in home directory' do
+        it 'falls back to the provided default file' do
+          expect(configuration_file_for).to end_with('config/default.yml')
+        end
+      end
+    end
+
+    context 'when a config file exists in the parent directory' do
+      let(:dir_path) { 'dir' }
+
+      before do
+        create_file('dir/example.rb', '')
+        create_file('.rubocop.yml', '')
+      end
+
+      it 'returns the path to that configuration file' do
+        expect(configuration_file_for).to end_with('work/.rubocop.yml')
+      end
+    end
+
+    context 'when multiple config files exist in ancestor directories' do
+      let(:dir_path) { 'dir' }
+
+      before do
+        create_file('dir/example.rb', '')
+        create_file('dir/.rubocop.yml', '')
+        create_file('.rubocop.yml', '')
+      end
+
+      it 'prefers closer config file' do
+        expect(configuration_file_for).to end_with('dir/.rubocop.yml')
+      end
+    end
+  end
+
+  describe '.configuration_from_file', :isolated_environment do
+    subject(:configuration_from_file) do
+      described_class.configuration_from_file(file_path)
+    end
+
+    context 'with any config file' do
+      let(:file_path) { '.rubocop.yml' }
+
+      before do
+        create_file(file_path, ['Encoding:',
+                                '  Enabled: false'])
+      end
+      it 'returns a configuration inheriting from default.yml' do
+        config = DEFAULT_CONFIG['Encoding'].dup
+        config['Enabled'] = false
+        expect(configuration_from_file)
+          .to eql(DEFAULT_CONFIG.merge('Encoding' => config))
+      end
+    end
+
+    context 'when multiple config files exist in ancestor directories' do
+      let(:file_path) { 'dir/.rubocop.yml' }
+
+      before do
+        create_file('.rubocop.yml',
+                    ['AllCops:',
+                     '  Excludes:',
+                     '    - vendor/**',
+                    ])
+
+        create_file(file_path,
+                    ['AllCops:',
+                     '  Excludes: []',
+                    ])
+      end
+
+      it 'gets AllCops/Excludes from the highest directory level' do
+        excludes = configuration_from_file['AllCops']['Excludes']
+        expect(excludes).to eq([File.expand_path('vendor/**')])
+      end
+    end
+
+    context 'when a file inherits from a parent file' do
+      let(:file_path) { 'dir/.rubocop.yml' }
+
+      before do
+        create_file('.rubocop.yml',
+                    ['AllCops:',
+                     '  Excludes:',
+                     '    - vendor/**',
+                     '    - !ruby/regexp /[A-Z]/',
+                    ])
+
+        create_file(file_path, ['inherit_from: ../.rubocop.yml'])
+      end
+
+      it 'gets an absolute AllCops/Excludes' do
+        excludes = configuration_from_file['AllCops']['Excludes']
+        expect(excludes).to eq([File.expand_path('vendor/**'), /[A-Z]/])
+      end
+    end
+
+    context 'when a file inherits from a sibling file' do
+      let(:file_path) { 'dir/.rubocop.yml' }
+
+      before do
+        create_file('src/.rubocop.yml',
+                    ['AllCops:',
+                     '  Excludes:',
+                     '    - vendor/**',
+                    ])
+
+        create_file(file_path, ['inherit_from: ../src/.rubocop.yml'])
+      end
+
+      it 'gets an absolute AllCops/Exclude' do
+        excludes = configuration_from_file['AllCops']['Excludes']
+        expect(excludes).to eq([File.expand_path('src/vendor/**')])
+      end
+    end
+
+    context 'when a file inherits from a parent and grandparent file' do
+      let(:file_path) { 'dir/subdir/.rubocop.yml' }
+
+      before do
+        create_file('dir/subdir/example.rb', '')
+
+        create_file('.rubocop.yml',
+                    ['LineLength:',
+                     '  Enabled: false',
+                     '  Max: 77'])
+
+        create_file('dir/.rubocop.yml',
+                    ['inherit_from: ../.rubocop.yml',
+                     '',
+                     'MethodLength:',
+                     '  Enabled: true',
+                     '  CountComments: false',
+                     '  Max: 10'
+                    ])
+
+        create_file(file_path,
+                    ['inherit_from: ../.rubocop.yml',
+                     '',
+                     'LineLength:',
+                     '  Enabled: true',
+                     '',
+                     'MethodLength:',
+                     '  Max: 5'
+                    ])
+      end
+
+      it 'returns the ancestor configuration plus local overrides' do
+        config = DEFAULT_CONFIG
+                   .merge('LineLength' => {
+                          'Description' =>
+                             DEFAULT_CONFIG['LineLength']['Description'],
+                          'Enabled' => true,
+                          'Max' => 77
+                          },
+                          'MethodLength' => {
+                            'Description' =>
+                               DEFAULT_CONFIG['MethodLength']['Description'],
+                            'Enabled' => true,
+                            'CountComments' => false,
+                            'Max' => 5
+                          })
+        expect(configuration_from_file).to eq(config)
+      end
+    end
+
+    context 'when a file inherits from two configurations' do
+      let(:file_path) { '.rubocop.yml' }
+
+      before do
+        create_file('example.rb', '')
+
+        create_file('normal.yml',
+                    ['MethodLength:',
+                     '  Enabled: false',
+                     '  CountComments: true',
+                     '  Max: 79'])
+
+        create_file('special.yml',
+                    ['MethodLength:',
+                     '  Enabled: false',
+                     '  Max: 200'])
+
+        create_file(file_path,
+                    ['inherit_from:',
+                     '  - normal.yml',
+                     '  - special.yml',
+                     '',
+                     'MethodLength:',
+                     '  Enabled: true'
+                    ])
+      end
+
+      it 'returns values from the last one when possible' do
+        expected = { 'Enabled' => true,        # overridden in .rubocop.yml
+                     'CountComments' => true,  # only defined in normal.yml
+                     'Max' => 200 }            # special.yml takes precedence
+        expect(configuration_from_file['MethodLength'].to_set)
+          .to be_superset(expected.to_set)
+      end
+    end
+  end
+
+  describe '.load_file', :isolated_environment do
+    subject(:load_file) do
+      described_class.load_file(configuration_path)
+    end
+
+    let(:configuration_path) { '.rubocop.yml' }
+
+    it 'returns a configuration loaded from the passed path' do
+      create_file(configuration_path, [
+        'Encoding:',
+        '  Enabled: true',
+      ])
+      configuration = load_file
+      expect(configuration['Encoding']).to eq(
+        'Enabled' => true
+      )
+    end
+  end
+
+  describe '.merge' do
+    subject(:merge) { described_class.merge(base, derived) }
+
+    let(:base) do
+      {
+        'AllCops' => {
+          'Includes' => ['**/*.gemspec', '**/Rakefile'],
+          'Excludes' => []
+        }
+      }
+    end
+    let(:derived) do
+      { 'AllCops' => { 'Excludes' => ['example.rb', 'exclude_*'] } }
+    end
+
+    it 'returns a recursive merge of its two arguments' do
+      expect(merge).to eq('AllCops' => {
+                            'Includes' => ['**/*.gemspec', '**/Rakefile'],
+                            'Excludes' => ['example.rb', 'exclude_*']
+                          })
+    end
+  end
+
+  describe 'configuration for SymbolArray', :isolated_environment do
+    let(:config) do
+      config_path = described_class.configuration_file_for('.')
+      described_class.configuration_from_file(config_path)
+    end
+
+    context 'when no config file exists for the target file' do
+      it 'is disabled' do
+        expect(config.cop_enabled?('SymbolArray')).to be_false
+      end
+    end
+
+    context 'when a config file which does not mention SymbolArray exists' do
+      it 'is disabled' do
+        create_file('.rubocop.yml', [
+          'LineLength:',
+          '  Max: 79'
+        ])
+        expect(config.cop_enabled?('SymbolArray')).to be_false
+      end
+    end
+
+    context 'when a config file which explicitly enables SymbolArray exists' do
+      it 'is enabled' do
+        create_file('.rubocop.yml', [
+          'SymbolArray:',
+          '  Enabled: true'
+        ])
+        expect(config.cop_enabled?('SymbolArray')).to be_true
+      end
+    end
+  end
+
+  describe 'configuration for SymbolName' do
+    describe 'AllowCamelCase' do
+      it 'is enabled by default' do
+        default_config = described_class.default_configuration
+        symbol_name_config = default_config.for_cop('SymbolName')
+        expect(symbol_name_config['AllowCamelCase']).to be_true
+      end
+    end
+  end
+end