dirwatch 0.0.6 → 0.0.7

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

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # The CLI is a class responsible of handling all the command line interface
-  # logic.
-  class CLI
-    include Formatter::TextUtil
-
-    class Finished < RuntimeError; end
-
-    attr_reader :options, :config_store
-
-    def initialize
-      @options = {}
-      @config_store = ConfigStore.new
-    end
-
-    # Entry point for the application logic. Here we
-    # do the command line arguments processing and inspect
-    # the target files
-    # @return [Integer] UNIX exit code
-    def run(args = ARGV)
-      @options, paths = Options.new.parse(args)
-      act_on_options
-      apply_default_formatter
-
-      execute_runner(paths)
-    rescue RuboCop::Error => e
-      $stderr.puts Rainbow("Error: #{e.message}").red
-      return 2
-    rescue Finished
-      return 0
-    rescue StandardError, SyntaxError => e
-      $stderr.puts e.message
-      $stderr.puts e.backtrace
-      return 2
-    end
-
-    def trap_interrupt(runner)
-      Signal.trap('INT') do
-        exit!(1) if runner.aborting?
-        runner.abort
-        $stderr.puts
-        $stderr.puts 'Exiting... Interrupt again to exit immediately.'
-      end
-    end
-
-    private
-
-    def act_on_options
-      handle_exiting_options
-
-      ConfigLoader.debug = @options[:debug]
-      ConfigLoader.auto_gen_config = @options[:auto_gen_config]
-
-      @config_store.options_config = @options[:config] if @options[:config]
-      @config_store.force_default_config! if @options[:force_default_config]
-
-      if @options[:color]
-        # color output explicitly forced on
-        Rainbow.enabled = true
-      elsif @options[:color] == false
-        # color output explicitly forced off
-        Rainbow.enabled = false
-      end
-    end
-
-    def execute_runner(paths)
-      runner = Runner.new(@options, @config_store)
-
-      trap_interrupt(runner)
-      all_passed = runner.run(paths)
-      display_warning_summary(runner.warnings)
-      display_error_summary(runner.errors)
-      maybe_print_corrected_source
-
-      all_passed && !runner.aborting? && runner.errors.empty? ? 0 : 1
-    end
-
-    def handle_exiting_options
-      return unless Options::EXITING_OPTIONS.any? { |o| @options.key? o }
-
-      puts RuboCop::Version.version(false) if @options[:version]
-      puts RuboCop::Version.version(true) if @options[:verbose_version]
-      print_available_cops if @options[:show_cops]
-      raise Finished
-    end
-
-    def apply_default_formatter
-      # This must be done after the options have already been processed,
-      # because they can affect how ConfigStore behaves
-      @options[:formatters] ||= begin
-        cfg = @config_store.for(Dir.pwd).for_all_cops
-        formatter = cfg['DefaultFormatter'] || 'progress'
-        [[formatter, @options[:output_path]]]
-      end
-
-      return unless @options[:auto_gen_config]
-
-      @options[:formatters] << [Formatter::DisabledConfigFormatter,
-                                ConfigLoader::AUTO_GENERATED_FILE]
-    end
-
-    def print_available_cops
-      # Load the configs so the require()s are done for custom cops
-      @config_store.for(Dir.pwd)
-      cops = Cop::Cop.all
-      show_all = @options[:show_cops].empty?
-
-      if show_all
-        puts "# Available cops (#{cops.length}) + config for #{Dir.pwd}: "
-      end
-
-      cops.types.sort!.each { |type| print_cops_of_type(cops, type, show_all) }
-    end
-
-    def print_cops_of_type(cops, type, show_all)
-      selected_cops = if show_all
-                        cops_of_type(cops, type)
-                      else
-                        selected_cops_of_type(cops, type)
-                      end
-
-      if show_all
-        puts "# Type '#{type.to_s.capitalize}' (#{selected_cops.size}):"
-      end
-
-      selected_cops.each do |cop|
-        puts '# Supports --auto-correct' if cop.new.support_autocorrect?
-        puts "#{cop.cop_name}:"
-        puts config_lines(cop)
-        puts
-      end
-    end
-
-    def selected_cops_of_type(cops, type)
-      cops_of_type(cops, type).select do |cop|
-        @options[:show_cops].include?(cop.cop_name)
-      end
-    end
-
-    def cops_of_type(cops, type)
-      cops.with_type(type).sort_by!(&:cop_name)
-    end
-
-    def config_lines(cop)
-      cnf = @config_store.for(Dir.pwd).for_cop(cop)
-      cnf.to_yaml.lines.to_a.butfirst.map { |line| '  ' + line }
-    end
-
-    def display_warning_summary(warnings)
-      return if warnings.empty?
-
-      warn Rainbow("\n#{pluralize(warnings.size, 'warning')}:").yellow
-
-      warnings.each { |warning| warn warning }
-    end
-
-    def display_error_summary(errors)
-      return if errors.empty?
-
-      warn Rainbow("\n#{pluralize(errors.size, 'error')} occurred:").red
-
-      errors.each { |error| warn error }
-
-      warn <<-END.strip_indent
-        Errors are usually caused by RuboCop bugs.
-        Please, report your problems to RuboCop's issue tracker.
-        Mention the following information in the issue report:
-        #{RuboCop::Version.version(true)}
-      END
-    end
-
-    def maybe_print_corrected_source
-      # If we are asked to autocorrect source code read from stdin, the only
-      # reasonable place to write it is to stdout
-      # Unfortunately, we also write other information to stdout
-      # So a delimiter is needed for tools to easily identify where the
-      # autocorrected source begins
-      return unless @options[:stdin] && @options[:auto_correct]
-      puts '=' * 20
-      print @options[:stdin]
-    end
-  end
-end

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

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # This class parses the special `rubocop:disable` comments in a source
-  # and provides a way to check if each cop is enabled at arbitrary line.
-  class CommentConfig
-    UNNEEDED_DISABLE = 'Lint/UnneededDisable'.freeze
-
-    COP_NAME_PATTERN = '([A-Z]\w+/)?(?:[A-Z]\w+)'.freeze
-    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}".freeze
-    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})".freeze
-
-    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
-      ('\A# rubocop : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
-    )
-
-    CopAnalysis = Struct.new(:line_ranges, :start_line_number)
-
-    attr_reader :processed_source
-
-    def initialize(processed_source)
-      @processed_source = processed_source
-    end
-
-    def cop_enabled_at_line?(cop, line_number)
-      cop = cop.cop_name if cop.respond_to?(:cop_name)
-      disabled_line_ranges = cop_disabled_line_ranges[cop]
-      return true unless disabled_line_ranges
-
-      disabled_line_ranges.none? { |range| range.include?(line_number) }
-    end
-
-    def cop_disabled_line_ranges
-      @cop_disabled_line_ranges ||= analyze
-    end
-
-    private
-
-    def analyze
-      analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
-
-      each_mentioned_cop do |cop_name, disabled, line, single_line|
-        analyses[cop_name] =
-          analyze_cop(analyses[cop_name], disabled, line, single_line)
-      end
-
-      analyses.each_with_object({}) do |element, hash|
-        cop_name, analysis = *element
-        hash[cop_name] = cop_line_ranges(analysis)
-      end
-    end
-
-    def analyze_cop(analysis, disabled, line, single_line)
-      if single_line
-        analyze_single_line(analysis, line, disabled)
-      elsif disabled
-        analyze_disabled(analysis, line)
-      else
-        analyze_rest(analysis, line)
-      end
-    end
-
-    def analyze_single_line(analysis, line, disabled)
-      return analysis unless disabled
-
-      CopAnalysis.new(analysis.line_ranges + [(line..line)],
-                      analysis.start_line_number)
-    end
-
-    def analyze_disabled(analysis, line)
-      if (start_line = analysis.start_line_number)
-        # Cop already disabled on this line, so we end the current disabled
-        # range before we start a new range.
-        return CopAnalysis.new(analysis.line_ranges + [start_line..line], line)
-      end
-
-      CopAnalysis.new(analysis.line_ranges, line)
-    end
-
-    def analyze_rest(analysis, line)
-      if (start_line = analysis.start_line_number)
-        return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
-      end
-
-      CopAnalysis.new(analysis.line_ranges, nil)
-    end
-
-    def cop_line_ranges(analysis)
-      return analysis.line_ranges unless analysis.start_line_number
-
-      analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
-    end
-
-    def each_mentioned_cop
-      each_directive do |comment, cop_names, disabled|
-        comment_line_number = comment.loc.expression.line
-        single_line = !comment_only_line?(comment_line_number)
-
-        cop_names.each do |cop_name|
-          yield qualified_cop_name(cop_name), disabled, comment_line_number,
-                single_line
-        end
-      end
-    end
-
-    def each_directive
-      return if processed_source.comments.nil?
-
-      processed_source.comments.each do |comment|
-        directive = directive_parts(comment)
-        next unless directive
-
-        yield comment, *directive
-      end
-    end
-
-    def directive_parts(comment)
-      match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
-      return unless match
-
-      switch, cops_string = match.captures
-
-      cop_names =
-        cops_string == 'all' ? all_cop_names : cops_string.split(/,\s*/)
-
-      disabled = (switch == 'disable')
-
-      [cop_names, disabled]
-    end
-
-    def qualified_cop_name(cop_name)
-      Cop::Cop.qualified_cop_name(cop_name.strip, processed_source.buffer.name)
-    end
-
-    def all_cop_names
-      @all_cop_names ||= Cop::Cop.all.map(&:cop_name).reject do |cop_name|
-        cop_name == UNNEEDED_DISABLE
-      end
-    end
-
-    def comment_only_line?(line_number)
-      non_comment_token_line_numbers.none? do |non_comment_line_number|
-        non_comment_line_number == line_number
-      end
-    end
-
-    def non_comment_token_line_numbers
-      @non_comment_token_line_numbers ||= begin
-        non_comment_tokens = processed_source.tokens.reject do |token|
-          token.type == :tCOMMENT
-        end
-
-        non_comment_tokens.map { |token| token.pos.line }.uniq
-      end
-    end
-  end
-end

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

