@ai-ecoverse/wasix-ruby 3.4.11-1 → 3.4.11-10

package/lib/ruby/gems/3.4.0/gems/power_assert-2.0.5/lib/power_assert/parser.rb

@@ -0,0 +1,251 @@
+require 'ripper'
+
+module PowerAssert
+  class Parser
+    Ident = Struct.new(:type, :name, :column)
+
+    attr_reader :line, :path, :lineno, :binding
+
+    def initialize(line, path, lineno, binding, assertion_method_name = nil, assertion_proc = nil)
+      @line = line
+      @line_for_parsing = (valid_syntax?(line) ? line : slice_expression(line)).b
+      @path = path
+      @lineno = lineno
+      @binding = binding
+      @proc_local_variables = binding.eval('local_variables').map(&:to_s)
+      @assertion_method_name = assertion_method_name
+      @assertion_proc = assertion_proc
+    end
+
+    def idents
+      @idents ||= extract_idents(Ripper.sexp(@line_for_parsing))
+    end
+
+    def call_paths
+      collect_paths(idents).uniq
+    end
+
+    def method_id_set
+      methods = idents.flatten.find_all {|i| i.type == :method }
+      @method_id_set ||= methods.map(&:name).map(&:to_sym).each_with_object({}) {|i, h| h[i] = true }
+    end
+
+    private
+
+    def valid_syntax?(str)
+      return true unless defined?(RubyVM)
+      begin
+        verbose, $VERBOSE = $VERBOSE, nil
+        RubyVM::InstructionSequence.compile(str)
+        true
+      rescue SyntaxError
+        false
+      ensure
+        $VERBOSE = verbose
+      end
+    end
+
+    def slice_expression(str)
+      str = str.chomp
+      str.sub!(/\A\s*(?:if|unless|elsif|case|while|until) /) {|i| ' ' * i.length }
+      str.sub!(/\A\s*(?:\}|\]|end)?\./) {|i| ' ' * i.length }
+      str.sub!(/[\{\.\\]\z/, '')
+      str.sub!(/(?:&&|\|\|)\z/, '')
+      str.sub!(/ (?:do|and|or)\z/, '')
+      str
+    end
+
+    class Branch < Array
+    end
+
+    AND_OR_OPS = %i(and or && ||)
+
+    #
+    # Returns idents as graph structure.
+    #
+    #                                                  +--c--b--+
+    #  extract_idents(Ripper.sexp('a&.b(c).d')) #=> a--+        +--d
+    #                                                  +--------+
+    #
+    def extract_idents(sexp)
+      tag, * = sexp
+      case tag
+      when :arg_paren, :assoc_splat, :fcall, :hash, :method_add_block, :string_literal, :return
+        extract_idents(sexp[1])
+      when :assign, :massign
+        extract_idents(sexp[2])
+      when :opassign
+        _, _, (_, op_name, (_, op_column)), s0 = sexp
+        extract_idents(s0) + [Ident[:method, op_name.sub(/=\z/, ''), op_column]]
+      when :dyna_symbol
+        if sexp[1][0].kind_of?(Symbol)
+          # sexp[1] can be [:string_content, [..]] while parsing { "a": 1 }
+          extract_idents(sexp[1])
+        else
+          sexp[1].flat_map {|s| extract_idents(s) }
+        end
+      when :assoclist_from_args, :bare_assoc_hash, :paren, :string_embexpr,
+        :regexp_literal, :xstring_literal
+        sexp[1].flat_map {|s| extract_idents(s) }
+      when :command
+        [sexp[2], sexp[1]].flat_map {|s| extract_idents(s) }
+      when :assoc_new, :dot2, :dot3, :string_content
+        sexp[1..-1].flat_map {|s| extract_idents(s) }
+      when :unary
+        handle_columnless_ident([], sexp[1], extract_idents(sexp[2]))
+      when :binary
+        op = sexp[2]
+        if AND_OR_OPS.include?(op)
+          extract_idents(sexp[1]) + [Branch[extract_idents(sexp[3]), []]]
+        else
+          handle_columnless_ident(extract_idents(sexp[1]), op, extract_idents(sexp[3]))
+        end
+      when :call
+        _, recv, (op_sym, op_name, _), method = sexp
+        with_safe_op = ((op_sym == :@op and op_name == '&.') or op_sym == :"&.")
+        if method == :call
+          handle_columnless_ident(extract_idents(recv), :call, [], with_safe_op)
+        else
+          extract_idents(recv) + (with_safe_op ? [Branch[extract_idents(method), []]] : extract_idents(method))
+        end
+      when :array
+        sexp[1] ? sexp[1].flat_map {|s| extract_idents(s) } : []
+      when :command_call
+        [sexp[1], sexp[4], sexp[3]].flat_map {|s| extract_idents(s) }
+      when :aref
+        handle_columnless_ident(extract_idents(sexp[1]), :[], extract_idents(sexp[2]))
+      when :method_add_arg
+        idents = extract_idents(sexp[1])
+        if idents.empty?
+          # idents may be empty(e.g. ->{}.())
+          extract_idents(sexp[2])
+        else
+          if idents[-1].kind_of?(Branch) and idents[-1][1].empty?
+            # Safe navigation operator is used. See :call clause also.
+            idents[0..-2] + [Branch[extract_idents(sexp[2]) + idents[-1][0], []]]
+          else
+            idents[0..-2] + extract_idents(sexp[2]) + [idents[-1]]
+          end
+        end
+      when :args_add_block
+        _, (tag, ss0, *ss1), _ = sexp
+        if tag == :args_add_star
+          (ss0 + ss1).flat_map {|s| extract_idents(s) }
+        else
+          sexp[1].flat_map {|s| extract_idents(s) }
+        end
+      when :vcall
+        _, (tag, name, (_, column)) = sexp
+        if tag == :@ident
+          [Ident[@proc_local_variables.include?(name) ? :ref : :method, name, column]]
+        else
+          []
+        end
+      when :program
+        _, ((tag0, (tag1, (tag2, (tag3, mname, _)), _), (tag4, _, ss))) = sexp
+        if tag0 == :method_add_block and tag1 == :method_add_arg and tag2 == :fcall and
+            (tag3 == :@ident or tag3 == :@const) and mname == @assertion_method_name and (tag4 == :brace_block or tag4 == :do_block)
+          ss.flat_map {|s| extract_idents(s) }
+        else
+          _, (s0, *) = sexp
+          extract_idents(s0)
+        end
+      when :ifop
+        _, s0, s1, s2 = sexp
+        [*extract_idents(s0), Branch[extract_idents(s1), extract_idents(s2)]]
+      when :if, :unless
+        _, s0, ss0, (_, ss1) = sexp
+        [*extract_idents(s0), Branch[ss0.flat_map {|s| extract_idents(s) }, ss1 ? ss1.flat_map {|s| extract_idents(s) } : []]]
+      when :if_mod, :unless_mod
+        _, s0, s1 = sexp
+        [*extract_idents(s0), Branch[extract_idents(s1), []]]
+      when :var_ref, :var_field
+        _, (tag, ref_name, (_, column)) = sexp
+        case tag
+        when :@kw
+          if ref_name == 'self'
+            [Ident[:ref, 'self', column]]
+          else
+            []
+          end
+        when :@ident, :@const, :@cvar, :@ivar, :@gvar
+          [Ident[:ref, ref_name, column]]
+        else
+          []
+        end
+      when :@ident, :@const, :@op
+        _, method_name, (_, column) = sexp
+        [Ident[:method, method_name, column]]
+      else
+        []
+      end
+    end
+
+    def str_indices(str, re, offset, limit)
+      idx = str.index(re, offset)
+      if idx and idx <= limit
+        [idx, *str_indices(str, re, idx + 1, limit)]
+      else
+        []
+      end
+    end
+
+    MID2SRCTXT = {
+      :[] => '[',
+      :+@ => '+',
+      :-@ => '-',
+      :call => '('
+    }
+
+    def handle_columnless_ident(left_idents, mid, right_idents, with_safe_op = false)
+      left_max = left_idents.flatten.max_by(&:column)
+      right_min = right_idents.flatten.min_by(&:column)
+      bg = left_max ? left_max.column + left_max.name.length : 0
+      ed = right_min ? right_min.column - 1 : @line_for_parsing.length - 1
+      mname = mid.to_s
+      srctxt = MID2SRCTXT[mid] || mname
+      re = /
+        #{'\b' if /\A\w/ =~ srctxt}
+        #{Regexp.escape(srctxt)}
+        #{'\b' if /\w\z/ =~ srctxt}
+      /x
+      indices = str_indices(@line_for_parsing, re, bg, ed)
+      if indices.length == 1 or !(right_idents.empty? and left_idents.empty?)
+        ident = Ident[:method, mname, right_idents.empty? ? indices.first : indices.last]
+        left_idents + right_idents + (with_safe_op ? [Branch[[ident], []]] : [ident])
+      else
+        left_idents + right_idents
+      end
+    end
+
+    def collect_paths(idents, prefixes = [[]], index = 0)
+      if index < idents.length
+        node = idents[index]
+        if node.kind_of?(Branch)
+          prefixes = node.flat_map {|n| collect_paths(n, prefixes, 0) }
+        else
+          prefixes = prefixes.map {|prefix| prefix + [node] }
+        end
+        collect_paths(idents, prefixes, index + 1)
+      else
+        prefixes
+      end
+    end
+
+    class DummyParser < Parser
+      def initialize
+        super('', nil, nil, TOPLEVEL_BINDING)
+      end
+
+      def idents
+        []
+      end
+
+      def call_paths
+        []
+      end
+    end
+    DUMMY = DummyParser.new
+  end
+  private_constant :Parser
+end

package/lib/ruby/gems/3.4.0/gems/power_assert-2.0.5/lib/power_assert/version.rb

@@ -0,0 +1,3 @@
+module PowerAssert
+  VERSION = "2.0.5"
+end

package/lib/ruby/gems/3.4.0/gems/power_assert-2.0.5/lib/power_assert.rb

@@ -0,0 +1,93 @@
+# power_assert.rb
+#
+# Copyright (C) 2014 Kazuki Tsujimoto
+
+begin
+  unless defined?(Byebug)
+    captured = false
+    target_thread = Thread.current
+    TracePoint.new(:return, :c_return) do |tp|
+      next unless Thread.current == target_thread
+      captured = true
+      unless tp.return_value and tp.callee_id
+        raise ''
+      end
+    end.enable { __id__ }
+    raise '' unless captured
+  end
+rescue
+  raise LoadError, 'Fully compatible TracePoint API required'
+end
+
+require 'power_assert/context'
+require 'power_assert/configuration'
+require 'power_assert/version'
+
+module PowerAssert
+  POWER_ASSERT_LIB_DIR = File.dirname(caller_locations(1, 1).first.path)
+  INTERNAL_LIB_DIRS = {PowerAssert => POWER_ASSERT_LIB_DIR}
+  private_constant :POWER_ASSERT_LIB_DIR, :INTERNAL_LIB_DIRS
+
+  class << self
+    def start(assertion_proc_or_source, assertion_method: nil, source_binding: TOPLEVEL_BINDING)
+      if respond_to?(:clear_global_method_cache, true)
+        clear_global_method_cache
+      end
+      yield BlockContext.new(assertion_proc_or_source, assertion_method, source_binding)
+    end
+
+    def trace(frame)
+      begin
+        raise 'Byebug is not started yet' unless Byebug.started?
+      rescue NameError
+        raise "PowerAssert.#{__method__} requires Byebug"
+      end
+      ctx = TraceContext.new(frame._binding)
+      ctx.enable
+      ctx
+    end
+
+    def app_caller_locations
+      caller_locations.drop_while {|i| internal_file?(i.path) }.take_while {|i| ! internal_file?(i.path) }
+    end
+
+    def app_context?
+      top_frame = caller_locations.drop_while {|i| i.path.start_with?(POWER_ASSERT_LIB_DIR) }.first
+      top_frame and ! internal_file?(top_frame.path)
+    end
+
+    private
+
+    def internal_file?(file)
+      setup_internal_lib_dir(Byebug, :attach, 2) if defined?(Byebug)
+      setup_internal_lib_dir(PryByebug, :start_with_pry_byebug, 2, Pry) if defined?(PryByebug)
+      INTERNAL_LIB_DIRS.find do |_, dir|
+        file.start_with?(dir)
+      end
+    end
+
+    def setup_internal_lib_dir(lib, mid, depth, lib_obj = lib)
+      unless INTERNAL_LIB_DIRS.key?(lib)
+        INTERNAL_LIB_DIRS[lib] = lib_dir(lib_obj, mid, depth)
+      end
+    rescue NameError
+    end
+
+    def lib_dir(obj, mid, depth)
+      File.expand_path('../' * depth, obj.method(mid).source_location[0])
+    end
+
+    if defined?(RubyVM)
+      CLEAR_CACHE_ISEQ = RubyVM::InstructionSequence.compile('using PowerAssert.const_get(:Empty)')
+      private_constant :CLEAR_CACHE_ISEQ
+
+      def clear_global_method_cache
+        CLEAR_CACHE_ISEQ.eval
+      end
+    end
+  end
+
+  module Empty
+  end
+  private_constant :Empty
+end

package/lib/ruby/gems/3.4.0/gems/prime-0.1.3/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

package/lib/ruby/gems/3.4.0/gems/prime-0.1.3/COPYING

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+   a. place your modifications in the Public Domain or otherwise
+      make them Freely Available, such as by posting said
+      modifications to Usenet or an equivalent medium, or by allowing
+      the author to include your modifications in the software.
+
+   b. use the modified software only within your corporation or
+      organization.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or binary form,
+   provided that you do at least ONE of the following:
+
+   a. distribute the binaries and library files of the software,
+      together with instructions (in the manual page or equivalent)
+      on where to get the original distribution.
+
+   b. accompany the distribution with the machine-readable source of
+      the software.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).  But some files in the distribution
+   are not written by the author, so that they are not under these terms.
+
+   For the list of those files and their copying conditions, see the
+   file LEGAL.
+
+5. The scripts and library files supplied as input to or produced as
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them,
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.

