dirwatch 0.0.6 → 0.0.7

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

@@ -1,320 +0,0 @@
-# frozen_string_literal: true
-
-require 'optparse'
-require 'shellwords'
-
-module RuboCop
-  # This class handles command line options.
-  class Options
-    EXITING_OPTIONS = [:version, :verbose_version, :show_cops].freeze
-    DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
-
-    def initialize
-      @options = {}
-      @validator = OptionsValidator.new(@options)
-    end
-
-    def parse(command_line_args)
-      args = args_from_file.concat(args_from_env).concat(command_line_args)
-      define_options(args).parse!(args)
-      # The --no-color CLI option sets `color: false` so we don't want the
-      # `no_color` key, which is created automatically.
-      @options.delete(:no_color)
-
-      @validator.validate_compatibility
-
-      if @options[:stdin] && !args.one?
-        raise ArgumentError, '-s/--stdin requires exactly one path.'
-      end
-
-      [@options, args]
-    end
-
-    private
-
-    def args_from_file
-      if File.exist?('.rubocop') && !File.directory?('.rubocop')
-        IO.readlines('.rubocop').map(&:strip)
-      else
-        []
-      end
-    end
-
-    def args_from_env
-      Shellwords.split(ENV.fetch('RUBOCOP_OPTS', ''))
-    end
-
-    def define_options(args)
-      OptionParser.new do |opts|
-        opts.banner = 'Usage: rubocop [options] [file1, file2, ...]'
-
-        add_list_options(opts)
-        add_only_options(opts)
-        add_configuration_options(opts, args)
-        add_formatting_options(opts)
-
-        option(opts, '-r', '--require FILE') { |f| require f }
-
-        add_severity_option(opts)
-        add_flags_with_optional_args(opts)
-        add_boolean_flags(opts)
-      end
-    end
-
-    def add_only_options(opts)
-      add_cop_selection_csv_option('except', opts)
-      add_cop_selection_csv_option('only', opts)
-      option(opts, '--only-guide-cops')
-    end
-
-    def add_cop_selection_csv_option(option, opts)
-      option(opts, "--#{option} [COP1,COP2,...]") do |list|
-        @options[:"#{option}"] =
-          if list.empty?
-            ['']
-          else
-            list.split(',').map do |c|
-              Cop::Cop.qualified_cop_name(c, "--#{option} option")
-            end
-          end
-      end
-    end
-
-    def add_configuration_options(opts, args)
-      option(opts, '-c', '--config FILE')
-
-      option(opts, '--auto-gen-config')
-
-      option(opts, '--exclude-limit COUNT') do
-        @validator.validate_exclude_limit_option(args)
-      end
-
-      option(opts, '--force-exclusion')
-
-      option(opts, '--force-default-config')
-
-      option(opts, '--no-offense-counts') do
-        @options[:no_offense_counts] = true
-      end
-    end
-
-    def add_formatting_options(opts)
-      option(opts, '-f', '--format FORMATTER') do |key|
-        @options[:formatters] ||= []
-        @options[:formatters] << [key]
-      end
-
-      option(opts, '-o', '--out FILE') do |path|
-        if @options[:formatters]
-          @options[:formatters].last << path
-        else
-          @options[:output_path] = path
-        end
-      end
-    end
-
-    def add_severity_option(opts)
-      table = RuboCop::Cop::Severity::CODE_TABLE.merge(A: :autocorrect)
-      option(opts, '--fail-level SEVERITY',
-             RuboCop::Cop::Severity::NAMES + [:autocorrect],
-             table) do |severity|
-        @options[:fail_level] = severity
-      end
-    end
-
-    def add_flags_with_optional_args(opts)
-      option(opts, '--show-cops [COP1,COP2,...]') do |list|
-        @options[:show_cops] = list.nil? ? [] : list.split(',')
-      end
-    end
-
-    def add_boolean_flags(opts) # rubocop:disable Metrics/MethodLength
-      option(opts, '-F', '--fail-fast')
-      option(opts, '-C', '--cache FLAG')
-      option(opts, '-d', '--debug')
-      option(opts, '-D', '--display-cop-names')
-      option(opts, '-E', '--extra-details')
-      option(opts, '-S', '--display-style-guide')
-      option(opts, '-R', '--rails')
-      option(opts, '-l', '--lint') do
-        @options[:only] ||= []
-        @options[:only] << 'Lint'
-      end
-      option(opts, '-a', '--auto-correct')
-
-      option(opts, '-n', '--[no-]color') { |c| @options[:color] = c }
-
-      option(opts, '-v', '--version')
-      option(opts, '-V', '--verbose-version')
-      option(opts, '-s', '--stdin') { @options[:stdin] = $stdin.binmode.read }
-    end
-
-    def add_list_options(opts)
-      option(opts, '-L', '--list-target-files')
-    end
-
-    # Sets a value in the @options hash, based on the given long option and its
-    # value, in addition to calling the block if a block is given.
-    def option(opts, *args)
-      long_opt_symbol = long_opt_symbol(args)
-      args += Array(OptionsHelp::TEXT[long_opt_symbol])
-      opts.on(*args) do |arg|
-        @options[long_opt_symbol] = arg
-        yield arg if block_given?
-      end
-    end
-
-    # Finds the option in `args` starting with -- and converts it to a symbol,
-    # e.g. [..., '--auto-correct', ...] to :auto_correct.
-    def long_opt_symbol(args)
-      long_opt = args.find { |arg| arg.start_with?('--') }
-      long_opt[2..-1].sub(/ .*/, '').tr('-', '_').gsub(/[\[\]]/, '').to_sym
-    end
-  end
-
-  # Validates option arguments and the options' compatibility with each other.
-  class OptionsValidator
-    # Cop name validation must be done later than option parsing, so it's not
-    # called from within Options.
-    def self.validate_cop_list(names)
-      return unless names
-
-      namespaces = Cop::Cop.all.types.map { |t| t.to_s.capitalize }
-      names.each do |name|
-        next if Cop::Cop.all.any? { |c| c.cop_name == name }
-        next if namespaces.include?(name)
-        next if %w(Syntax Lint/Syntax).include?(name)
-
-        raise ArgumentError, "Unrecognized cop or namespace: #{name}."
-      end
-    end
-
-    def initialize(options)
-      @options = options
-    end
-
-    def validate_compatibility # rubocop:disable Metrics/MethodLength
-      if only_includes_unneeded_disable?
-        raise ArgumentError, 'Lint/UnneededDisable can not be used with --only.'
-      end
-      if except_syntax?
-        raise ArgumentError, 'Syntax checking can not be turned off.'
-      end
-      unless boolean_or_empty_cache?
-        raise ArgumentError, '-C/--cache argument must be true or false'
-      end
-      if no_offense_counts_without_auto_gen_config?
-        raise ArgumentError, '--no-offense-counts can only be used together ' \
-                             'with --auto-gen-config.'
-      end
-      return if incompatible_options.size <= 1
-      raise ArgumentError, 'Incompatible cli options: ' \
-                           "#{incompatible_options.inspect}"
-    end
-
-    def only_includes_unneeded_disable?
-      @options.key?(:only) &&
-        (@options[:only] & %w(Lint/UnneededDisable UnneededDisable)).any?
-    end
-
-    def except_syntax?
-      @options.key?(:except) &&
-        (@options[:except] & %w(Lint/Syntax Syntax)).any?
-    end
-
-    def boolean_or_empty_cache?
-      !@options.key?(:cache) || %w(true false).include?(@options[:cache])
-    end
-
-    def no_offense_counts_without_auto_gen_config?
-      @options.key?(:no_offense_counts) && !@options.key?(:auto_gen_config)
-    end
-
-    def incompatible_options
-      @incompatible_options ||= @options.keys & Options::EXITING_OPTIONS
-    end
-
-    def validate_exclude_limit_option(args)
-      if @options[:exclude_limit] !~ /^\d+$/
-        # Emulate OptionParser's behavior to make failures consistent regardless
-        # of option order.
-        raise OptionParser::MissingArgument
-      end
-
-      # --exclude-limit is valid if there's a parsed or yet unparsed
-      # --auto-gen-config.
-      return if @options[:auto_gen_config] || args.include?('--auto-gen-config')
-
-      raise ArgumentError,
-            '--exclude-limit can only be used with --auto-gen-config.'
-    end
-  end
-
-  # This module contains help texts for command line options.
-  module OptionsHelp
-    MAX_EXCL = RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS.to_s
-    TEXT = {
-      only:                  'Run only the given cop(s).',
-      only_guide_cops:      ['Run only cops for rules that link to a',
-                             'style guide.'],
-      except:                'Disable the given cop(s).',
-      require:               'Require Ruby file.',
-      config:                'Specify configuration file.',
-      auto_gen_config:      ['Generate a configuration file acting as a',
-                             'TODO list.'],
-      no_offense_counts:    ['Do not include offense counts in configuration',
-                             'file generated by --auto-gen-config.'],
-      exclude_limit:        ['Used together with --auto-gen-config to',
-                             'set the limit for how many Exclude',
-                             "properties to generate. Default is #{MAX_EXCL}."],
-      force_exclusion:      ['Force excluding files specified in the',
-                             'configuration `Exclude` even if they are',
-                             'explicitly passed as arguments.'],
-      force_default_config: ['Use default configuration even if configuration',
-                             'files are present in the directory tree.'],
-      format:               ['Choose an output formatter. This option',
-                             'can be specified multiple times to enable',
-                             'multiple formatters at the same time.',
-                             '  [p]rogress (default)',
-                             '  [s]imple',
-                             '  [c]lang',
-                             '  [d]isabled cops via inline comments',
-                             '  [fu]ubar',
-                             '  [e]macs',
-                             '  [j]son',
-                             '  [h]tml',
-                             '  [fi]les',
-                             '  [o]ffenses',
-                             '  [w]orst',
-                             '  custom formatter class name'],
-      out:                  ['Write output to a file instead of STDOUT.',
-                             'This option applies to the previously',
-                             'specified --format, or the default format',
-                             'if no format is specified.'],
-      fail_level:           ['Minimum severity (A/R/C/W/E/F) for exit',
-                             'with error code.'],
-      show_cops:            ['Shows the given cops, or all cops by',
-                             'default, and their configurations for the',
-                             'current directory.'],
-      fail_fast:            ['Inspect files in order of modification',
-                             'time and stop after the first file',
-                             'containing offenses.'],
-      cache:                ["Use result caching (FLAG=true) or don't",
-                             '(FLAG=false), default determined by',
-                             'configuration parameter AllCops: UseCache.'],
-      debug:                 'Display debug info.',
-      display_cop_names:     'Display cop names in offense messages.',
-      display_style_guide:   'Display style guide URLs in offense messages.',
-      extra_details:         'Display extra details in offense messages.',
-      rails:                 'Run extra Rails cops.',
-      lint:                  'Run only lint cops.',
-      list_target_files:     'List all files RuboCop will inspect.',
-      auto_correct:          'Auto-correct offenses.',
-      no_color:              'Force color output on or off.',
-      version:               'Display version.',
-      verbose_version:       'Display verbose version.',
-      stdin:                ['Pipe source from STDIN.',
-                             'This is useful for editor integration.']
-    }.freeze
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # Common methods and behaviors for dealing with paths.
-  module PathUtil
-    module_function
-
-    def relative_path(path, base_dir = Dir.pwd)
-      # Optimization for the common case where path begins with the base
-      # dir. Just cut off the first part.
-      return path[(base_dir.length + 1)..-1] if path.start_with?(base_dir)
-
-      path_name = Pathname.new(File.expand_path(path))
-      path_name.relative_path_from(Pathname.new(base_dir)).to_s
-    end
-
-    def match_path?(pattern, path)
-      case pattern
-      when String
-        File.fnmatch?(pattern, path, File::FNM_PATHNAME)
-      when Regexp
-        path =~ pattern
-      end
-    end
-
-    # Returns true for an absolute Unix or Windows path.
-    def absolute?(path)
-      path =~ %r{\A([A-Z]:)?/}
-    end
-  end
-end

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

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest/md5'
-
-module RuboCop
-  # ProcessedSource contains objects which are generated by Parser
-  # and other information such as disabled lines for cops.
-  # It also provides a convenient way to access source lines.
-  class ProcessedSource
-    STRING_SOURCE_NAME = '(string)'.freeze
-
-    attr_reader :path, :buffer, :ast, :comments, :tokens, :diagnostics,
-                :parser_error, :raw_source, :ruby_version
-
-    def self.from_file(path, ruby_version)
-      file = File.read(path, mode: 'rb')
-      new(file, ruby_version, path)
-    rescue Errno::ENOENT
-      raise RuboCop::Error, "No such file or directory: #{path}"
-    end
-
-    def initialize(source, ruby_version, path = nil)
-      # Defaults source encoding to UTF-8, regardless of the encoding it has
-      # been read with, which could be non-utf8 depending on the default
-      # external encoding.
-      unless source.encoding == Encoding::UTF_8
-        source.force_encoding(Encoding::UTF_8)
-      end
-
-      @raw_source = source
-      @path = path
-      @diagnostics = []
-      @ruby_version = ruby_version
-      @parser_error = nil
-
-      parse(source, ruby_version)
-    end
-
-    def comment_config
-      @comment_config ||= CommentConfig.new(self)
-    end
-
-    def disabled_line_ranges
-      comment_config.cop_disabled_line_ranges
-    end
-
-    def ast_with_comments
-      return if !ast || !comments
-      @ast_with_comments ||= Parser::Source::Comment.associate(ast, comments)
-    end
-
-    # Returns the source lines, line break characters removed, excluding a
-    # possible __END__ and everything that comes after.
-    def lines
-      @lines ||= begin
-        all_lines = @buffer.source_lines
-        last_token_line = tokens.any? ? tokens.last.pos.line : all_lines.size
-        result = []
-        all_lines.each_with_index do |line, ix|
-          break if ix >= last_token_line && line == '__END__'
-          result << line
-        end
-        result
-      end
-    end
-
-    def [](*args)
-      lines[*args]
-    end
-
-    def valid_syntax?
-      return false if @parser_error
-      @diagnostics.none? { |d| [:error, :fatal].include?(d.level) }
-    end
-
-    # Raw source checksum for tracking infinite loops.
-    def checksum
-      Digest::MD5.hexdigest(@raw_source)
-    end
-
-    private
-
-    def parse(source, ruby_version)
-      buffer_name = @path || STRING_SOURCE_NAME
-      @buffer = Parser::Source::Buffer.new(buffer_name, 1)
-
-      begin
-        @buffer.source = source
-      rescue EncodingError => error
-        @parser_error = error
-        return
-      end
-
-      @ast, @comments, @tokens = tokenize(create_parser(ruby_version))
-    end
-
-    def tokenize(parser)
-      begin
-        ast, comments, tokens = parser.tokenize(@buffer)
-        ast.complete! if ast
-      rescue Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
-        # All errors are in diagnostics. No need to handle exception.
-      end
-
-      tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
-
-      [ast, comments, tokens]
-    end
-
-    def parser_class(ruby_version) # rubocop:disable Metrics/MethodLength
-      case ruby_version
-      when 1.9
-        require 'parser/ruby19'
-        Parser::Ruby19
-      when 2.0
-        require 'parser/ruby20'
-        Parser::Ruby20
-      when 2.1
-        require 'parser/ruby21'
-        Parser::Ruby21
-      when 2.2
-        require 'parser/ruby22'
-        Parser::Ruby22
-      when 2.3
-        require 'parser/ruby23'
-        Parser::Ruby23
-      when 2.4
-        require 'parser/ruby24'
-        Parser::Ruby24
-      else
-        raise ArgumentError, "Unknown Ruby version: #{ruby_version.inspect}"
-      end
-    end
-
-    def create_parser(ruby_version)
-      builder = RuboCop::Node::Builder.new
-
-      parser_class(ruby_version).new(builder).tap do |parser|
-        # On JRuby and Rubinius, there's a risk that we hang in tokenize() if we
-        # don't set the all errors as fatal flag. The problem is caused by a bug
-        # in Racc that is discussed in issue #93 of the whitequark/parser
-        # project on GitHub.
-        parser.diagnostics.all_errors_are_fatal = (RUBY_ENGINE != 'ruby')
-        parser.diagnostics.ignore_warnings = false
-        parser.diagnostics.consumer = lambda do |diagnostic|
-          @diagnostics << diagnostic
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require 'rake'
-require 'rake/tasklib'
-
-module RuboCop
-  # Provides a custom rake task.
-  #
-  # require 'rubocop/rake_task'
-  # RuboCop::RakeTask.new
-  class RakeTask < Rake::TaskLib
-    attr_accessor :name
-    attr_accessor :verbose
-    attr_accessor :fail_on_error
-    attr_accessor :patterns
-    attr_accessor :formatters
-    attr_accessor :requires
-    attr_accessor :options
-
-    def initialize(*args, &task_block)
-      setup_ivars(args)
-
-      desc 'Run RuboCop' unless ::Rake.application.last_description
-
-      task(name, *args) do |_, task_args|
-        RakeFileUtils.send(:verbose, verbose) do
-          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
-          run_main_task(verbose)
-        end
-      end
-
-      setup_subtasks(name, *args, &task_block)
-    end
-
-    def run_main_task(verbose)
-      run_cli(verbose, full_options)
-    end
-
-    private
-
-    def run_cli(verbose, options)
-      # We lazy-load rubocop so that the task doesn't dramatically impact the
-      # load time of your Rakefile.
-      require 'rubocop'
-
-      cli = CLI.new
-      puts 'Running RuboCop...' if verbose
-      result = cli.run(options)
-      abort('RuboCop failed!') if result.nonzero? && fail_on_error
-    end
-
-    def full_options
-      [].tap do |result|
-        result.concat(formatters.map { |f| ['--format', f] }.flatten)
-        result.concat(requires.map { |r| ['--require', r] }.flatten)
-        result.concat(options.flatten)
-        result.concat(patterns)
-      end
-    end
-
-    def setup_ivars(args)
-      # More lazy-loading to keep load time down.
-      require 'rubocop/options'
-
-      @name = args.shift || :rubocop
-      @verbose = true
-      @fail_on_error = true
-      @patterns = []
-      @requires = []
-      @options = []
-      @formatters = []
-    end
-
-    def setup_subtasks(name, *args, &task_block)
-      namespace name do
-        desc 'Auto-correct RuboCop offenses'
-
-        task(:auto_correct, *args) do |_, task_args|
-          yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
-          options = full_options.unshift('--auto-correct')
-          run_cli(verbose, options)
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require 'time'
-
-module RuboCop
-  # Common methods and behaviors for dealing with remote config files.
-  class RemoteConfig
-    CACHE_LIFETIME = 24 * 60 * 60
-
-    def initialize(url, base_dir)
-      @uri = URI.parse(url)
-      @base_dir = base_dir
-    end
-
-    def file
-      return cache_path unless cache_path_expired?
-
-      request do |response|
-        open cache_path, 'w' do |io|
-          io.write response.body
-        end
-      end
-
-      cache_path
-    end
-
-    private
-
-    def request
-      http = Net::HTTP.new(@uri.hostname, @uri.port)
-      http.use_ssl = true if @uri.instance_of? URI::HTTPS
-
-      request = Net::HTTP::Get.new(@uri.request_uri)
-      if cache_path_exists?
-        request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822
-      end
-
-      response = http.request(request)
-      yield response if response.is_a?(Net::HTTPSuccess)
-    end
-
-    def cache_path
-      File.expand_path(".rubocop-#{cache_name_from_uri}", @base_dir)
-    end
-
-    def cache_path_exists?
-      @cache_path_exists ||= File.exist?(cache_path)
-    end
-
-    def cache_path_expired?
-      return true unless cache_path_exists?
-
-      @cache_path_expired ||= begin
-        file_age = (Time.now - File.stat(cache_path).mtime).to_f
-        (file_age / CACHE_LIFETIME) > 1
-      end
-    end
-
-    def cache_name_from_uri
-      uri = @uri.clone
-      uri.query = nil
-      uri.to_s.gsub!(/[^0-9A-Za-z]/, '-')
-    end
-  end
-end