win32-api 1.4.8 → 1.9.1

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.1/lib/rake/file_task.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require "rake/task"
+require "rake/early_time"
+
+module Rake
+
+  # A FileTask is a task that includes time based dependencies.  If any of a
+  # FileTask's prerequisites have a timestamp that is later than the file
+  # represented by this task, then the file must be rebuilt (using the
+  # supplied actions).
+  #
+  class FileTask < Task
+
+    # Is this file task needed?  Yes if it doesn't exist, or if its time stamp
+    # is out of date.
+    def needed?
+      !File.exist?(name) || out_of_date?(timestamp) || @application.options.build_all
+    end
+
+    # Time stamp for file task.
+    def timestamp
+      if File.exist?(name)
+        File.mtime(name.to_s)
+      else
+        Rake::LATE
+      end
+    end
+
+    private
+
+    # Are there any prerequisites with a later time than the given time stamp?
+    def out_of_date?(stamp)
+      all_prerequisite_tasks.any? { |prereq|
+        prereq_task = application[prereq, @scope]
+        if prereq_task.instance_of?(Rake::FileTask)
+          prereq_task.timestamp > stamp || @application.options.build_all
+        else
+          prereq_task.timestamp > stamp
+        end
+      }
+    end
+
+    # ----------------------------------------------------------------
+    # Task class methods.
+    #
+    class << self
+      # Apply the scope to the task name according to the rules for this kind
+      # of task.  File based tasks ignore the scope when creating the name.
+      def scope_name(scope, task_name)
+        Rake.from_pathname(task_name)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.1/lib/rake/file_utils.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+require "rbconfig"
+require "fileutils"
+
+#--
+# This a FileUtils extension that defines several additional commands to be
+# added to the FileUtils utility functions.
+module FileUtils
+  # Path to the currently running Ruby program
+  RUBY = ENV["RUBY"] || File.join(
+    RbConfig::CONFIG["bindir"],
+    RbConfig::CONFIG["ruby_install_name"] + RbConfig::CONFIG["EXEEXT"]).
+    sub(/.*\s.*/m, '"\&"')
+
+  # Run the system command +cmd+.  If multiple arguments are given the command
+  # is run directly (without the shell, same semantics as Kernel::exec and
+  # Kernel::system).
+  #
+  # It is recommended you use the multiple argument form over interpolating
+  # user input for both usability and security reasons.  With the multiple
+  # argument form you can easily process files with spaces or other shell
+  # reserved characters in them.  With the multiple argument form your rake
+  # tasks are not vulnerable to users providing an argument like
+  # <code>; rm # -rf /</code>.
+  #
+  # If a block is given, upon command completion the block is called with an
+  # OK flag (true on a zero exit status) and a Process::Status object.
+  # Without a block a RuntimeError is raised when the command exits non-zero.
+  #
+  # Examples:
+  #
+  #   sh 'ls -ltr'
+  #
+  #   sh 'ls', 'file with spaces'
+  #
+  #   # check exit status after command runs
+  #   sh %{grep pattern file} do |ok, res|
+  #     if !ok
+  #       puts "pattern not found (status = #{res.exitstatus})"
+  #     end
+  #   end
+  #
+  def sh(*cmd, &block)
+    options = (Hash === cmd.last) ? cmd.pop : {}
+    shell_runner = block_given? ? block : create_shell_runner(cmd)
+
+    set_verbose_option(options)
+    verbose = options.delete :verbose
+    noop    = options.delete(:noop) || Rake::FileUtilsExt.nowrite_flag
+
+    Rake.rake_output_message sh_show_command cmd if verbose
+
+    unless noop
+      res = (Hash === cmd.last) ? system(*cmd) : system(*cmd, options)
+      status = $?
+      status = Rake::PseudoStatus.new(1) if !res && status.nil?
+      shell_runner.call(res, status)
+    end
+  end
+
+  def create_shell_runner(cmd) # :nodoc:
+    show_command = sh_show_command cmd
+    show_command = show_command[0, 42] + "..." unless $trace
+
+    lambda do |ok, status|
+      ok or
+        fail "Command failed with status (#{status.exitstatus}): " +
+        "[#{show_command}]"
+    end
+  end
+  private :create_shell_runner
+
+  def sh_show_command(cmd) # :nodoc:
+    cmd = cmd.dup
+
+    if Hash === cmd.first
+      env = cmd.first
+      env = env.map { |name, value| "#{name}=#{value}" }.join " "
+      cmd[0] = env
+    end
+
+    cmd.join " "
+  end
+  private :sh_show_command
+
+  def set_verbose_option(options) # :nodoc:
+    unless options.key? :verbose
+      options[:verbose] =
+        (Rake::FileUtilsExt.verbose_flag == Rake::FileUtilsExt::DEFAULT) ||
+        Rake::FileUtilsExt.verbose_flag
+    end
+  end
+  private :set_verbose_option
+
+  # Run a Ruby interpreter with the given arguments.
+  #
+  # Example:
+  #   ruby %{-pe '$_.upcase!' <README}
+  #
+  def ruby(*args, **options, &block)
+    if args.length > 1
+      sh(RUBY, *args, **options, &block)
+    else
+      sh("#{RUBY} #{args.first}", **options, &block)
+    end
+  end
+
+  LN_SUPPORTED = [true]
+
+  #  Attempt to do a normal file link, but fall back to a copy if the link
+  #  fails.
+  def safe_ln(*args, **options)
+    if LN_SUPPORTED[0]
+      begin
+        return options.empty? ? ln(*args) : ln(*args, **options)
+      rescue StandardError, NotImplementedError
+        LN_SUPPORTED[0] = false
+      end
+    end
+    options.empty? ? cp(*args) : cp(*args, **options)
+  end
+
+  # Split a file path into individual directory names.
+  #
+  # Example:
+  #   split_all("a/b/c") =>  ['a', 'b', 'c']
+  #
+  def split_all(path)
+    head, tail = File.split(path)
+    return [tail] if head == "." || tail == "/"
+    return [head, tail] if head == "/"
+    return split_all(head) + [tail]
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.1/lib/rake/file_utils_ext.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+require "rake/file_utils"
+
+module Rake
+  #
+  # FileUtilsExt provides a custom version of the FileUtils methods
+  # that respond to the <tt>verbose</tt> and <tt>nowrite</tt>
+  # commands.
+  #
+  module FileUtilsExt
+    include FileUtils
+
+    class << self
+      attr_accessor :verbose_flag, :nowrite_flag
+    end
+
+    DEFAULT = Object.new
+
+    FileUtilsExt.verbose_flag = DEFAULT
+    FileUtilsExt.nowrite_flag = false
+
+    FileUtils.commands.each do |name|
+      opts = FileUtils.options_of name
+      default_options = []
+      if opts.include?("verbose")
+        default_options << "verbose: FileUtilsExt.verbose_flag"
+      end
+      if opts.include?("noop")
+        default_options << "noop: FileUtilsExt.nowrite_flag"
+      end
+
+      next if default_options.empty?
+      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{name}(*args, **options, &block)
+        super(*args,
+            #{default_options.join(', ')},
+            **options, &block)
+      end
+      EOS
+    end
+
+    # Get/set the verbose flag controlling output from the FileUtils
+    # utilities.  If verbose is true, then the utility method is
+    # echoed to standard output.
+    #
+    # Examples:
+    #    verbose              # return the current value of the
+    #                         # verbose flag
+    #    verbose(v)           # set the verbose flag to _v_.
+    #    verbose(v) { code }  # Execute code with the verbose flag set
+    #                         # temporarily to _v_.  Return to the
+    #                         # original value when code is done.
+    def verbose(value=nil)
+      oldvalue = FileUtilsExt.verbose_flag
+      FileUtilsExt.verbose_flag = value unless value.nil?
+      if block_given?
+        begin
+          yield
+        ensure
+          FileUtilsExt.verbose_flag = oldvalue
+        end
+      end
+      FileUtilsExt.verbose_flag
+    end
+
+    # Get/set the nowrite flag controlling output from the FileUtils
+    # utilities.  If verbose is true, then the utility method is
+    # echoed to standard output.
+    #
+    # Examples:
+    #    nowrite              # return the current value of the
+    #                         # nowrite flag
+    #    nowrite(v)           # set the nowrite flag to _v_.
+    #    nowrite(v) { code }  # Execute code with the nowrite flag set
+    #                         # temporarily to _v_. Return to the
+    #                         # original value when code is done.
+    def nowrite(value=nil)
+      oldvalue = FileUtilsExt.nowrite_flag
+      FileUtilsExt.nowrite_flag = value unless value.nil?
+      if block_given?
+        begin
+          yield
+        ensure
+          FileUtilsExt.nowrite_flag = oldvalue
+        end
+      end
+      oldvalue
+    end
+
+    # Use this function to prevent potentially destructive ruby code
+    # from running when the :nowrite flag is set.
+    #
+    # Example:
+    #
+    #   when_writing("Building Project") do
+    #     project.build
+    #   end
+    #
+    # The following code will build the project under normal
+    # conditions. If the nowrite(true) flag is set, then the example
+    # will print:
+    #
+    #      DRYRUN: Building Project
+    #
+    # instead of actually building the project.
+    #
+    def when_writing(msg=nil)
+      if FileUtilsExt.nowrite_flag
+        $stderr.puts "DRYRUN: #{msg}" if msg
+      else
+        yield
+      end
+    end
+
+    # Send the message to the default rake output (which is $stderr).
+    def rake_output_message(message)
+      $stderr.puts(message)
+    end
+
+    # Check that the options do not contain options not listed in
+    # +optdecl+.  An ArgumentError exception is thrown if non-declared
+    # options are found.
+    def rake_check_options(options, *optdecl)
+      h = options.dup
+      optdecl.each do |name|
+        h.delete name
+      end
+      raise ArgumentError, "no such option: #{h.keys.join(' ')}" unless
+        h.empty?
+    end
+
+    extend self
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.1/lib/rake/invocation_chain.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module Rake
+
+  # InvocationChain tracks the chain of task invocations to detect
+  # circular dependencies.
+  class InvocationChain < LinkedList
+
+    # Is the invocation already in the chain?
+    def member?(invocation)
+      head == invocation || tail.member?(invocation)
+    end
+
+    # Append an invocation to the chain of invocations. It is an error
+    # if the invocation already listed.
+    def append(invocation)
+      if member?(invocation)
+        fail RuntimeError, "Circular dependency detected: #{to_s} => #{invocation}"
+      end
+      conj(invocation)
+    end
+
+    # Convert to string, ie: TOP => invocation => invocation
+    def to_s
+      "#{prefix}#{head}"
+    end
+
+    # Class level append.
+    def self.append(invocation, chain)
+      chain.append(invocation)
+    end
+
+    private
+
+    def prefix
+      "#{tail} => "
+    end
+
+    # Null object for an empty chain.
+    class EmptyInvocationChain < LinkedList::EmptyLinkedList
+      @parent = InvocationChain
+
+      def member?(obj)
+        false
+      end
+
+      def append(invocation)
+        conj(invocation)
+      end
+
+      def to_s
+        "TOP"
+      end
+    end
+
+    EMPTY = EmptyInvocationChain.new
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.1/lib/rake/invocation_exception_mixin.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Rake
+  module InvocationExceptionMixin
+    # Return the invocation chain (list of Rake tasks) that were in
+    # effect when this exception was detected by rake.  May be null if
+    # no tasks were active.
+    def chain
+      @rake_invocation_chain ||= nil
+    end
+
+    # Set the invocation chain in effect when this exception was
+    # detected.
+    def chain=(value)
+      @rake_invocation_chain = value
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.1/lib/rake/late_time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Rake
+  # LateTime is a fake timestamp that occurs _after_ any other time value.
+  class LateTime
+    include Comparable
+    include Singleton
+
+    def <=>(other)
+      1
+    end
+
+    def to_s
+      "<LATE TIME>"
+    end
+  end
+
+  LATE = LateTime.instance
+end

