rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/clobbering_error.rb

@@ -1,11 +0,0 @@
-module Parser
-  ##
-  # {Parser::ClobberingError} is raised when {Parser::Source::Rewriter}
-  # detects a clobbering rewrite action. This class inherits {RuntimeError}
-  # rather than {StandardError} for backward compatibility.
-  #
-  # @api public
-  #
-  class ClobberingError < RuntimeError
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/compatibility/ruby1_8.rb

@@ -1,20 +0,0 @@
-##
-# @api public
-#
-# This monkeypatch extends Ruby 1.8 {String#%} with an ability
-# to replace named capture groups, i.e.
-# `"foo: %{bar}" % { :bar => 10 } # => "foo: 10"`.
-#
-class String
-  alias original_percent %
-
-  def %(arg, *args)
-    if arg.is_a?(Hash)
-      gsub(/%\{(\w+)\}/) do
-        arg[$1.to_sym]
-      end
-    else
-      original_percent(arg, *args)
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/compatibility/ruby1_9.rb

@@ -1,32 +0,0 @@
-unless Array.method_defined? :bsearch
-  class Array
-    def bsearch
-      return to_enum(__method__) unless block_given?
-      from = 0
-      to   = size - 1
-      satisfied = nil
-      while from <= to
-        midpoint = (from + to).div(2)
-        result = yield(cur = self[midpoint])
-        case result
-        when Numeric
-          return cur if result == 0
-          result = result < 0
-        when true
-          satisfied = cur
-        when nil, false
-          # nothing to do
-        else
-          fail TypeError, "wrong argument type #{result.class} (must be numeric, true, false or nil)"
-        end
-
-        if result
-          to = midpoint - 1
-        else
-          from = midpoint + 1
-        end
-      end
-      satisfied
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/current.rb

@@ -1,45 +0,0 @@
-module Parser
-  class << self
-    def warn_syntax_deviation(feature, version)
-      warn "warning: parser/current is loading #{feature}, which recognizes"
-      warn "warning: #{version}-compliant syntax, but you are running #{RUBY_VERSION}."
-    end
-    private :warn_syntax_deviation
-  end
-
-  case RUBY_VERSION
-  when /^1\.8\./
-    if RUBY_VERSION != '1.8.7'
-      warn_syntax_deviation 'parser/ruby18', '1.8.7'
-    end
-
-    require 'parser/ruby18'
-    CurrentRuby = Ruby18
-
-  when /^1\.9\./
-    if RUBY_VERSION != '1.9.3'
-      warn_syntax_deviation 'parser/ruby19', '1.9.3'
-    end
-
-    require 'parser/ruby19'
-    CurrentRuby = Ruby19
-
-  when /^2\.0\./
-    require 'parser/ruby20'
-    CurrentRuby = Ruby20
-
-  when /^2\.1\./
-    require 'parser/ruby21'
-    CurrentRuby = Ruby21
-
-  when /^2\.2\./
-    require 'parser/ruby22'
-    CurrentRuby = Ruby22
-
-  else # :nocov:
-    # Keep this in sync with released Ruby.
-    warn_syntax_deviation 'parser/ruby21', '2.1'
-    require 'parser/ruby21'
-    CurrentRuby = Ruby21
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/diagnostic/engine.rb

