dirwatch 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.0/test/bug_163/test_runner_rewrite.rb

@@ -0,0 +1,35 @@
+require 'pathname'
+require 'fileutils'
+require 'shellwords'
+
+BASE_DIR = Pathname.new(__FILE__) + '../..'
+require (BASE_DIR + 'helper').expand_path
+
+class TestRunnerRewrite < Minitest::Test
+  def setup
+    @ruby_rewrite = BASE_DIR.expand_path + '../bin/ruby-rewrite'
+    @test_dir     = BASE_DIR + 'bug_163'
+    @fixtures_dir = @test_dir + 'fixtures'
+  end
+
+  def test_rewriter
+    Dir.mktmpdir("parser", BASE_DIR.expand_path.to_s) do |tmp_dir|
+      tmp_dir = Pathname.new(tmp_dir)
+      sample_file = tmp_dir + 'bug_163.rb'
+      sample_file_expanded = sample_file.expand_path
+      expected_file = @fixtures_dir + 'output.rb'
+
+      FileUtils.cp(@fixtures_dir + 'input.rb', tmp_dir + 'bug_163.rb')
+      FileUtils.cd @test_dir do
+        exit_code = system %Q{
+          #{Shellwords.escape(@ruby_rewrite.to_s)} --modify \
+            -l rewriter.rb \
+            #{Shellwords.escape(sample_file_expanded.to_s)}
+        }
+      end
+
+      assert File.read(expected_file.expand_path) == File.read(sample_file),
+        "#{sample_file} should be identical to #{expected_file}"
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.0/test/helper.rb

@@ -0,0 +1,41 @@
+require 'tempfile'
+require 'minitest/test'
+
+require 'simplecov'
+
+if ENV.include?('COVERAGE') && SimpleCov.usable?
+  if defined?(TracePoint)
+    require_relative 'racc_coverage_helper'
+
+    RaccCoverage.start(%w(ruby18.y ruby19.y ruby20.y ruby21.y ruby22.y ruby23.y ruby24.y),
+                       File.expand_path('../../lib/parser', __FILE__))
+
+    # Report results faster.
+    at_exit { RaccCoverage.stop }
+  end
+
+  SimpleCov.start do
+    self.formatter = SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+    ]
+
+    add_group 'Grammars' do |source_file|
+      source_file.filename =~ %r{\.y$}
+    end
+
+    # Exclude the testsuite itself.
+    add_filter '/test/'
+
+    # Exclude generated files.
+    add_filter do |source_file|
+      source_file.filename =~ %r{/lib/parser/(lexer|ruby\d+|macruby|rubymotion)\.rb$}
+    end
+  end
+end
+
+# minitest/autorun must go after SimpleCov to preserve
+# correct order of at_exit hooks.
+require 'minitest/autorun'
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser'

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.0/test/parse_helper.rb

