ory-kratos-client 1.3.8 → 25.4.0

data/vendor/bundle/ruby/3.1.0/gems/pry-0.15.2/lib/pry/commands/shell_command.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class ShellCommand < Pry::ClassCommand
+      match(/\.(.*)/)
+      group 'Input and Output'
+      description "All text following a '.' is forwarded to the shell."
+      command_options listing: '.<shell command>', use_prefix: false,
+                      takes_block: true, state: %i[old_pwd]
+
+      banner <<-'BANNER'
+        Usage: .COMMAND_NAME
+
+        All text following a "." is forwarded to the shell.
+
+        .ls -aF
+        .uname
+      BANNER
+
+      def process(cmd)
+        if cmd =~ /^cd\s*(.*)/i
+          process_cd parse_destination(Regexp.last_match(1))
+        else
+          pass_block(cmd)
+          if command_block
+            command_block.call `#{cmd}`
+          else
+            pry_instance.config.system.call(output, cmd, pry_instance)
+          end
+        end
+      end
+
+      private
+
+      def parse_destination(dest)
+        return "~" if dest.empty?
+        return dest unless dest == "-"
+
+        state.old_pwd || raise(CommandError, "No prior directory available")
+      end
+
+      def process_cd(dest)
+        state.old_pwd = Dir.pwd
+        Dir.chdir(File.expand_path(path_from_cd_path(dest) || dest))
+      rescue Errno::ENOENT
+        raise CommandError, "No such directory: #{dest}"
+      end
+
+      def cd_path_env
+        Pry::Env['CDPATH']
+      end
+
+      def cd_path_exists?
+        cd_path_env && cd_path_env.length.nonzero?
+      end
+
+      def path_from_cd_path(dest)
+        return if !(dest && cd_path_exists?) || special_case_path?(dest)
+
+        cd_path_env.split(File::PATH_SEPARATOR).each do |path|
+          return path if File.directory?(path) && path.split(File::SEPARATOR).last == dest
+        end
+
+        nil
+      end
+
+      def special_case_path?(dest)
+        ['.', '..', '-'].include?(dest) || dest =~ /\A[#{File::PATH_SEPARATOR}~]/
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::ShellCommand)
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/pry-0.15.2/lib/pry/commands/shell_mode.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class ShellMode < Pry::ClassCommand
+      match 'shell-mode'
+      group 'Input and Output'
+      description 'Toggle shell mode. Bring in pwd prompt and file completion.'
+      command_options state: %i[disabled prev_prompt]
+
+      banner <<-'BANNER'
+        Toggle shell mode. Bring in pwd prompt and file completion.
+      BANNER
+
+      def process
+        state.disabled ^= true
+
+        if state.disabled
+          state.prev_prompt = pry_instance.prompt
+          pry_instance.prompt = Pry::Prompt[:shell]
+        else
+          pry_instance.prompt = state.prev_prompt
+        end
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::ShellMode)
+    Pry::Commands.alias_command 'file-mode', 'shell-mode'
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/pry-0.15.2/lib/pry/commands/watch_expression/expression.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class WatchExpression
+      class Expression
+        attr_reader :target, :source, :value, :previous_value, :pry_instance
+
+        def initialize(pry_instance, target, source)
+          @pry_instance = pry_instance
+          @target = target
+          @source = Code.new(source).strip
+        end
+
+        def eval!
+          @previous_value = value
+          @value = Pry::ColorPrinter.pp(target_eval(target, source), ''.dup)
+        end
+
+        def to_s
+          "#{Code.new(source).highlighted.strip} => #{value}"
+        end
+
+        # Has the value of the expression changed?
+        #
+        # We use the pretty-printed string representation to detect differences
+        # as this avoids problems with dup (causes too many differences) and ==
+        # (causes too few)
+        def changed?
+          (value != previous_value)
+        end
+
+        private
+
+        def target_eval(target, source)
+          target.eval(source)
+        rescue StandardError => e
+          e
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/pry-0.15.2/lib/pry/commands/watch_expression.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class WatchExpression < Pry::ClassCommand
+      match 'watch'
+      group 'Context'
+      description 'Watch the value of an expression and print a notification ' \
+                  'whenever it changes.'
+      command_options use_prefix: false, state: %i[watch_expressions]
+
+      banner <<-'BANNER'
+        Usage: watch [EXPRESSION]
+               watch
+               watch --delete [INDEX]
+
+        watch [EXPRESSION] adds an expression to the list of those being watched.
+        It will be re-evaluated every time you hit enter in pry. If its value has
+        changed, the new value will be printed to the console.
+
+        This is useful if you are step-through debugging and want to see how
+        something changes over time.  It's also useful if you're trying to write
+        a method inside pry and want to check that it gives the right answers
+        every time you redefine it.
+
+        watch on its own displays all the currently watched expressions and their
+        values, and watch --delete [INDEX] allows you to delete expressions from
+        the list being watched.
+      BANNER
+
+      def options(opt)
+        opt.on :d, :delete,
+               "Delete the watch expression with the given index. If no index " \
+               "is given; clear all watch expressions.",
+               optional_argument: true, as: Integer
+        opt.on :l, :list,
+               "Show all current watch expressions and their values. Calling " \
+               "watch with no expressions or options will also show the watch " \
+               "expressions."
+      end
+
+      def process
+        if opts.present?(:delete)
+          delete opts[:delete]
+        elsif opts.present?(:list) || args.empty?
+          list
+        else
+          add_hook
+          add_expression
+        end
+      end
+
+      private
+
+      def expressions
+        state.watch_expressions ||= []
+      end
+
+      def delete(index)
+        if index
+          output.puts "Deleting watch expression ##{index}: #{expressions[index - 1]}"
+          expressions.delete_at(index - 1)
+        else
+          output.puts "Deleting all watched expressions"
+          expressions.clear
+        end
+      end
+
+      def list
+        if expressions.empty?
+          output.puts "No watched expressions"
+        else
+          pry_instance.pager.open do |pager|
+            pager.puts "Listing all watched expressions:"
+            pager.puts ""
+            expressions.each_with_index do |expr, index|
+              pager.print with_line_numbers(expr.to_s, index + 1)
+            end
+            pager.puts ""
+          end
+        end
+      end
+
+      def eval_and_print_changed(output)
+        expressions.each do |expr|
+          expr.eval!
+          output.puts "#{blue 'watch'}: #{expr}" if expr.changed?
+        end
+      end
+
+      def add_expression
+        expressions << Expression.new(pry_instance, target, arg_string)
+        output.puts "Watching #{Code.new(arg_string).highlighted}"
+      end
+
+      def add_hook
+        hook = %i[after_eval watch_expression]
+        return if pry_instance.hooks.hook_exists?(*hook)
+
+        pry_instance.hooks.add_hook(*hook) do |_, pry_instance|
+          eval_and_print_changed pry_instance.output
+        end
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::WatchExpression)
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/pry-0.15.2/lib/pry/config.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+class Pry
+  # @api private
+  class Config
+    extend Attributable
+
+    # @return [IO, #readline] the object from which Pry retrieves its lines of
+    #   input
+    attribute :input
+
+    # @return [IO, #puts] where Pry should output results provided by {input}
+    attribute :output
+
+    # @return [Pry::CommandSet]
+    attribute :commands
+
+    # @return [Proc] the printer for Ruby expressions (not commands)
+    attribute :print
+
+    # @return [Proc] the printer for exceptions
+    attribute :exception_handler
+
+    # @return [Array] Exception that Pry shouldn't rescue
+    attribute :unrescued_exceptions
+
+    # @return [Integer] The number of lines of context to show before and after
+    #   exceptions
+    attribute :default_window_size
+
+    # @return [Pry::Hooks]
+    attribute :hooks
+
+    # @return [Pry::Prompt]
+    attribute :prompt
+
+    # @return [String] The display name that is part of the prompt
+    attribute :prompt_name
+
+    # @return [Array<Object>] the list of objects that are known to have a
+    #   1-line #inspect output suitable for prompt
+    attribute :prompt_safe_contexts
+
+    # If it is a String, then that String is used as the shell
+    # command to invoke the editor.
+    #
+    # If it responds to #call is callable then `file`, `line`, and `reloading`
+    # are passed to it. `reloading` indicates whether Pry will be reloading code
+    # after the shell command returns. All parameters are optional.
+    # @return [String, #call]
+    attribute :editor
+
+    # A string that must precede all commands. For example, if is is
+    # set to "%", the "cd" command must be invoked as "%cd").
+    # @return [String]
+    attribute :command_prefix
+
+    # @return [Boolean]
+    attribute :color
+
+    # @return [Boolean]
+    attribute :pager
+
+    # @return [Boolean]
+    attribute :multiline
+
+    # @return [Boolean] whether the global ~/.pryrc should be loaded
+    attribute :should_load_rc
+
+    # @return [Boolean] whether the local ./.pryrc should be loaded
+    attribute :should_load_local_rc
+
+    # @return [Boolean] whether to load files specified with the -r flag
+    attribute :should_load_requires
+
+    # @return [Boolean] whether to disable edit-method's auto-reloading behavior
+    attribute :disable_auto_reload
+
+    # Whether Pry should trap SIGINT and cause it to raise an Interrupt
+    # exception. This is only useful on JRuby, MRI does this for us.
+    # @return [Boolean]
+    attribute :should_trap_interrupts
+
+    # @return [Pry::History]
+    attribute :history
+
+    # @return [Boolean]
+    attribute :history_save
+
+    # @return [Boolean]
+    attribute :history_load
+
+    # @return [String]
+    attribute :history_file
+
+    # @return [Array<String,Regexp>]
+    attribute :history_ignorelist
+
+    # @return [Array<String>] Ruby files to be required
+    attribute :requires
+
+    # @return [Integer] how many input/output lines to keep in memory
+    attribute :memory_size
+
+    # @return [Proc] The proc that runs system commands
+    attribute :system
+
+    # @return [Boolean]
+    attribute :auto_indent
+
+    # @return [Boolean]
+    attribute :correct_indent
+
+    # @return [Boolean] whether or not display a warning when a command name
+    #   collides with a method/local in the current context.
+    attribute :collision_warning
+
+    # @return [Hash{Symbol=>Proc}]
+    attribute :extra_sticky_locals
+
+    # @return [#build_completion_proc] a completer to use
+    attribute :completer
+
+    # @return [Boolean] suppresses whereami output on `binding.pry`
+    attribute :quiet
+
+    # @return [Boolean] displays a warning about experience improvement on
+    #   Windows
+    attribute :windows_console_warning
+
+    # @return [Proc]
+    attribute :command_completions
+
+    # @return [Proc]
+    attribute :file_completions
+
+    # @return [Hash]
+    attribute :ls
+
+    # @return [String] a line of code to execute in context before the session
+    #   starts
+    attribute :exec_string
+
+    # @return [String]
+    attribute :output_prefix
+
+    # @return [String]
+    # @since v0.13.0
+    attribute :rc_file
+
+    def initialize
+      merge!(
+        input: MemoizedValue.new { choose_input },
+        output: $stdout.tap { |out| out.sync = true },
+        commands: Pry::Commands,
+        prompt_name: 'pry',
+        prompt: Pry::Prompt[:default],
+        prompt_safe_contexts: [String, Numeric, Symbol, nil, true, false],
+        print: Pry::ColorPrinter.method(:default),
+        quiet: false,
+        exception_handler: Pry::ExceptionHandler.method(:handle_exception),
+
+        unrescued_exceptions: [
+          ::SystemExit, ::SignalException, Pry::TooSafeException
+        ],
+
+        hooks: Pry::Hooks.default,
+        pager: true,
+        system: Pry::SystemCommandHandler.method(:default),
+        multiline: true,
+        color: Pry::Helpers::BaseHelpers.use_ansi_codes?,
+        default_window_size: 5,
+        editor: Pry::Editor.default,
+        rc_file: default_rc_file,
+        should_load_rc: true,
+        should_load_local_rc: true,
+        should_trap_interrupts: Pry::Helpers::Platform.jruby?,
+        disable_auto_reload: false,
+        command_prefix: '',
+        auto_indent: Pry::Helpers::BaseHelpers.use_ansi_codes?,
+        correct_indent: true,
+        collision_warning: false,
+        output_prefix: '=> ',
+        requires: [],
+        should_load_requires: true,
+        windows_console_warning: true,
+        control_d_handler: Pry::ControlDHandler.method(:default),
+        memory_size: 100,
+        extra_sticky_locals: {},
+        command_completions: proc { commands.keys },
+        file_completions: proc { Dir['.'] },
+        ls: Pry::Command::Ls::Config.default,
+        completer: Pry::InputCompleter,
+        history_save: true,
+        history_load: true,
+        history_file: Pry::History.default_file,
+        history_ignorelist: [],
+        history: MemoizedValue.new do
+          if defined?(input::HISTORY)
+            Pry::History.new(history: input::HISTORY)
+          else
+            Pry::History.new
+          end
+        end,
+        exec_string: ''
+      )
+
+      @custom_attrs = {}
+    end
+
+    def merge!(config_hash)
+      config_hash.each_pair { |attr, value| __send__("#{attr}=", value) }
+      self
+    end
+
+    def merge(config_hash)
+      dup.merge!(config_hash)
+    end
+
+    def []=(attr, value)
+      @custom_attrs[attr.to_s] = Config::Value.new(value)
+    end
+
+    def [](attr)
+      @custom_attrs[attr.to_s].call
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    def method_missing(method_name, *args, &_block)
+      name = method_name.to_s
+
+      if name.end_with?('=')
+        self[name[0..-2]] = args.first
+      elsif @custom_attrs.key?(name)
+        self[name]
+      end
+    end
+    # rubocop:enable Style/MethodMissingSuper
+
+    def respond_to_missing?(method_name, include_all = false)
+      @custom_attrs.key?(method_name.to_s.tr('=', '')) || super
+    end
+
+    def initialize_dup(other)
+      super
+      @custom_attrs = @custom_attrs.dup
+    end
+
+    attr_reader :control_d_handler
+    def control_d_handler=(value)
+      proxy_proc =
+        if value.arity == 2
+          Pry::Warning.warn(
+            "control_d_handler's arity of 2 parameters was deprecated " \
+            '(eval_string, pry_instance). Now it gets passed just 1 ' \
+            'parameter (pry_instance)'
+          )
+          proc do |*args|
+            if args.size == 2
+              value.call(args.first, args[1])
+            else
+              value.call(args.first.eval_string, args.first)
+            end
+          end
+        else
+          proc do |*args|
+            if args.size == 2
+              value.call(args[1])
+            else
+              value.call(args.first)
+            end
+          end
+        end
+      @control_d_handler = proxy_proc
+    end
+
+    private
+
+    def choose_input
+      input = load_readline
+
+      if Pry::Env['TERM'] == 'dumb' && (defined?(Reline) && input == Reline)
+        input = Pry::Input::SimpleStdio
+      end
+
+      input
+    end
+
+    def load_readline
+      require 'readline'
+      ::Readline
+    rescue LoadError
+      output.puts(
+        "Sorry, you can't use Pry without Readline or a compatible library. \n" \
+        "Possible solutions: \n" \
+        " * Rebuild Ruby with Readline support using `--with-readline` \n" \
+        " * Use the rb-readline gem, which is a pure-Ruby port of Readline \n" \
+        " * Use the pry-coolline gem, a pure-ruby alternative to Readline"
+      )
+      raise
+    end
+
+    def default_rc_file
+      [Pry::Env['PRYRC'],
+       # See XDG Base Directory Specification at
+       # https://specifications.freedesktop.org/basedir-spec/latest/
+       "#{Pry::Env['XDG_CONFIG_HOME']}/pry/pryrc",
+       File.expand_path('~/.pryrc'),
+       File.expand_path('~/.config/pry/pryrc')]
+        .compact
+        .find { |file| File.exist?(file) }
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/pry-0.15.2/lib/pry/control_d_handler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Pry
+  # @api private
+  # @since v0.13.0
+  module ControlDHandler
+    # Deal with the ^D key being pressed. Different behaviour in different
+    # cases:
+    #   1. In an expression behave like `!` command.
+    #   2. At top-level session behave like `exit` command.
+    #   3. In a nested session behave like `cd ..`.
+    def self.default(pry_instance)
+      if !pry_instance.eval_string.empty?
+        # Clear input buffer.
+        pry_instance.eval_string = ''
+      elsif pry_instance.binding_stack.one?
+        pry_instance.binding_stack.clear
+        throw(:breakout)
+      else
+        # Otherwise, saves current binding stack as old stack and pops last
+        # binding out of binding stack (the old stack still has that binding).
+        cd_state = Pry::CommandState.default.state_for(Pry::Command::Cd)
+        cd_state.old_stack = pry_instance.binding_stack.dup
+        pry_instance.binding_stack.pop
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/pry-0.15.2/lib/pry/exception_handler.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Pry
+  # @api private
+  # @since v0.13.0
+  module ExceptionHandler
+    class << self
+      # Will only show the first line of the backtrace.
+      def handle_exception(output, exception, _pry_instance)
+        if exception.is_a?(UserError) && exception.is_a?(SyntaxError)
+          output.puts "SyntaxError: #{exception.message.sub(/.*syntax error, */m, '')}"
+        else
+          output.puts standard_error_text_for(exception)
+        end
+      end
+
+      private
+
+      def standard_error_text_for(exception)
+        text = exception_text(exception)
+        return text unless exception.respond_to?(:cause)
+
+        cause = exception.cause
+        while cause
+          text += cause_text(cause)
+          cause = cause.cause
+        end
+
+        text
+      end
+
+      def exception_text(exception)
+        if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.2')
+          "#{exception.class}: #{exception.message}\n" \
+          "from #{exception.backtrace.first}\n"
+        else
+          "#{exception.class}: #{exception.detailed_message}\n" \
+          "from #{exception.backtrace.first}\n"
+        end
+      end
+
+      def cause_text(cause)
+        "Caused by #{cause.class}: #{cause}\n" \
+        "from #{cause.backtrace.first}\n"
+      end
+    end
+  end
+end