@@ -1,103 +0,0 @@
-module Parser
-
-  ##
-  # {Parser::Diagnostic::Engine} provides a basic API for dealing with
-  # diagnostics by delegating them to registered consumers.
-  #
-  # @example
-  #  buffer      = Parser::Source::Buffer.new(__FILE__)
-  #  buffer.code = 'foobar'
-  #
-  #  consumer = lambda do |diagnostic|
-  #    puts diagnostic.message
-  #  end
-  #
-  #  engine     = Parser::Diagnostic::Engine.new(consumer)
-  #  diagnostic = Parser::Diagnostic.new(
-  #      :warning, :unexpected_token, { :token => 'abc' }, buffer, 1..2)
-  #
-  #  engine.process(diagnostic) # => "unexpected token abc"
-  #
-  # @api public
-  #
-  # @!attribute [rw] consumer
-  #  @return [#call(Diagnostic)]
-  #
-  # @!attribute [rw] all_errors_are_fatal
-  #  When set to `true` any error that is encountered will result in
-  #  {Parser::SyntaxError} being raised.
-  #  @return [Boolean]
-  #
-  # @!attribute [rw] ignore_warnings
-  #  When set to `true` warnings will be ignored.
-  #  @return [Boolean]
-  #
-  class Diagnostic::Engine
-    attr_accessor :consumer
-
-    attr_accessor :all_errors_are_fatal
-    attr_accessor :ignore_warnings
-
-    ##
-    # @param [#call(Diagnostic)] consumer
-    #
-    def initialize(consumer=nil)
-      @consumer             = consumer
-
-      @all_errors_are_fatal = false
-      @ignore_warnings      = false
-    end
-
-    ##
-    # Processes a `diagnostic`:
-    #   * Passes the diagnostic to the consumer, if it's not a warning when
-    #     `ignore_warnings` is set.
-    #   * After that, raises {Parser::SyntaxError} when `all_errors_are_fatal`
-    #     is set to true.
-    #
-    # @param [Parser::Diagnostic] diagnostic
-    # @return [Parser::Diagnostic::Engine]
-    # @see ignore?
-    # @see raise?
-    #
-    def process(diagnostic)
-      if ignore?(diagnostic)
-        # do nothing
-      elsif @consumer
-        @consumer.call(diagnostic)
-      end
-
-      if raise?(diagnostic)
-        raise Parser::SyntaxError, diagnostic
-      end
-
-      self
-    end
-
-    protected
-
-    ##
-    # Checks whether `diagnostic` should be ignored.
-    #
-    # @param [Parser::Diagnostic] diagnostic
-    # @return [Boolean]
-    #
-    def ignore?(diagnostic)
-      @ignore_warnings &&
-            diagnostic.level == :warning
-    end
-
-    ##
-    # Checks whether `diagnostic` should be raised as an exception.
-    #
-    # @param [Parser::Diagnostic] diagnostic
-    # @return [Boolean]
-    #
-    def raise?(diagnostic)
-      (@all_errors_are_fatal &&
-          diagnostic.level == :error) ||
-        diagnostic.level == :fatal
-    end
-  end
-
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/diagnostic.rb

@@ -1,104 +0,0 @@
-module Parser
-
-  ##
-  # @api public
-  #
-  # @!attribute [r] level
-  #  @see LEVELS
-  #  @return [Symbol] diagnostic level
-  #
-  # @!attribute [r] reason
-  #  @see Parser::MESSAGES
-  #  @return [Symbol] reason for error
-  #
-  # @!attribute [r] arguments
-  #  @see Parser::MESSAGES
-  #  @return [Symbol] extended arguments that describe the error
-  #
-  # @!attribute [r] message
-  #  @return [String] error message
-  #
-  # @!attribute [r] location
-  #  Main error-related source range.
-  #  @return [Parser::Source::Range]
-  #
-  # @!attribute [r] highlights
-  #  Supplementary error-related source ranges.
-  #  @return [Array<Parser::Source::Range>]
-  #
-  class Diagnostic
-    ##
-    # Collection of the available diagnostic levels.
-    #
-    # @return [Array]
-    #
-    LEVELS = [:note, :warning, :error, :fatal].freeze
-
-    attr_reader :level, :reason, :arguments
-    attr_reader :location, :highlights
-
-    ##
-    # @param [Symbol] level
-    # @param [Symbol] reason
-    # @param [Hash] arguments
-    # @param [Parser::Source::Range] location
-    # @param [Array<Parser::Source::Range>] highlights
-    #
-    def initialize(level, reason, arguments, location, highlights=[])
-      unless LEVELS.include?(level)
-        raise ArgumentError,
-              "Diagnostic#level must be one of #{LEVELS.join(', ')}; " \
-              "#{level.inspect} provided."
-      end
-      raise 'Expected a location' unless location
-
-      @level       = level
-      @reason      = reason
-      @arguments   = (arguments || {}).dup.freeze
-      @location    = location
-      @highlights  = highlights.dup.freeze
-
-      freeze
-    end
-
-    ##
-    # @return [String] the rendered message.
-    #
-    def message
-      MESSAGES[@reason] % @arguments
-    end
-
-    ##
-    # Renders the diagnostic message as a clang-like diagnostic.
-    #
-    # @example
-    #  diagnostic.render # =>
-    #  # [
-    #  #   "(fragment:0):1:5: error: unexpected token $end",
-    #  #   "foo +",
-    #  #   "    ^"
-    #  # ]
-    #
-    # @return [Array<String>]
-    #
-    def render
-      source_line    = @location.source_line
-      highlight_line = ' ' * source_line.length
-
-      @highlights.each do |hilight|
-        range = hilight.column_range
-        highlight_line[range] = '~' * hilight.size
-      end
-
-      range = @location.column_range
-      highlight_line[range] = '^' * @location.size
-
-      [
-        "#{@location.to_s}: #{@level}: #{message}",
-        source_line,
-        highlight_line,
-      ]
-    end
-  end
-
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/lexer/explanation.rb

