zuora_connect_ui 0.8.2 → 0.8.3

data/vendor/ruby/2.6.0/gems/parser-2.6.4.1/lib/parser/runner.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'find'
+require 'optparse'
+
+require 'parser'
+
+module Parser
+
+  class Runner
+    def self.go(options)
+      new.execute(options)
+    end
+
+    def initialize
+      Parser::Builders::Default.modernize
+
+      @option_parser = OptionParser.new { |opts| setup_option_parsing(opts) }
+      @parser_class  = nil
+      @parser        = nil
+      @files         = []
+      @fragments     = []
+      @warnings      = false
+      @benchmark     = false
+
+      @source_count = 0
+      @source_size  = 0
+    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(opts)
+      opts.banner = "Usage: #{runner_name} [options] FILE|DIRECTORY..."
+
+      opts.on_tail '-h', '--help', 'Display this help message and exit' do
+        puts opts.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
+
+      opts.on_tail '-V', '--version', 'Output version information and exit' do
+        puts "#{runner_name} based on parser version #{Parser::VERSION}"
+        exit
+      end
+
+      opts.on '--18', 'Parse as Ruby 1.8.7 would' do
+        require 'parser/ruby18'
+        @parser_class = Parser::Ruby18
+      end
+
+      opts.on '--19', 'Parse as Ruby 1.9.3 would' do
+        require 'parser/ruby19'
+        @parser_class = Parser::Ruby19
+      end
+
+      opts.on '--20', 'Parse as Ruby 2.0 would' do
+        require 'parser/ruby20'
+        @parser_class = Parser::Ruby20
+      end
+
+      opts.on '--21', 'Parse as Ruby 2.1 would' do
+        require 'parser/ruby21'
+        @parser_class = Parser::Ruby21
+      end
+
+      opts.on '--22', 'Parse as Ruby 2.2 would' do
+        require 'parser/ruby22'
+        @parser_class = Parser::Ruby22
+      end
+
+      opts.on '--23', 'Parse as Ruby 2.3 would' do
+        require 'parser/ruby23'
+        @parser_class = Parser::Ruby23
+      end
+
+      opts.on '--24', 'Parse as Ruby 2.4 would' do
+        require 'parser/ruby24'
+        @parser_class = Parser::Ruby24
+      end
+
+      opts.on '--25', 'Parse as Ruby 2.5 would' do
+        require 'parser/ruby25'
+        @parser_class = Parser::Ruby25
+      end
+
+      opts.on '--26', 'Parse as Ruby 2.6 would' do
+        require 'parser/ruby26'
+        @parser_class = Parser::Ruby26
+      end
+
+      opts.on '--27', 'Parse as Ruby 2.7 would' do
+        require 'parser/ruby27'
+        @parser_class = Parser::Ruby27
+      end
+
+      opts.on '--mac', 'Parse as MacRuby 0.12 would' do
+        require 'parser/macruby'
+        @parser_class = Parser::MacRuby
+      end
+
+      opts.on '--ios', 'Parse as mid-2015 RubyMotion would' do
+        require 'parser/rubymotion'
+        @parser_class = Parser::RubyMotion
+      end
+
+      opts.on '-w', '--warnings', 'Enable warnings' do |w|
+        @warnings = w
+      end
+
+      opts.on '-B',  '--benchmark', 'Benchmark the processor' do |b|
+        @benchmark = b
+      end
+
+      opts.on '-e fragment', 'Process a fragment of Ruby code' do |fragment|
+        @fragments << fragment
+      end
+    end
+
+    def parse_options(options)
+      @option_parser.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      = !@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 @benchmark
+        report_with_time(parsing_time)
+      end
+    end
+
+    def process_fragments
+      @fragments.each_with_index do |fragment, index|
+        fragment = fragment.dup.force_encoding(@parser.default_encoding)
+
+        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).force_encoding(@parser.default_encoding)
+
+        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/ruby/2.6.0/gems/parser-2.6.4.1/lib/parser/runner/ruby_parse.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'parser/runner'
+require 'parser/color'
+require 'parser/lexer/explanation'
+require 'json'
+
+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| Color.yellow(m, bold: true) }.
+                gsub(/[~.]+/)   { |m| Color.magenta(m, bold: true) }
+              hilight_line = ''
+            end
+          end
+
+          print_source = lambda do |range|
+            source_line = range.source_line
+            puts Color.green(source_line)
+            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
+
+    def initialize
+      super
+
+      @locate = false
+      @emit_ruby = false
+      @emit_json = false
+    end
+
+    private
+
+    def runner_name
+      'ruby-parse'
+    end
+
+    def setup_option_parsing(opts)
+      super(opts)
+
+      opts.on '-L', '--locate', 'Explain how source maps for AST nodes are laid out' do |v|
+        @locate = v
+      end
+
+      opts.on '-E', '--explain', 'Explain how the source is tokenized' do
+        ENV['RACC_DEBUG'] = '1'
+
+        Lexer.send :include, Lexer::Explanation
+      end
+
+      opts.on '--emit-ruby', 'Emit S-expressions as valid Ruby code' do
+        @emit_ruby = true
+      end
+
+      opts.on '--emit-json', 'Emit S-expressions as valid JSON' do
+        @emit_json = true
+      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 @locate
+        LocationProcessor.new.process(ast)
+      elsif !@benchmark
+        if @emit_ruby
+          puts ast.inspect
+        elsif @emit_json
+          puts(ast ? JSON.generate(ast.to_sexp_array) : nil)
+        else
+          puts ast.to_s
+        end
+      end
+    end
+  end
+
+end

data/vendor/ruby/2.6.0/gems/parser-2.6.4.1/lib/parser/runner/ruby_rewrite.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+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(opts)
+      super(opts)
+
+      opts.on '-l file', '--load', 'Load a rewriter' do |file|
+        load_and_discover(file)
+      end
+
+      opts.on '-m', '--modify', 'Assume rewriters normally modify AST' do
+        @modify = true
+      end
+    end
+
+    def load_and_discover(file)
+      load file
+
+      const_name = File.basename(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
+      original_name = buffer.name
+
+      @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?(original_name)
+        File.open(original_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