package/lib/ruby/gems/3.4.0/gems/prime-0.1.3/README.md

@@ -0,0 +1,49 @@
+# Prime
+
+[![CI](https://github.com/ruby/prime/actions/workflows/test.yml/badge.svg)](https://github.com/ruby/prime/actions/workflows/test.yml)
+
+Prime numbers and factorization library.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'prime'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install prime
+
+## Usage
+
+```ruby
+require 'prime'
+
+# Prime is the set of all prime numbers, and it is Enumerable.
+Prime.take(4)             #=> [2, 3, 5, 7]
+Prime.first(4)            #=> [2, 3, 5, 7]
+Prime.each(7).to_a        #=> [2, 3, 5, 7]
+
+# Determining whether an arbitrary integer is a prime number
+Prime.prime?(7)           #=> true
+8.prime?                  #=> false
+
+# Factorization in prime numbers
+Prime.prime_division(8959)                          #=> [[17, 2], [31, 1]]
+Prime.int_from_prime_division([[17, 2], [31, 1]])   #=> 8959
+17**2 * 31                                          #=> 8959
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/prime.
+
+## License
+
+The gem is available as open source under the terms of the [BSD-2-Clause](LICENSE.txt).

package/lib/ruby/gems/3.4.0/gems/prime-0.1.3/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test/lib"
+  t.ruby_opts << "-rhelper"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test