diy_rails 0.1.0

data/vendor/bundle/ruby/3.0.0/gems/rake-13.0.6/lib/rake/thread_pool.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+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)
+      require "set"
+      @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/vendor/bundle/ruby/3.0.0/gems/rake-13.0.6/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

data/vendor/bundle/ruby/3.0.0/gems/rake-13.0.6/lib/rake/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Rake
+  VERSION = "13.0.6"
+
+  module Version # :nodoc: all
+    MAJOR, MINOR, BUILD, *OTHER = Rake::VERSION.split "."
+
+    NUMBERS = [MAJOR, MINOR, BUILD, *OTHER]
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/rake-13.0.6/lib/rake/win32.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "rbconfig"
+
+module Rake
+  # Win 32 interface methods for Rake. Windows specific functionality
+  # will be placed here to collect that knowledge in one spot.
+  module Win32 # :nodoc: all
+
+    # Error indicating a problem in locating the home directory on a
+    # Win32 system.
+    class Win32HomeError < RuntimeError
+    end
+
+    class << self
+      # True if running on a windows system.
+      def windows?
+        RbConfig::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw|[Ww]indows)!
+      end
+
+      # The standard directory containing system wide rake files on
+      # Win 32 systems. Try the following environment variables (in
+      # order):
+      #
+      # * HOME
+      # * HOMEDRIVE + HOMEPATH
+      # * APPDATA
+      # * USERPROFILE
+      #
+      # If the above are not defined, the return nil.
+      def win32_system_dir #:nodoc:
+        win32_shared_path = ENV["HOME"]
+        if win32_shared_path.nil? && ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+          win32_shared_path = ENV["HOMEDRIVE"] + ENV["HOMEPATH"]
+        end
+
+        win32_shared_path ||= ENV["APPDATA"]
+        win32_shared_path ||= ENV["USERPROFILE"]
+        raise Win32HomeError,
+          "Unable to determine home path environment variable." if
+            win32_shared_path.nil? or win32_shared_path.empty?
+        normalize(File.join(win32_shared_path, "Rake"))
+      end
+
+      # Normalize a win32 path so that the slashes are all forward slashes.
+      def normalize(path)
+        path.gsub(/\\/, "/")
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/rake-13.0.6/lib/rake.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+#--
+# Copyright 2003-2010 by Jim Weirich (jim.weirich@gmail.com)
+#
+# 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.
+#++
+
+module Rake; end
+
+require "rake/version"
+
+require "rbconfig"
+require "fileutils"
+require "singleton"
+require "monitor"
+require "optparse"
+require "ostruct"
+
+require "rake/ext/string"
+
+require "rake/win32"
+
+require "rake/linked_list"
+require "rake/cpu_counter"
+require "rake/scope"
+require "rake/task_argument_error"
+require "rake/rule_recursion_overflow_error"
+require "rake/rake_module"
+require "rake/trace_output"
+require "rake/pseudo_status"
+require "rake/task_arguments"
+require "rake/invocation_chain"
+require "rake/task"
+require "rake/file_task"
+require "rake/file_creation_task"
+require "rake/multi_task"
+require "rake/dsl_definition"
+require "rake/file_utils_ext"
+require "rake/file_list"
+require "rake/default_loader"
+require "rake/early_time"
+require "rake/late_time"
+require "rake/name_space"
+require "rake/task_manager"
+require "rake/application"
+require "rake/backtrace"
+
+$trace = false
+
+# :stopdoc:
+#
+# Some top level Constants.
+
+FileList = Rake::FileList
+RakeFileUtils = Rake::FileUtilsExt

