tdiary 5.4.0 → 5.5.0.beta1

data/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/lib/rake/phony.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# Defines a :phony task that you can use as a dependency. This allows
+# file-based tasks to use non-file-based tasks as prerequisites
+# without forcing them to rebuild.
+#
+# See FileTask#out_of_date? and Task#timestamp for more info.
+
+require_relative "../rake"
+
+task :phony
+
+Rake::Task[:phony].tap do |task|
+  def task.timestamp # :nodoc:
+    Time.at 0
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/lib/rake/private_reader.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Rake
+
+  # Include PrivateReader to use +private_reader+.
+  module PrivateReader           # :nodoc: all
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Declare a list of private accessors
+      def private_reader(*names)
+        attr_reader(*names)
+        private(*names)
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/lib/rake/promise.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module Rake
+
+  # A Promise object represents a promise to do work (a chore) in the
+  # future. The promise is created with a block and a list of
+  # arguments for the block. Calling value will return the value of
+  # the promised chore.
+  #
+  # Used by ThreadPool.
+  #
+  class Promise               # :nodoc: all
+    NOT_SET = Object.new.freeze # :nodoc:
+
+    attr_accessor :recorder
+
+    # Create a promise to do the chore specified by the block.
+    def initialize(args, &block)
+      @mutex = Mutex.new
+      @result = NOT_SET
+      @error = NOT_SET
+      @args = args
+      @block = block
+    end
+
+    # Return the value of this promise.
+    #
+    # If the promised chore is not yet complete, then do the work
+    # synchronously. We will wait.
+    def value
+      unless complete?
+        stat :sleeping_on, item_id: object_id
+        @mutex.synchronize do
+          stat :has_lock_on, item_id: object_id
+          chore
+          stat :releasing_lock_on, item_id: object_id
+        end
+      end
+      error? ? raise(@error) : @result
+    end
+
+    # If no one else is working this promise, go ahead and do the chore.
+    def work
+      stat :attempting_lock_on, item_id: object_id
+      if @mutex.try_lock
+        stat :has_lock_on, item_id: object_id
+        chore
+        stat :releasing_lock_on, item_id: object_id
+        @mutex.unlock
+      else
+        stat :bailed_on, item_id: object_id
+      end
+    end
+
+    private
+
+    # Perform the chore promised
+    def chore
+      if complete?
+        stat :found_completed, item_id: object_id
+        return
+      end
+      stat :will_execute, item_id: object_id
+      begin
+        @result = @block.call(*@args)
+      rescue Exception => e
+        @error = e
+      end
+      stat :did_execute, item_id: object_id
+      discard
+    end
+
+    # Do we have a result for the promise
+    def result?
+      !@result.equal?(NOT_SET)
+    end
+
+    # Did the promise throw an error
+    def error?
+      !@error.equal?(NOT_SET)
+    end
+
+    # Are we done with the promise
+    def complete?
+      result? || error?
+    end
+
+    # free up these items for the GC
+    def discard
+      @args = nil
+      @block = nil
+    end
+
+    # Record execution statistics if there is a recorder
+    def stat(*args)
+      @recorder.call(*args) if @recorder
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/lib/rake/pseudo_status.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Rake
+
+  ##
+  # Exit status class for times the system just gives us a nil.
+  class PseudoStatus # :nodoc: all
+    attr_reader :exitstatus
+
+    def initialize(code=0)
+      @exitstatus = code
+    end
+
+    def to_i
+      @exitstatus << 8
+    end
+
+    def >>(n)
+      to_i >> n
+    end
+
+    def stopped?
+      false
+    end
+
+    def exited?
+      true
+    end
+  end
+
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/lib/rake/rake_module.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require "rake/application"
+
+module Rake
+
+  class << self
+    # Current Rake Application
+    def application
+      @application ||= Rake::Application.new
+    end
+
+    # Set the current Rake application object.
+    def application=(app)
+      @application = app
+    end
+
+    def suggested_thread_count # :nodoc:
+      @cpu_count ||= Rake::CpuCounter.count
+      @cpu_count + 4
+    end
+
+    # Return the original directory where the Rake application was started.
+    def original_dir
+      application.original_dir
+    end
+
+    # Load a rakefile.
+    def load_rakefile(path)
+      load(path)
+    end
+
+    # Add files to the rakelib list
+    def add_rakelib(*files)
+      application.options.rakelib ||= []
+      application.options.rakelib.concat(files)
+    end
+
+    # Make +block_application+ the default rake application inside a block so
+    # you can load rakefiles into a different application.
+    #
+    # This is useful when you want to run rake tasks inside a library without
+    # running rake in a sub-shell.
+    #
+    # Example:
+    #
+    #   Dir.chdir 'other/directory'
+    #
+    #   other_rake = Rake.with_application do |rake|
+    #     rake.load_rakefile
+    #   end
+    #
+    #   puts other_rake.tasks
+
+    def with_application(block_application = Rake::Application.new)
+      orig_application = Rake.application
+
+      Rake.application = block_application
+
+      yield block_application
+
+      block_application
+    ensure
+      Rake.application = orig_application
+    end
+  end
+
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/lib/rake/rake_test_loader.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "file_list"
+
+# Load the test files from the command line.
+argv = ARGV.select do |argument|
+  case argument
+  when /^-/ then
+    argument
+  when /\*/ then
+    Rake::FileList[argument].to_a.each do |file|
+      require File.expand_path file
+    end
+
+    false
+  else
+    path = File.expand_path argument
+
+    abort "\nFile does not exist: #{path}\n\n" unless File.exist?(path)
+
+    require path
+
+    false
+  end
+end
+
+ARGV.replace argv

data/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/lib/rake/rule_recursion_overflow_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Rake
+
+  # Error indicating a recursion overflow error in task selection.
+  class RuleRecursionOverflowError < StandardError
+    def initialize(*args)
+      super
+      @targets = []
+    end
+
+    def add_target(target)
+      @targets << target
+    end
+
+    def message
+      super + ": [" + @targets.reverse.join(" => ") + "]"
+    end
+  end
+
+end

data/vendor/bundle/ruby/3.4.0/gems/rake-13.4.2/lib/rake/scope.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Rake
+  class Scope < LinkedList # :nodoc: all
+
+    # Path for the scope.
+    def path
+      map(&:to_s).reverse.join(":")
+    end
+
+    # Path for the scope + the named path.
+    def path_with_task_name(task_name)
+      "#{path}:#{task_name}"
+    end
+
+    # Trim +n+ innermost scope levels from the scope. In no case will
+    # this trim beyond the toplevel scope.
+    def trim(n)
+      result = self
+      while n > 0 && !result.empty?
+        result = result.tail
+        n -= 1
+      end
+      result
+    end
+
+    # Scope lists always end with an EmptyScope object. See Null
+    # Object Pattern)
+    class EmptyScope < EmptyLinkedList
+      @parent = Scope
+
+      def path
+        ""
+      end
+
+      def path_with_task_name(task_name)
+        task_name
+      end
+    end
+
+    # Singleton null object for an empty scope.
+    EMPTY = EmptyScope.new
+  end
+end