cocRb 0.1.0

data/.bundle/ruby/3.0.0/gems/parallel-1.20.1/lib/parallel/processor_count.rb

@@ -0,0 +1,42 @@
+require 'etc'
+
+module Parallel
+  # TODO: inline this method into parallel.rb and kill physical_processor_count in next major release
+  module ProcessorCount
+    # Number of processors seen by the OS, used for process scheduling
+    def processor_count
+      @processor_count ||= Integer(ENV['PARALLEL_PROCESSOR_COUNT'] || Etc.nprocessors)
+    end
+
+    # Number of physical processor cores on the current system.
+    def physical_processor_count
+      @physical_processor_count ||= begin
+        ppc = case RbConfig::CONFIG["target_os"]
+        when /darwin1/
+          IO.popen("/usr/sbin/sysctl -n hw.physicalcpu").read.to_i
+        when /linux/
+          cores = {}  # unique physical ID / core ID combinations
+          phy = 0
+          IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
+            if ln.start_with?("physical")
+              phy = ln[/\d+/]
+            elsif ln.start_with?("core")
+              cid = phy + ":" + ln[/\d+/]
+              cores[cid] = true if not cores[cid]
+            end
+          end
+          cores.count
+        when /mswin|mingw/
+          require 'win32ole'
+          result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
+            "select NumberOfCores from Win32_Processor")
+          result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
+        else
+          processor_count
+        end
+        # fall back to logical count if physical info is invalid
+        ppc > 0 ? ppc : processor_count
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/parallel-1.20.1/lib/parallel/version.rb

@@ -0,0 +1,3 @@
+module Parallel
+  VERSION = Version = '1.20.1'
+end

data/.bundle/ruby/3.0.0/gems/parser-3.0.1.1/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2013-2016 whitequark  <whitequark@whitequark.org>
+
+Parts of the source are derived from ruby_parser:
+Copyright (c) Ryan Davis, seattle.rb
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/.bundle/ruby/3.0.0/gems/parser-3.0.1.1/bin/ruby-parse

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser/runner/ruby_parse'
+
+Parser::Runner::RubyParse.go(ARGV)

data/.bundle/ruby/3.0.0/gems/parser-3.0.1.1/bin/ruby-rewrite

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser/runner/ruby_rewrite'
+
+Parser::Runner::RubyRewrite.go(ARGV)

data/.bundle/ruby/3.0.0/gems/parser-3.0.1.1/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/.bundle/ruby/3.0.0/gems/parser-3.0.1.1/lib/parser.rb

@@ -0,0 +1,85 @@
+# 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/method_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/max_numparam_stack'
+  require 'parser/current_arg_stack'
+  require 'parser/variables_stack'
+
+  require 'parser/base'
+
+  require 'parser/rewriter'
+  require 'parser/tree_rewriter'
+end

data/.bundle/ruby/3.0.0/gems/parser-3.0.1.1/lib/parser/all.rb

@@ -0,0 +1,14 @@
+# 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'
+require 'parser/ruby27'
+require 'parser/ruby30'
+require 'parser/ruby31'

data/.bundle/ruby/3.0.0/gems/parser-3.0.1.1/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/.bundle/ruby/3.0.0/gems/parser-3.0.1.1/lib/parser/ast/processor.rb

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