data/vendor/bundle/ruby/3.0.0/gems/rake-13.0.6/rake.gemspec

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+require_relative 'lib/rake/version'
+
+Gem::Specification.new do |s|
+  s.name = "rake".freeze
+  s.version = Rake::VERSION
+  s.authors = ["Hiroshi SHIBATA".freeze, "Eric Hodel".freeze, "Jim Weirich".freeze]
+  s.email = ["hsbt@ruby-lang.org".freeze, "drbrain@segment7.net".freeze, "".freeze]
+
+  s.summary = "Rake is a Make-like program implemented in Ruby".freeze
+  s.description = <<-DESCRIPTION
+Rake is a Make-like program implemented in Ruby. Tasks and dependencies are
+specified in standard Ruby syntax.
+Rake has the following features:
+  * Rakefiles (rake's version of Makefiles) are completely defined in standard Ruby syntax.
+    No XML files to edit. No quirky Makefile syntax to worry about (is that a tab or a space?)
+  * Users can specify tasks with prerequisites.
+  * Rake supports rule patterns to synthesize implicit tasks.
+  * Flexible FileLists that act like arrays but know about manipulating file names and paths.
+  * Supports parallel execution of tasks.
+  DESCRIPTION
+  s.homepage = "https://github.com/ruby/rake".freeze
+  s.licenses = ["MIT".freeze]
+
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/ruby/rake/issues",
+    "changelog_uri"     => "https://github.com/ruby/rake/blob/v#{s.version}/History.rdoc",
+    "documentation_uri" => "https://ruby.github.io/rake",
+    "source_code_uri"   => "https://github.com/ruby/rake/tree/v#{s.version}",
+  }
+
+  s.files = [
+    "History.rdoc",
+    "MIT-LICENSE",
+    "README.rdoc",
+    "doc/command_line_usage.rdoc",
+    "doc/example/Rakefile1",
+    "doc/example/Rakefile2",
+    "doc/example/a.c",
+    "doc/example/b.c",
+    "doc/example/main.c",
+    "doc/glossary.rdoc",
+    "doc/jamis.rb",
+    "doc/proto_rake.rdoc",
+    "doc/rake.1",
+    "doc/rakefile.rdoc",
+    "doc/rational.rdoc",
+    "exe/rake",
+    "lib/rake.rb",
+    "lib/rake/application.rb",
+    "lib/rake/backtrace.rb",
+    "lib/rake/clean.rb",
+    "lib/rake/cloneable.rb",
+    "lib/rake/cpu_counter.rb",
+    "lib/rake/default_loader.rb",
+    "lib/rake/dsl_definition.rb",
+    "lib/rake/early_time.rb",
+    "lib/rake/ext/core.rb",
+    "lib/rake/ext/string.rb",
+    "lib/rake/file_creation_task.rb",
+    "lib/rake/file_list.rb",
+    "lib/rake/file_task.rb",
+    "lib/rake/file_utils.rb",
+    "lib/rake/file_utils_ext.rb",
+    "lib/rake/invocation_chain.rb",
+    "lib/rake/invocation_exception_mixin.rb",
+    "lib/rake/late_time.rb",
+    "lib/rake/linked_list.rb",
+    "lib/rake/loaders/makefile.rb",
+    "lib/rake/multi_task.rb",
+    "lib/rake/name_space.rb",
+    "lib/rake/packagetask.rb",
+    "lib/rake/phony.rb",
+    "lib/rake/private_reader.rb",
+    "lib/rake/promise.rb",
+    "lib/rake/pseudo_status.rb",
+    "lib/rake/rake_module.rb",
+    "lib/rake/rake_test_loader.rb",
+    "lib/rake/rule_recursion_overflow_error.rb",
+    "lib/rake/scope.rb",
+    "lib/rake/task.rb",
+    "lib/rake/task_argument_error.rb",
+    "lib/rake/task_arguments.rb",
+    "lib/rake/task_manager.rb",
+    "lib/rake/tasklib.rb",
+    "lib/rake/testtask.rb",
+    "lib/rake/thread_history_display.rb",
+    "lib/rake/thread_pool.rb",
+    "lib/rake/trace_output.rb",
+    "lib/rake/version.rb",
+    "lib/rake/win32.rb",
+    "rake.gemspec"
+  ]
+  s.bindir = "exe"
+  s.executables = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib".freeze]
+
+  s.required_ruby_version = Gem::Requirement.new(">= 2.2".freeze)
+  s.rdoc_options = ["--main".freeze, "README.rdoc".freeze]
+end

