rubocop 0.6.1 → 0.7.0

data/lib/rubocop/config.rb

@@ -0,0 +1,202 @@
+# encoding: utf-8
+
+require 'delegate'
+require 'yaml'
+require 'pathname'
+
+module Rubocop
+  class Config < DelegateClass(Hash)
+    class ValidationError < StandardError; end
+
+    DOTFILE = '.rubocop.yml'
+    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
+
+    attr_reader :loaded_path
+
+    class << self
+      def load_file(path)
+        hash = YAML.load_file(path)
+
+        base_configs(path, hash['inherit_from']).reverse.each do |base_config|
+          base_config.each do |key, value|
+            if value.is_a?(Hash)
+              hash[key] = hash.has_key?(key) ? merge(value, hash[key]) : value
+            end
+          end
+        end
+
+        hash.delete('inherit_from')
+        config = new(hash, File.realpath(path))
+        config.warn_unless_valid
+        config
+      end
+
+      # Return a recursive merge of two hashes. That is, a normal hash
+      # merge, with the addition that any value that is a hash, and
+      # occurs in both arguments, will also be merged. And so on.
+      def merge(base_hash, derived_hash)
+        result = {}
+        base_hash.each do |key, value|
+          result[key] = if derived_hash.has_key?(key)
+                          if value.is_a?(Hash)
+                            merge(value, derived_hash[key])
+                          else
+                            derived_hash[key]
+                          end
+                        else
+                          base_hash[key]
+                        end
+        end
+        derived_hash.each do |key, value|
+          result[key] = value unless base_hash.has_key?(key)
+        end
+        result
+      end
+
+      def base_configs(path, inherit_from)
+        base_files = case inherit_from
+                     when nil then []
+                     when String then [inherit_from]
+                     when Array then inherit_from
+                     end
+        base_files.map do |f|
+          f = File.join(File.dirname(path), f) unless f.start_with?('/')
+          load_file(f)
+        end
+      end
+
+      # Returns the path of .rubocop.yml searching upwards in the
+      # directory structure starting at the given directory where the
+      # inspected file is. If no .rubocop.yml is found there, the
+      # user's home directory is checked. If there's no .rubocop.yml
+      # there either, the path to the default file is returned.
+      def configuration_file_for(target_dir)
+        possible_config_files = dirs_to_search(target_dir).map do |dir|
+          File.join(dir, DOTFILE)
+        end
+
+        found_file = possible_config_files.find do |config_file|
+          File.exist?(config_file)
+        end
+        found_file || DEFAULT_FILE
+      end
+
+      def configuration_from_file(config_file)
+        config = load_file(config_file)
+        merge_with_default(config, config_file)
+      end
+
+      def merge_with_default(config, config_file)
+        default_config = load_file(DEFAULT_FILE)
+        new(merge(default_config, config), config_file)
+      end
+
+      private
+
+      def dirs_to_search(target_dir)
+        dirs_to_search = []
+        target_dir_pathname = Pathname.new(File.expand_path(target_dir))
+        target_dir_pathname.ascend do |dir_pathname|
+          dirs_to_search << dir_pathname.to_s
+        end
+        dirs_to_search << Dir.home
+        dirs_to_search
+      end
+    end
+
+    def initialize(hash = {}, loaded_path = nil)
+      @hash = hash
+      @loaded_path = loaded_path
+      super(@hash)
+    end
+
+    def for_cop(cop)
+      self[cop]
+    end
+
+    def cop_enabled?(cop)
+      self[cop].nil? || self[cop]['Enabled']
+    end
+
+    def warn_unless_valid
+      validate!
+    rescue Config::ValidationError => e
+      puts "Warning: #{e.message}".color(:red)
+    end
+
+    # TODO: This should be a private method
+    def validate!
+      # Don't validate RuboCop's own files. Avoids inifinite recursion.
+      return if @loaded_path.start_with?(RUBOCOP_HOME)
+
+      default_config = Config.load_file(DEFAULT_FILE)
+
+      valid_cop_names, invalid_cop_names = @hash.keys.partition do |key|
+        default_config.has_key?(key)
+      end
+
+      invalid_cop_names.each do |name|
+        fail ValidationError,
+             "unrecognized cop #{name} found in #{loaded_path || self}"
+      end
+
+      valid_cop_names.each do |name|
+        @hash[name].each_key do |param|
+          unless default_config[name].has_key?(param)
+            fail ValidationError,
+                 "unrecognized parameter #{name}:#{param} found " +
+                 "in #{loaded_path || self}"
+          end
+        end
+      end
+    end
+
+    def file_to_include?(file)
+      relative_file_path = relative_path_to_loaded_dir(file)
+      patterns_to_include.any? do |pattern|
+        match_path?(pattern, relative_file_path)
+      end
+    end
+
+    def file_to_exclude?(file)
+      relative_file_path = relative_path_to_loaded_dir(file)
+      patterns_to_exclude.any? do |pattern|
+        match_path?(pattern, relative_file_path)
+      end
+    end
+
+    def patterns_to_include
+      @hash['AllCops']['Includes']
+    end
+
+    def patterns_to_exclude
+      @hash['AllCops']['Excludes']
+    end
+
+    private
+
+    def relative_path_to_loaded_dir(file)
+      return file unless loaded_path
+      file_pathname = Pathname.new(File.expand_path(file))
+      file_pathname.relative_path_from(loaded_dir_pathname).to_s
+    end
+
+    def loaded_dir_pathname
+      return nil unless loaded_path
+      @loaded_dir ||= begin
+        loaded_dir = File.expand_path(File.dirname(loaded_path))
+        Pathname.new(loaded_dir)
+      end
+    end
+
+    def match_path?(pattern, path)
+      case pattern
+      when String
+        File.basename(path) == pattern || File.fnmatch(pattern, path)
+      when Regexp
+        path =~ pattern
+      end
+    end
+  end
+end

