@appthreat/atom 2.1.10 → 2.1.11

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/vendor/thor/lib/thor/command.rb

@@ -1,151 +0,0 @@
-class Bundler::Thor
-  class Command < Struct.new(:name, :description, :long_description, :wrap_long_description, :usage, :options, :options_relation, :ancestor_name)
-    FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
-
-    def initialize(name, description, long_description, wrap_long_description, usage, options = nil, options_relation = nil)
-      super(name.to_s, description, long_description, wrap_long_description, usage, options || {}, options_relation || {})
-    end
-
-    def initialize_copy(other) #:nodoc:
-      super(other)
-      self.options = other.options.dup if other.options
-      self.options_relation = other.options_relation.dup if other.options_relation
-    end
-
-    def hidden?
-      false
-    end
-
-    # By default, a command invokes a method in the thor class. You can change this
-    # implementation to create custom commands.
-    def run(instance, args = [])
-      arity = nil
-
-      if private_method?(instance)
-        instance.class.handle_no_command_error(name)
-      elsif public_method?(instance)
-        arity = instance.method(name).arity
-        instance.__send__(name, *args)
-      elsif local_method?(instance, :method_missing)
-        instance.__send__(:method_missing, name.to_sym, *args)
-      else
-        instance.class.handle_no_command_error(name)
-      end
-    rescue ArgumentError => e
-      handle_argument_error?(instance, e, caller) ? instance.class.handle_argument_error(self, e, args, arity) : (raise e)
-    rescue NoMethodError => e
-      handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (raise e)
-    end
-
-    # Returns the formatted usage by injecting given required arguments
-    # and required options into the given usage.
-    def formatted_usage(klass, namespace = true, subcommand = false)
-      if ancestor_name
-        formatted = "#{ancestor_name} ".dup # add space
-      elsif namespace
-        namespace = klass.namespace
-        formatted = "#{namespace.gsub(/^(default)/, '')}:".dup
-      end
-      formatted ||= "#{klass.namespace.split(':').last} ".dup if subcommand
-
-      formatted ||= "".dup
-
-      Array(usage).map do |specific_usage|
-        formatted_specific_usage = formatted
-
-        formatted_specific_usage += required_arguments_for(klass, specific_usage)
-
-        # Add required options
-        formatted_specific_usage += " #{required_options}"
-
-        # Strip and go!
-        formatted_specific_usage.strip
-      end.join("\n")
-    end
-
-    def method_exclusive_option_names #:nodoc:
-      self.options_relation[:exclusive_option_names] || []
-    end
-
-    def method_at_least_one_option_names #:nodoc:
-      self.options_relation[:at_least_one_option_names] || []
-    end
-
-  protected
-
-    # Add usage with required arguments
-    def required_arguments_for(klass, usage)
-      if klass && !klass.arguments.empty?
-        usage.to_s.gsub(/^#{name}/) do |match|
-          match << " " << klass.arguments.map(&:usage).compact.join(" ")
-        end
-      else
-        usage.to_s
-      end
-    end
-
-    def not_debugging?(instance)
-      !(instance.class.respond_to?(:debugging) && instance.class.debugging)
-    end
-
-    def required_options
-      @required_options ||= options.map { |_, o| o.usage if o.required? }.compact.sort.join(" ")
-    end
-
-    # Given a target, checks if this class name is a public method.
-    def public_method?(instance) #:nodoc:
-      !(instance.public_methods & [name.to_s, name.to_sym]).empty?
-    end
-
-    def private_method?(instance)
-      !(instance.private_methods & [name.to_s, name.to_sym]).empty?
-    end
-
-    def local_method?(instance, name)
-      methods = instance.public_methods(false) + instance.private_methods(false) + instance.protected_methods(false)
-      !(methods & [name.to_s, name.to_sym]).empty?
-    end
-
-    def sans_backtrace(backtrace, caller) #:nodoc:
-      saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ %r{^kernel/} && RUBY_ENGINE =~ /rbx/) }
-      saned - caller
-    end
-
-    def handle_argument_error?(instance, error, caller)
-      not_debugging?(instance) && (error.message =~ /wrong number of arguments/ || error.message =~ /given \d*, expected \d*/) && begin
-        saned = sans_backtrace(error.backtrace, caller)
-        saned.empty? || saned.size == 1
-      end
-    end
-
-    def handle_no_method_error?(instance, error, caller)
-      not_debugging?(instance) &&
-        error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
-    end
-  end
-  Task = Command
-
-  # A command that is hidden in help messages but still invocable.
-  class HiddenCommand < Command
-    def hidden?
-      true
-    end
-  end
-  HiddenTask = HiddenCommand
-
-  # A dynamic command that handles method missing scenarios.
-  class DynamicCommand < Command
-    def initialize(name, options = nil)
-      super(name.to_s, "A dynamically-generated command", name.to_s, nil, name.to_s, options)
-    end
-
-    def run(instance, args = [])
-      if (instance.methods & [name.to_s, name.to_sym]).empty?
-        super
-      else
-        instance.class.handle_no_command_error(name)
-      end
-    end
-  end
-  DynamicTask = DynamicCommand
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/vendor/thor/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -1,107 +0,0 @@
-class Bundler::Thor
-  module CoreExt #:nodoc:
-    # A hash with indifferent access and magic predicates.
-    #
-    #   hash = Bundler::Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
-    #
-    #   hash[:foo]  #=> 'bar'
-    #   hash['foo'] #=> 'bar'
-    #   hash.foo?   #=> true
-    #
-    class HashWithIndifferentAccess < ::Hash #:nodoc:
-      def initialize(hash = {})
-        super()
-        hash.each do |key, value|
-          self[convert_key(key)] = value
-        end
-      end
-
-      def [](key)
-        super(convert_key(key))
-      end
-
-      def []=(key, value)
-        super(convert_key(key), value)
-      end
-
-      def delete(key)
-        super(convert_key(key))
-      end
-
-      def except(*keys)
-        dup.tap do |hash|
-          keys.each { |key| hash.delete(convert_key(key)) }
-        end
-      end
-
-      def fetch(key, *args)
-        super(convert_key(key), *args)
-      end
-
-      def slice(*keys)
-        super(*keys.map{ |key| convert_key(key) })
-      end
-
-      def key?(key)
-        super(convert_key(key))
-      end
-
-      def values_at(*indices)
-        indices.map { |key| self[convert_key(key)] }
-      end
-
-      def merge(other)
-        dup.merge!(other)
-      end
-
-      def merge!(other)
-        other.each do |key, value|
-          self[convert_key(key)] = value
-        end
-        self
-      end
-
-      def reverse_merge(other)
-        self.class.new(other).merge(self)
-      end
-
-      def reverse_merge!(other_hash)
-        replace(reverse_merge(other_hash))
-      end
-
-      def replace(other_hash)
-        super(other_hash)
-      end
-
-      # Convert to a Hash with String keys.
-      def to_hash
-        Hash.new(default).merge!(self)
-      end
-
-    protected
-
-      def convert_key(key)
-        key.is_a?(Symbol) ? key.to_s : key
-      end
-
-      # Magic predicates. For instance:
-      #
-      #   options.force?                  # => !!options['force']
-      #   options.shebang                 # => "/usr/lib/local/ruby"
-      #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
-      #
-      def method_missing(method, *args)
-        method = method.to_s
-        if method =~ /^(\w+)\?$/
-          if args.empty?
-            !!self[$1]
-          else
-            self[$1] == args.first
-          end
-        else
-          self[method]
-        end
-      end
-    end
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/vendor/thor/lib/thor/error.rb

