@appthreat/atom-parsetools 1.0.3 → 1.0.5

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

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Index
+    include Enumerable
+
+    def self.build
+      i = new
+      yield i
+      i
+    end
+
+    attr_reader :specs, :duplicates, :sources
+    protected :specs, :duplicates
+
+    RUBY = "ruby"
+    NULL = "\0"
+
+    def initialize
+      @sources = []
+      @cache = {}
+      @specs = {}
+      @duplicates = {}
+    end
+
+    def initialize_copy(o)
+      @sources = o.sources.dup
+      @cache = {}
+      @specs = {}
+      @duplicates = {}
+
+      o.specs.each do |name, hash|
+        @specs[name] = hash.dup
+      end
+      o.duplicates.each do |name, array|
+        @duplicates[name] = array.dup
+      end
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id} sources=#{sources.map(&:inspect)} specs.size=#{specs.size}>"
+    end
+
+    def empty?
+      each { return false }
+      true
+    end
+
+    def search_all(name, &blk)
+      return enum_for(:search_all, name) unless blk
+      specs_by_name(name).each(&blk)
+      @duplicates[name]&.each(&blk)
+      @sources.each {|source| source.search_all(name, &blk) }
+    end
+
+    # Search this index's specs, and any source indexes that this index knows
+    # about, returning all of the results.
+    def search(query)
+      results = local_search(query)
+      return results unless @sources.any?
+
+      @sources.each do |source|
+        results = safe_concat(results, source.search(query))
+      end
+      results.uniq!(&:full_name) unless results.empty? # avoid modifying frozen EMPTY_SEARCH
+      results
+    end
+
+    alias_method :[], :search
+
+    def local_search(query)
+      case query
+      when Gem::Specification, RemoteSpecification, LazySpecification, EndpointSpecification then search_by_spec(query)
+      when String then specs_by_name(query)
+      when Array then specs_by_name_and_version(*query)
+      else
+        raise "You can't search for a #{query.inspect}."
+      end
+    end
+
+    def add(spec)
+      (@specs[spec.name] ||= {}).store(spec.full_name, spec)
+    end
+    alias_method :<<, :add
+
+    def each(&blk)
+      return enum_for(:each) unless blk
+      specs.values.each do |spec_sets|
+        spec_sets.values.each(&blk)
+      end
+      sources.each {|s| s.each(&blk) }
+      self
+    end
+
+    def spec_names
+      names = specs.keys + sources.map(&:spec_names)
+      names.uniq!
+      names
+    end
+
+    def unmet_dependency_names
+      dependency_names.select do |name|
+        search(name).empty?
+      end
+    end
+
+    def dependency_names
+      names = []
+      each do |spec|
+        spec.dependencies.each do |dep|
+          next if dep.type == :development
+          names << dep.name
+        end
+      end
+      names.uniq
+    end
+
+    # Combines indexes proritizing existing specs, like `Hash#reverse_merge!`
+    # Duplicate specs found in `other` are stored in `@duplicates`.
+    def use(other)
+      return unless other
+      other.each do |spec|
+        exist?(spec) ? add_duplicate(spec) : add(spec)
+      end
+      self
+    end
+
+    # Combines indexes proritizing specs from `other`, like `Hash#merge!`
+    # Duplicate specs found in `self` are saved in `@duplicates`.
+    def merge!(other)
+      return unless other
+      other.each do |spec|
+        if existing = find_by_spec(spec)
+          add_duplicate(existing)
+        end
+        add spec
+      end
+      self
+    end
+
+    def size
+      @sources.inject(@specs.size) do |size, source|
+        size += source.size
+      end
+    end
+
+    # Whether all the specs in self are in other
+    def subset?(other)
+      all? do |spec|
+        other_spec = other[spec].first
+        other_spec && dependencies_eql?(spec, other_spec) && spec.source == other_spec.source
+      end
+    end
+
+    def dependencies_eql?(spec, other_spec)
+      deps       = spec.dependencies.select {|d| d.type != :development }
+      other_deps = other_spec.dependencies.select {|d| d.type != :development }
+      deps.sort == other_deps.sort
+    end
+
+    def add_source(index)
+      raise ArgumentError, "Source must be an index, not #{index.class}" unless index.is_a?(Index)
+      @sources << index
+      @sources.uniq! # need to use uniq! here instead of checking for the item before adding
+    end
+
+    private
+
+    def safe_concat(a, b)
+      return a if b.empty?
+      return b if a.empty?
+      a.concat(b)
+    end
+
+    def add_duplicate(spec)
+      (@duplicates[spec.name] ||= []) << spec
+    end
+
+    def specs_by_name_and_version(name, version)
+      results = @specs[name]&.values
+      return EMPTY_SEARCH unless results
+      results.select! {|spec| spec.version == version }
+      results
+    end
+
+    def specs_by_name(name)
+      @specs[name]&.values || EMPTY_SEARCH
+    end
+
+    EMPTY_SEARCH = [].freeze
+
+    def search_by_spec(spec)
+      spec = find_by_spec(spec)
+      spec ? [spec] : EMPTY_SEARCH
+    end
+
+    def find_by_spec(spec)
+      @specs[spec.name]&.fetch(spec.full_name, nil)
+    end
+
+    def exist?(spec)
+      @specs[spec.name]&.key?(spec.full_name)
+    end
+  end
+end

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

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Injector
+    INJECTED_GEMS = "injected gems"
+
+    def self.inject(new_deps, options = {})
+      injector = new(new_deps, options)
+      injector.inject(Bundler.default_gemfile, Bundler.default_lockfile)
+    end
+
+    def self.remove(gems, options = {})
+      injector = new(gems, options)
+      injector.remove(Bundler.default_gemfile, Bundler.default_lockfile)
+    end
+
+    def initialize(deps, options = {})
+      @deps = deps
+      @options = options
+    end
+
+    # @param [Pathname] gemfile_path The Gemfile in which to inject the new dependency.
+    # @param [Pathname] lockfile_path The lockfile in which to inject the new dependency.
+    # @return [Array]
+    def inject(gemfile_path, lockfile_path)
+      Bundler.definition.ensure_equivalent_gemfile_and_lockfile(true)
+
+      # temporarily unfreeze
+      Bundler.settings.temporary(deployment: false, frozen: false) do
+        # evaluate the Gemfile we have now
+        builder = Dsl.new
+        builder.eval_gemfile(gemfile_path)
+
+        # don't inject any gems that are already in the Gemfile
+        @deps -= builder.dependencies
+
+        # add new deps to the end of the in-memory Gemfile
+        # Set conservative versioning to false because
+        # we want to let the resolver resolve the version first
+        builder.eval_gemfile(INJECTED_GEMS, build_gem_lines(false)) if @deps.any?
+
+        # resolve to see if the new deps broke anything
+        @definition = builder.to_definition(lockfile_path, {})
+        @definition.remotely!
+
+        # since nothing broke, we can add those gems to the gemfile
+        append_to(gemfile_path, build_gem_lines(@options[:conservative_versioning])) if @deps.any?
+
+        # since we resolved successfully, write out the lockfile
+        @definition.lock
+
+        # invalidate the cached Bundler.definition
+        Bundler.reset_paths!
+
+        # return an array of the deps that we added
+        @deps
+      end
+    end
+
+    # @param [Pathname] gemfile_path The Gemfile from which to remove dependencies.
+    # @param [Pathname] lockfile_path The lockfile from which to remove dependencies.
+    # @return [Array]
+    def remove(gemfile_path, lockfile_path)
+      # remove gems from each gemfiles we have
+      Bundler.definition.gemfiles.each do |path|
+        deps = remove_deps(path)
+
+        show_warning("No gems were removed from the gemfile.") if deps.empty?
+
+        deps.each {|dep| Bundler.ui.confirm "#{SharedHelpers.pretty_dependency(dep)} was removed." }
+      end
+
+      # Invalidate the cached Bundler.definition.
+      # This prevents e.g. `bundle remove ...` from using outdated information.
+      Bundler.reset_paths!
+    end
+
+    private
+
+    def conservative_version(spec)
+      version = spec.version
+      return ">= 0" if version.nil?
+      segments = version.segments
+      seg_end_index = version >= Gem::Version.new("1.0") ? 1 : 2
+
+      prerelease_suffix = version.to_s.delete_prefix(version.release.to_s) if version.prerelease?
+      "#{version_prefix}#{segments[0..seg_end_index].join(".")}#{prerelease_suffix}"
+    end
+
+    def version_prefix
+      if @options[:strict]
+        "= "
+      elsif @options[:optimistic]
+        ">= "
+      else
+        "~> "
+      end
+    end
+
+    def build_gem_lines(conservative_versioning)
+      @deps.map do |d|
+        name = d.name.dump
+
+        requirement = if conservative_versioning
+          ", \"#{conservative_version(@definition.specs[d.name][0])}\""
+        else
+          ", #{d.requirement.as_list.map(&:dump).join(", ")}"
+        end
+
+        if d.groups != Array(:default)
+          group = d.groups.size == 1 ? ", group: #{d.groups.first.inspect}" : ", groups: #{d.groups.inspect}"
+        end
+
+        source = ", source: \"#{d.source}\"" unless d.source.nil?
+        path = ", path: \"#{d.path}\"" unless d.path.nil?
+        git = ", git: \"#{d.git}\"" unless d.git.nil?
+        github = ", github: \"#{d.github}\"" unless d.github.nil?
+        branch = ", branch: \"#{d.branch}\"" unless d.branch.nil?
+        ref = ", ref: \"#{d.ref}\"" unless d.ref.nil?
+        glob = ", glob: \"#{d.glob}\"" unless d.glob.nil?
+        require_path = ", require: #{convert_autorequire(d.autorequire)}" unless d.autorequire.nil?
+
+        %(gem #{name}#{requirement}#{group}#{source}#{path}#{git}#{github}#{branch}#{ref}#{glob}#{require_path})
+      end.join("\n")
+    end
+
+    def append_to(gemfile_path, new_gem_lines)
+      gemfile_path.open("a") do |f|
+        f.puts
+        f.puts new_gem_lines
+      end
+    end
+
+    # evaluates a gemfile to remove the specified gem
+    # from it.
+    def remove_deps(gemfile_path)
+      initial_gemfile = File.readlines(gemfile_path)
+
+      Bundler.ui.info "Removing gems from #{gemfile_path}"
+
+      # evaluate the Gemfile we have
+      builder = Dsl.new
+      builder.eval_gemfile(gemfile_path)
+
+      removed_deps = remove_gems_from_dependencies(builder, @deps, gemfile_path)
+
+      # abort the operation if no gems were removed
+      # no need to operate on gemfile further
+      return [] if removed_deps.empty?
+
+      cleaned_gemfile = remove_gems_from_gemfile(@deps, gemfile_path)
+
+      SharedHelpers.write_to_gemfile(gemfile_path, cleaned_gemfile)
+
+      # check for errors
+      # including extra gems being removed
+      # or some gems not being removed
+      # and return the actual removed deps
+      cross_check_for_errors(gemfile_path, builder.dependencies, removed_deps, initial_gemfile)
+    end
+
+    # @param [Dsl]      builder Dsl object of current Gemfile.
+    # @param [Array]    gems Array of names of gems to be removed.
+    # @param [Pathname] gemfile_path Path of the Gemfile.
+    # @return [Array]   Array of removed dependencies.
+    def remove_gems_from_dependencies(builder, gems, gemfile_path)
+      removed_deps = []
+
+      gems.each do |gem_name|
+        deleted_dep = builder.dependencies.find {|d| d.name == gem_name }
+
+        if deleted_dep.nil?
+          raise GemfileError, "`#{gem_name}` is not specified in #{gemfile_path} so it could not be removed."
+        end
+
+        builder.dependencies.delete(deleted_dep)
+
+        removed_deps << deleted_dep
+      end
+
+      removed_deps
+    end
+
+    # @param [Array] gems            Array of names of gems to be removed.
+    # @param [Pathname] gemfile_path The Gemfile from which to remove dependencies.
+    def remove_gems_from_gemfile(gems, gemfile_path)
+      patterns = /gem\s+(['"])#{Regexp.union(gems)}\1|gem\s*\((['"])#{Regexp.union(gems)}\2.*\)/
+      new_gemfile = []
+      multiline_removal = false
+      File.readlines(gemfile_path).each do |line|
+        match_data = line.match(patterns)
+        if match_data && is_not_within_comment?(line, match_data)
+          multiline_removal = line.rstrip.end_with?(",")
+          # skip lines which match the regex
+          next
+        end
+
+        # skip followup lines until line does not end with ','
+        new_gemfile << line unless multiline_removal
+        multiline_removal = line.rstrip.end_with?(",") if multiline_removal
+      end
+
+      # remove line \n and append them with other strings
+      new_gemfile.each_with_index do |_line, index|
+        if new_gemfile[index + 1] == "\n"
+          new_gemfile[index] += new_gemfile[index + 1]
+          new_gemfile.delete_at(index + 1)
+        end
+      end
+
+      %w[group source env install_if].each {|block| remove_nested_blocks(new_gemfile, block) }
+
+      new_gemfile.join.chomp
+    end
+
+    # @param [String] line          Individual line of gemfile content.
+    # @param [MatchData] match_data Data about Regex match.
+    def is_not_within_comment?(line, match_data)
+      match_start_index = match_data.offset(0).first
+      !line[0..match_start_index].include?("#")
+    end
+
+    # @param [Array] gemfile       Array of gemfile contents.
+    # @param [String] block_name   Name of block name to look for.
+    def remove_nested_blocks(gemfile, block_name)
+      nested_blocks = 0
+
+      # count number of nested blocks
+      gemfile.each_with_index {|line, index| nested_blocks += 1 if !gemfile[index + 1].nil? && gemfile[index + 1].include?(block_name) && line.include?(block_name) }
+
+      while nested_blocks >= 0
+        nested_blocks -= 1
+
+        gemfile.each_with_index do |line, index|
+          next unless !line.nil? && line.strip.start_with?(block_name)
+          if /^\s*end\s*$/.match?(gemfile[index + 1])
+            gemfile[index] = nil
+            gemfile[index + 1] = nil
+          end
+        end
+
+        gemfile.compact!
+      end
+    end
+
+    # @param [Pathname] gemfile_path   The Gemfile from which to remove dependencies.
+    # @param [Array] original_deps     Array of original dependencies.
+    # @param [Array] removed_deps      Array of removed dependencies.
+    # @param [Array] initial_gemfile   Contents of original Gemfile before any operation.
+    def cross_check_for_errors(gemfile_path, original_deps, removed_deps, initial_gemfile)
+      # evaluate the new gemfile to look for any failure cases
+      builder = Dsl.new
+      builder.eval_gemfile(gemfile_path)
+
+      # record gems which were removed but not requested
+      extra_removed_gems = original_deps - builder.dependencies
+
+      # if some extra gems were removed then raise error
+      # and revert Gemfile to original
+      unless extra_removed_gems.empty?
+        SharedHelpers.write_to_gemfile(gemfile_path, initial_gemfile.join)
+
+        raise InvalidOption, "Gems could not be removed. #{extra_removed_gems.join(", ")} would also have been removed. Bundler cannot continue."
+      end
+
+      # record gems which could not be removed due to some reasons
+      errored_deps = builder.dependencies.select {|d| d.gemfile == gemfile_path } & removed_deps.select {|d| d.gemfile == gemfile_path }
+
+      show_warning "#{errored_deps.map(&:name).join(", ")} could not be removed." unless errored_deps.empty?
+
+      # return actual removed dependencies
+      removed_deps - errored_deps
+    end
+
+    def show_warning(message)
+      Bundler.ui.info Bundler.ui.add_color(message, :yellow)
+    end
+
+    def convert_autorequire(autorequire)
+      autorequire = autorequire.first
+      return autorequire if autorequire == "false"
+      autorequire.inspect
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Allows for declaring a Gemfile inline in a ruby script, installing any gems
+# that aren't already installed on the user's system.
+#
+# @note Every gem that is specified in this 'Gemfile' will be `require`d, as if
+#       the user had manually called `Bundler.require`. To avoid a requested gem
+#       being automatically required, add the `:require => false` option to the
+#       `gem` dependency declaration.
+#
+# @param force_latest_compatible [Boolean] Force installing the *latest*
+#                                          compatible versions of the gems,
+#                                          even if compatible versions are
+#                                          already installed locally.
+#                                          This also logs output if the
+#                                          `:quiet` option is not set.
+#                                          Defaults to `false`.
+#
+# @param gemfile [Proc]    a block that is evaluated as a `Gemfile`.
+#
+# @example Using an inline Gemfile
+#
+#          #!/usr/bin/env ruby
+#
+#          require 'bundler/inline'
+#
+#          gemfile do
+#            source 'https://rubygems.org'
+#            gem 'json', require: false
+#            gem 'nap', require: 'rest'
+#            gem 'cocoapods', '~> 0.34.1'
+#          end
+#
+#          puts Pod::VERSION # => "0.34.4"
+#
+def gemfile(force_latest_compatible = false, options = {}, &gemfile)
+  require_relative "../bundler"
+  Bundler.reset!
+
+  opts = options.dup
+  ui = opts.delete(:ui) { Bundler::UI::Shell.new }
+  ui.level = "silent" if opts.delete(:quiet) || !force_latest_compatible
+  Bundler.ui = ui
+  raise ArgumentError, "Unknown options: #{opts.keys.join(", ")}" unless opts.empty?
+
+  old_gemfile = ENV["BUNDLE_GEMFILE"]
+
+  Bundler.unbundle_env!
+
+  begin
+    Bundler.instance_variable_set(:@bundle_path, Pathname.new(Gem.dir))
+    Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", "Gemfile"
+
+    Bundler::Plugin.gemfile_install(&gemfile) if Bundler.feature_flag.plugins?
+    builder = Bundler::Dsl.new
+    builder.instance_eval(&gemfile)
+
+    Bundler.settings.temporary(deployment: false, frozen: false) do
+      definition = builder.to_definition(nil, true)
+      definition.validate_runtime!
+
+      if force_latest_compatible || definition.missing_specs?
+        Bundler.settings.temporary(inline: true, no_install: false) do
+          installer = Bundler::Installer.install(Bundler.root, definition, system: true)
+          installer.post_install_messages.each do |name, message|
+            Bundler.ui.info "Post-install message from #{name}:\n#{message}"
+          end
+        end
+      end
+
+      begin
+        runtime = Bundler::Runtime.new(nil, definition).setup
+      rescue Gem::LoadError => e
+        name = e.name
+        version = e.requirement.requirements.first[1]
+        activated_version = Gem.loaded_specs[name].version
+
+        Bundler.ui.info \
+          "The #{name} gem was resolved to #{version}, but #{activated_version} was activated by Bundler while installing it, causing a conflict. " \
+          "Bundler will now retry resolving with #{activated_version} instead."
+
+        builder.dependencies.delete_if {|d| d.name == name }
+        builder.instance_eval { gem name, activated_version }
+        definition = builder.to_definition(nil, true)
+
+        retry
+      end
+
+      runtime.require
+    end
+  ensure
+    if old_gemfile
+      ENV["BUNDLE_GEMFILE"] = old_gemfile
+    else
+      ENV["BUNDLE_GEMFILE"] = ""
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Bundler
+  class GemInstaller
+    attr_reader :spec, :standalone, :worker, :force, :local, :installer
+
+    def initialize(spec, installer, standalone = false, worker = 0, force = false, local = false)
+      @spec = spec
+      @installer = installer
+      @standalone = standalone
+      @worker = worker
+      @force = force
+      @local = local
+    end
+
+    def install_from_spec
+      post_install_message = install
+      Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
+      generate_executable_stubs
+      [true, post_install_message]
+    rescue Bundler::InstallHookError, Bundler::SecurityError, Bundler::APIResponseMismatchError, Bundler::InsecureInstallPathError
+      raise
+    rescue Errno::ENOSPC
+      [false, out_of_space_message]
+    rescue Bundler::BundlerError, Gem::InstallError => e
+      [false, specific_failure_message(e)]
+    end
+
+    private
+
+    def specific_failure_message(e)
+      message = "#{e.class}: #{e.message}\n"
+      message += "  " + e.backtrace.join("\n  ") + "\n\n"
+      message = message.lines.first + Bundler.ui.add_color(message.lines.drop(1).join, :clear)
+      message + Bundler.ui.add_color(failure_message, :red)
+    end
+
+    def failure_message
+      install_error_message
+    end
+
+    def install_error_message
+      "An error occurred while installing #{spec.name} (#{spec.version}), and Bundler cannot continue."
+    end
+
+    def spec_settings
+      # Fetch the build settings, if there are any
+      if settings = Bundler.settings["build.#{spec.name}"]
+        require "shellwords"
+        Shellwords.shellsplit(settings)
+      end
+    end
+
+    def install
+      spec.source.install(
+        spec,
+        force: force,
+        local: local,
+        build_args: Array(spec_settings),
+        previous_spec: previous_spec,
+      )
+    end
+
+    def previous_spec
+      locked_gems = installer.definition.locked_gems
+      return unless locked_gems
+
+      locked_gems.specs.find {|s| s.name == spec.name }
+    end
+
+    def out_of_space_message
+      "#{install_error_message}\nYour disk is out of space. Free some space to be able to install your bundle."
+    end
+
+    def generate_executable_stubs
+      return if Bundler.feature_flag.forget_cli_options?
+      return if Bundler.settings[:inline]
+      if Bundler.settings[:bin] && standalone
+        installer.generate_standalone_bundler_executable_stubs(spec)
+      elsif Bundler.settings[:bin]
+        installer.generate_bundler_executable_stubs(spec, force: true)
+      end
+    end
+  end
+end