data/vendor/bundle/ruby/2.7.0/gems/rake-13.0.1/lib/rake/linked_list.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+module Rake
+
+  # Polylithic linked list structure used to implement several data
+  # structures in Rake.
+  class LinkedList
+    include Enumerable
+    attr_reader :head, :tail
+
+    # Polymorphically add a new element to the head of a list. The
+    # type of head node will be the same list type as the tail.
+    def conj(item)
+      self.class.cons(item, self)
+    end
+
+    # Is the list empty?
+    # .make guards against a list being empty making any instantiated LinkedList
+    # object not empty by default
+    # You should consider overriding this method if you implement your own .make method
+    def empty?
+      false
+    end
+
+    # Lists are structurally equivalent.
+    def ==(other)
+      current = self
+      while !current.empty? && !other.empty?
+        return false if current.head != other.head
+        current = current.tail
+        other = other.tail
+      end
+      current.empty? && other.empty?
+    end
+
+    # Convert to string: LL(item, item...)
+    def to_s
+      items = map(&:to_s).join(", ")
+      "LL(#{items})"
+    end
+
+    # Same as +to_s+, but with inspected items.
+    def inspect
+      items = map(&:inspect).join(", ")
+      "LL(#{items})"
+    end
+
+    # For each item in the list.
+    def each
+      current = self
+      while !current.empty?
+        yield(current.head)
+        current = current.tail
+      end
+      self
+    end
+
+    # Make a list out of the given arguments. This method is
+    # polymorphic
+    def self.make(*args)
+      # return an EmptyLinkedList if there are no arguments
+      return empty if !args || args.empty?
+
+      # build a LinkedList by starting at the tail and iterating
+      # through each argument
+      # inject takes an EmptyLinkedList to start
+      args.reverse.inject(empty) do |list, item|
+        list = cons(item, list)
+        list # return the newly created list for each item in the block
+      end
+    end
+
+    # Cons a new head onto the tail list.
+    def self.cons(head, tail)
+      new(head, tail)
+    end
+
+    # The standard empty list class for the given LinkedList class.
+    def self.empty
+      self::EMPTY
+    end
+
+    protected
+
+    def initialize(head, tail=EMPTY)
+      @head = head
+      @tail = tail
+    end
+
+    # Represent an empty list, using the Null Object Pattern.
+    #
+    # When inheriting from the LinkedList class, you should implement
+    # a type specific Empty class as well. Make sure you set the class
+    # instance variable @parent to the associated list class (this
+    # allows conj, cons and make to work polymorphically).
+    class EmptyLinkedList < LinkedList
+      @parent = LinkedList
+
+      def initialize
+      end
+
+      def empty?
+        true
+      end
+
+      def self.cons(head, tail)
+        @parent.cons(head, tail)
+      end
+    end
+
+    EMPTY = EmptyLinkedList.new
+  end
+end