@@ -1,51 +0,0 @@
-module Parser
-
-  module Lexer::Explanation
-
-    def self.included(klass)
-      klass.class_exec do
-        alias_method :state_before_explanation=,  :state=
-        alias_method :advance_before_explanation, :advance
-
-        remove_method :state=, :advance
-      end
-    end
-
-    # Like #advance, but also pretty-print the token and its position
-    # in the stream to `stdout`.
-    def advance
-      type, (val, range) = advance_before_explanation
-
-      puts decorate(range,
-                    "\e[0;32m#{type} #{val.inspect}\e[0m",
-                    "#{state.to_s.ljust(12)} #{@cond} #{@cmdarg}\e[0m")
-
-      [ type, [val, range] ]
-    end
-
-    def state=(new_state)
-      puts "  \e[1;33m>>> STATE SET <<<\e[0m " +
-           "#{new_state.to_s.ljust(12)} #{@cond} #{@cmdarg}".rjust(66)
-
-      self.state_before_explanation = new_state
-    end
-
-    private
-
-    def decorate(range, token, info)
-      from, to = range.begin.column, range.end.column
-
-      line = range.source_line + '   '
-      line[from...to] = "\e[4m#{line[from...to]}\e[0m"
-
-      tail_len   = to - from - 1
-      tail       = '~' * (tail_len >= 0 ? tail_len : 0)
-      decoration =  "#{" " * from}\e[1;31m^#{tail}\e[0m #{token} ".
-                        ljust(70) + info
-
-      [ line, decoration ]
-    end
-
-  end
-
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/lexer/literal.rb

