rubyjobbuilderdsl 0.0.2 → 0.0.3

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

@@ -1,129 +0,0 @@
-require 'parser/runner'
-require 'parser/lexer/explanation'
-
-module Parser
-
-  class Runner::RubyParse < Parser::Runner
-
-    class LocationProcessor < Parser::AST::Processor
-      def process(node)
-        if node
-          p node
-
-          source_line_no = nil
-          source_line    = ''
-          hilight_line   = ''
-
-          print_line = lambda do
-            unless hilight_line.empty?
-              puts hilight_line.
-                gsub(/[a-z_]+/) { |m| "\e[1;33m#{m}\e[0m" }.
-                gsub(/[~.]+/)   { |m| "\e[1;35m#{m}\e[0m" }
-              hilight_line = ''
-            end
-          end
-
-          print_source = lambda do |range|
-            source_line = range.source_line
-            puts "\e[32m#{source_line}\e[0m"
-            source_line
-          end
-
-          (node.loc || {}).to_hash.
-            sort_by do |name, range|
-              [(range ? range.line : 0),
-               (name == :expression ? 1 : 0)]
-            end.
-            each do |name, range|
-              next if range.nil?
-
-              if source_line_no != range.line
-                print_line.call()
-                source_line    = print_source.call(range)
-                source_line_no = range.line
-              end
-
-              beg_col = range.begin.column
-
-              if beg_col + range.length > source_line.length
-                multiline    = true
-                range_length = source_line.length - beg_col + 3
-              else
-                multiline    = false
-                range_length = range.length
-              end
-
-              length  = range_length + 1 + name.length
-              end_col = beg_col + length
-
-              if beg_col > 0
-                col_range = (beg_col - 1)...end_col
-              else
-                col_range = beg_col...end_col
-              end
-
-              if hilight_line.length < end_col
-                hilight_line = hilight_line.ljust(end_col)
-              end
-
-              if hilight_line[col_range] =~ /^\s*$/
-                if multiline
-                  tail = ('~' * (source_line.length - beg_col)) + '...'
-                else
-                  tail = '~' * range_length
-                end
-
-                tail = ' ' + tail if beg_col > 0
-
-                hilight_line[col_range] = tail + " #{name}"
-              else
-                print_line.call
-                redo
-              end
-            end
-
-          print_line.call
-        end
-
-        super
-      end
-    end
-
-    private
-
-    def runner_name
-      'ruby-parse'
-    end
-
-    def setup_option_parsing
-      super
-
-      @slop.on 'L', 'locate',  'Explain how source maps for AST nodes are laid out'
-
-      @slop.on 'E', 'explain', 'Explain how the source is tokenized' do
-        ENV['RACC_DEBUG'] = '1'
-
-        Lexer.send :include, Lexer::Explanation
-      end
-    end
-
-    def process_all_input
-      if input_size > 1
-        puts "Using #{@parser_class} to parse #{input_size} files."
-      end
-
-      super
-    end
-
-    def process(buffer)
-      ast = @parser.parse(buffer)
-
-      if @slop.locate?
-        LocationProcessor.new.process(ast)
-      elsif !@slop.benchmark?
-        p ast
-      end
-    end
-  end
-
-end

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

@@ -1,98 +0,0 @@
-require 'parser/runner'
-require 'tempfile'
-
-module Parser
-
-  class Runner::RubyRewrite < Runner
-    def initialize
-      super
-
-      @rewriters = []
-      @modify    = false
-    end
-
-    private
-
-    def runner_name
-      'ruby-rewrite'
-    end
-
-    def setup_option_parsing
-      super
-
-      @slop.on 'l=', 'load=', 'Load a rewriter' do |file|
-        load_and_discover(file)
-      end
-
-      @slop.on 'm', 'modify', 'Assume rewriters normally modify AST' do
-        @modify = true
-      end
-    end
-
-    def load_and_discover(file)
-      load file
-
-      const_name = file.
-        sub(/\.rb$/, '').
-        gsub(/(^|_)([a-z])/) do |m|
-          "#{$2.upcase}"
-        end
-
-      @rewriters << Object.const_get(const_name)
-    end
-
-    def process(initial_buffer)
-      buffer = initial_buffer
-
-      @rewriters.each do |rewriter_class|
-        @parser.reset
-        ast = @parser.parse(buffer)
-
-        rewriter = rewriter_class.new
-        new_source = rewriter.rewrite(buffer, ast)
-
-        new_buffer = Source::Buffer.new(initial_buffer.name +
-                                    '|after ' + rewriter_class.name)
-        new_buffer.source = new_source
-
-        @parser.reset
-        new_ast = @parser.parse(new_buffer)
-
-        if !@modify && ast != new_ast
-          $stderr.puts 'ASTs do not match:'
-
-          old = Tempfile.new('old')
-          old.write ast.inspect + "\n"; old.flush
-
-          new = Tempfile.new('new')
-          new.write new_ast.inspect + "\n"; new.flush
-
-          IO.popen("diff -u #{old.path} #{new.path}") do |io|
-            diff = io.read.
-              sub(/^---.*/,    "--- #{buffer.name}").
-              sub(/^\+\+\+.*/, "+++ #{new_buffer.name}")
-
-            $stderr.write diff
-          end
-
-          exit 1
-        end
-
-        buffer = new_buffer
-      end
-
-      if File.exist?(buffer.name)
-        File.open(buffer.name, 'w') do |file|
-          file.write buffer.source
-        end
-      else
-        if input_size > 1
-          puts "Rewritten content of #{buffer.name}:"
-        end
-
-        puts buffer.source
-      end
-    end
-  end
-
-end

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

