rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/test/parse_helper.rb

@@ -1,241 +0,0 @@
-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/ruby22'
-
-    ALL_VERSIONS = %w(1.8 1.9 2.0 2.1 2.2)
-  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
-    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|
-      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.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
-  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.1.0/gems/parser-2.2.0.pre.4/test/racc_coverage_helper.rb

@@ -1,130 +0,0 @@
-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.1.0/gems/parser-2.2.0.pre.4/test/test_base.rb

@@ -1,18 +0,0 @@
-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
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/test/test_current.rb

@@ -1,21 +0,0 @@
-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
-    else
-      flunk "Update test_parser_current for #{RUBY_VERSION}"
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/test/test_diagnostic.rb

@@ -1,49 +0,0 @@
-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 `+'",
-      'if (this is some bad code + bugs)',
-      '                     ~~~~ ^ ~~~~ '
-    ], diag.render)
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/test/test_diagnostic_engine.rb

@@ -1,60 +0,0 @@
-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

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/test/test_encoding.rb

@@ -1,78 +0,0 @@
-# encoding: binary
-
-require 'helper'
-
-class TestEncoding < Minitest::Test
-  include AST::Sexp
-
-  def recognize(string)
-    Parser::Source::Buffer.recognize_encoding(string)
-  end
-
-  if defined?(Encoding)
-    require 'parser/all'
-
-    def test_default
-      assert_equal nil, recognize('foobar')
-    end
-
-    def test_bom
-      assert_equal Encoding::UTF_8, recognize("\xef\xbb\xbf\nfoobar")
-      assert_equal Encoding::UTF_8, recognize("\xef\xbb\xbf# coding:koi8-r\nfoobar")
-    end
-
-    def test_magic_comment
-      assert_equal Encoding::KOI8_R, recognize("# coding:koi8-r\nfoobar")
-    end
-
-    def test_shebang
-      assert_equal Encoding::KOI8_R, recognize("#!/bin/foo\n# coding:koi8-r\nfoobar")
-    end
-
-    def test_case
-      assert_equal Encoding::KOI8_R, recognize("# coding:KoI8-r\nfoobar")
-    end
-
-    def test_space
-      assert_equal Encoding::KOI8_R, recognize("# coding : koi8-r\nfoobar")
-    end
-
-    def test_empty
-      assert_equal nil, recognize('')
-    end
-
-    def test_no_comment
-      assert_equal nil, recognize(%{require 'cane/encoding_aware_iterator'})
-    end
-
-    def test_adjacent
-      assert_equal nil, recognize('# codingkoi8-r')
-      assert_equal nil, recognize('# coding koi8-r')
-    end
-
-    def test_utf8_mac
-      assert_equal Encoding::UTF8_MAC, recognize('# coding: utf8-mac')
-    end
-
-    def test_suffix
-      assert_equal Encoding::UTF_8, recognize('# coding: utf-8-dos')
-      assert_equal Encoding::UTF_8, recognize('# coding: utf-8-unix')
-      assert_equal Encoding::UTF_8, recognize('# coding: utf-8-mac')
-
-      assert_raises(ArgumentError) do
-        assert_equal nil,           recognize('# coding: utf-8-dicks')
-      end
-    end
-
-    def test_parse_18_invalid_enc
-      ast = Parser::Ruby18.parse("# encoding:feynman-diagram\n1")
-      assert_equal ast, s(:int, 1)
-    end
-
-    def test_parse_19_invalid_enc
-      assert_raises(ArgumentError) do
-        Parser::Ruby19.parse("# encoding:feynman-diagram\n1")
-      end
-    end
-  end
-end