@@ -1,235 +0,0 @@
-# encoding: binary
-
-module Parser
-
-  class Lexer::Literal
-    DELIMITERS = { '(' => ')', '[' => ']', '{' => '}', '<' => '>' }
-    MONOLITHIC = { :tSTRING_BEG => :tSTRING }
-
-    TYPES = {
-    # type      start token     interpolate?
-      "'"   => [ :tSTRING_BEG,   false ],
-      "<<'" => [ :tSTRING_BEG,   false ],
-      '%q'  => [ :tSTRING_BEG,   false ],
-      '"'   => [ :tSTRING_BEG,   true  ],
-      '<<"' => [ :tSTRING_BEG,   true  ],
-      '%'   => [ :tSTRING_BEG,   true  ],
-      '%Q'  => [ :tSTRING_BEG,   true  ],
-
-      '%w'  => [ :tQWORDS_BEG,   false ],
-      '%W'  => [ :tWORDS_BEG,    true  ],
-
-      '%i'  => [ :tQSYMBOLS_BEG, false ],
-      '%I'  => [ :tSYMBOLS_BEG,  true  ],
-
-      ":'"  => [ :tSYMBEG,       false ],
-      '%s'  => [ :tSYMBEG,       false ],
-      ':"'  => [ :tSYMBEG,       true  ],
-
-      '/'   => [ :tREGEXP_BEG,   true  ],
-      '%r'  => [ :tREGEXP_BEG,   true  ],
-
-      '%x'  => [ :tXSTRING_BEG,  true  ],
-      '`'   => [ :tXSTRING_BEG,  true  ],
-      '<<`' => [ :tXSTRING_BEG,  true  ],
-    }
-
-    attr_reader   :heredoc_e, :str_s
-    attr_accessor :saved_herebody_s
-
-    def initialize(lexer, str_type, delimiter, str_s, heredoc_e = nil, indent = false)
-      @lexer       = lexer
-      @nesting     = 1
-
-      # DELIMITERS and TYPES are hashes with keys encoded in binary.
-      # Coerce incoming data to the same encoding.
-      str_type     = coerce_encoding(str_type)
-      delimiter    = coerce_encoding(delimiter)
-
-      unless TYPES.include?(str_type)
-        lexer.send(:diagnostic, :error, :unexpected_percent_str,
-                   { :type => str_type }, @lexer.send(:range, str_s, str_s + 2))
-      end
-
-      # String type. For :'foo', it is :'
-      @str_type    = str_type
-      # Start of the string type specifier.
-      @str_s       = str_s
-
-      @start_tok, @interpolate = TYPES[str_type]
-      @start_delim = DELIMITERS.include?(delimiter) ? delimiter : nil
-      @end_delim   = DELIMITERS.fetch(delimiter, delimiter)
-
-      @heredoc_e   = heredoc_e
-      @indent      = indent
-
-      @interp_braces = 0
-
-      @space_emitted = true
-
-      # Monolithic strings are glued into a single token, e.g.
-      # tSTRING_BEG tSTRING_CONTENT tSTRING_END -> tSTRING.
-      @monolithic  = (@start_tok == :tSTRING_BEG  &&
-                      %w(' ").include?(str_type) &&
-                      !heredoc?)
-
-      # Capture opening delimiter in percent-literals.
-      unless @heredoc_e || @str_type.end_with?(delimiter)
-        @str_type << delimiter
-      end
-
-      clear_buffer
-
-      emit_start_tok unless @monolithic
-    end
-
-    def interpolate?
-      @interpolate
-    end
-
-    def words?
-      type == :tWORDS_BEG || type == :tQWORDS_BEG ||
-        type == :tSYMBOLS_BEG || type == :tQSYMBOLS_BEG
-    end
-
-    def regexp?
-      type == :tREGEXP_BEG
-    end
-
-    def heredoc?
-      !!@heredoc_e
-    end
-
-    def type
-      @start_tok
-    end
-
-    def munge_escape?(character)
-      character = coerce_encoding(character)
-
-      if words? && character =~ /[ \t\v\r\f\n]/
-        true
-      else
-        ['\\', @start_delim, @end_delim].include?(character)
-      end
-    end
-
-    def nest_and_try_closing(delimiter, ts, te)
-      delimiter = coerce_encoding(delimiter)
-
-      if @start_delim && @start_delim == delimiter
-        @nesting += 1
-      elsif delimiter?(delimiter)
-        @nesting -= 1
-      end
-
-      # Finalize if last matching delimiter is closed.
-      if @nesting == 0
-        if words?
-          extend_space(ts, ts)
-        end
-
-        # Emit the string as a single token if it's applicable.
-        if @monolithic
-          emit(MONOLITHIC[@start_tok], @buffer, @str_s, te)
-        else
-          # If this is a heredoc, @buffer contains the sentinel now.
-          # Just throw it out. Lexer flushes the heredoc after each
-          # non-heredoc-terminating \n anyway, so no data will be lost.
-          flush_string unless heredoc?
-
-          emit(:tSTRING_END, @end_delim, ts, te)
-        end
-      end
-    end
-
-    def start_interp_brace
-      @interp_braces += 1
-    end
-
-    def end_interp_brace_and_try_closing
-      @interp_braces -= 1
-
-      (@interp_braces == 0)
-    end
-
-    def extend_string(string, ts, te)
-      if @buffer_s.nil?
-        @buffer_s = ts
-      end
-
-      @buffer_e = te
-
-      @buffer << string
-    end
-
-    def flush_string
-      if @monolithic
-        emit_start_tok
-        @monolithic = false
-      end
-
-      unless @buffer.empty?
-        emit(:tSTRING_CONTENT, @buffer, @buffer_s, @buffer_e)
-
-        clear_buffer
-        extend_content
-      end
-    end
-
-    def extend_content
-      @space_emitted = false
-    end
-
-    def extend_space(ts, te)
-      flush_string
-
-      unless @space_emitted
-        emit(:tSPACE, nil, ts, te)
-
-        @space_emitted = true
-      end
-    end
-
-    protected
-
-    def delimiter?(delimiter)
-      if @indent
-        @end_delim == delimiter.lstrip
-      else
-        @end_delim == delimiter
-      end
-    end
-
-    def coerce_encoding(string)
-      if defined?(Encoding)
-        string.dup.force_encoding(Encoding::BINARY)
-      else
-        string
-      end
-    end
-
-    def clear_buffer
-      @buffer = ''
-
-      # Prime the buffer with lexer encoding; otherwise,
-      # concatenation will produce varying results.
-      if defined?(Encoding)
-        @buffer.force_encoding(@lexer.encoding)
-      end
-
-      @buffer_s = nil
-      @buffer_e = nil
-    end
-
-    def emit_start_tok
-      str_e = @heredoc_e || @str_s + @str_type.length
-      emit(@start_tok, @str_type, @str_s, str_e)
-    end
-
-    def emit(token, type, s, e)
-      @lexer.send(:emit, token, type, s, e)
-    end
-  end
-
-end

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/lib/parser/lexer/stack_state.rb

@@ -1,42 +0,0 @@
-module Parser
-
-  class Lexer::StackState
-    def initialize(name)
-      @name  = name.freeze
-      clear
-    end
-
-    def clear
-      @stack = 0
-    end
-
-    def push(bit)
-      bit_value = bit ? 1 : 0
-      @stack = (@stack << 1) | bit_value
-
-      bit
-    end
-
-    def pop
-      bit_value = @stack & 1
-      @stack  >>= 1
-
-      bit_value == 1
-    end
-
-    def lexpop
-      push(pop || pop)
-    end
-
-    def active?
-      @stack[0] == 1
-    end
-
-    def to_s
-      "[#{@stack.to_s(2)} <= #{@name}]"
-    end
-
-    alias inspect to_s
-  end
-
-end