@@ -1,106 +0,0 @@
-class Bundler::Thor
-  Correctable = if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable) # rubocop:disable Naming/ConstantName
-    Module.new do
-      def to_s
-        super + DidYouMean.formatter.message_for(corrections)
-      end
-
-      def corrections
-        @corrections ||= self.class.const_get(:SpellChecker).new(self).corrections
-      end
-    end
-  end
-
-  # Bundler::Thor::Error is raised when it's caused by wrong usage of thor classes. Those
-  # errors have their backtrace suppressed and are nicely shown to the user.
-  #
-  # Errors that are caused by the developer, like declaring a method which
-  # overwrites a thor keyword, SHOULD NOT raise a Bundler::Thor::Error. This way, we
-  # ensure that developer errors are shown with full backtrace.
-  class Error < StandardError
-  end
-
-  # Raised when a command was not found.
-  class UndefinedCommandError < Error
-    class SpellChecker
-      attr_reader :error
-
-      def initialize(error)
-        @error = error
-      end
-
-      def corrections
-        @corrections ||= spell_checker.correct(error.command).map(&:inspect)
-      end
-
-      def spell_checker
-        DidYouMean::SpellChecker.new(dictionary: error.all_commands)
-      end
-    end
-
-    attr_reader :command, :all_commands
-
-    def initialize(command, all_commands, namespace)
-      @command = command
-      @all_commands = all_commands
-
-      message = "Could not find command #{command.inspect}"
-      message = namespace ? "#{message} in #{namespace.inspect} namespace." : "#{message}."
-
-      super(message)
-    end
-
-    prepend Correctable if Correctable
-  end
-  UndefinedTaskError = UndefinedCommandError
-
-  class AmbiguousCommandError < Error
-  end
-  AmbiguousTaskError = AmbiguousCommandError
-
-  # Raised when a command was found, but not invoked properly.
-  class InvocationError < Error
-  end
-
-  class UnknownArgumentError < Error
-    class SpellChecker
-      attr_reader :error
-
-      def initialize(error)
-        @error = error
-      end
-
-      def corrections
-        @corrections ||=
-          error.unknown.flat_map { |unknown| spell_checker.correct(unknown) }.uniq.map(&:inspect)
-      end
-
-      def spell_checker
-        @spell_checker ||= DidYouMean::SpellChecker.new(dictionary: error.switches)
-      end
-    end
-
-    attr_reader :switches, :unknown
-
-    def initialize(switches, unknown)
-      @switches = switches
-      @unknown = unknown
-
-      super("Unknown switches #{unknown.map(&:inspect).join(', ')}")
-    end
-
-    prepend Correctable if Correctable
-  end
-
-  class RequiredArgumentMissingError < InvocationError
-  end
-
-  class MalformattedArgumentError < InvocationError
-  end
-
-  class ExclusiveArgumentError < InvocationError
-  end
-
-  class AtLeastOneRequiredArgumentError < InvocationError
-  end
-end

