dirwatch 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/config_loader.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+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 ConfigLoader
+    DOTFILE = '.rubocop.yml'.freeze
+    RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+    DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
+    AUTO_GENERATED_FILE = '.rubocop_todo.yml'.freeze
+
+    class << self
+      include ConfigLoaderResolver
+
+      attr_accessor :debug, :auto_gen_config
+      attr_writer :root_level # The upwards search is stopped at this level.
+      attr_writer :default_configuration
+
+      alias debug? debug
+      alias auto_gen_config? auto_gen_config
+
+      def clear_options
+        @debug = @auto_gen_config = @root_level = nil
+      end
+
+      def load_file(path)
+        path = File.absolute_path(path)
+        hash = load_yaml_configuration(path)
+
+        add_missing_namespaces(path, hash)
+
+        resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
+        resolve_inheritance(path, hash)
+        resolve_requires(path, hash)
+
+        hash.delete('inherit_from')
+        config = Config.new(hash, path)
+
+        config.deprecation_check do |deprecation_message|
+          warn("#{path} - #{deprecation_message}")
+        end
+
+        config.validate
+        config.make_excludes_absolute
+        config
+      end
+
+      def add_missing_namespaces(path, hash)
+        hash.keys.each do |k|
+          q = Cop::Cop.qualified_cop_name(k, path)
+          next if q == k
+
+          hash[q] = hash.delete(k)
+        end
+      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.merge(derived_hash)
+        keys_appearing_in_both = base_hash.keys & derived_hash.keys
+        keys_appearing_in_both.each do |key|
+          next unless base_hash[key].is_a?(Hash)
+          result[key] = merge(base_hash[key], derived_hash[key])
+        end
+        result
+      end
+
+      def base_configs(path, inherit_from)
+        configs = Array(inherit_from).compact.map do |f|
+          if f =~ /\A#{URI::Parser.new.make_regexp(%w(http https))}\z/
+            f = RemoteConfig.new(f, File.dirname(path)).file
+          else
+            f = File.expand_path(f, File.dirname(path))
+
+            if auto_gen_config?
+              next if f.include?(AUTO_GENERATED_FILE)
+            end
+
+            print 'Inheriting ' if debug?
+          end
+          load_file(f)
+        end
+
+        configs.compact
+      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)
+        return config if config_file == DEFAULT_FILE
+
+        found_files = config_files_in_path(config_file)
+        if found_files.any? && found_files.last != config_file
+          print 'AllCops/Exclude ' if debug?
+          config.add_excludes_from_higher_level(load_file(found_files.last))
+        end
+        merge_with_default(config, config_file)
+      end
+
+      def default_configuration
+        @default_configuration ||= begin
+                                     print 'Default ' if debug?
+                                     load_file(DEFAULT_FILE)
+                                   end
+      end
+
+      # Merges the given configuration with the default one. If
+      # AllCops:DisabledByDefault is true, it changes the Enabled params so
+      # that only cops from user configuration are enabled.
+      def merge_with_default(config, config_file)
+        configs =
+          if config.for_all_cops['DisabledByDefault']
+            disabled_default = transform(default_configuration) do |params|
+              params.merge('Enabled' => false) # Overwrite with false.
+            end
+            enabled_user_config = transform(config) do |params|
+              { 'Enabled' => true }.merge(params) # Set true if not set.
+            end
+            [disabled_default, enabled_user_config]
+          else
+            [default_configuration, config]
+          end
+        Config.new(merge(configs.first, configs.last), config_file)
+      end
+
+      private
+
+      # Returns a new hash where the parameters of the given config hash have
+      # been replaced by parameters returned by the given block.
+      def transform(config)
+        Hash[config.map { |cop, params| [cop, yield(params)] }]
+      end
+
+      def load_yaml_configuration(absolute_path)
+        yaml_code = IO.read(absolute_path, encoding: Encoding::UTF_8)
+        hash = yaml_safe_load(yaml_code, absolute_path) || {}
+
+        puts "configuration from #{absolute_path}" if debug?
+
+        unless hash.is_a?(Hash)
+          raise(TypeError, "Malformed configuration in #{absolute_path}")
+        end
+
+        hash
+      end
+
+      def yaml_safe_load(yaml_code, filename)
+        if YAML.respond_to?(:safe_load) # Ruby 2.1+
+          if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
+            SafeYAML.load(yaml_code, filename,
+                          whitelisted_tags: %w(!ruby/regexp))
+          else
+            YAML.safe_load(yaml_code, [Regexp], [], false, filename)
+          end
+        else
+          YAML.load(yaml_code, filename)
+        end
+      end
+
+      def gem_config_path(gem_name, relative_config_path)
+        spec = Gem::Specification.find_by_name(gem_name)
+        return File.join(spec.gem_dir, relative_config_path)
+      rescue Gem::LoadError => e
+        raise Gem::LoadError,
+              "Unable to find gem #{gem_name}; is the gem installed? #{e}"
+      end
+
+      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 = []
+        Pathname.new(File.expand_path(target_dir)).ascend do |dir_pathname|
+          break if dir_pathname.to_s == @root_level
+          dirs_to_search << dir_pathname.to_s
+        end
+        dirs_to_search << Dir.home if ENV.key? 'HOME'
+        dirs_to_search
+      end
+    end
+
+    # Initializing class ivars
+    clear_options
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/config_loader_resolver.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'pathname'
+
+module RuboCop
+  # A mixin to break up ConfigLoader
+  module ConfigLoaderResolver
+    def resolve_requires(path, hash)
+      config_dir = File.dirname(path)
+      Array(hash.delete('require')).each do |r|
+        if r.start_with?('.')
+          require(File.join(config_dir, r))
+        else
+          require(r)
+        end
+      end
+    end
+
+    def resolve_inheritance(path, hash)
+      base_configs(path, hash['inherit_from']).reverse_each do |base_config|
+        base_config.each do |k, v|
+          hash[k] = hash.key?(k) ? merge(v, hash[k]) : v if v.is_a?(Hash)
+        end
+      end
+    end
+
+    def resolve_inheritance_from_gems(hash, gems)
+      (gems || {}).each_pair do |gem_name, config_path|
+        if gem_name == 'rubocop'
+          raise ArgumentError,
+                "can't inherit configuration from the rubocop gem"
+        end
+
+        hash['inherit_from'] = Array(hash['inherit_from'])
+        Array(config_path).reverse.each do |path|
+          # Put gem configuration first so local configuration overrides it.
+          hash['inherit_from'].unshift gem_config_path(gem_name, path)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/config_store.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Handles caching of configurations and association of inspected
+  # ruby files to configurations.
+  class ConfigStore
+    def initialize
+      # @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 options_config=(options_config)
+      loaded_config = ConfigLoader.load_file(options_config)
+      @options_config = ConfigLoader.merge_with_default(loaded_config,
+                                                        options_config)
+    end
+
+    def force_default_config!
+      @options_config = ConfigLoader.default_configuration
+    end
+
+    def for(file_or_dir)
+      return @options_config if @options_config
+
+      dir = if File.directory?(file_or_dir)
+              file_or_dir
+            else
+              File.dirname(file_or_dir)
+            end
+      @path_cache[dir] ||= ConfigLoader.configuration_file_for(dir)
+      path = @path_cache[dir]
+      @object_cache[path] ||= begin
+                                print "For #{dir}: " if ConfigLoader.debug?
+                                ConfigLoader.configuration_from_file(path)
+                              end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/autocorrect_logic.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the logic for autocorrect behavior for a cop.
+    module AutocorrectLogic
+      def autocorrect?
+        autocorrect_requested? && support_autocorrect? && autocorrect_enabled?
+      end
+
+      def autocorrect_requested?
+        @options.fetch(:auto_correct, false)
+      end
+
+      def support_autocorrect?
+        respond_to?(:autocorrect, true)
+      end
+
+      def autocorrect_enabled?
+        # allow turning off autocorrect on a cop by cop basis
+        return true unless cop_config
+        cop_config['AutoCorrect'] != false
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # A Gem's requirements should be listed only once in a Gemfile.
+      # @example
+      #   # bad
+      #   gem 'rubocop'
+      #   gem 'rubocop'
+      #
+      #   # bad
+      #   group :development do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   group :test do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   # good
+      #   group :development, :test do
+      #     gem 'rubocop'
+      #   end
+      #
+      #   # good
+      #   gem 'rubocop', groups: [:development, :test]
+      class DuplicatedGem < Cop
+        MSG = 'Gem `%s` requirements already given on line %d ' \
+              'of the Gemfile.'.freeze
+
+        def investigate(processed_source)
+          return unless processed_source.ast
+
+          duplicated_gem_nodes.each do |nodes|
+            nodes[1..-1].each do |node|
+              offense(
+                node,
+                node.method_args.first.to_a.first,
+                nodes.first.loc.line
+              )
+            end
+          end
+        end
+
+        private
+
+        def_node_search :gem_declarations, '(send nil :gem str ...)'
+
+        def duplicated_gem_nodes
+          gem_declarations(processed_source.ast)
+            .group_by { |e| e.method_args.first }
+            .keep_if { |_, nodes| nodes.length > 1 }
+            .values
+        end
+
+        def offense(node, gem_name, line_of_first_occurence)
+          line_range = node.loc.column...node.loc.last_column
+
+          add_offense(
+            node,
+            source_range(processed_source.buffer, node.loc.line, line_range),
+            format(MSG, gem_name, line_of_first_occurence)
+          )
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module RuboCop
+  module Cop
+    module Bundler
+      # Gems in consecutive lines should be alphabetically sorted
+      # @example
+      #   # bad
+      #   gem 'rubocop'
+      #   gem 'rspec'
+      #
+      #   # good
+      #   gem 'rspec'
+      #   gem 'rubocop'
+      #
+      #   # good
+      #   gem 'rubocop'
+      #
+      #   gem 'rspec'
+      class OrderedGems < Cop
+        MSG = 'Gem `%s` should appear before `%s` in their gem group.'.freeze
+        def investigate(processed_source)
+          return if processed_source.ast.nil?
+          gem_declarations(processed_source.ast)
+            .each_cons(2) do |previous, current|
+            next unless consecutive_lines(previous, current)
+            next unless current.children[2].children.first.to_s <
+                        previous.children[2].children.first.to_s
+            register_offense(previous, current)
+          end
+        end
+
+        def consecutive_lines(previous, current)
+          previous.source_range.last_line == current.source_range.first_line - 1
+        end
+
+        def register_offense(previous, current)
+          add_offense(
+            current,
+            current.source_range,
+            format(
+              MSG,
+              current.children[2].children.first,
+              previous.children[2].children.first
+            )
+          )
+        end
+
+        def_node_search :gem_declarations, <<-PATTERN
+          (:send, nil, :gem, ...)
+        PATTERN
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rubocop-0.46.0/lib/rubocop/cop/commissioner.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Commissioner class is responsible for processing the AST and delegating
+    # work to the specified cops.
+    class Commissioner
+      include RuboCop::Node::Traversal
+
+      attr_reader :errors
+
+      def self.callback_methods
+        Parser::Meta::NODE_TYPES.map { |type| :"on_#{type}" }
+      end
+
+      def initialize(cops, forces = [], options = {})
+        @cops = cops
+        @forces = forces
+        @options = options
+        @callbacks = {}
+
+        reset_errors
+      end
+
+      # In the dynamically generated methods below, a call to `super` is used
+      # to continue iterating over the children of a node.
+      # However, if we know that a certain node type (like `int`) never has
+      # child nodes, there is no reason to pay the cost of calling `super`.
+      no_child_callbacks = Node::Traversal::NO_CHILD_NODES.map do |type|
+        :"on_#{type}"
+      end
+
+      callback_methods.each do |callback|
+        next unless RuboCop::Node::Traversal.method_defined?(callback)
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{callback}(node)
+            @callbacks[:"#{callback}"] ||= @cops.select do |cop|
+              cop.respond_to?(:"#{callback}")
+            end
+            @callbacks[:#{callback}].each do |cop|
+              with_cop_error_handling(cop) do
+                cop.send(:#{callback}, node)
+              end
+            end
+
+            #{!no_child_callbacks.include?(callback) && 'super'}
+          end
+        EOS
+      end
+
+      def investigate(processed_source)
+        reset_errors
+        remove_irrelevant_cops(processed_source.buffer.name)
+        reset_callbacks
+        prepare(processed_source)
+        invoke_custom_processing(@cops, processed_source)
+        invoke_custom_processing(@forces, processed_source)
+        walk(processed_source.ast) if processed_source.ast
+        @cops.flat_map(&:offenses)
+      end
+
+      private
+
+      def reset_errors
+        @errors = Hash.new { |hash, k| hash[k] = [] }
+      end
+
+      def remove_irrelevant_cops(filename)
+        @cops.reject! { |cop| cop.excluded_file?(filename) }
+      end
+
+      def reset_callbacks
+        @callbacks.clear
+      end
+
+      # TODO: Bad design.
+      def prepare(processed_source)
+        @cops.each { |cop| cop.processed_source = processed_source }
+      end
+
+      # There are cops/forces that require their own custom processing.
+      # If they define the #investigate method, all input parameters passed
+      # to the commissioner will be passed to the cop too in order to do
+      # its own processing.
+      def invoke_custom_processing(cops_or_forces, processed_source)
+        cops_or_forces.each do |cop|
+          next unless cop.respond_to?(:investigate)
+
+          with_cop_error_handling(cop) do
+            cop.investigate(processed_source)
+          end
+        end
+      end
+
+      def with_cop_error_handling(cop)
+        yield
+      rescue => e
+        raise e if @options[:raise_error]
+        @errors[cop] << e
+      end
+    end
+  end
+end