data/lib/rubocop/config_store.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module ConfigStore
+    module_function
+
+    def prepare
+      # @options_config stores a config that is specified in the command line.
+      # This takes precedence over configs located in any directories
+      @options_config = nil
+
+      # @path_cache maps directories to configuration paths. We search
+      # for .rubocop.yml only if we haven't already found it for the
+      # given directory.
+      @path_cache = {}
+
+      # @object_cache maps configuration file paths to
+      # configuration objects so we only need to load them once.
+      @object_cache = {}
+    end
+
+    def set_options_config(options_config)
+      loaded_config = Config.load_file(options_config)
+      @options_config = Config.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 = @path_cache[dir]
+      @object_cache[path] ||= Config.configuration_from_file(path)
+    end
+  end
+end

data/lib/rubocop/cop/alias.rb

@@ -6,11 +6,8 @@ module Rubocop
       ERROR_MESSAGE = 'Use alias_method instead of alias.'
 
       def inspect(file, source, tokens, sexp)
-        tokens.each_index do |ix|
-          t = tokens[ix]
-          if t.type == :on_kw && t.text == 'alias'
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-          end
+        each_keyword('alias', tokens) do |t|
+          add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
         end
       end
     end

data/lib/rubocop/cop/align_parameters.rb

@@ -105,7 +105,7 @@ module Rubocop
             end
           end
         end
-        offset = @tokens[start_ix..-1].index { |t| not whitespace?(t) }
+        offset = @tokens[start_ix..-1].index { |t| !whitespace?(t) }
         start_ix + offset
       end
     end

data/lib/rubocop/cop/array_literal.rb

@@ -6,16 +6,55 @@ module Rubocop
       ERROR_MESSAGE = 'Use array literal [] instead of Array.new.'
 
       def inspect(file, source, tokens, sexp)
+        offences = preliminary_scan(sexp)
+
+        # find Array.new()
         each(:method_add_arg, sexp) do |s|
-          potential_class = s[1][1][1]
+          next if s[1][0] != :call
+
+          receiver = s[1][1][1]
+          method_name = s[1][3][1]
 
-          if potential_class && potential_class[1] == 'Array' &&
-              s[1][3][1] == 'new' && s[2] == [:arg_paren, nil]
+          if receiver && receiver[1] == 'Array' &&
+              method_name == 'new' && s[2] == [:arg_paren, nil]
+            offences.delete(Offence.new(:convention,
+                                        receiver[2].lineno,
+                                        ERROR_MESSAGE))
             add_offence(:convention,
-                        potential_class[2].lineno,
+                        receiver[2].lineno,
                         ERROR_MESSAGE)
           end
