SkullCyberArmy Bypass Shell - chauffeursltd.com

Uname : Linux premium36.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Soft : LiteSpeed
Ip : 198.54.115.237
Port : 443

command.rb

class Bundler::Thor
  class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
    FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/

def initialize(name, description, long_description, usage, options = nil)
      super(name.to_s, description, long_description, usage, options || {})
    end

def initialize_copy(other) #:nodoc:
      super(other)
      self.options = other.options.dup if other.options
    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

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, 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

Name	Type	Size	Permission	Last Modified	Actions
.	dir	-	0755	2024-03-05 11:46:19
..	dir	-	0755	2024-03-05 11:46:19
actions	dir	-	0755	2024-03-05 11:46:19
core_ext	dir	-	0755	2024-03-05 11:46:19
line_editor	dir	-	0755	2024-03-05 11:46:19
parser	dir	-	0755	2024-03-05 11:46:19
shell	dir	-	0755	2024-03-05 11:46:09
actions.rb	text/x-ruby	10.43 KB	0644	2023-03-30 12:34:08
base.rb	text/x-ruby	23.89 KB	0644	2023-03-30 12:34:08
command.rb	text/x-ruby	4.63 KB	0644	2023-03-30 12:34:08
error.rb	text/x-ruby	3.19 KB	0644	2023-03-30 12:34:08
group.rb	text/x-ruby	8.85 KB	0644	2023-03-30 12:34:08
invocation.rb	text/x-ruby	6.07 KB	0644	2023-03-30 12:34:08
line_editor.rb	text/x-ruby	391 B	0644	2023-03-30 12:34:08
nested_context.rb	text/x-ruby	299 B	0644	2023-03-30 12:34:08
parser.rb	text/plain	138 B	0644	2023-03-30 12:34:08
rake_compat.rb	text/x-ruby	2.12 KB	0644	2023-03-30 12:34:08
runner.rb	text/x-ruby	9.85 KB	0644	2023-03-30 12:34:08
shell.rb	text/x-ruby	2.29 KB	0644	2023-03-30 12:34:08
util.rb	text/x-ruby	8.83 KB	0644	2023-03-30 12:34:08
version.rb	text/x-ruby	44 B	0644	2023-03-30 12:34:08