tdiary 5.2.2 → 5.2.4

data/vendor/bundle/ruby/3.1.0/gems/bundler-2.3.7/lib/bundler/friendly_errors.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "vendored_thor"
+
+module Bundler
+  module FriendlyErrors
+    module_function
+
+    def enable!
+      @disabled = false
+    end
+
+    def disabled?
+      @disabled
+    end
+
+    def disable!
+      @disabled = true
+    end
+
+    def log_error(error)
+      case error
+      when YamlSyntaxError
+        Bundler.ui.error error.message
+        Bundler.ui.trace error.orig_exception
+      when Dsl::DSLError, GemspecError
+        Bundler.ui.error error.message
+      when GemRequireError
+        Bundler.ui.error error.message
+        Bundler.ui.trace error.orig_exception
+      when BundlerError
+        Bundler.ui.error error.message, :wrap => true
+        Bundler.ui.trace error
+      when Thor::Error
+        Bundler.ui.error error.message
+      when LoadError
+        raise error unless error.message =~ /cannot load such file -- openssl|openssl.so|libcrypto.so/
+        Bundler.ui.error "\nCould not load OpenSSL. #{error.class}: #{error}\n#{error.backtrace.join("\n  ")}"
+      when Interrupt
+        Bundler.ui.error "\nQuitting..."
+        Bundler.ui.trace error
+      when Gem::InvalidSpecificationException
+        Bundler.ui.error error.message, :wrap => true
+      when SystemExit
+      when *[defined?(Java::JavaLang::OutOfMemoryError) && Java::JavaLang::OutOfMemoryError].compact
+        Bundler.ui.error "\nYour JVM has run out of memory, and Bundler cannot continue. " \
+          "You can decrease the amount of memory Bundler needs by removing gems from your Gemfile, " \
+          "especially large gems. (Gems can be as large as hundreds of megabytes, and Bundler has to read those files!). " \
+          "Alternatively, you can increase the amount of memory the JVM is able to use by running Bundler with jruby -J-Xmx1024m -S bundle (JRuby defaults to 500MB)."
+      else request_issue_report_for(error)
+      end
+    end
+
+    def exit_status(error)
+      case error
+      when BundlerError then error.status_code
+      when Thor::Error then 15
+      when SystemExit then error.status
+      else 1
+      end
+    end
+
+    def request_issue_report_for(e)
+      Bundler.ui.error <<-EOS.gsub(/^ {8}/, ""), nil, nil
+        --- ERROR REPORT TEMPLATE -------------------------------------------------------
+
+        ```
+        #{e.class}: #{e.message}
+          #{e.backtrace && e.backtrace.join("\n          ").chomp}
+        ```
+
+        #{Bundler::Env.report}
+        --- TEMPLATE END ----------------------------------------------------------------
+
+      EOS
+
+      Bundler.ui.error "Unfortunately, an unexpected error occurred, and Bundler cannot continue."
+
+      Bundler.ui.error <<-EOS.gsub(/^ {8}/, ""), nil, :yellow
+
+        First, try this link to see if there are any existing issue reports for this error:
+        #{issues_url(e)}
+
+        If there aren't any reports for this error yet, please fill in the new issue form located at #{new_issue_url}, and copy and paste the report template above in there.
+      EOS
+    end
+
+    def issues_url(exception)
+      message = exception.message.lines.first.tr(":", " ").chomp
+      message = message.split("-").first if exception.is_a?(Errno)
+      require "cgi"
+      "https://github.com/rubygems/rubygems/search?q=" \
+        "#{CGI.escape(message)}&type=Issues"
+    end
+
+    def new_issue_url
+      "https://github.com/rubygems/rubygems/issues/new?labels=Bundler&template=bundler-related-issue.md"
+    end
+  end
+
+  def self.with_friendly_errors
+    FriendlyErrors.enable!
+    yield
+  rescue SignalException
+    raise
+  rescue Exception => e # rubocop:disable Lint/RescueException
+    raise if FriendlyErrors.disabled?
+
+    FriendlyErrors.log_error(e)
+    exit FriendlyErrors.exit_status(e)
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/bundler-2.3.7/lib/bundler/gem_helper.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require_relative "../bundler"
+require "shellwords"
+
+module Bundler
+  class GemHelper
+    include Rake::DSL if defined? Rake::DSL
+
+    class << self
+      # set when install'd.
+      attr_accessor :instance
+
+      def install_tasks(opts = {})
+        new(opts[:dir], opts[:name]).install
+      end
+
+      def tag_prefix=(prefix)
+        instance.tag_prefix = prefix
+      end
+
+      def gemspec(&block)
+        gemspec = instance.gemspec
+        block.call(gemspec) if block
+        gemspec
+      end
+    end
+
+    attr_reader :spec_path, :base, :gemspec
+
+    attr_writer :tag_prefix
+
+    def initialize(base = nil, name = nil)
+      @base = File.expand_path(base || SharedHelpers.pwd)
+      gemspecs = name ? [File.join(@base, "#{name}.gemspec")] : Gem::Util.glob_files_in_dir("{,*}.gemspec", @base)
+      raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
+      @spec_path = gemspecs.first
+      @gemspec = Bundler.load_gemspec(@spec_path)
+      @tag_prefix = ""
+    end
+
+    def install
+      built_gem_path = nil
+
+      desc "Build #{name}-#{version}.gem into the pkg directory."
+      task "build" do
+        built_gem_path = build_gem
+      end
+
+      desc "Generate SHA512 checksum if #{name}-#{version}.gem into the checksums directory."
+      task "build:checksum" => "build" do
+        build_checksum(built_gem_path)
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems."
+      task "install" => "build" do
+        install_gem(built_gem_path)
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems without network access."
+      task "install:local" => "build" do
+        install_gem(built_gem_path, :local)
+      end
+
+      desc "Create tag #{version_tag} and build and push #{name}-#{version}.gem to #{gem_push_host}\n" \
+           "To prevent publishing in RubyGems use `gem_push=no rake release`"
+      task "release", [:remote] => ["build", "release:guard_clean",
+                                    "release:source_control_push", "release:rubygem_push"] do
+      end
+
+      task "release:guard_clean" do
+        guard_clean
+      end
+
+      task "release:source_control_push", [:remote] do |_, args|
+        tag_version { git_push(args[:remote]) } unless already_tagged?
+      end
+
+      task "release:rubygem_push" => "build" do
+        rubygem_push(built_gem_path) if gem_push?
+      end
+
+      GemHelper.instance = self
+    end
+
+    def build_gem
+      file_name = nil
+      sh([*gem_command, "build", "-V", spec_path]) do
+        file_name = File.basename(built_gem_path)
+        SharedHelpers.filesystem_access(File.join(base, "pkg")) {|p| FileUtils.mkdir_p(p) }
+        FileUtils.mv(built_gem_path, "pkg")
+        Bundler.ui.confirm "#{name} #{version} built to pkg/#{file_name}."
+      end
+      File.join(base, "pkg", file_name)
+    end
+
+    def install_gem(built_gem_path = nil, local = false)
+      built_gem_path ||= build_gem
+      cmd = [*gem_command, "install", built_gem_path.to_s]
+      cmd << "--local" if local
+      sh(cmd)
+      Bundler.ui.confirm "#{name} (#{version}) installed."
+    end
+
+    def build_checksum(built_gem_path = nil)
+      built_gem_path ||= build_gem
+      SharedHelpers.filesystem_access(File.join(base, "checksums")) {|p| FileUtils.mkdir_p(p) }
+      file_name = "#{File.basename(built_gem_path)}.sha512"
+      require "digest/sha2"
+      checksum = ::Digest::SHA512.file(built_gem_path).hexdigest
+      target = File.join(base, "checksums", file_name)
+      File.write(target, checksum + "\n")
+      Bundler.ui.confirm "#{name} #{version} checksum written to checksums/#{file_name}."
+    end
+
+    protected
+
+    def rubygem_push(path)
+      cmd = [*gem_command, "push", path]
+      cmd << "--key" << gem_key if gem_key
+      cmd << "--host" << allowed_push_host if allowed_push_host
+      sh_with_input(cmd)
+      Bundler.ui.confirm "Pushed #{name} #{version} to #{gem_push_host}"
+    end
+
+    def built_gem_path
+      Gem::Util.glob_files_in_dir("#{name}-*.gem", base).sort_by {|f| File.mtime(f) }.last
+    end
+
+    def git_push(remote = nil)
+      remote ||= default_remote
+      sh("git push #{remote} refs/heads/#{current_branch}".shellsplit)
+      sh("git push #{remote} refs/tags/#{version_tag}".shellsplit)
+      Bundler.ui.confirm "Pushed git commits and release tag."
+    end
+
+    def default_remote
+      remote_for_branch, status = sh_with_status(%W[git config --get branch.#{current_branch}.remote])
+      return "origin" unless status.success?
+
+      remote_for_branch.strip
+    end
+
+    def current_branch
+      # We can replace this with `git branch --show-current` once we drop support for git < 2.22.0
+      sh(%w[git rev-parse --abbrev-ref HEAD]).gsub(%r{\Aheads/}, "").strip
+    end
+
+    def allowed_push_host
+      @gemspec.metadata["allowed_push_host"] if @gemspec.respond_to?(:metadata)
+    end
+
+    def gem_push_host
+      env_rubygems_host = ENV["RUBYGEMS_HOST"]
+      env_rubygems_host = nil if
+        env_rubygems_host && env_rubygems_host.empty?
+
+      allowed_push_host || env_rubygems_host || "rubygems.org"
+    end
+
+    def already_tagged?
+      return false unless sh(%w[git tag]).split(/\n/).include?(version_tag)
+      Bundler.ui.confirm "Tag #{version_tag} has already been created."
+      true
+    end
+
+    def guard_clean
+      clean? && committed? || raise("There are files that need to be committed first.")
+    end
+
+    def clean?
+      sh_with_status(%w[git diff --exit-code])[1].success?
+    end
+
+    def committed?
+      sh_with_status(%w[git diff-index --quiet --cached HEAD])[1].success?
+    end
+
+    def tag_version
+      sh %W[git tag -m Version\ #{version} #{version_tag}]
+      Bundler.ui.confirm "Tagged #{version_tag}."
+      yield if block_given?
+    rescue RuntimeError
+      Bundler.ui.error "Untagging #{version_tag} due to error."
+      sh_with_status %W[git tag -d #{version_tag}]
+      raise
+    end
+
+    def version
+      gemspec.version
+    end
+
+    def version_tag
+      "#{@tag_prefix}v#{version}"
+    end
+
+    def name
+      gemspec.name
+    end
+
+    def sh_with_input(cmd)
+      Bundler.ui.debug(cmd)
+      SharedHelpers.chdir(base) do
+        abort unless Kernel.system(*cmd)
+      end
+    end
+
+    def sh(cmd, &block)
+      out, status = sh_with_status(cmd, &block)
+      unless status.success?
+        raise("Running `#{cmd.shelljoin}` failed with the following output:\n\n#{out}\n")
+      end
+      out
+    end
+
+    def sh_with_status(cmd, &block)
+      Bundler.ui.debug(cmd)
+      SharedHelpers.chdir(base) do
+        outbuf = IO.popen(cmd, :err => [:child, :out], &:read)
+        status = $?
+        block.call(outbuf) if status.success? && block
+        [outbuf, status]
+      end
+    end
+
+    def gem_key
+      Bundler.settings["gem.push_key"].to_s.downcase if Bundler.settings["gem.push_key"]
+    end
+
+    def gem_push?
+      !%w[n no nil false off 0].include?(ENV["gem_push"].to_s.downcase)
+    end
+
+    def gem_command
+      ENV["GEM_COMMAND"]&.shellsplit || ["gem"]
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/bundler-2.3.7/lib/bundler/gem_helpers.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Bundler
+  module GemHelpers
+    GENERIC_CACHE = { Gem::Platform::RUBY => Gem::Platform::RUBY } # rubocop:disable Style/MutableConstant
+    GENERICS = [
+      [Gem::Platform.new("java"), Gem::Platform.new("java")],
+      [Gem::Platform.new("mswin32"), Gem::Platform.new("mswin32")],
+      [Gem::Platform.new("mswin64"), Gem::Platform.new("mswin64")],
+      [Gem::Platform.new("universal-mingw32"), Gem::Platform.new("universal-mingw32")],
+      [Gem::Platform.new("x64-mingw32"), Gem::Platform.new("x64-mingw32")],
+      [Gem::Platform.new("x86_64-mingw32"), Gem::Platform.new("x64-mingw32")],
+      [Gem::Platform.new("mingw32"), Gem::Platform.new("x86-mingw32")],
+    ].freeze
+
+    def generic(p)
+      GENERIC_CACHE[p] ||= begin
+        _, found = GENERICS.find do |match, _generic|
+          p.os == match.os && (!match.cpu || p.cpu == match.cpu)
+        end
+        found || Gem::Platform::RUBY
+      end
+    end
+    module_function :generic
+
+    def generic_local_platform
+      generic(local_platform)
+    end
+    module_function :generic_local_platform
+
+    def local_platform
+      Bundler.local_platform
+    end
+    module_function :local_platform
+
+    def platform_specificity_match(spec_platform, user_platform)
+      spec_platform = Gem::Platform.new(spec_platform)
+
+      PlatformMatch.specificity_score(spec_platform, user_platform)
+    end
+    module_function :platform_specificity_match
+
+    def select_best_platform_match(specs, platform)
+      matching = specs.select {|spec| spec.match_platform(platform) }
+      exact = matching.select {|spec| spec.platform == platform }
+      return exact if exact.any?
+
+      sorted_matching = matching.sort_by {|spec| platform_specificity_match(spec.platform, platform) }
+      exemplary_spec = sorted_matching.first
+
+      sorted_matching.take_while{|spec| same_specificity(platform, spec, exemplary_spec) && same_deps(spec, exemplary_spec) }
+    end
+    module_function :select_best_platform_match
+
+    class PlatformMatch
+      def self.specificity_score(spec_platform, user_platform)
+        return -1 if spec_platform == user_platform
+        return 1_000_000 if spec_platform.nil? || spec_platform == Gem::Platform::RUBY || user_platform == Gem::Platform::RUBY
+
+        os_match(spec_platform, user_platform) +
+          cpu_match(spec_platform, user_platform) * 10 +
+          platform_version_match(spec_platform, user_platform) * 100
+      end
+
+      def self.os_match(spec_platform, user_platform)
+        if spec_platform.os == user_platform.os
+          0
+        else
+          1
+        end
+      end
+
+      def self.cpu_match(spec_platform, user_platform)
+        if spec_platform.cpu == user_platform.cpu
+          0
+        elsif spec_platform.cpu == "arm" && user_platform.cpu.to_s.start_with?("arm")
+          0
+        elsif spec_platform.cpu.nil? || spec_platform.cpu == "universal"
+          1
+        else
+          2
+        end
+      end
+
+      def self.platform_version_match(spec_platform, user_platform)
+        if spec_platform.version == user_platform.version
+          0
+        elsif spec_platform.version.nil?
+          1
+        else
+          2
+        end
+      end
+    end
+
+    def same_specificity(platform, spec, exemplary_spec)
+      platform_specificity_match(spec.platform, platform) == platform_specificity_match(exemplary_spec.platform, platform)
+    end
+    module_function :same_specificity
+
+    def same_deps(spec, exemplary_spec)
+      same_runtime_deps = spec.dependencies.sort == exemplary_spec.dependencies.sort
+      return same_runtime_deps unless spec.is_a?(Gem::Specification) && exemplary_spec.is_a?(Gem::Specification)
+
+      same_metadata_deps = spec.required_ruby_version == exemplary_spec.required_ruby_version && spec.required_rubygems_version == exemplary_spec.required_rubygems_version
+      same_runtime_deps && same_metadata_deps
+    end
+    module_function :same_deps
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/bundler-2.3.7/lib/bundler/gem_tasks.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rake/clean"
+CLOBBER.include "pkg"
+
+require_relative "gem_helper"
+Bundler::GemHelper.install_tasks

data/vendor/bundle/ruby/3.1.0/gems/bundler-2.3.7/lib/bundler/gem_version_promoter.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Bundler
+  # This class contains all of the logic for determining the next version of a
+  # Gem to update to based on the requested level (patch, minor, major).
+  # Primarily designed to work with Resolver which will provide it the list of
+  # available dependency versions as found in its index, before returning it to
+  # to the resolution engine to select the best version.
+  class GemVersionPromoter
+    DEBUG = ENV["BUNDLER_DEBUG_RESOLVER"] || ENV["DEBUG_RESOLVER"]
+
+    attr_reader :level, :locked_specs, :unlock_gems
+
+    # By default, strict is false, meaning every available version of a gem
+    # is returned from sort_versions. The order gives preference to the
+    # requested level (:patch, :minor, :major) but in complicated requirement
+    # cases some gems will by necessity by promoted past the requested level,
+    # or even reverted to older versions.
+    #
+    # If strict is set to true, the results from sort_versions will be
+    # truncated, eliminating any version outside the current level scope.
+    # This can lead to unexpected outcomes or even VersionConflict exceptions
+    # that report a version of a gem not existing for versions that indeed do
+    # existing in the referenced source.
+    attr_accessor :strict
+
+    attr_accessor :prerelease_specified
+
+    # Given a list of locked_specs and a list of gems to unlock creates a
+    # GemVersionPromoter instance.
+    #
+    # @param locked_specs [SpecSet] All current locked specs. Unlike Definition
+    #   where this list is empty if all gems are being updated, this should
+    #   always be populated for all gems so this class can properly function.
+    # @param unlock_gems [String] List of gem names being unlocked. If empty,
+    #   all gems will be considered unlocked.
+    # @return [GemVersionPromoter]
+    def initialize(locked_specs = SpecSet.new([]), unlock_gems = [])
+      @level = :major
+      @strict = false
+      @locked_specs = locked_specs
+      @unlock_gems = unlock_gems
+      @sort_versions = {}
+      @prerelease_specified = {}
+    end
+
+    # @param value [Symbol] One of three Symbols: :major, :minor or :patch.
+    def level=(value)
+      v = case value
+          when String, Symbol
+            value.to_sym
+      end
+
+      raise ArgumentError, "Unexpected level #{v}. Must be :major, :minor or :patch" unless [:major, :minor, :patch].include?(v)
+      @level = v
+    end
+
+    # Given a Dependency and an Array of SpecGroups of available versions for a
+    # gem, this method will return the Array of SpecGroups sorted (and possibly
+    # truncated if strict is true) in an order to give preference to the current
+    # level (:major, :minor or :patch) when resolution is deciding what versions
+    # best resolve all dependencies in the bundle.
+    # @param dep [Dependency] The Dependency of the gem.
+    # @param spec_groups [SpecGroup] An array of SpecGroups for the same gem
+    #    named in the @dep param.
+    # @return [SpecGroup] A new instance of the SpecGroup Array sorted and
+    #    possibly filtered.
+    def sort_versions(dep, spec_groups)
+      before_result = "before sort_versions: #{debug_format_result(dep, spec_groups).inspect}" if DEBUG
+
+      @sort_versions[dep] ||= begin
+        gem_name = dep.name
+
+        # An Array per version returned, different entries for different platforms.
+        # We only need the version here so it's ok to hard code this to the first instance.
+        locked_spec = locked_specs[gem_name].first
+
+        if strict
+          filter_dep_specs(spec_groups, locked_spec)
+        else
+          sort_dep_specs(spec_groups, locked_spec)
+        end.tap do |specs|
+          if DEBUG
+            puts before_result
+            puts " after sort_versions: #{debug_format_result(dep, specs).inspect}"
+          end
+        end
+      end
+    end
+
+    # @return [bool] Convenience method for testing value of level variable.
+    def major?
+      level == :major
+    end
+
+    # @return [bool] Convenience method for testing value of level variable.
+    def minor?
+      level == :minor
+    end
+
+    private
+
+    def filter_dep_specs(spec_groups, locked_spec)
+      res = spec_groups.select do |spec_group|
+        if locked_spec && !major?
+          gsv = spec_group.version
+          lsv = locked_spec.version
+
+          must_match = minor? ? [0] : [0, 1]
+
+          matches = must_match.map {|idx| gsv.segments[idx] == lsv.segments[idx] }
+          matches.uniq == [true] ? (gsv >= lsv) : false
+        else
+          true
+        end
+      end
+
+      sort_dep_specs(res, locked_spec)
+    end
+
+    def sort_dep_specs(spec_groups, locked_spec)
+      return spec_groups unless locked_spec
+      @gem_name = locked_spec.name
+      @locked_version = locked_spec.version
+
+      result = spec_groups.sort do |a, b|
+        @a_ver = a.version
+        @b_ver = b.version
+
+        unless @prerelease_specified[@gem_name]
+          a_pre = @a_ver.prerelease?
+          b_pre = @b_ver.prerelease?
+
+          next -1 if a_pre && !b_pre
+          next  1 if b_pre && !a_pre
+        end
+
+        if major?
+          @a_ver <=> @b_ver
+        elsif either_version_older_than_locked
+          @a_ver <=> @b_ver
+        elsif segments_do_not_match(:major)
+          @b_ver <=> @a_ver
+        elsif !minor? && segments_do_not_match(:minor)
+          @b_ver <=> @a_ver
+        else
+          @a_ver <=> @b_ver
+        end
+      end
+      post_sort(result)
+    end
+
+    def either_version_older_than_locked
+      @a_ver < @locked_version || @b_ver < @locked_version
+    end
+
+    def segments_do_not_match(level)
+      index = [:major, :minor].index(level)
+      @a_ver.segments[index] != @b_ver.segments[index]
+    end
+
+    def unlocking_gem?
+      unlock_gems.empty? || unlock_gems.include?(@gem_name)
+    end
+
+    # Specific version moves can't always reliably be done during sorting
+    # as not all elements are compared against each other.
+    def post_sort(result)
+      # default :major behavior in Bundler does not do this
+      return result if major?
+      if unlocking_gem?
+        result
+      else
+        move_version_to_end(result, @locked_version)
+      end
+    end
+
+    def move_version_to_end(result, version)
+      move, keep = result.partition {|s| s.version.to_s == version.to_s }
+      keep.concat(move)
+    end
+
+    def debug_format_result(dep, spec_groups)
+      a = [dep.to_s,
+           spec_groups.map {|sg| [sg.version, sg.dependencies_for_activated_platforms.map {|dp| [dp.name, dp.requirement.to_s] }] }]
+      last_map = a.last.map {|sg_data| [sg_data.first.version, sg_data.last.map {|aa| aa.join(" ") }] }
+      [a.first, last_map, level, strict ? :strict : :not_strict]
+    end
+  end
+end