qiita_org 0.1.0

data/.bandle/ruby/2.7.0/gems/rake-12.3.3/lib/rake/testtask.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+require "rake"
+require "rake/tasklib"
+
+module Rake
+
+  # Create a task that runs a set of tests.
+  #
+  # Example:
+  #   require "rake/testtask"
+  #
+  #   Rake::TestTask.new do |t|
+  #     t.libs << "test"
+  #     t.test_files = FileList['test/test*.rb']
+  #     t.verbose = true
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "TESTOPTS=options" command line option,
+  # then the given options are passed to the test process after a
+  # '--'.  This allows Test::Unit options to be passed to the test
+  # suite.
+  #
+  # Examples:
+  #
+  #   rake test                           # run tests normally
+  #   rake test TEST=just_one_file.rb     # run just one test file.
+  #   rake test TESTOPTS="-v"             # run in verbose mode
+  #   rake test TESTOPTS="--runner=fox"   # use the fox test runner
+  #
+  class TestTask < TaskLib
+
+    # Name of test task. (default is :test)
+    attr_accessor :name
+
+    # List of directories added to $LOAD_PATH before running the
+    # tests. (default is 'lib')
+    attr_accessor :libs
+
+    # True if verbose test output desired. (default is false)
+    attr_accessor :verbose
+
+    # Test options passed to the test suite.  An explicit
+    # TESTOPTS=opts on the command line will override this. (default
+    # is NONE)
+    attr_accessor :options
+
+    # Request that the tests be run with the warning flag set.
+    # E.g. warning=true implies "ruby -w" used to run the tests.
+    # (default is true)
+    attr_accessor :warning
+
+    # Glob pattern to match test files. (default is 'test/test*.rb')
+    attr_accessor :pattern
+
+    # Style of test loader to use.  Options are:
+    #
+    # * :rake -- Rake provided test loading script (default).
+    # * :testrb -- Ruby provided test loading script.
+    # * :direct -- Load tests using command line loader.
+    #
+    attr_accessor :loader
+
+    # Array of command line options to pass to ruby when running test loader.
+    attr_accessor :ruby_opts
+
+    # Description of the test task. (default is 'Run tests')
+    attr_accessor :description
+
+    # Task prerequisites.
+    attr_accessor :deps
+
+    # Explicitly define the list of test files to be included in a
+    # test.  +list+ is expected to be an array of file names (a
+    # FileList is acceptable).  If both +pattern+ and +test_files+ are
+    # used, then the list of test files is the union of the two.
+    def test_files=(list)
+      @test_files = list
+    end
+
+    # Create a testing task.
+    def initialize(name=:test)
+      @name = name
+      @libs = ["lib"]
+      @pattern = nil
+      @options = nil
+      @test_files = nil
+      @verbose = false
+      @warning = true
+      @loader = :rake
+      @ruby_opts = []
+      @description = "Run tests" + (@name == :test ? "" : " for #{@name}")
+      @deps = []
+      if @name.is_a?(Hash)
+        @deps = @name.values.first
+        @name = @name.keys.first
+      end
+      yield self if block_given?
+      @pattern = "test/test*.rb" if @pattern.nil? && @test_files.nil?
+      define
+    end
+
+    # Create the tasks defined by this task lib.
+    def define
+      desc @description
+      task @name => Array(deps) do
+        FileUtilsExt.verbose(@verbose) do
+          puts "Use TESTOPTS=\"--verbose\" to pass --verbose" \
+            ", etc. to runners." if ARGV.include? "--verbose"
+          args =
+            "#{ruby_opts_string} #{run_code} " +
+            "#{file_list_string} #{option_list}"
+          ruby args do |ok, status|
+            if !ok && status.respond_to?(:signaled?) && status.signaled?
+              raise SignalException.new(status.termsig)
+            elsif !ok
+              status  = "Command failed with status (#{status.exitstatus})"
+              details = ": [ruby #{args}]"
+              message =
+                if Rake.application.options.trace or @verbose
+                  status + details
+                else
+                  status
+                end
+
+              fail message
+            end
+          end
+        end
+      end
+      self
+    end
+
+    def option_list # :nodoc:
+      (ENV["TESTOPTS"] ||
+        ENV["TESTOPT"] ||
+        ENV["TEST_OPTS"] ||
+        ENV["TEST_OPT"] ||
+        @options ||
+        "")
+    end
+
+    def ruby_opts_string # :nodoc:
+      opts = @ruby_opts.dup
+      opts.unshift("-I\"#{lib_path}\"") unless @libs.empty?
+      opts.unshift("-w") if @warning
+      opts.join(" ")
+    end
+
+    def lib_path # :nodoc:
+      @libs.join(File::PATH_SEPARATOR)
+    end
+
+    def file_list_string # :nodoc:
+      file_list.map { |fn| "\"#{fn}\"" }.join(" ")
+    end
+
+    def file_list # :nodoc:
+      if ENV["TEST"]
+        FileList[ENV["TEST"]]
+      else
+        result = []
+        result += @test_files.to_a if @test_files
+        result += FileList[@pattern].to_a if @pattern
+        result
+      end
+    end
+
+    def ruby_version # :nodoc:
+      RUBY_VERSION
+    end
+
+    def run_code # :nodoc:
+      case @loader
+      when :direct
+        "-e \"ARGV.each{|f| require f}\""
+      when :testrb
+        "-S testrb"
+      when :rake
+        "#{rake_include_arg} \"#{rake_loader}\""
+      end
+    end
+
+    def rake_loader # :nodoc:
+      find_file("rake/rake_test_loader") or
+        fail "unable to find rake test loader"
+    end
+
+    def find_file(fn) # :nodoc:
+      $LOAD_PATH.each do |path|
+        file_path = File.join(path, "#{fn}.rb")
+        return file_path if File.exist? file_path
+      end
+      nil
+    end
+
+    def rake_include_arg # :nodoc:
+      spec = Gem.loaded_specs["rake"]
+      if spec.respond_to?(:default_gem?) && spec.default_gem?
+        ""
+      else
+        "-I\"#{rake_lib_dir}\""
+      end
+    end
+
+    def rake_lib_dir # :nodoc:
+      find_dir("rake") or
+        fail "unable to find rake lib"
+    end
+
+    def find_dir(fn) # :nodoc:
+      $LOAD_PATH.each do |path|
+        file_path = File.join(path, "#{fn}.rb")
+        return path if File.exist? file_path
+      end
+      nil
+    end
+
+  end
+end

