dirwatch 0.0.8 → 0.0.9

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/doc/CUSTOMIZATION.md

@@ -0,0 +1,37 @@
+# Customizing Parsers
+
+While the default setup of the parsers provided by this Gem should be suitable
+for most some developers might want to change parts of it. An example would be
+the use of a custom class for nodes instead of `Parser::AST::Node`.
+
+Customizing the AST is done by creating a custom builder class and passing it
+to the constructor method of a parser. The default setup comes down to the
+following:
+
+    builder = Parser::Builders::Default.new
+    parser  = Parser::Ruby19.new(builder)
+
+When creating your own builder class it's best to subclass the default one so
+that you don't have to redefine every used method again:
+
+    class MyBuilder < Parser::Builders::Default
+
+    end
+
+    builder = MyBuilder.new
+    parser  = Parser::Ruby19.new(builder)
+
+## Custom Node Classes
+
+To use a custom node class you have to override the method
+`Parser::Builders::Default#n`:
+
+    class MyBuilder < Parser::Builders::Default
+      def n(type, children, location)
+        return MyNodeClass.new(type, children, :location => location)
+      end
+    end
+
+Note that the used class (and corresponding instance) must be compatible with
+`Parser::AST::Node` so it's best to subclass it and override/add code where
+needed.

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/doc/INTERNALS.md

@@ -0,0 +1,21 @@
+Entry points
+------------
+
+Parser should be kept as slim as possible. This includes not loading
+any potentially large files when they are likely to be unused in practice.
+
+Parser has five main (classes of) `require` entry points:
+
+ * `require 'parser'`. Main entry point, requires all classes which
+   are used across the entire library.
+ * `require 'parser/rubyXX'`. Version-specific entry point. Can raise
+   a NotImplementedError if current Ruby runtime is unable to parse the
+   requested Ruby version.
+ * `require 'parser/all'`. Requires all available parsers for released
+   versions of Ruby. Can raise NotImplementedError.
+ * `require 'parser/runner'`. Requires all the stuff which is useful for
+   command-line tools but not otherwise.
+ * `require 'parser/runner/X'`. Runner-specific entry point.
+
+All non-main entry points internally `require 'parser'`. Additionally, all
+runner-specific entry points internally `requre 'parser/runner'`.

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/doc/css/common.css

