@appthreat/atom-parsetools 1.0.0

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/parser-3.3.8.0/lib/gauntlet_parser.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'gauntlet'
+require_relative '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

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/parser-3.3.8.0/lib/parser/all.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'ruby18'
+require_relative 'ruby19'
+require_relative 'ruby20'
+require_relative 'ruby21'
+require_relative 'ruby22'
+require_relative 'ruby23'
+require_relative 'ruby24'
+require_relative 'ruby25'
+require_relative 'ruby26'
+require_relative 'ruby27'
+require_relative 'ruby30'
+require_relative 'ruby31'
+require_relative 'ruby32'
+require_relative 'ruby33'
+require_relative 'ruby34'

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/parser-3.3.8.0/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](https://www.rubydoc.info/gems/ast/AST/Node)
+    # class provided by gem [ast](https://www.rubydoc.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

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/parser-3.3.8.0/lib/parser/ast/processor.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+module Parser
+  module AST
+
+    ##
+    # @api public
+    #
+    class Processor
+      include ::AST::Processor::Mixin
+
+      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_kwargs   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_forward_arg    process_argument_node
+
+      def on_procarg0(node)
+        if node.children[0].is_a?(Symbol)
+          # This branch gets executed when the builder
+          # is not configured to emit and 'arg' inside 'procarg0', i.e. when
+          #   Parser::Builders::Default.emit_arg_inside_procarg0
+          # is set to false.
+          #
+          # If this flag is set to true this branch is unreachable.
+          # s(:procarg0, :a)
+          on_argument(node)
+        else
+          # s(:procarg0, s(:arg, :a), s(:arg, :b))
+          process_regular_node(node)
+        end
+      end
+
+      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_forwarded_restarg   process_regular_node
+      alias on_forwarded_kwrestarg 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
+
+      def on_numblock(node)
+        method_call, max_numparam, body = *node
+
+        node.updated(nil, [
+          process(method_call), max_numparam, process(body)
+        ])
+      end
+
+      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
+
+      alias on_case_match              process_regular_node
+      alias on_in_match                process_regular_node
+      alias on_match_pattern           process_regular_node
+      alias on_match_pattern_p         process_regular_node
+      alias on_in_pattern              process_regular_node
+      alias on_if_guard                process_regular_node
+      alias on_unless_guard            process_regular_node
+      alias on_match_var               process_variable_node
+      alias on_match_rest              process_regular_node
+      alias on_pin                     process_regular_node
+      alias on_match_alt               process_regular_node
+      alias on_match_as                process_regular_node
+      alias on_array_pattern           process_regular_node
+      alias on_array_pattern_with_tail process_regular_node
+      alias on_hash_pattern            process_regular_node
+      alias on_const_pattern           process_regular_node
+      alias on_find_pattern            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
+
+      def on_empty_else(node)
+        node
+      end
+    end
+  end
+end