@@ -1,346 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-
-# rubocop:disable Metrics/ClassLength
-
-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
-    include PathUtil
-
-    COMMON_PARAMS = %w(Exclude Include Severity
-                       AutoCorrect StyleGuide Details).freeze
-    # 2.1 is the oldest officially supported Ruby version.
-    DEFAULT_RUBY_VERSION = 2.1
-    KNOWN_RUBIES = [1.9, 2.0, 2.1, 2.2, 2.3, 2.4].freeze
-    OBSOLETE_COPS = {
-      'Style/TrailingComma' =>
-        'The `Style/TrailingComma` cop no longer exists. Please use ' \
-        '`Style/TrailingCommaInLiteral` and/or ' \
-        '`Style/TrailingCommaInArguments` instead.',
-      'Rails/DefaultScope' =>
-        'The `Rails/DefaultScope` cop no longer exists.',
-      'Style/SingleSpaceBeforeFirstArg' =>
-        'The `Style/SingleSpaceBeforeFirstArg` cop has been renamed to ' \
-        '`Style/SpaceBeforeFirstArg. ',
-      'Lint/SpaceBeforeFirstArg' =>
-        'The `Lint/SpaceBeforeFirstArg` cop has been removed, since it was a ' \
-        'duplicate of `Style/SpaceBeforeFirstArg`. Please use ' \
-        '`Style/SpaceBeforeFirstArg` instead.',
-      'Style/SpaceAfterControlKeyword' =>
-        'The `Style/SpaceAfterControlKeyword` cop has been removed. Please ' \
-        'use `Style/SpaceAroundKeyword` instead.',
-      'Style/SpaceBeforeModifierKeyword' =>
-        'The `Style/SpaceBeforeModifierKeyword` cop has been removed. Please ' \
-        'use `Style/SpaceAroundKeyword` instead.'
-    }.freeze
-
-    attr_reader :loaded_path
-
-    def initialize(hash = {}, loaded_path = nil)
-      @loaded_path = loaded_path
-      @for_cop = Hash.new do |h, cop|
-        h[cop] = self[Cop::Cop.qualified_cop_name(cop, loaded_path)] || {}
-      end
-      @hash = hash
-    end
-
-    def [](key)
-      @hash[key]
-    end
-
-    def []=(key, value)
-      @hash[key] = value
-    end
-
-    def delete(key)
-      @hash.delete(key)
-    end
-
-    def each(&block)
-      @hash.each(&block)
-    end
-
-    def key?(key)
-      @hash.key?(key)
-    end
-
-    def keys
-      @hash.keys
-    end
-
-    def map(&block)
-      @hash.map(&block)
-    end
-
-    def merge(other_hash)
-      @hash.merge(other_hash)
-    end
-
-    def to_h
-      @hash
-    end
-
-    def to_hash
-      @hash
-    end
-
-    def to_s
-      @to_s ||= @hash.to_s
-    end
-
-    def make_excludes_absolute
-      each do |key, _|
-        validate_section_presence(key)
-        next unless self[key]['Exclude']
-
-        self[key]['Exclude'].map! do |exclude_elem|
-          if exclude_elem.is_a?(String) && !absolute?(exclude_elem)
-            File.expand_path(File.join(base_dir_for_path_parameters,
-                                       exclude_elem))
-          else
-            exclude_elem
-          end
-        end
-      end
-    end
-
-    def add_excludes_from_higher_level(highest_config)
-      return unless highest_config.for_all_cops['Exclude']
-
-      excludes = for_all_cops['Exclude'] ||= []
-      highest_config.for_all_cops['Exclude'].each do |path|
-        unless path.is_a?(Regexp) || absolute?(path)
-          path = File.join(File.dirname(highest_config.loaded_path), path)
-        end
-        excludes << path unless excludes.include?(path)
-      end
-    end
-
-    def deprecation_check
-      %w(Exclude Include).each do |key|
-        plural = "#{key}s"
-        next unless for_all_cops[plural]
-
-        for_all_cops[key] = for_all_cops[plural] # Stay backwards compatible.
-        for_all_cops.delete(plural)
-        yield "AllCops/#{plural} was renamed to AllCops/#{key}"
-      end
-    end
-
-    def for_cop(cop)
-      @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
-    end
-
-    def for_all_cops
-      @for_all_cops ||= self['AllCops'] || {}
-    end
-
-    def cop_enabled?(cop)
-      department = cop.cop_type.to_s.capitalize!
-
-      if (dept_config = self[department])
-        return false if dept_config['Enabled'] == false
-      end
-
-      for_cop(cop).empty? || for_cop(cop)['Enabled']
-    end
-
-    def validate
-      # Don't validate RuboCop's own files. Avoids infinite recursion.
-      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
-                                                    'config'))
-      return if File.expand_path(loaded_path).start_with?(base_config_path)
-
-      valid_cop_names, invalid_cop_names = keys.partition do |key|
-        ConfigLoader.default_configuration.key?(key)
-      end
-
-      reject_obsolete_cops
-      warn_about_unrecognized_cops(invalid_cop_names)
-      reject_obsolete_parameters
-      check_target_ruby
-      validate_parameter_names(valid_cop_names)
-      validate_enforced_styles(valid_cop_names)
-    end
-
-    def file_to_include?(file)
-      relative_file_path = path_relative_to_config(file)
-
-      # Optimization to quickly decide if the given file is hidden (on the top
-      # level) and can not be matched by any pattern.
-      is_hidden = relative_file_path.start_with?('.') &&
-                  !relative_file_path.start_with?('..')
-      return false if is_hidden && !possibly_include_hidden?
-
-      absolute_file_path = File.expand_path(file)
-
-      patterns_to_include.any? do |pattern|
-        match_path?(pattern, relative_file_path) ||
-          match_path?(pattern, absolute_file_path)
-      end
-    end
-
-    # Returns true if there's a chance that an Include pattern matches hidden
-    # files, false if that's definitely not possible.
-    def possibly_include_hidden?
-      return @possibly_include_hidden if defined?(@possibly_include_hidden)
-
-      @possibly_include_hidden = patterns_to_include.any? do |s|
-        s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
-      end
-    end
-
-    def file_to_exclude?(file)
-      file = File.expand_path(file)
-      patterns_to_exclude.any? do |pattern|
-        match_path?(pattern, file)
-      end
-    end
-
-    def patterns_to_include
-      for_all_cops['Include']
-    end
-
-    def patterns_to_exclude
-      for_all_cops['Exclude']
-    end
-
-    def path_relative_to_config(path)
-      relative_path(path, base_dir_for_path_parameters)
-    end
-
-    # Paths specified in .rubocop.yml and .rubocop_todo.yml files are relative
-    # to the directory where that file is. Paths in other config files are
-    # relative to the current directory. This is so that paths in
-    # config/default.yml, for example, are not relative to RuboCop's config
-    # directory since that wouldn't work.
-    def base_dir_for_path_parameters
-      config_files = [ConfigLoader::DOTFILE, ConfigLoader::AUTO_GENERATED_FILE]
-      @base_dir_for_path_parameters ||=
-        if config_files.include?(File.basename(loaded_path)) &&
-           loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
-          File.expand_path(File.dirname(loaded_path))
-        else
-          Dir.pwd
-        end
-    end
-
-    def target_ruby_version
-      @target_ruby_version ||=
-        if for_all_cops['TargetRubyVersion']
-          @target_ruby_version_source = :rubocop_yml
-
-          for_all_cops['TargetRubyVersion']
-        elsif File.file?('.ruby-version') &&
-              /\A(ruby-)?(?<version>\d+\.\d+)/ =~ File.read('.ruby-version')
-
-          @target_ruby_version_source = :dot_ruby_version
-
-          version.to_f
-        else
-          DEFAULT_RUBY_VERSION
-        end
-    end
-
-    private
-
-    def warn_about_unrecognized_cops(invalid_cop_names)
-      invalid_cop_names.each do |name|
-        if name == 'Syntax'
-          raise ValidationError,
-                "configuration for Syntax cop found in #{loaded_path}\n" \
-                'This cop cannot be configured.'
-        end
-
-        # There could be a custom cop with this name. If so, don't warn
-        next if Cop::Cop.all.any? { |c| c.match?([name]) }
-
-        warn Rainbow("Warning: unrecognized cop #{name} found in " \
-                     "#{loaded_path}").yellow
-      end
-    end
-
-    def validate_section_presence(name)
-      return unless key?(name) && self[name].nil?
-      raise ValidationError, "empty section #{name} found in #{loaded_path}"
-    end
-
-    def validate_parameter_names(valid_cop_names)
-      valid_cop_names.each do |name|
-        validate_section_presence(name)
-        self[name].each_key do |param|
-          next if COMMON_PARAMS.include?(param) ||
-                  ConfigLoader.default_configuration[name].key?(param)
-
-          warn Rainbow("Warning: unrecognized parameter #{name}:#{param} " \
-                       "found in #{loaded_path}").yellow
-        end
-      end
-    end
-
-    def validate_enforced_styles(valid_cop_names)
-      valid_cop_names.each do |name|
-        next unless (style = self[name]['EnforcedStyle'])
-        valid = ConfigLoader.default_configuration[name]['SupportedStyles']
-        next if valid.include?(style)
-
-        msg = "invalid EnforcedStyle '#{style}' for #{name} found in " \
-              "#{loaded_path}\n" \
-              "Valid choices are: #{valid.join(', ')}"
-        raise ValidationError, msg
-      end
-    end
-
-    def reject_obsolete_parameters
-      check_obsolete_parameter('Style/SpaceAroundOperators',
-                               'MultiSpaceAllowedForOperators',
-                               'If your intention was to allow extra spaces ' \
-                               'for alignment, please use AllowForAlignment: ' \
-                               'true instead.')
-      check_obsolete_parameter('AllCops', 'RunRailsCops',
-                               "Use the following configuration instead:\n" \
-                               "Rails:\n  Enabled: true")
-    end
-
-    def check_obsolete_parameter(cop, parameter, alternative = nil)
-      return unless self[cop] && self[cop].key?(parameter)
-
-      raise ValidationError, "obsolete parameter #{parameter} (for #{cop}) " \
-                            "found in #{loaded_path}" \
-                            "#{"\n" if alternative}#{alternative}"
-    end
-
-    def reject_obsolete_cops
-      OBSOLETE_COPS.each do |cop_name, message|
-        next unless key?(cop_name) || key?(cop_name.split('/').last)
-        message += "\n(obsolete configuration found in #{loaded_path}, please" \
-                   ' update it)'
-        raise ValidationError, message
-      end
-    end
-
-    def check_target_ruby
-      return if KNOWN_RUBIES.include?(target_ruby_version)
-
-      msg = "Unknown Ruby version #{target_ruby_version.inspect} found "
-
-      msg +=
-        case @target_ruby_version_source
-        when :dot_ruby_version
-          'in `.ruby-version`.'
-        when :rubocop_yml
-          "in `TargetRubyVersion` parameter (in #{loaded_path})." \
-        end
-
-      msg += "\nKnown versions: #{KNOWN_RUBIES.join(', ')}"
-
-      raise ValidationError, msg
-    end
-  end
-end