sabat-rubocop 0.9.0

data/lib/rubocop/config.rb

@@ -0,0 +1,250 @@
+# encoding: utf-8
+
+require 'delegate'
+require 'yaml'
+require 'pathname'
+
+module Rubocop
+  # This class represents the configuration of the RuboCop application
+  # and all its cops. A Config is associated with a YAML configuration
+  # file from which it was read. Several different Configs can be used
+  # during a run of the rubocop program, if files in several
+  # directories are inspected.
+  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)
+        path = File.absolute_path(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)
+              if key == 'AllCops' && value['Excludes']
+                correct_relative_excludes(value, base_config, path)
+              end
+              hash[key] = hash.has_key?(key) ? merge(value, hash[key]) : value
+            end
+          end
+        end
+
+        hash.delete('inherit_from')
+        config = new(hash, path)
+        config.warn_unless_valid
+        config
+      end
+
+      def correct_relative_excludes(all_cops, base_config, path)
+        all_cops['Excludes'].map! do |exclude_elem|
+          if exclude_elem.is_a?(String) && exclude_elem =~ %r([^/].*/)
+            rel_path = relative_path(base_config.loaded_path,
+                                     File.dirname(path))
+            rel_path.to_s.sub(/#{DOTFILE}$/, '') + exclude_elem
+          else
+            exclude_elem
+          end
+        end
+      end
+
+      def relative_path(path, base)
+        path_name = Pathname.new(File.expand_path(path))
+        path_name.relative_path_from(Pathname.new(base)).to_s
+      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)
+        config_files_in_path(target_dir).first || DEFAULT_FILE
+      end
+
+      def configuration_from_file(config_file)
+        config = load_file(config_file)
+        found_files = config_files_in_path(config_file)
+        if found_files.any? && found_files.last != config_file
+          add_excludes_from_higher_level(config, load_file(found_files.last))
+        end
+        merge_with_default(config, config_file)
+      end
+
+      def add_excludes_from_higher_level(config, highest_config)
+        if highest_config['AllCops'] && highest_config['AllCops']['Excludes']
+          config['AllCops'] ||= {}
+          config['AllCops']['Excludes'] ||= []
+          highest_config['AllCops']['Excludes'].each do |path|
+            unless path.is_a?(Regexp) || path.start_with?('/')
+              diff_in_level = config.loaded_path.count('/') -
+                highest_config.loaded_path.count('/')
+              path = '../' * diff_in_level + path
+            end
+            config['AllCops']['Excludes'] << path
+          end
+          config['AllCops']['Excludes'].uniq!
+        end
+      end
+
+      def default_configuration
+        @default_configuration ||= load_file(DEFAULT_FILE)
+      end
+
+      def merge_with_default(config, config_file)
+        new(merge(default_configuration, config), config_file)
+      end
+
+      private
+
+      def config_files_in_path(target)
+        possible_config_files = dirs_to_search(target).map do |dir|
+          File.join(dir, DOTFILE)
+        end
+        possible_config_files.select { |config_file| File.exist?(config_file) }
+      end
+
+      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 = self.class.default_configuration
+
+      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
+      Config.relative_path(file, loaded_dir_pathname)
+    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,39 @@
+# encoding: utf-8
+
+module Rubocop
+  # Handles chaching of configurations and association of inspected
+  # ruby files to configurations.
+  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/cop.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # A basic wrapper around Parser's tokens.
+    class Token
+      attr_reader :pos, :type, :text
+
+      def initialize(pos, type, text)
+        @pos, @type, @text = pos, type, text
+      end
+
+      def to_s
+        "[[#{@pos.line}, #{@pos.column}], #{@type}, #{@text.inspect}]"
+      end
+    end
+
+    # A scaffold for concrete cops.
+    #
+    # The Cop class is meant to be extended.
+    #
+    # Cops track offences and can autocorrect them of the fly.
+    class Cop < Parser::Rewriter
+      extend AST::Sexp
+
+      attr_accessor :offences
+      attr_accessor :debug
+      attr_accessor :autocorrect
+      attr_writer :disabled_lines
+
+      @all = []
+      @config = {}
+
+      class << self
+        attr_accessor :all
+        attr_accessor :config
+      end
+
+      def self.inherited(subclass)
+        all << subclass
+      end
+
+      def self.cop_name
+        name.to_s.split('::').last
+      end
+
+      def self.cop_type
+        name.to_s.split('::')[-2].downcase.to_sym
+      end
+
+      def self.style?
+        cop_type == :style
+      end
+
+      def self.lint?
+        cop_type == :lint
+      end
+
+      def self.rails?
+        cop_type == :rails
+      end
+
+      def initialize
+        @offences = []
+        @debug = false
+        @autocorrect = false
+      end
+
+      def inspect(source_buffer, source, tokens, ast, comments)
+        if autocorrect
+          filename = source_buffer.instance_variable_get(:@name)
+          new_source = rewrite(source_buffer, ast)
+          unless new_source == source_buffer.source
+            File.open(filename, 'w') { |f| f.write(new_source) }
+            source_buffer.instance_variable_set(:@source, nil)
+            source_buffer.read
+          end
+        else
+          process(ast)
+        end
+      end
+
+      def do_autocorrect(node)
+        autocorrect_action(node) if autocorrect
+      end
+
+      def autocorrect_action(node)
+      end
+
+      def ignore_node(node)
+      end
+
+      def add_offence(severity, location, message)
+        unless @disabled_lines && @disabled_lines.include?(location.line)
+          message = debug ? "#{name}: #{message}" : message
+          @offences << Offence.new(severity, location, message, name)
+        end
+      end
+
+      def name
+        self.class.cop_name
+      end
+
+      private
+
+      def on_node(syms, sexp, excludes = [])
+        yield sexp if Array(syms).include?(sexp.type)
+
+        return if Array(excludes).include?(sexp.type)
+
+        sexp.children.each do |elem|
+          if elem.is_a?(Parser::AST::Node)
+            on_node(syms, elem, excludes) { |s| yield s }
+          end
+        end
+      end
+
+      def command?(name, node)
+        return unless node.type == :send
+
+        receiver, method_name, _args = *node
+
+        # commands have no explicit receiver
+        !receiver && method_name == name
+      end
+
+      def source_range(source_buffer, preceding_lines, begin_column,
+                       column_count)
+        newline_length = 1
+        begin_pos = preceding_lines.reduce(0) do |a, e|
+          a + e.length + newline_length
+        end + begin_column
+        Parser::Source::Range.new(source_buffer, begin_pos,
+                                  begin_pos + column_count)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for assignments in the conditions of
+      # if/while/until.
+      class AssignmentInCondition < Cop
+        ASGN_NODES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn]
+        MSG = 'Assignment in condition - you probably meant to use ==.'
+
+        def on_if(node)
+          check(node)
+          super
+        end
+
+        def on_while(node)
+          check(node)
+          super
+        end
+
+        def on_until(node)
+          check(node)
+          super
+        end
+
+        private
+
+        def check(node)
+          condition, = *node
+
+          on_node([:begin, *ASGN_NODES], condition) do |asgn_node|
+            # skip safe assignment nodes if safe assignment is allowed
+            return if safe_assignment_allowed? && safe_assignment?(asgn_node)
+
+            # assignment nodes from shorthand ops like ||= don't have operator
+            if asgn_node.type != :begin && asgn_node.loc.operator
+              add_offence(:warning, asgn_node.loc.operator, MSG)
+            end
+          end
+        end
+
+        def safe_assignment?(node)
+          node.type == :begin && node.children.size == 1 &&
+            ASGN_NODES.include?(node.children[0].type)
+        end
+
+        def safe_assignment_allowed?
+          AssignmentInCondition.config['AllowSafeAssignment']
+        end
+      end
+    end
+  end
+end