dirwatch 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.2/lib/parser/runner/ruby_parse.rb

@@ -1,146 +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
-
-    def initialize
-      super
-
-      @locate = false
-      @emit_ruby = 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
-    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
-        else
-          puts ast.to_s
-        end
-      end
-    end
-  end
-
-end

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.2/lib/parser/runner/ruby_rewrite.rb

@@ -1,99 +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(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

data/vendor/bundle/ruby/2.3.0/gems/parser-2.4.0.2/lib/parser/runner.rb

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