@@ -1,215 +0,0 @@
-require 'benchmark'
-require 'find'
-require 'slop'
-
-require 'parser'
-
-module Parser
-
-  class Runner
-    def self.go(options)
-      new.execute(options)
-    end
-
-    def initialize
-      @slop         = Slop.new(:strict => true)
-      @parser_class = nil
-      @parser       = nil
-      @files        = []
-      @fragments    = []
-
-      @source_count = 0
-      @source_size  = 0
-
-      setup_option_parsing
-    end
-
-    def execute(options)
-      parse_options(options)
-      prepare_parser
-
-      process_all_input
-    end
-
-    private
-
-    def runner_name
-      raise NotImplementedError, "implement #{self.class}##{__callee__}"
-    end
-
-    def setup_option_parsing
-      @slop.banner "Usage: #{runner_name} [options] FILE|DIRECTORY..."
-
-      @slop.on 'h', 'help', 'Display this help message and exit', :tail => true do
-        puts @slop.help
-        puts <<-HELP
-
-  If you specify a DIRECTORY, then all *.rb files are fetched
-  from it recursively and appended to the file list.
-
-  The default parsing mode is for current Ruby (#{RUBY_VERSION}).
-        HELP
-        exit
-      end
-
-      @slop.on 'V', 'version', 'Output version information and exit', :tail => true do
-        puts "#{runner_name} based on parser version #{Parser::VERSION}"
-        exit
-      end
-
-      @slop.on '18', 'Parse as Ruby 1.8.7 would' do
-        require 'parser/ruby18'
-        @parser_class = Parser::Ruby18
-      end
-
-      @slop.on '19', 'Parse as Ruby 1.9.3 would' do
-        require 'parser/ruby19'
-        @parser_class = Parser::Ruby19
-      end
-
-      @slop.on '20', 'Parse as Ruby 2.0 would' do
-        require 'parser/ruby20'
-        @parser_class = Parser::Ruby20
-      end
-
-      @slop.on '21', 'Parse as Ruby 2.1 would' do
-        require 'parser/ruby21'
-        @parser_class = Parser::Ruby21
-      end
-
-      @slop.on '22', 'Parse as Ruby 2.2 would' do
-        require 'parser/ruby22'
-        @parser_class = Parser::Ruby22
-      end
-
-      @slop.on 'w',  'warnings',  'Enable warnings'
-
-      @slop.on 'B',  'benchmark', 'Benchmark the processor'
-
-      @slop.on 'e=', 'Process a fragment of Ruby code' do |fragment|
-        @fragments << fragment
-      end
-    end
-
-    def parse_options(options)
-      @slop.parse!(options)
-
-      # Slop has just removed recognized options from `options`.
-      options.each do |file_or_dir|
-        if File.directory?(file_or_dir)
-          Find.find(file_or_dir) do |path|
-            @files << path if path.end_with? '.rb'
-          end
-        else
-          @files << file_or_dir
-        end
-      end
-
-      if @files.empty? && @fragments.empty?
-        $stderr.puts 'Need something to parse!'
-        exit 1
-      end
-
-      if @parser_class.nil?
-        require 'parser/current'
-        @parser_class = Parser::CurrentRuby
-      end
-    end
-
-    def prepare_parser
-      @parser = @parser_class.new
-
-      @parser.diagnostics.all_errors_are_fatal = true
-      @parser.diagnostics.ignore_warnings      = !@slop.warnings?
-
-      @parser.diagnostics.consumer = lambda do |diagnostic|
-        puts(diagnostic.render)
-      end
-    end
-
-    def input_size
-      @files.size + @fragments.size
-    end
-
-    def process_all_input
-      parsing_time =
-        Benchmark.measure do
-          process_fragments
-          process_files
-        end
-
-      if @slop.benchmark?
-        report_with_time(parsing_time)
-      end
-    end
-
-    def process_fragments
-      @fragments.each_with_index do |fragment, index|
-        if fragment.respond_to? :force_encoding
-          fragment = fragment.dup.force_encoding(@parser.default_encoding)
-        end
-
-        buffer = Source::Buffer.new("(fragment:#{index})")
-        buffer.source = fragment
-
-        process_buffer(buffer)
-      end
-    end
-
-    def process_files
-      @files.each do |filename|
-        source = File.read(filename)
-        if source.respond_to? :force_encoding
-          source.force_encoding(@parser.default_encoding)
-        end
-
-        buffer = Parser::Source::Buffer.new(filename)
-
-        if @parser.class.name == 'Parser::Ruby18'
-          buffer.raw_source = source
-        else
-          buffer.source     = source
-        end
-
-        process_buffer(buffer)
-      end
-    end
-
-    def process_buffer(buffer)
-      @parser.reset
-
-      process(buffer)
-
-      @source_count += 1
-      @source_size  += buffer.source.size
-
-    rescue Parser::SyntaxError
-      # skip
-
-    rescue StandardError
-      $stderr.puts("Failed on: #{buffer.name}")
-      raise
-    end
-
-    def process(buffer)
-      raise NotImplementedError, "implement #{self.class}##{__callee__}"
-    end
-
-    def report_with_time(parsing_time)
-      cpu_time = parsing_time.utime
-
-      speed = '%.3f' % (@source_size / cpu_time / 1000)
-      puts "Parsed #{@source_count} files (#{@source_size} characters)" \
-           " in #{'%.2f' % cpu_time} seconds (#{speed} kchars/s)."
-
-      if defined?(RUBY_ENGINE)
-        engine = RUBY_ENGINE
-      else
-        engine = 'ruby'
-      end
-
-      puts "Running on #{engine} #{RUBY_VERSION}."
-    end
-  end
-
-end

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

@@ -1,245 +0,0 @@
-# encoding: ascii-8bit
-
-module Parser
-  module Source
-
-    ##
-    # A buffer with source code. {Buffer} contains the source code itself,
-    # associated location information (name and first line), and takes care
-    # of encoding.
-    #
-    # A source buffer is immutable once populated.
-    #
-    # @!attribute [r] name
-    #  Buffer name. If the buffer was created from a file, the name corresponds
-    #  to relative path to the file.
-    #  @return [String] buffer name
-    #
-    # @!attribute [r] first_line
-    #  First line of the buffer, 1 by default.
-    #  @return [Integer] first line
-    #
-    # @api public
-    #
-    class Buffer
-      attr_reader :name, :first_line
-
-      ##
-      # @api private
-      #
-      ENCODING_RE =
-        /\#.*coding\s*[:=]\s*
-          (
-            # Special-case: there's a UTF8-MAC encoding.
-            (utf8-mac)
-          |
-            # Chew the suffix; it's there for emacs compat.
-            ([A-Za-z0-9_-]+?)(-unix|-dos|-mac)
-          |
-            ([A-Za-z0-9_-]+)
-          )
-        /x
-
-      ##
-      # Try to recognize encoding of `string` as Ruby would, i.e. by looking for
-      # magic encoding comment or UTF-8 BOM. `string` can be in any encoding.
-      #
-      # @param [String]  string
-      # @return [String|nil] encoding name, if recognized
-      #
-      def self.recognize_encoding(string)
-        return if string.empty?
-
-        # extract the first two lines in an efficient way
-        string =~ /\A(.*)\n?(.*\n)?/
-        first_line, second_line = $1, $2
-
-        if first_line =~ /\A\xef\xbb\xbf/ # BOM
-          return Encoding::UTF_8
-        elsif first_line[0, 2] == '#!'
-          encoding_line = second_line
-        else
-          encoding_line = first_line
-        end
-
-        if (result = ENCODING_RE.match(encoding_line))
-          Encoding.find(result[2] || result[3] || result[5])
-        else
-          nil
-        end
-      end
-
-      ##
-      # Recognize encoding of `input` and process it so it could be lexed.
-      #
-      #  * If `input` does not contain BOM or magic encoding comment, it is
-      #    kept in the original encoding.
-      #  * If the detected encoding is binary, `input` is kept in binary.
-      #  * Otherwise, `input` is re-encoded into UTF-8 and returned as a
-      #    new string.
-      #
-      # This method mutates the encoding of `input`, but not its content.
-      #
-      # @param  [String] input
-      # @return [String]
-      # @raise  [EncodingError]
-      #
-      def self.reencode_string(input)
-        original_encoding = input.encoding
-        detected_encoding = recognize_encoding(input.force_encoding(Encoding::BINARY))
-
-        if detected_encoding.nil?
-          input.force_encoding(original_encoding)
-        elsif detected_encoding == Encoding::BINARY
-          input
-        else
-          input.
-            force_encoding(detected_encoding).
-            encode(Encoding::UTF_8)
-        end
-      end
-
-      def initialize(name, first_line = 1)
-        @name        = name
-        @source      = nil
-        @first_line  = first_line
-
-        @lines       = nil
-        @line_begins = nil
-      end
-
-      ##
-      # Populate this buffer from correspondingly named file.
-      #
-      # @example
-      #  Parser::Source::Buffer.new('foo/bar.rb').read
-      #
-      # @return [Buffer] self
-      # @raise  [ArgumentError] if already populated
-      #
-      def read
-        File.open(@name, 'rb') do |io|
-          self.source = io.read
-        end
-
-        self
-      end
-
-      ##
-      # Source code contained in this buffer.
-      #
-      # @return [String] source code
-      # @raise  [RuntimeError] if buffer is not populated yet
-      #
-      def source
-        if @source.nil?
-          raise RuntimeError, 'Cannot extract source from uninitialized Source::Buffer'
-        end
-
-        @source
-      end
-
-      ##
-      # Populate this buffer from a string with encoding autodetection.
-      # `input` is mutated if not frozen.
-      #
-      # @param [String] input
-      # @raise [ArgumentError] if already populated
-      # @raise [EncodingError] if `input` includes invalid byte sequence for the encoding
-      # @return [String]
-      #
-      def source=(input)
-        if defined?(Encoding)
-          input = input.dup if input.frozen?
-          input = self.class.reencode_string(input)
-
-          unless input.valid_encoding?
-            raise EncodingError, "invalid byte sequence in #{input.encoding.name}"
-          end
-        end
-
-        self.raw_source = input
-      end
-
-      ##
-      # Populate this buffer from a string without encoding autodetection.
-      #
-      # @param [String] input
-      # @raise [ArgumentError] if already populated
-      # @return [String]
-      #
-      def raw_source=(input)
-        if @source
-          raise ArgumentError, 'Source::Buffer is immutable'
-        end
-
-        @source = input.gsub("\r\n", "\n").freeze
-      end
-
-      ##
-      # Convert a character index into the source to a `[line, column]` tuple.
-      #
-      # @param  [Integer] position
-      # @return [[Integer, Integer]] `[line, column]`
-      #
-      def decompose_position(position)
-        line_no, line_begin = line_for(position)
-
-        [ @first_line + line_no, position - line_begin ]
-      end
-
-      ##
-      # Extract line `lineno` from source, taking `first_line` into account.
-      #
-      # @param  [Integer] lineno
-      # @return [String]
-      # @raise  [IndexError] if `lineno` is out of bounds
-      #
-      def source_line(lineno)
-        unless @lines
-          @lines = @source.lines.to_a
-          @lines.each { |line| line.chomp!("\n") }
-
-          # If a file ends with a newline, the EOF token will appear
-          # to be one line further than the end of file.
-          @lines << ""
-        end
-
-        @lines.fetch(lineno - @first_line).dup
-      end
-
-      private
-
-      def line_begins
-        unless @line_begins
-          @line_begins, index = [ [ 0, 0 ] ], 1
-
-          @source.each_char do |char|
-            if char == "\n"
-              @line_begins.unshift [ @line_begins.length, index ]
-            end
-
-            index += 1
-          end
-        end
-
-        @line_begins
-      end
-
-      def line_for(position)
-        if line_begins.respond_to? :bsearch
-          # Fast O(log n) variant for Ruby >=2.0.
-          line_begins.bsearch do |line, line_begin|
-            line_begin <= position
-          end
-        else
-          # Slower O(n) variant for Ruby <2.0.
-          line_begins.find do |line, line_begin|
-            line_begin <= position
-          end
-        end
-      end
-    end
-
-  end
-end