@@ -0,0 +1,68 @@
+body
+{
+    font-size:   14px;
+    line-height: 1.6;
+    margin:      0 auto;
+    max-width:   960px;
+}
+
+p code
+{
+    background:    #f2f2f2;
+    padding-left:  3px;
+    padding-right: 3px;
+}
+
+pre.code
+{
+    font-size:   13px;
+    line-height: 1.4;
+}
+
+/**
+ * YARD uses generic table styles, using a special class means those tables
+ * don't get messed up.
+ */
+.table
+{
+    border:          1px solid #ccc;
+    border-right:    none;
+    border-collapse: separate;
+    border-spacing:  0;
+    text-align:      left;
+}
+
+.table.full
+{
+    width: 100%;
+}
+
+    .table .field_name
+    {
+        min-width: 160px;
+    }
+
+    .table thead tr th.no_sort:first-child
+    {
+        width: 25px;
+    }
+
+    .table thead tr th, .table tbody tr td
+    {
+        border-bottom:  1px solid #ccc;
+        border-right:   1px solid #ccc;
+        min-width:      20px;
+        padding:        8px 5px;
+        text-align:     left;
+        vertical-align: top;
+    }
+
+    .table tbody tr:last-child td
+    {
+        border-bottom: none;
+    }
+
+    .table tr:nth-child(odd) td
+    {
+        background: #f9f9f9;
+    }

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/gauntlet_parser.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'gauntlet'
+require 'parser/all'
+require 'shellwords'
+
+class ParserGauntlet < Gauntlet
+  RUBY20 = 'ruby'
+  RUBY19 = 'ruby1.9.1'
+  RUBY18 = '/opt/rubies/ruby-1.8.7-p370/bin/ruby'
+
+  def try(parser, ruby, file, show_ok: false)
+    try_ruby = lambda do |e|
+      Process.spawn(%{#{ruby} -c #{Shellwords.escape file}},
+                    :err => '/dev/null', :out => '/dev/null')
+      _, status = Process.wait2
+
+      if status.success?
+        # Bug in Parser.
+        puts "Parser bug."
+        @result[file] = { parser.to_s => "#{e.class}: #{e.to_s}" }
+      else
+        # No, this file is not Ruby.
+        yield if block_given?
+      end
+    end
+
+    begin
+      parser.parse_file(file)
+
+    rescue Parser::SyntaxError => e
+      if e.diagnostic.location.resize(2).is?('<%')
+        puts "ERb."
+        return
+      end
+
+      try_ruby.call(e)
+
+    rescue ArgumentError, RegexpError,
+           Encoding::UndefinedConversionError => e
+      puts "#{file}: #{e.class}: #{e.to_s}"
+
+      try_ruby.call(e)
+
+    rescue Interrupt
+      raise
+
+    rescue Exception => e
+      puts "Parser bug: #{file} #{e.class}: #{e.to_s}"
+      @result[file] = { parser.to_s => "#{e.class}: #{e.to_s}" }
+
+    else
+      puts "Ok." if show_ok
+    end
+  end
+
+  def parse(name)
+    puts "GEM: #{name}"
+
+    @result = {}
+
+    if ENV.include?('FAST')
+      total_size = Dir["**/*.rb"].map(&File.method(:size)).reduce(:+)
+      if total_size > 300_000
+        puts "Skip."
+        return
+      end
+    end
+
+    Dir["**/*.rb"].each do |file|
+      next if File.directory? file
+
+      try(Parser::Ruby20, RUBY20, file) do
+        puts "Trying 1.9:"
+        try(Parser::Ruby19, RUBY19, file, show_ok: true) do
+          puts "Trying 1.8:"
+          try(Parser::Ruby18, RUBY18, file, show_ok: true) do
+            puts "Invalid syntax."
+          end
+        end
+      end
+    end
+
+    @result
+  end
+
+  def run(name)
+    data[name] = parse(name)
+    self.dirty = true
+  end
+
+  def should_skip?(name)
+    data[name] == {}
+  end
+
+  def load_yaml(*)
+    data = super
+    @was_errors = data.count { |_name, errs| errs != {} }
+
+    data
+  end
+
+  def shutdown
+    super
+
+    errors  = data.count { |_name, errs| errs != {} }
+    total   = data.count
+    percent = "%.5f" % [100 - errors.to_f / total * 100]
+    puts "!!! was: #{@was_errors} now: #{errors} total: #{total} frac: #{percent}%"
+  end
+end
+
+filter = ARGV.shift
+filter = Regexp.new filter if filter
+
+gauntlet = ParserGauntlet.new
+
+if ENV.include? 'UPDATE'
+  gauntlet.source_index
+  gauntlet.update_gem_tarballs
+end
+
+gauntlet.run_the_gauntlet filter

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION =~ /^1\.[89]\./
+  require 'parser/version'
+  raise LoadError, <<-UNSUPPORTED_VERSION_MSG
+parser v#{Parser::VERSION} cannot run on Ruby #{RUBY_VERSION}.
+Please upgrade to Ruby 2.0.0 or higher, or use an older version of the parser gem.
+  UNSUPPORTED_VERSION_MSG
+end
+
+require 'set'
+require 'racc/parser'
+
+require 'ast'
+
+##
+# @api public
+#
+module Parser
+  require 'parser/version'
+  require 'parser/messages'
+  require 'parser/deprecation'
+
+  module AST
+    require 'parser/ast/node'
+    require 'parser/ast/processor'
+    require 'parser/meta'
+  end
+
+  module Source
+    require 'parser/source/buffer'
+    require 'parser/source/range'
+
+    require 'parser/source/comment'
+    require 'parser/source/comment/associator'
+
+    require 'parser/source/rewriter'
+    require 'parser/source/rewriter/action'
+    require 'parser/source/tree_rewriter'
+    require 'parser/source/tree_rewriter/action'
+
+    require 'parser/source/map'
+    require 'parser/source/map/operator'
+    require 'parser/source/map/collection'
+    require 'parser/source/map/constant'
+    require 'parser/source/map/variable'
+    require 'parser/source/map/keyword'
+    require 'parser/source/map/definition'
+    require 'parser/source/map/send'
+    require 'parser/source/map/index'
+    require 'parser/source/map/condition'
+    require 'parser/source/map/ternary'
+    require 'parser/source/map/for'
+    require 'parser/source/map/rescue_body'
+    require 'parser/source/map/heredoc'
+    require 'parser/source/map/objc_kwarg'
+  end
+
+  require 'parser/syntax_error'
+  require 'parser/clobbering_error'
+  require 'parser/diagnostic'
+  require 'parser/diagnostic/engine'
+
+  require 'parser/static_environment'
+
+  require 'parser/lexer'
+  require 'parser/lexer/literal'
+  require 'parser/lexer/stack_state'
+  require 'parser/lexer/dedenter'
+
+  module Builders
+    require 'parser/builders/default'
+  end
+
+  require 'parser/context'
+
+  require 'parser/base'
+
+  require 'parser/rewriter'
+  require 'parser/tree_rewriter'
+end

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser/all.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'parser/ruby18'
+require 'parser/ruby19'
+require 'parser/ruby20'
+require 'parser/ruby21'
+require 'parser/ruby22'
+require 'parser/ruby23'
+require 'parser/ruby24'
+require 'parser/ruby25'
+require 'parser/ruby26'

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser/ast/node.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Parser
+  module AST
+
+    ##
+    # {Parser::AST::Node} contains information about a single AST node and its
+    # child nodes. It extends the basic [AST::Node](http://rdoc.info/gems/ast/AST/Node)
+    # class provided by gem [ast](http://rdoc.info/gems/ast).
+    #
+    # @api public
+    #
+    # @!attribute [r] location
+    #  Source map for this Node.
+    #  @return [Parser::Source::Map]
+    #
+    class Node < ::AST::Node
+      attr_reader :location
+
+      alias loc location
+
+      ##
+      # Assigns various properties to this AST node. Currently only the
+      # location can be set.
+      #
+      # @param [Hash] properties
+      # @option properties [Parser::Source::Map] :location Location information
+      #  of the node.
+      #
+      def assign_properties(properties)
+        if (location = properties[:location])
+          location = location.dup if location.frozen?
+          location.node = self
+          @location = location
+        end
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/parser-2.5.1.2/lib/parser/ast/processor.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Parser
+  module AST
+
+    ##
+    # @api public
+    #
+    class Processor < ::AST::Processor
+      def process_regular_node(node)
+        node.updated(nil, process_all(node))
+      end
+
+      alias on_dstr     process_regular_node
+      alias on_dsym     process_regular_node
+      alias on_regexp   process_regular_node
+      alias on_xstr     process_regular_node
+      alias on_splat    process_regular_node
+      alias on_kwsplat  process_regular_node
+      alias on_array    process_regular_node
+      alias on_pair     process_regular_node
+      alias on_hash     process_regular_node
+      alias on_irange   process_regular_node
+      alias on_erange   process_regular_node
+
+      def on_var(node)
+        node
+      end
+
+      # @private
+      def process_variable_node(node)
+        on_var(node)
+      end
+
+      alias on_lvar     process_variable_node
+      alias on_ivar     process_variable_node
+      alias on_gvar     process_variable_node
+      alias on_cvar     process_variable_node
+      alias on_back_ref process_variable_node
+      alias on_nth_ref  process_variable_node
+
+      def on_vasgn(node)
+        name, value_node = *node
+
+        if !value_node.nil?
+          node.updated(nil, [
+            name, process(value_node)
+          ])
+        else
+          node
+        end
+      end
+
+      # @private
+      def process_var_asgn_node(node)
+        on_vasgn(node)
+      end
+
+      alias on_lvasgn   process_var_asgn_node
+      alias on_ivasgn   process_var_asgn_node
+      alias on_gvasgn   process_var_asgn_node
+      alias on_cvasgn   process_var_asgn_node
+
+      alias on_and_asgn process_regular_node
+      alias on_or_asgn  process_regular_node
+
+      def on_op_asgn(node)
+        var_node, method_name, value_node = *node
+
+        node.updated(nil, [
+          process(var_node), method_name, process(value_node)
+        ])
+      end
+
+      alias on_mlhs     process_regular_node
+      alias on_masgn    process_regular_node
+
+      def on_const(node)
+        scope_node, name = *node
+
+        node.updated(nil, [
+          process(scope_node), name
+        ])
+      end
+
+      def on_casgn(node)
+        scope_node, name, value_node = *node
+
+        if !value_node.nil?
+          node.updated(nil, [
+            process(scope_node), name, process(value_node)
+          ])
+        else
+          node.updated(nil, [
+            process(scope_node), name
+          ])
+        end
+      end
+
+      alias on_args     process_regular_node
+
+      def on_argument(node)
+        arg_name, value_node = *node
+
+        if !value_node.nil?
+          node.updated(nil, [
+            arg_name, process(value_node)
+          ])
+        else
+          node
+        end
+      end
+
+      # @private
+      def process_argument_node(node)
+        on_argument(node)
+      end
+
+      alias on_arg            process_argument_node
+      alias on_optarg         process_argument_node
+      alias on_restarg        process_argument_node
+      alias on_blockarg       process_argument_node
+      alias on_shadowarg      process_argument_node
+      alias on_kwarg          process_argument_node
+      alias on_kwoptarg       process_argument_node
+      alias on_kwrestarg      process_argument_node
+      alias on_procarg0       process_argument_node
+
+      alias on_arg_expr       process_regular_node
+      alias on_restarg_expr   process_regular_node
+      alias on_blockarg_expr  process_regular_node
+      alias on_block_pass     process_regular_node
+
+      alias on_module         process_regular_node
+      alias on_class          process_regular_node
+      alias on_sclass         process_regular_node
+
+      def on_def(node)
+        name, args_node, body_node = *node
+
+        node.updated(nil, [
+          name,
+          process(args_node), process(body_node)
+        ])
+      end
+
+      def on_defs(node)
+        definee_node, name, args_node, body_node = *node
+
+        node.updated(nil, [
+          process(definee_node), name,
+          process(args_node), process(body_node)
+        ])
+      end
+
+      alias on_undef    process_regular_node
+      alias on_alias    process_regular_node
+
+      def on_send(node)
+        receiver_node, method_name, *arg_nodes = *node
+
+        receiver_node = process(receiver_node) if receiver_node
+        node.updated(nil, [
+          receiver_node, method_name, *process_all(arg_nodes)
+        ])
+      end
+
+      alias on_csend on_send
+
+      alias on_index     process_regular_node
+      alias on_indexasgn process_regular_node
+
+      alias on_block    process_regular_node
+      alias on_lambda   process_regular_node
+
+      alias on_while      process_regular_node
+      alias on_while_post process_regular_node
+      alias on_until      process_regular_node
+      alias on_until_post process_regular_node
+      alias on_for        process_regular_node
+
+      alias on_return   process_regular_node
+      alias on_break    process_regular_node
+      alias on_next     process_regular_node
+      alias on_redo     process_regular_node
+      alias on_retry    process_regular_node
+      alias on_super    process_regular_node
+      alias on_yield    process_regular_node
+      alias on_defined? process_regular_node
+
+      alias on_not      process_regular_node
+      alias on_and      process_regular_node
+      alias on_or       process_regular_node
+
+      alias on_if       process_regular_node
+
+      alias on_when     process_regular_node
+      alias on_case     process_regular_node
+
+      alias on_iflipflop process_regular_node
+      alias on_eflipflop process_regular_node
+
+      alias on_match_current_line process_regular_node
+      alias on_match_with_lvasgn  process_regular_node
+
+      alias on_resbody  process_regular_node
+      alias on_rescue   process_regular_node
+      alias on_ensure   process_regular_node
+
+      alias on_begin    process_regular_node
+      alias on_kwbegin  process_regular_node
+
+      alias on_preexe   process_regular_node
+      alias on_postexe  process_regular_node
+
+      # @private
+      def process_variable_node(node)
+        warn 'Parser::AST::Processor#process_variable_node is deprecated as a' \
+          ' public API and will be removed. Please use ' \
+          'Parser::AST::Processor#on_var instead.'
+        on_var(node)
+      end
+
+      # @private
+      def process_var_asgn_node(node)
+        warn 'Parser::AST::Processor#process_var_asgn_node is deprecated as a' \
+          ' public API and will be removed. Please use ' \
+          'Parser::AST::Processor#on_vasgn instead.'
+        on_vasgn(node)
+      end
+
+      # @private
+      def process_argument_node(node)
+        warn 'Parser::AST::Processor#process_argument_node is deprecated as a' \
+          ' public API and will be removed. Please use ' \
+          'Parser::AST::Processor#on_argument instead.'
+        on_argument(node)
+      end
+    end
+  end
+end