data/vendor/bundle/ruby/3.0.0/specifications/rack-2.2.4.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+# stub: rack 2.2.4 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "rack".freeze
+  s.version = "2.2.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "bug_tracker_uri" => "https://github.com/rack/rack/issues", "changelog_uri" => "https://github.com/rack/rack/blob/master/CHANGELOG.md", "documentation_uri" => "https://rubydoc.info/github/rack/rack", "source_code_uri" => "https://github.com/rack/rack" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Leah Neukirchen".freeze]
+  s.date = "2022-06-30"
+  s.description = "Rack provides a minimal, modular and adaptable interface for developing\nweb applications in Ruby. By wrapping HTTP requests and responses in\nthe simplest way possible, it unifies and distills the API for web\nservers, web frameworks, and software in between (the so-called\nmiddleware) into a single method call.\n".freeze
+  s.email = "leah@vuxu.org".freeze
+  s.executables = ["rackup".freeze]
+  s.extra_rdoc_files = ["README.rdoc".freeze, "CHANGELOG.md".freeze, "CONTRIBUTING.md".freeze]
+  s.files = ["CHANGELOG.md".freeze, "CONTRIBUTING.md".freeze, "README.rdoc".freeze, "bin/rackup".freeze]
+  s.homepage = "https://github.com/rack/rack".freeze
+  s.licenses = ["MIT".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.3.0".freeze)
+  s.rubygems_version = "3.3.21".freeze
+  s.summary = "A modular Ruby webserver interface.".freeze
+
+  s.installed_by_version = "3.3.21" if s.respond_to? :installed_by_version
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_development_dependency(%q<minitest>.freeze, ["~> 5.0"])
+    s.add_development_dependency(%q<minitest-sprint>.freeze, [">= 0"])
+    s.add_development_dependency(%q<minitest-global_expectations>.freeze, [">= 0"])
+    s.add_development_dependency(%q<rake>.freeze, [">= 0"])
+  else
+    s.add_dependency(%q<minitest>.freeze, ["~> 5.0"])
+    s.add_dependency(%q<minitest-sprint>.freeze, [">= 0"])
+    s.add_dependency(%q<minitest-global_expectations>.freeze, [">= 0"])
+    s.add_dependency(%q<rake>.freeze, [">= 0"])
+  end
+end

data/vendor/bundle/ruby/3.0.0/specifications/rake-13.0.6.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+# stub: rake 13.0.6 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "rake".freeze
+  s.version = "13.0.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "bug_tracker_uri" => "https://github.com/ruby/rake/issues", "changelog_uri" => "https://github.com/ruby/rake/blob/v13.0.6/History.rdoc", "documentation_uri" => "https://ruby.github.io/rake", "source_code_uri" => "https://github.com/ruby/rake/tree/v13.0.6" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Hiroshi SHIBATA".freeze, "Eric Hodel".freeze, "Jim Weirich".freeze]
+  s.bindir = "exe".freeze
+  s.date = "2021-07-09"
+  s.description = "Rake is a Make-like program implemented in Ruby. Tasks and dependencies are\nspecified in standard Ruby syntax.\nRake has the following features:\n  * Rakefiles (rake's version of Makefiles) are completely defined in standard Ruby syntax.\n    No XML files to edit. No quirky Makefile syntax to worry about (is that a tab or a space?)\n  * Users can specify tasks with prerequisites.\n  * Rake supports rule patterns to synthesize implicit tasks.\n  * Flexible FileLists that act like arrays but know about manipulating file names and paths.\n  * Supports parallel execution of tasks.\n".freeze
+  s.email = ["hsbt@ruby-lang.org".freeze, "drbrain@segment7.net".freeze, "".freeze]
+  s.executables = ["rake".freeze]
+  s.files = ["exe/rake".freeze]
+  s.homepage = "https://github.com/ruby/rake".freeze
+  s.licenses = ["MIT".freeze]
+  s.rdoc_options = ["--main".freeze, "README.rdoc".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.2".freeze)
+  s.rubygems_version = "3.3.21".freeze
+  s.summary = "Rake is a Make-like program implemented in Ruby".freeze
+
+  s.installed_by_version = "3.3.21" if s.respond_to? :installed_by_version
+end