@appthreat/atom-parsetools 1.0.3 → 1.0.5

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/gem_helper.rb

@@ -0,0 +1,237 @@
+# 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)
+        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 of #{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&.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?
+        [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

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/gem_helpers.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Bundler
+  module GemHelpers
+    GENERIC_CACHE = { Gem::Platform::RUBY => Gem::Platform::RUBY } # rubocop:disable Style/MutableConstant
+    GENERICS = [
+      Gem::Platform::JAVA,
+      *Gem::Platform::WINDOWS,
+    ].freeze
+
+    def generic(p)
+      GENERIC_CACHE[p] ||= begin
+        found = GENERICS.find do |match|
+          p === match
+        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 generic_local_platform_is_ruby?
+      generic_local_platform == Gem::Platform::RUBY
+    end
+    module_function :generic_local_platform_is_ruby?
+
+    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_all_platform_match(specs, platform, force_ruby: false, prefer_locked: false)
+      matching = if force_ruby
+        specs.select {|spec| spec.match_platform(Gem::Platform::RUBY) && spec.force_ruby_platform! }
+      else
+        specs.select {|spec| spec.match_platform(platform) }
+      end
+
+      if prefer_locked
+        locked_originally = matching.select {|spec| spec.is_a?(LazySpecification) }
+        return locked_originally if locked_originally.any?
+      end
+
+      matching
+    end
+    module_function :select_all_platform_match
+
+    def select_best_platform_match(specs, platform, force_ruby: false, prefer_locked: false)
+      matching = select_all_platform_match(specs, platform, force_ruby: force_ruby, prefer_locked: prefer_locked)
+
+      sort_and_filter_best_platform_match(matching, platform)
+    end
+    module_function :select_best_platform_match
+
+    def select_best_local_platform_match(specs, force_ruby: false)
+      matching = select_all_platform_match(specs, local_platform, force_ruby: force_ruby).filter_map(&:materialized_for_installation)
+
+      sort_best_platform_match(matching, local_platform)
+    end
+    module_function :select_best_local_platform_match
+
+    def sort_and_filter_best_platform_match(matching, platform)
+      return matching if matching.one?
+
+      exact = matching.select {|spec| spec.platform == platform }
+      return exact if exact.any?
+
+      sorted_matching = sort_best_platform_match(matching, 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 :sort_and_filter_best_platform_match
+
+    def sort_best_platform_match(matching, platform)
+      matching.sort_by {|spec| platform_specificity_match(spec.platform, platform) }
+    end
+    module_function :sort_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
+      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

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.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

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/gem_version_promoter.rb

@@ -0,0 +1,147 @@
+# 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
+    attr_reader :level
+    attr_accessor :pre
+
+    # 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 be 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
+
+    # Creates a GemVersionPromoter instance.
+    #
+    # @return [GemVersionPromoter]
+    def initialize
+      @level = :major
+      @strict = false
+      @pre = false
+    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 Resolver::Package and an Array of Specifications of available
+    # versions for a gem, this method will return the Array of Specifications
+    # sorted 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 package [Resolver::Package] The package being resolved.
+    # @param specs [Specification] An array of Specifications for the package.
+    # @return [Specification] A new instance of the Specification Array sorted.
+    def sort_versions(package, specs)
+      locked_version = package.locked_version
+
+      result = specs.sort do |a, b|
+        unless package.prerelease_specified? || pre?
+          a_pre = a.prerelease?
+          b_pre = b.prerelease?
+
+          next 1 if a_pre && !b_pre
+          next -1 if b_pre && !a_pre
+        end
+
+        if major? || locked_version.nil?
+          b <=> a
+        elsif either_version_older_than_locked?(a, b, locked_version)
+          b <=> a
+        elsif segments_do_not_match?(a, b, :major)
+          a <=> b
+        elsif !minor? && segments_do_not_match?(a, b, :minor)
+          a <=> b
+        else
+          b <=> a
+        end
+      end
+      post_sort(result, package.unlock?, locked_version)
+    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
+
+    # @return [bool] Convenience method for testing value of pre variable.
+    def pre?
+      pre == true
+    end
+
+    # Given a Resolver::Package and an Array of Specifications of available
+    # versions for a gem, this method will truncate the Array if strict
+    # is true. That means filtering out downgrades from the version currently
+    # locked, and filtering out upgrades that go past the selected level (major,
+    # minor, or patch).
+    # @param package [Resolver::Package] The package being resolved.
+    # @param specs [Specification] An array of Specifications for the package.
+    # @return [Specification] A new instance of the Specification Array
+    #   truncated.
+    def filter_versions(package, specs)
+      return specs unless strict
+
+      locked_version = package.locked_version
+      return specs if locked_version.nil? || major?
+
+      specs.select do |spec|
+        gsv = spec.version
+
+        must_match = minor? ? [0] : [0, 1]
+
+        all_match = must_match.all? {|idx| gsv.segments[idx] == locked_version.segments[idx] }
+        all_match && gsv >= locked_version
+      end
+    end
+
+    private
+
+    def either_version_older_than_locked?(a, b, locked_version)
+      a.version < locked_version || b.version < locked_version
+    end
+
+    def segments_do_not_match?(a, b, level)
+      index = [:major, :minor].index(level)
+      a.segments[index] != b.segments[index]
+    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, unlock, locked_version)
+      if unlock || locked_version.nil?
+        result
+      else
+        move_version_to_beginning(result, locked_version)
+      end
+    end
+
+    def move_version_to_beginning(result, version)
+      move, keep = result.partition {|s| s.version.to_s == version.to_s }
+      move.concat(keep)
+    end
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/graph.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "set"
+module Bundler
+  class Graph
+    GRAPH_NAME = :Gemfile
+
+    def initialize(env, output_file, show_version = false, show_requirements = false, output_format = "png", without = [])
+      @env               = env
+      @output_file       = output_file
+      @show_version      = show_version
+      @show_requirements = show_requirements
+      @output_format     = output_format
+      @without_groups    = without.map(&:to_sym)
+
+      @groups            = []
+      @relations         = Hash.new {|h, k| h[k] = Set.new }
+      @node_options      = {}
+      @edge_options      = {}
+
+      _populate_relations
+    end
+
+    attr_reader :groups, :relations, :node_options, :edge_options, :output_file, :output_format
+
+    def viz
+      GraphVizClient.new(self).run
+    end
+
+    private
+
+    def _populate_relations
+      parent_dependencies = _groups.values.to_set.flatten
+      loop do
+        break if parent_dependencies.empty?
+
+        tmp = Set.new
+        parent_dependencies.each do |dependency|
+          child_dependencies = spec_for_dependency(dependency).runtime_dependencies.to_set
+          @relations[dependency.name] += child_dependencies.map(&:name).to_set
+          tmp += child_dependencies
+
+          @node_options[dependency.name] = _make_label(dependency, :node)
+          child_dependencies.each do |c_dependency|
+            @edge_options["#{dependency.name}_#{c_dependency.name}"] = _make_label(c_dependency, :edge)
+          end
+        end
+        parent_dependencies = tmp
+      end
+    end
+
+    def _groups
+      relations = Hash.new {|h, k| h[k] = Set.new }
+      @env.current_dependencies.each do |dependency|
+        dependency.groups.each do |group|
+          next if @without_groups.include?(group)
+
+          relations[group.to_s].add(dependency)
+          @relations[group.to_s].add(dependency.name)
+
+          @node_options[group.to_s] ||= _make_label(group, :node)
+          @edge_options["#{group}_#{dependency.name}"] = _make_label(dependency, :edge)
+        end
+      end
+      @groups = relations.keys
+      relations
+    end
+
+    def _make_label(symbol_or_string_or_dependency, element_type)
+      case element_type.to_sym
+      when :node
+        if symbol_or_string_or_dependency.is_a?(Gem::Dependency)
+          label = symbol_or_string_or_dependency.name.dup
+          label << "\n#{spec_for_dependency(symbol_or_string_or_dependency).version}" if @show_version
+        else
+          label = symbol_or_string_or_dependency.to_s
+        end
+      when :edge
+        label = nil
+        if symbol_or_string_or_dependency.respond_to?(:requirements_list) && @show_requirements
+          tmp = symbol_or_string_or_dependency.requirements_list.join(", ")
+          label = tmp if tmp != ">= 0"
+        end
+      else
+        raise ArgumentError, "2nd argument is invalid"
+      end
+      label.nil? ? {} : { label: label }
+    end
+
+    def spec_for_dependency(dependency)
+      @env.requested_specs.find {|s| s.name == dependency.name }
+    end
+
+    class GraphVizClient
+      def initialize(graph_instance)
+        @graph_name    = graph_instance.class::GRAPH_NAME
+        @groups        = graph_instance.groups
+        @relations     = graph_instance.relations
+        @node_options  = graph_instance.node_options
+        @edge_options  = graph_instance.edge_options
+        @output_file   = graph_instance.output_file
+        @output_format = graph_instance.output_format
+      end
+
+      def g
+        @g ||= ::GraphViz.digraph(@graph_name, concentrate: true, normalize: true, nodesep: 0.55) do |g|
+          g.edge[:weight]   = 2
+          g.edge[:fontname] = g.node[:fontname] = "Arial, Helvetica, SansSerif"
+          g.edge[:fontsize] = 12
+        end
+      end
+
+      def run
+        @groups.each do |group|
+          g.add_nodes(
+            group, {
+              style: "filled",
+              fillcolor: "#B9B9D5",
+              shape: "box3d",
+              fontsize: 16,
+            }.merge(@node_options[group])
+          )
+        end
+
+        @relations.each do |parent, children|
+          children.each do |child|
+            if @groups.include?(parent)
+              g.add_nodes(child, { style: "filled", fillcolor: "#B9B9D5" }.merge(@node_options[child]))
+              g.add_edges(parent, child, { constraint: false }.merge(@edge_options["#{parent}_#{child}"]))
+            else
+              g.add_nodes(child, @node_options[child])
+              g.add_edges(parent, child, @edge_options["#{parent}_#{child}"])
+            end
+          end
+        end
+
+        if @output_format.to_s == "debug"
+          $stdout.puts g.output none: String
+          Bundler.ui.info "debugging bundle viz..."
+        else
+          begin
+            g.output @output_format.to_sym => "#{@output_file}.#{@output_format}"
+            Bundler.ui.info "#{@output_file}.#{@output_format}"
+          rescue ArgumentError => e
+            warn "Unsupported output format. See Ruby-Graphviz/lib/graphviz/constants.rb"
+            raise e
+          end
+        end
+      end
+    end
+  end
+end