@@ -0,0 +1,258 @@
+module ParseHelper
+  include AST::Sexp
+
+  if RUBY_VERSION == '1.8.7'
+    require 'parser/ruby18'
+
+    ALL_VERSIONS = %w(1.8)
+  else
+    require 'parser/all'
+    require 'parser/macruby'
+    require 'parser/rubymotion'
+
+    ALL_VERSIONS = %w(1.8 1.9 2.0 2.1 2.2 2.3 2.4 mac ios)
+  end
+
+  def setup
+    @diagnostics = []
+
+    super if defined?(super)
+  end
+
+  def parser_for_ruby_version(version)
+    case version
+    when '1.8' then parser = Parser::Ruby18.new
+    when '1.9' then parser = Parser::Ruby19.new
+    when '2.0' then parser = Parser::Ruby20.new
+    when '2.1' then parser = Parser::Ruby21.new
+    when '2.2' then parser = Parser::Ruby22.new
+    when '2.3' then parser = Parser::Ruby23.new
+    when '2.4' then parser = Parser::Ruby24.new
+    when 'mac' then parser = Parser::MacRuby.new
+    when 'ios' then parser = Parser::RubyMotion.new
+    else raise "Unrecognized Ruby version #{version}"
+    end
+
+    parser.diagnostics.consumer = lambda do |diagnostic|
+      @diagnostics << diagnostic
+    end
+
+    parser
+  end
+
+  def with_versions(versions)
+    (versions & ALL_VERSIONS).each do |version|
+      @diagnostics.clear
+
+      parser = parser_for_ruby_version(version)
+      yield version, parser
+    end
+  end
+
+  def assert_source_range(begin_pos, end_pos, range, version, what)
+    assert range.is_a?(Parser::Source::Range),
+           "(#{version}) #{range.inspect}.is_a?(Source::Range) for #{what}"
+
+    assert_equal begin_pos, range.begin_pos,
+                 "(#{version}) begin of #{what}"
+
+    assert_equal end_pos, range.end_pos,
+                 "(#{version}) end of #{what}"
+  end
+
+  # Use like this:
+  # ~~~
+  # assert_parses(
+  #   s(:send, s(:lit, 10), :+, s(:lit, 20))
+  #   %q{10 + 20},
+  #   %q{~~~~~~~ expression
+  #     |   ^ operator
+  #     |     ~~ expression (lit)
+  #     },
+  #     %w(1.8 1.9) # optional
+  # )
+  # ~~~
+  def assert_parses(ast, code, source_maps='', versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      try_parsing(ast, code, parser, source_maps, version)
+    end
+
+    # Also try parsing with lexer set to use UTF-32LE internally
+    with_versions(versions) do |version, parser|
+      parser.instance_eval { @lexer.force_utf32 = true }
+      try_parsing(ast, code, parser, source_maps, version)
+    end
+  end
+
+  def try_parsing(ast, code, parser, source_maps, version)
+    source_file = Parser::Source::Buffer.new('(assert_parses)')
+    source_file.source = code
+
+    begin
+      parsed_ast = parser.parse(source_file)
+    rescue => exc
+      backtrace = exc.backtrace
+      Exception.instance_method(:initialize).bind(exc).
+        call("(#{version}) #{exc.message}")
+      exc.set_backtrace(backtrace)
+      raise
+    end
+
+    assert_equal ast, parsed_ast,
+                 "(#{version}) AST equality"
+
+    parse_source_map_descriptions(source_maps) \
+        do |begin_pos, end_pos, map_field, ast_path, line|
+
+      astlet = traverse_ast(parsed_ast, ast_path)
+
+      if astlet.nil?
+        # This is a testsuite bug.
+        raise "No entity with AST path #{ast_path} in #{parsed_ast.inspect}"
+      end
+
+      assert astlet.frozen?
+
+      assert astlet.location.respond_to?(map_field),
+             "(#{version}) #{astlet.location.inspect}.respond_to?(#{map_field.inspect}) for:\n#{parsed_ast.inspect}"
+
+      range = astlet.location.send(map_field)
+
+      assert_source_range(begin_pos, end_pos, range, version, line.inspect)
+    end
+  end
+
+  # Use like this:
+  # ~~~
+  # assert_diagnoses(
+  #   [:warning, :ambiguous_prefix, { prefix: '*' }],
+  #   %q{foo *bar},
+  #   %q{    ^ location
+  #     |     ~~~ highlights (0)})
+  # ~~~
+  def assert_diagnoses(diagnostic, code, source_maps='', versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      source_file = Parser::Source::Buffer.new('(assert_diagnoses)')
+      source_file.source = code
+
+      begin
+        parser = parser.parse(source_file)
+      rescue Parser::SyntaxError
+        # do nothing; the diagnostic was reported
+      end
+
+      assert_equal 1, @diagnostics.count,
+                   "(#{version}) emits a single diagnostic, not\n" \
+                   "#{@diagnostics.map(&:render).join("\n")}"
+
+      emitted_diagnostic = @diagnostics.first
+
+      level, reason, arguments = diagnostic
+      arguments ||= {}
+      message     = Parser::MESSAGES[reason] % arguments
+
+      assert_equal level, emitted_diagnostic.level
+      assert_equal reason, emitted_diagnostic.reason
+      assert_equal arguments, emitted_diagnostic.arguments
+      assert_equal message, emitted_diagnostic.message
+
+      parse_source_map_descriptions(source_maps) \
+          do |begin_pos, end_pos, map_field, ast_path, line|
+
+        case map_field
+        when 'location'
+          assert_source_range begin_pos, end_pos,
+                              emitted_diagnostic.location,
+                              version, 'location'
+
+        when 'highlights'
+          index = ast_path.first.to_i
+
+          assert_source_range begin_pos, end_pos,
+                              emitted_diagnostic.highlights[index],
+                              version, "#{index}th highlight"
+
+        else
+          raise "Unknown diagnostic range #{map_field}"
+        end
+      end
+    end
+  end
+
+  def refute_diagnoses(code, versions=ALL_VERSIONS)
+    with_versions(versions) do |version, parser|
+      source_file = Parser::Source::Buffer.new('(refute_diagnoses)')
+      source_file.source = code
+
+      begin
+        parser = parser.parse(source_file)
+      rescue Parser::SyntaxError
+        # do nothing; the diagnostic was reported
+      end
+
+      assert_empty @diagnostics,
+                   "(#{version}) emits no diagnostics, not\n" \
+                   "#{@diagnostics.map(&:render).join("\n")}"
+    end
+  end
+
+  SOURCE_MAP_DESCRIPTION_RE =
+      /(?x)
+       ^(?# $1 skip)            ^(\s*)
+        (?# $2 highlight)        ([~\^]+)
+                                 \s+
+        (?# $3 source_map_field) ([a-z_]+)
+        (?# $5 ast_path)         (\s+\(([a-z_.\/0-9]+)\))?
+                                $/
+
+  def parse_source_map_descriptions(descriptions)
+    unless block_given?
+      return to_enum(:parse_source_map_descriptions, descriptions)
+    end
+
+    descriptions.each_line do |line|
+      # Remove leading "     |", if it exists.
+      line = line.sub(/^\s*\|/, '').rstrip
+
+      next if line.empty?
+
+      if (match = SOURCE_MAP_DESCRIPTION_RE.match(line))
+        begin_pos        = match[1].length
+        end_pos          = begin_pos + match[2].length
+        source_map_field = match[3]
+
+        if match[5]
+          ast_path = match[5].split('.')
+        else
+          ast_path = []
+        end
+
+        yield begin_pos, end_pos, source_map_field, ast_path, line
+      else
+        raise "Cannot parse source map description line: #{line.inspect}."
+      end
+    end
+  end
+
+  def traverse_ast(ast, path)
+    path.inject(ast) do |astlet, path_component|
+      # Split "dstr/2" to :dstr and 1
+      type_str, index_str = path_component.split('/')
+
+      type  = type_str.to_sym
+
+      if index_str.nil?
+        index = 0
+      else
+        index = index_str.to_i - 1
+      end
+
+      matching_children = \
+        astlet.children.select do |child|
+          AST::Node === child && child.type == type
+        end
+
+      matching_children[index]
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.0/test/racc_coverage_helper.rb

@@ -0,0 +1,130 @@
+require 'racc/grammarfileparser'
+
+# Unfortunately, Ruby's Coverage module ignores module_eval statements,
+# which Racc uses to map `parser.y` locations in the generated
+# `parser.rb`.
+module RaccCoverage
+  @coverage  = {}
+  @base_path = nil
+  @trace     = nil
+
+  def self.start(parsers, base_path)
+    @base_path = base_path
+
+    parsers.each do |parser|
+      @coverage[parser] = extract_interesting_lines(parser, base_path)
+    end
+
+    @trace = TracePoint.trace(:line) do |trace|
+      lineno = trace.lineno - 1
+
+      if (line_coverage = @coverage[trace.path])
+        if line_coverage[lineno]
+          line_coverage[lineno] += 1
+        end
+      end
+    end
+  end
+
+  def self.stop
+    @trace.disable
+  end
+
+  # Ruby's TracePoint#lineno will point only on "interesting" lines,
+  # i.e.: only code (no comments or empty lines), no `end` keywords,
+  # and for multi-line statements, only the first line of the statement.
+  #
+  # This method implements a very dumb Ruby parser, which skips empty lines
+  # or lines with just comments, `end` keywords, and correctly handles
+  # multi-line statements of the following form:
+  #
+  #  * All lines of the statement except the last must end with `,`, `.` or `(`.
+  #
+  # Coverage can be disabled for code regions with annotations :nocov: and :cov:.
+  #
+  # Also, for best results, all actions should be delimited by at least
+  # one non-action line.
+  #
+  def self.extract_interesting_lines(parser, base_path)
+    grammar_source = File.join(@base_path, parser)
+    grammar_file   = Racc::GrammarFileParser.parse_file(grammar_source)
+
+    ruby_sources = [
+      # Header and footer aren't passed through module_eval
+      # in Racc-generated file, so the location info is lost.
+      *grammar_file.params.inner,
+    ].compact
+
+    grammar_file.grammar.each_rule do |rule|
+      source = rule.action.source
+      next if source.nil?
+
+      ruby_sources << source
+    end
+
+    lines = []
+
+    ruby_sources.each do |source|
+      first_line = source.lineno
+
+      state = :first_line
+
+      source.text.each_line.with_index do |line, index|
+        line = line.strip
+
+        continues = line.end_with?(',')   ||
+                      line.end_with?('(') ||
+                      line.end_with?('.')
+
+        case state
+        when :first_line
+          if line =~ /:nocov/
+            state = :nocov
+            next
+          elsif line.empty?   ||
+                  line == 'end' ||
+                  line.start_with?('#')
+            next
+          elsif continues
+            state = :mid_line
+          end
+
+          lines[first_line + index - 1] = 0
+
+        when :mid_line
+          unless continues
+            state = :first_line
+          end
+
+        when :nocov
+          if line =~ /:cov:/
+            state = :first_line
+          end
+        end
+      end
+    end
+
+    lines
+  end
+
+  def self.result
+    result =
+      @coverage.map do |parser, coverage|
+        [File.join(@base_path, parser), coverage]
+      end
+
+    Hash[result]
+  end
+end
+
+class << SimpleCov
+  def result_with_racc_coverage
+    @result ||= SimpleCov::Result.new(
+                  Coverage.result.merge(RaccCoverage.result))
+
+    result_without_racc_coverage
+  end
+
+  alias result_without_racc_coverage result
+  alias result result_with_racc_coverage
+end

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.0/test/test_base.rb

@@ -0,0 +1,29 @@
+require 'helper'
+require 'parser/current'
+
+class TestBase < Minitest::Test
+  include AST::Sexp
+
+  def test_parse
+    ast = Parser::CurrentRuby.parse('1')
+    assert_equal s(:int, 1), ast
+  end
+
+  def test_parse_with_comments
+    ast, comments = Parser::CurrentRuby.parse_with_comments('1 # foo')
+    assert_equal s(:int, 1), ast
+    assert_equal 1, comments.size
+    assert_equal '# foo', comments.first.text
+  end
+
+  def test_loc_to_node
+    ast = Parser::CurrentRuby.parse('1')
+    assert_equal ast.loc.node, ast
+  end
+
+  def test_loc_dup
+    ast = Parser::CurrentRuby.parse('1')
+    assert_equal nil, ast.loc.dup.node
+    Parser::AST::Node.new(:root, [], :location => ast.loc)
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.0/test/test_current.rb

@@ -0,0 +1,25 @@
+require 'helper'
+require 'parser/current'
+
+class TestCurrent < Minitest::Test
+  def test_current
+    case RUBY_VERSION
+    when '1.8.7'
+      assert_equal Parser::Ruby18, Parser::CurrentRuby
+    when '1.9.2', '1.9.3'
+      assert_equal Parser::Ruby19, Parser::CurrentRuby
+    when '2.0.0'
+      assert_equal Parser::Ruby20, Parser::CurrentRuby
+    when /^2\.1\.\d+/
+      assert_equal Parser::Ruby21, Parser::CurrentRuby
+    when /^2\.2\.\d+/
+      assert_equal Parser::Ruby22, Parser::CurrentRuby
+    when /^2\.3\.\d+/
+      assert_equal Parser::Ruby23, Parser::CurrentRuby
+    when /^2\.4\.\d+/
+      assert_equal Parser::Ruby24, Parser::CurrentRuby
+    else
+      flunk "Update test_current for #{RUBY_VERSION}"
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.0/test/test_diagnostic.rb

@@ -0,0 +1,94 @@
+require 'helper'
+
+class TestDiagnostic < Minitest::Test
+  def setup
+    @buffer = Parser::Source::Buffer.new('(string)')
+    @buffer.source = 'if (this is some bad code + bugs)'
+
+    @range1 = Parser::Source::Range.new(@buffer, 0, 2) # if
+    @range2 = Parser::Source::Range.new(@buffer, 4, 8) # this
+  end
+
+  def test_verifies_levels
+    error = assert_raises ArgumentError do
+      Parser::Diagnostic.new(:foobar, :escape_eof, {}, @range1)
+    end
+
+    assert_match /level/, error.message
+  end
+
+  def test_freezes
+    string     = 'foo'
+    highlights = [@range2]
+
+    diag = Parser::Diagnostic.new(:error, :escape_eof, @range1, highlights)
+    assert diag.frozen?
+    assert diag.arguments.frozen?
+    assert diag.highlights.frozen?
+
+    refute string.frozen?
+    refute highlights.frozen?
+  end
+
+  def test_render
+    location = Parser::Source::Range.new(@buffer, 26, 27)
+
+    highlights = [
+      Parser::Source::Range.new(@buffer, 21, 25),
+      Parser::Source::Range.new(@buffer, 28, 32)
+    ]
+
+    diag  = Parser::Diagnostic.new(:error, :unexpected, { :character => '+' },
+                                   location, highlights)
+    assert_equal([
+      "(string):1:27: error: unexpected `+'",
+      '(string):1: if (this is some bad code + bugs)',
+      '(string):1:                      ~~~~ ^ ~~~~ '
+    ], diag.render)
+  end
+
+  def test_multiline_render
+    @buffer = Parser::Source::Buffer.new('(string)')
+    @buffer.source = "abc abc abc\ndef def def\nghi ghi ghi\n"
+
+    location = Parser::Source::Range.new(@buffer, 4, 27)
+
+    highlights = [
+      Parser::Source::Range.new(@buffer, 0, 3),
+      Parser::Source::Range.new(@buffer, 28, 31)
+    ]
+
+    diag = Parser::Diagnostic.new(:error, :unexpected_token, { :token => 'ghi' },
+                                  location, highlights)
+
+    assert_equal([
+      "(string):1:5-3:3: error: unexpected token ghi",
+      '(string):1: abc abc abc',
+      '(string):1: ~~~ ^~~~~~~...',
+      '(string):3: ghi ghi ghi',
+      '(string):3: ~~~ ~~~    '
+    ], diag.render)
+  end
+
+  def test_bug_error_on_newline
+    # regression test; see GitHub issue 273
+    source = <<-CODE
+{
+  foo: ->() # I forgot my brace
+  }
+}
+    CODE
+    @buffer = Parser::Source::Buffer.new('(string)')
+    @buffer.source = source
+
+    location = Parser::Source::Range.new(@buffer, 33, 34)
+    diag = Parser::Diagnostic.new(:error, :unexpected_token, { :token => 'tNL' },
+                                  location)
+
+    assert_equal([
+      '(string):2:32: error: unexpected token tNL',
+      '(string):2:   foo: ->() # I forgot my brace',
+      '(string):2:                                ^'
+    ], diag.render)
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.0/test/test_diagnostic_engine.rb

@@ -0,0 +1,60 @@
+require 'helper'
+
+class TestDiagnosticEngine < Minitest::Test
+  def setup
+    @buffer  = Parser::Source::Buffer.new('(source)')
+    @buffer.source = 'foobar'
+
+    @engine = Parser::Diagnostic::Engine.new
+
+    @queue  = []
+    @engine.consumer = lambda { |diag| @queue << diag }
+  end
+
+  def test_process_warnings
+    warn = Parser::Diagnostic.new(:warning, :invalid_escape, @buffer, 1..2)
+    @engine.process(warn)
+
+    assert_equal [warn], @queue
+  end
+
+  def test_ignore_warnings
+    @engine.ignore_warnings = true
+
+    warn = Parser::Diagnostic.new(:warning, :invalid_escape, @buffer, 1..2)
+    @engine.process(warn)
+
+    assert_equal [], @queue
+  end
+
+  def test_all_errors_are_fatal
+    @engine.all_errors_are_fatal = true
+
+    error = Parser::Diagnostic.new(:error, :invalid_escape, @buffer, 1..2)
+
+    err = assert_raises Parser::SyntaxError do
+      @engine.process(error)
+    end
+
+    assert_equal error, err.diagnostic
+
+    assert_equal [error], @queue
+  end
+
+  def test_all_errors_are_collected
+    error = Parser::Diagnostic.new(:error, :invalid_escape, @buffer, 1..2)
+    @engine.process(error)
+
+    assert_equal [error], @queue
+  end
+
+  def test_fatal_error
+    fatal = Parser::Diagnostic.new(:fatal, :invalid_escape, @buffer, 1..2)
+
+    assert_raises Parser::SyntaxError do
+      @engine.process(fatal)
+    end
+
+    assert_equal [fatal], @queue
+  end
+end