rubyjobbuilderdsl 0.0.0 → 0.0.1

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

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

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

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

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