data/.bandle/ruby/2.7.0/gems/rake-12.3.3/lib/rake/thread_history_display.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require "rake/private_reader"
+
+module Rake
+
+  class ThreadHistoryDisplay    # :nodoc: all
+    include Rake::PrivateReader
+
+    private_reader :stats, :items, :threads
+
+    def initialize(stats)
+      @stats   = stats
+      @items   = { _seq_: 1  }
+      @threads = { _seq_: "A" }
+    end
+
+    def show
+      puts "Job History:"
+      stats.each do |stat|
+        stat[:data] ||= {}
+        rename(stat, :thread, threads)
+        rename(stat[:data], :item_id, items)
+        rename(stat[:data], :new_thread, threads)
+        rename(stat[:data], :deleted_thread, threads)
+        printf("%8d %2s %-20s %s\n",
+          (stat[:time] * 1_000_000).round,
+          stat[:thread],
+          stat[:event],
+          stat[:data].map do |k, v| "#{k}:#{v}" end.join(" "))
+      end
+    end
+
+    private
+
+    def rename(hash, key, renames)
+      if hash && hash[key]
+        original = hash[key]
+        value = renames[original]
+        unless value
+          value = renames[:_seq_]
+          renames[:_seq_] = renames[:_seq_].succ
+          renames[original] = value
+        end
+        hash[key] = value
+      end
+    end
+  end
+
+end