package/plugins/rubyastgen/bundle/jruby/3.1.0/gems/bundler-2.6.2/lib/bundler/vendor/thor/lib/thor/group.rb

@@ -1,292 +0,0 @@
-require_relative "base"
-
-# Bundler::Thor has a special class called Bundler::Thor::Group. The main difference to Bundler::Thor class
-# is that it invokes all commands at once. It also include some methods that allows
-# invocations to be done at the class method, which are not available to Bundler::Thor
-# commands.
-class Bundler::Thor::Group
-  class << self
-    # The description for this Bundler::Thor::Group. If none is provided, but a source root
-    # exists, tries to find the USAGE one folder above it, otherwise searches
-    # in the superclass.
-    #
-    # ==== Parameters
-    # description<String>:: The description for this Bundler::Thor::Group.
-    #
-    def desc(description = nil)
-      if description
-        @desc = description
-      else
-        @desc ||= from_superclass(:desc, nil)
-      end
-    end
-
-    # Prints help information.
-    #
-    # ==== Options
-    # short:: When true, shows only usage.
-    #
-    def help(shell)
-      shell.say "Usage:"
-      shell.say "  #{banner}\n"
-      shell.say
-      class_options_help(shell)
-      shell.say desc if desc
-    end
-
-    # Stores invocations for this class merging with superclass values.
-    #
-    def invocations #:nodoc:
-      @invocations ||= from_superclass(:invocations, {})
-    end
-
-    # Stores invocation blocks used on invoke_from_option.
-    #
-    def invocation_blocks #:nodoc:
-      @invocation_blocks ||= from_superclass(:invocation_blocks, {})
-    end
-
-    # Invoke the given namespace or class given. It adds an instance
-    # method that will invoke the klass and command. You can give a block to
-    # configure how it will be invoked.
-    #
-    # The namespace/class given will have its options showed on the help
-    # usage. Check invoke_from_option for more information.
-    #
-    def invoke(*names, &block)
-      options = names.last.is_a?(Hash) ? names.pop : {}
-      verbose = options.fetch(:verbose, true)
-
-      names.each do |name|
-        invocations[name] = false
-        invocation_blocks[name] = block if block_given?
-
-        class_eval <<-METHOD, __FILE__, __LINE__ + 1
-          def _invoke_#{name.to_s.gsub(/\W/, '_')}
-            klass, command = self.class.prepare_for_invocation(nil, #{name.inspect})
-
-            if klass
-              say_status :invoke, #{name.inspect}, #{verbose.inspect}
-              block = self.class.invocation_blocks[#{name.inspect}]
-              _invoke_for_class_method klass, command, &block
-            else
-              say_status :error, %(#{name.inspect} [not found]), :red
-            end
-          end
-        METHOD
-      end
-    end
-
-    # Invoke a thor class based on the value supplied by the user to the
-    # given option named "name". A class option must be created before this
-    # method is invoked for each name given.
-    #
-    # ==== Examples
-    #
-    #   class GemGenerator < Bundler::Thor::Group
-    #     class_option :test_framework, :type => :string
-    #     invoke_from_option :test_framework
-    #   end
-    #
-    # ==== Boolean options
-    #
-    # In some cases, you want to invoke a thor class if some option is true or
-    # false. This is automatically handled by invoke_from_option. Then the
-    # option name is used to invoke the generator.
-    #
-    # ==== Preparing for invocation
-    #
-    # In some cases you want to customize how a specified hook is going to be
-    # invoked. You can do that by overwriting the class method
-    # prepare_for_invocation. The class method must necessarily return a klass
-    # and an optional command.
-    #
-    # ==== Custom invocations
-    #
-    # You can also supply a block to customize how the option is going to be
-    # invoked. The block receives two parameters, an instance of the current
-    # class and the klass to be invoked.
-    #
-    def invoke_from_option(*names, &block)
-      options = names.last.is_a?(Hash) ? names.pop : {}
-      verbose = options.fetch(:verbose, :white)
-
-      names.each do |name|
-        unless class_options.key?(name)
-          raise ArgumentError, "You have to define the option #{name.inspect} " \
-                              "before setting invoke_from_option."
-        end
-
-        invocations[name] = true
-        invocation_blocks[name] = block if block_given?
-
-        class_eval <<-METHOD, __FILE__, __LINE__ + 1
-          def _invoke_from_option_#{name.to_s.gsub(/\W/, '_')}
-            return unless options[#{name.inspect}]
-
-            value = options[#{name.inspect}]
-            value = #{name.inspect} if TrueClass === value
-            klass, command = self.class.prepare_for_invocation(#{name.inspect}, value)
-
-            if klass
-              say_status :invoke, value, #{verbose.inspect}
-              block = self.class.invocation_blocks[#{name.inspect}]
-              _invoke_for_class_method klass, command, &block
-            else
-              say_status :error, %(\#{value} [not found]), :red
-            end
-          end
-        METHOD
-      end
-    end
-
-    # Remove a previously added invocation.
-    #
-    # ==== Examples
-    #
-    #   remove_invocation :test_framework
-    #
-    def remove_invocation(*names)
-      names.each do |name|
-        remove_command(name)
-        remove_class_option(name)
-        invocations.delete(name)
-        invocation_blocks.delete(name)
-      end
-    end
-
-    # Overwrite class options help to allow invoked generators options to be
-    # shown recursively when invoking a generator.
-    #
-    def class_options_help(shell, groups = {}) #:nodoc:
-      get_options_from_invocations(groups, class_options) do |klass|
-        klass.send(:get_options_from_invocations, groups, class_options)
-      end
-      super(shell, groups)
-    end
-
-    # Get invocations array and merge options from invocations. Those
-    # options are added to group_options hash. Options that already exists
-    # in base_options are not added twice.
-    #
-    def get_options_from_invocations(group_options, base_options) #:nodoc:
-      invocations.each do |name, from_option|
-        value = if from_option
-          option = class_options[name]
-          option.type == :boolean ? name : option.default
-        else
-          name
-        end
-        next unless value
-
-        klass, _ = prepare_for_invocation(name, value)
-        next unless klass && klass.respond_to?(:class_options)
-
-        value = value.to_s
-        human_name = value.respond_to?(:classify) ? value.classify : value
-
-        group_options[human_name] ||= []
-        group_options[human_name] += klass.class_options.values.select do |class_option|
-          base_options[class_option.name.to_sym].nil? && class_option.group.nil? &&
-            !group_options.values.flatten.any? { |i| i.name == class_option.name }
-        end
-
-        yield klass if block_given?
-      end
-    end
-
-    # Returns commands ready to be printed.
-    def printable_commands(*)
-      item = []
-      item << banner
-      item << (desc ? "# #{desc.gsub(/\s+/m, ' ')}" : "")
-      [item]
-    end
-    alias_method :printable_tasks, :printable_commands
-
-    def handle_argument_error(command, error, _args, arity) #:nodoc:
-      msg = "#{basename} #{command.name} takes #{arity} argument".dup
-      msg << "s" if arity > 1
-      msg << ", but it should not."
-      raise error, msg
-    end
-
-    # Checks if a specified command exists.
-    #
-    # ==== Parameters
-    # command_name<String>:: The name of the command to check for existence.
-    #
-    # ==== Returns
-    # Boolean:: +true+ if the command exists, +false+ otherwise.
-    def command_exists?(command_name) #:nodoc:
-      commands.keys.include?(command_name)
-    end
-
-  protected
-
-    # The method responsible for dispatching given the args.
-    def dispatch(command, given_args, given_opts, config) #:nodoc:
-      if Bundler::Thor::HELP_MAPPINGS.include?(given_args.first)
-        help(config[:shell])
-        return
-      end
-
-      args, opts = Bundler::Thor::Options.split(given_args)
-      opts = given_opts || opts
-
-      instance = new(args, opts, config)
-      yield instance if block_given?
-
-      if command
-        instance.invoke_command(all_commands[command])
-      else
-        instance.invoke_all
-      end
-    end
-
-    # The banner for this class. You can customize it if you are invoking the
-    # thor class by another ways which is not the Bundler::Thor::Runner.
-    def banner
-      "#{basename} #{self_command.formatted_usage(self, false)}"
-    end
-
-    # Represents the whole class as a command.
-    def self_command #:nodoc:
-      Bundler::Thor::DynamicCommand.new(namespace, class_options)
-    end
-    alias_method :self_task, :self_command
-
-    def baseclass #:nodoc:
-      Bundler::Thor::Group
-    end
-
-    def create_command(meth) #:nodoc:
-      commands[meth.to_s] = Bundler::Thor::Command.new(meth, nil, nil, nil, nil)
-      true
-    end
-    alias_method :create_task, :create_command
-  end
-
-  include Bundler::Thor::Base
-
-protected
-
-  # Shortcut to invoke with padding and block handling. Use internally by
-  # invoke and invoke_from_option class methods.
-  def _invoke_for_class_method(klass, command = nil, *args, &block) #:nodoc:
-    with_padding do
-      if block
-        case block.arity
-        when 3
-          yield(self, klass, command)
-        when 2
-          yield(self, klass)
-        when 1
-          instance_exec(klass, &block)
-        end
-      else
-        invoke klass, command, *args
-      end
-    end
-  end
-end