+
+          # check for false positives
+          if receiver && receiver[1] == 'Array' &&
+              method_name == 'new' && s[2] != [:arg_paren, nil]
+            offences.delete(Offence.new(:convention,
+                                        receiver[2].lineno,
+                                        ERROR_MESSAGE))
+          end
+        end
+
+        offences.each { |o| add_offence(*o.explode) }
+      end
+
+      def preliminary_scan(sexp)
+        offences = []
+
+        # find Array.new
+        # there will be some false positives here, which
+        # we'll eliminate later on
+        each(:call, sexp) do |s|
+          receiver = s[1][1]
+
+          if receiver && receiver[1] == 'Array' &&
+              s[3][1] == 'new'
+            offences << Offence.new(:convention,
+                                    receiver[2].lineno,
+                                    ERROR_MESSAGE)
+          end
         end
+
+        offences
       end
     end
   end

data/lib/rubocop/cop/avoid_for.rb

@@ -6,10 +6,8 @@ module Rubocop
       ERROR_MESSAGE = 'Prefer *each* over *for*.'
 
       def inspect(file, source, tokens, sexp)
-        each(:for, sexp) do |s|
-          add_offence(:convention,
-                      s[1][1][2].lineno,
-                      ERROR_MESSAGE)
+        each_keyword('for', tokens) do |t|
+          add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
         end
       end
     end

data/lib/rubocop/cop/avoid_global_vars.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AvoidGlobalVars < Cop
+      ERROR_MESSAGE = 'Do not introduce global variables.'
+
+      # predefined global variables their English aliases
+      # http://www.zenspider.com/Languages/Ruby/QuickRef.html
+      BUILT_IN_VARS = %w(
+        $: $LOAD_PATH
+        $" $LOADED_FEATURES
+        $0 $PROGRAM_NAME
+        $! $ERROR_INFO
+        $@ $ERROR_POSITION
+        $; $FS $FIELD_SEPARATOR
+        $, $OFS $OUTPUT_FIELD_SEPARATOR
+        $/ $RS $INPUT_RECORD_SEPARATOR
+        $\\ $ORS $OUTPUT_RECORD_SEPARATOR
+        $. $NR $INPUT_LINE_NUMBER
+        $_ $LAST_READ_LINE
+        $> $DEFAULT_OUTPUT
+        $< $DEFAULT_INPUT
+        $$ $PID $PROCESS_ID
+        $? $CHILD_STATUS
+        $~ $LAST_MATCH_INFO
+        $= $IGNORECASE
+        $* $ARGV
+        $& $MATCH
+        $` $PREMATCH
+        $' $POSTMATCH
+        $+ $LAST_PAREN_MATCH
+        $stdin $stdout $stderr
+        $DEBUG $FILENAME $VERBOSE
+        $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
+      )
+
+      def inspect(file, source, tokens, sexp)
+        each(:@gvar, sexp) do |s|
+          global_var = s[1]
+
+          unless BUILT_IN_VARS.include?(global_var)
+            add_offence(:convention, s[2].lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/block_comments.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class BlockComments < Cop
+      ERROR_MESSAGE = 'Do not use block comments.'
+
+      def inspect(file, source, tokens, sexp)
+        tokens.each do |t|
+          if t.type == :on_embdoc_beg
+            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/brace_after_percent.rb

@@ -5,9 +5,11 @@ module Rubocop
     class BraceAfterPercent < Cop
       ERROR_MESSAGE = 'Prefer () as delimiters for all % literals.'
       LITERALS = {
-        on_tstring_beg: '%q',
+        on_tstring_beg: ['%q', '%Q'],
         on_words_beg: '%W',
         on_qwords_beg: '%w',
+        on_qsymbols_beg: '%i',
+        on_symbols_beg: '%I',
         on_regexp_beg: '%r',
         on_symbeg: '%s',
         on_backtick: '%x'
@@ -16,10 +18,12 @@ module Rubocop
       def inspect(file, source, tokens, sexp)
         tokens.each_index do |ix|
           t = tokens[ix]
-          token = LITERALS[t.type]
-          if token && t.text.downcase.start_with?(token) && t.text[2] != '('
-            add_offence(:convention, t.pos.lineno,
-                        ERROR_MESSAGE)
+          literals = Array(LITERALS[t.type])
+          literals.each do |literal|
+            if literal && t.text.start_with?(literal) && t.text[2] != '('
+              add_offence(:convention, t.pos.lineno,
+                          ERROR_MESSAGE)
+            end
           end
         end
       end

data/lib/rubocop/cop/{indentation.rb → case_indentation.rb}

@@ -2,7 +2,7 @@
 
 module Rubocop
   module Cop
-    class Indentation < Cop
+    class CaseIndentation < Cop
       ERROR_MESSAGE = 'Indent when as deep as case.'
 
       def inspect(file, source, tokens, sexp)