data/.bandle/ruby/2.7.0/gems/rake-12.3.3/lib/rake/thread_pool.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+require "set"
+
+require "rake/promise"
+
+module Rake
+
+  class ThreadPool # :nodoc: all
+
+    # Creates a ThreadPool object.  The +thread_count+ parameter is the size
+    # of the pool.
+    def initialize(thread_count)
+      @max_active_threads = [thread_count, 0].max
+      @threads = Set.new
+      @threads_mon = Monitor.new
+      @queue = Queue.new
+      @join_cond = @threads_mon.new_cond
+
+      @history_start_time = nil
+      @history = []
+      @history_mon = Monitor.new
+      @total_threads_in_play = 0
+    end
+
+    # Creates a future executed by the +ThreadPool+.
+    #
+    # The args are passed to the block when executing (similarly to
+    # Thread#new) The return value is an object representing
+    # a future which has been created and added to the queue in the
+    # pool. Sending #value to the object will sleep the
+    # current thread until the future is finished and will return the
+    # result (or raise an exception thrown from the future)
+    def future(*args, &block)
+      promise = Promise.new(args, &block)
+      promise.recorder = lambda { |*stats| stat(*stats) }
+
+      @queue.enq promise
+      stat :queued, item_id: promise.object_id
+      start_thread
+      promise
+    end
+
+    # Waits until the queue of futures is empty and all threads have exited.
+    def join
+      @threads_mon.synchronize do
+        begin
+          stat :joining
+          @join_cond.wait unless @threads.empty?
+          stat :joined
+        rescue Exception => e
+          stat :joined
+          $stderr.puts e
+          $stderr.print "Queue contains #{@queue.size} items. " +
+            "Thread pool contains #{@threads.count} threads\n"
+          $stderr.print "Current Thread #{Thread.current} status = " +
+            "#{Thread.current.status}\n"
+          $stderr.puts e.backtrace.join("\n")
+          @threads.each do |t|
+            $stderr.print "Thread #{t} status = #{t.status}\n"
+            $stderr.puts t.backtrace.join("\n")
+          end
+          raise e
+        end
+      end
+    end
+
+    # Enable the gathering of history events.
+    def gather_history          #:nodoc:
+      @history_start_time = Time.now if @history_start_time.nil?
+    end
+
+    # Return a array of history events for the thread pool.
+    #
+    # History gathering must be enabled to be able to see the events
+    # (see #gather_history). Best to call this when the job is
+    # complete (i.e. after ThreadPool#join is called).
+    def history                 # :nodoc:
+      @history_mon.synchronize { @history.dup }.
+        sort_by { |i| i[:time] }.
+        each { |i| i[:time] -= @history_start_time }
+    end
+
+    # Return a hash of always collected statistics for the thread pool.
+    def statistics              #  :nodoc:
+      {
+        total_threads_in_play: @total_threads_in_play,
+        max_active_threads: @max_active_threads,
+      }
+    end
+
+    private
+
+    # processes one item on the queue. Returns true if there was an
+    # item to process, false if there was no item
+    def process_queue_item      #:nodoc:
+      return false if @queue.empty?
+
+      # Even though we just asked if the queue was empty, it
+      # still could have had an item which by this statement
+      # is now gone. For this reason we pass true to Queue#deq
+      # because we will sleep indefinitely if it is empty.
+      promise = @queue.deq(true)
+      stat :dequeued, item_id: promise.object_id
+      promise.work
+      return true
+
+    rescue ThreadError # this means the queue is empty
+      false
+    end
+
+    def safe_thread_count
+      @threads_mon.synchronize do
+        @threads.count
+      end
+    end
+
+    def start_thread # :nodoc:
+      @threads_mon.synchronize do
+        next unless @threads.count < @max_active_threads
+
+        t = Thread.new do
+          begin
+            while safe_thread_count <= @max_active_threads
+              break unless process_queue_item
+            end
+          ensure
+            @threads_mon.synchronize do
+              @threads.delete Thread.current
+              stat :ended, thread_count: @threads.count
+              @join_cond.broadcast if @threads.empty?
+            end
+          end
+        end
+
+        @threads << t
+        stat(
+          :spawned,
+          new_thread: t.object_id,
+          thread_count: @threads.count)
+        @total_threads_in_play = @threads.count if
+          @threads.count > @total_threads_in_play
+      end
+    end
+
+    def stat(event, data=nil) # :nodoc:
+      return if @history_start_time.nil?
+      info = {
+        event: event,
+        data: data,
+        time: Time.now,
+        thread: Thread.current.object_id,
+      }
+      @history_mon.synchronize { @history << info }
+    end
+
+    # for testing only
+
+    def __queue__ # :nodoc:
+      @queue
+    end
+  end
+
+end

data/.bandle/ruby/2.7.0/gems/rake-12.3.3/lib/rake/trace_output.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Rake
+  module TraceOutput # :nodoc: all
+
+    # Write trace output to output stream +out+.
+    #
+    # The write is done as a single IO call (to print) to lessen the
+    # chance that the trace output is interrupted by other tasks also
+    # producing output.
+    def trace_on(out, *strings)
+      sep = $\ || "\n"
+      if strings.empty?
+        output = sep
+      else
+        output = strings.map { |s|
+          next if s.nil?
+          s.end_with?(sep) ? s : s + sep
+        }.join
+      end
+      out.print(output)
+    end
+  end
+end