ory-keto-client 0.10.0.alpha0 → 25.4.0

data/vendor/bundle/ruby/2.5.0/gems/pry-0.13.1/lib/pry/commands/edit.rb

@@ -1,223 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class Edit < Pry::ClassCommand
-      match 'edit'
-      group 'Editing'
-      description 'Invoke the default editor on a file.'
-
-      banner <<-'BANNER'
-        Usage: edit [--no-reload|--reload|--patch] [--line LINE] [--temp|--ex|FILE[:LINE]|OBJECT|--in N]
-
-        Open a text editor. When no FILE is given, edits the pry input buffer.
-        When a method/module/command is given, the code is opened in an editor.
-        Ensure `Pry.config.editor` or `pry_instance.config.editor` is set to your editor of choice.
-
-        edit sample.rb                edit -p MyClass#my_method
-        edit sample.rb --line 105     edit MyClass
-        edit MyClass#my_method        edit --ex
-        edit --method                 edit --ex -p
-
-        https://github.com/pry/pry/wiki/Editor-integration#wiki-Edit_command
-      BANNER
-
-      def options(opt)
-        opt.on :e, :ex, "Open the file that raised the most recent exception " \
-                        "(_ex_.file)",
-               optional_argument: true, as: Integer
-        opt.on :i, :in, "Open a temporary file containing the Nth input " \
-                        "expression. N may be a range",
-               optional_argument: true, as: Range, default: -1..-1
-        opt.on :t, :temp, "Open an empty temporary file"
-        opt.on :l, :line, "Jump to this line in the opened file",
-               argument: true, as: Integer
-        opt.on :n, :"no-reload", "Don't automatically reload the edited file"
-        opt.on :c, :current, "Open the current __FILE__ and at __LINE__ (as " \
-                             "returned by `whereami`)"
-        opt.on :r, :reload, "Reload the edited code immediately (default for " \
-                            "ruby files)"
-        opt.on :p, :patch, "Instead of editing the object's file, try to edit " \
-                           "in a tempfile and apply as a monkey patch"
-        opt.on :m, :method, "Explicitly edit the _current_ method (when " \
-                            "inside a method context)."
-      end
-
-      def process
-        if bad_option_combination?
-          raise CommandError, "Only one of --ex, --temp, --in, --method and " \
-                              "FILE may be specified."
-        end
-
-        if repl_edit?
-          # code defined in pry, eval'd within pry.
-          repl_edit
-        elsif runtime_patch?
-          # patch code without persisting changes, implies future changes are patches
-          apply_runtime_patch
-        else
-          # code stored in actual files, eval'd at top-level
-          file_edit
-        end
-      end
-
-      def repl_edit?
-        !opts.present?(:ex) && !opts.present?(:current) && !opts.present?(:method) &&
-          filename_argument.empty?
-      end
-
-      def repl_edit
-        content = Pry::Editor.new(pry_instance).edit_tempfile_with_content(
-          initial_temp_file_content,
-          initial_temp_file_content.lines.count
-        )
-        pry_instance.eval_string = content
-        Pry.history.push(content)
-      end
-
-      def file_based_exception?
-        opts.present?(:ex) && !opts.present?(:patch)
-      end
-
-      def runtime_patch?
-        !file_based_exception? &&
-          (opts.present?(:patch) ||
-           previously_patched?(code_object) ||
-           pry_method?(code_object))
-      end
-
-      def apply_runtime_patch
-        if patch_exception?
-          ExceptionPatcher.new(
-            pry_instance, state, file_and_line_for_current_exception
-          ).perform_patch
-        elsif code_object.is_a?(Pry::Method)
-          code_object.redefine(
-            Pry::Editor.new(pry_instance).edit_tempfile_with_content(
-              code_object.source
-            )
-          )
-        else
-          raise NotImplementedError, "Cannot yet patch #{code_object} objects!"
-        end
-      end
-
-      def ensure_file_name_is_valid(file_name)
-        unless file_name
-          raise CommandError, "Cannot find a valid file for #{filename_argument}"
-        end
-
-        return unless not_a_real_file?(file_name)
-
-        raise CommandError, "#{file_name} is not a valid file name, cannot edit!"
-      end
-
-      def file_and_line_for_current_exception
-        FileAndLineLocator.from_exception(pry_instance.last_exception, opts[:ex].to_i)
-      end
-
-      def file_and_line
-        file_name, line =
-          if opts.present?(:current)
-            FileAndLineLocator.from_binding(target)
-          elsif opts.present?(:ex)
-            file_and_line_for_current_exception
-          elsif code_object
-            FileAndLineLocator.from_code_object(code_object, filename_argument)
-          else
-            # when file and line are passed as a single arg, e.g my_file.rb:30
-            FileAndLineLocator.from_filename_argument(filename_argument)
-          end
-
-        [file_name, opts.present?(:line) ? opts[:l].to_i : line]
-      end
-
-      def file_edit
-        file_name, line = file_and_line
-
-        ensure_file_name_is_valid(file_name)
-
-        Pry::Editor.new(pry_instance).invoke_editor(file_name, line, reload?(file_name))
-        set_file_and_dir_locals(file_name)
-
-        return unless reload?(file_name)
-
-        silence_warnings { load(file_name) }
-      end
-
-      def filename_argument
-        args.join(' ')
-      end
-
-      def code_object
-        @code_object ||=
-          !probably_a_file?(filename_argument) &&
-          Pry::CodeObject.lookup(filename_argument, pry_instance)
-      end
-
-      def pry_method?(code_object)
-        code_object.is_a?(Pry::Method) &&
-          code_object.pry_method?
-      end
-
-      def previously_patched?(code_object)
-        code_object.is_a?(Pry::Method) &&
-          Pry::Method::Patcher.code_for(code_object.source_location.first)
-      end
-
-      def patch_exception?
-        opts.present?(:ex) && opts.present?(:patch)
-      end
-
-      def bad_option_combination?
-        [
-          opts.present?(:ex), opts.present?(:temp),
-          opts.present?(:in), opts.present?(:method),
-          !filename_argument.empty?
-        ].count(true) > 1
-      end
-
-      def input_expression
-        case opts[:i]
-        when Range
-          (pry_instance.input_ring[opts[:i]] || []).join
-        when Integer
-          pry_instance.input_ring[opts[:i]] || ""
-        else
-          raise Pry::CommandError, "Not a valid range: #{opts[:i]}"
-        end
-      end
-
-      def reloadable?
-        opts.present?(:reload) || opts.present?(:ex)
-      end
-
-      def never_reload?
-        opts.present?(:'no-reload') || pry_instance.config.disable_auto_reload
-      end
-
-      def reload?(file_name = "")
-        (reloadable? || file_name.end_with?(".rb")) && !never_reload?
-      end
-
-      def initial_temp_file_content
-        if opts.present?(:temp)
-          ""
-        elsif opts.present?(:in)
-          input_expression
-        elsif eval_string.strip != ""
-          eval_string
-        else
-          pry_instance.input_ring.to_a.reverse_each.find { |x| x && x.strip != "" } || ""
-        end
-      end
-
-      def probably_a_file?(str)
-        [".rb", ".c", ".py", ".yml", ".gemspec"].include?(File.extname(str)) ||
-          str =~ %r{/|\\}
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::Edit)
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.13.1/lib/pry/commands/find_method.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class FindMethod < Pry::ClassCommand
-      extend Pry::Helpers::BaseHelpers
-
-      match 'find-method'
-      group 'Context'
-      description 'Recursively search for a method within a Class/Module or ' \
-                  'the current namespace.'
-      command_options shellwords: false
-
-      banner <<-'BANNER'
-        Usage: find-method  [-n|-c] METHOD [NAMESPACE]
-
-        Recursively search for a method within a Class/Module or the current namespace.
-        Use the `-n` switch (the default) to search for methods whose name matches the
-        given regex. Use the `-c` switch to search for methods that contain the given
-        code.
-
-        # Find all methods whose name match /re/ inside
-        # the Pry namespace. Matches Pry#repl, etc.
-        find-method re Pry
-
-        # Find all methods that contain the code:
-        # output.puts inside the Pry namespace.
-        find-method -c 'output.puts' Pry
-      BANNER
-
-      def options(opt)
-        opt.on :n, :name,    "Search for a method by name"
-        opt.on :c, :content, "Search for a method based on content in Regex form"
-      end
-
-      def process
-        return if args.empty?
-
-        klass = search_class
-
-        matches = opts.content? ? content_search(klass) : name_search(klass)
-        show_search_results(matches)
-      end
-
-      private
-
-      # @return [Regexp] The pattern to search for.
-      def pattern
-        @pattern ||= ::Regexp.new args[0]
-      end
-
-      # Output the result of the search.
-      #
-      # @param [Array] matches
-      def show_search_results(matches)
-        if matches.empty?
-          output.puts bold("No Methods Matched")
-        else
-          print_matches(matches)
-        end
-      end
-
-      # The class to search for methods.
-      # We only search classes, so if the search object is an
-      # instance, return its class. If no search object is given
-      # search `target_self`.
-      def search_class
-        klass = if args[1]
-                  target.eval(args[1])
-                else
-                  target_self
-                end
-
-        klass.is_a?(Module) ? klass : klass.class
-      end
-
-      # pretty-print a list of matching methods.
-      #
-      # @param [Array<Method>] matches
-      def print_matches(matches)
-        grouped = matches.group_by(&:owner)
-        order = grouped.keys.sort_by { |x| x.name || x.to_s }
-
-        order.each do |klass|
-          print_matches_for_class(klass, grouped)
-        end
-      end
-
-      # Print matched methods for a class
-      def print_matches_for_class(klass, grouped)
-        output.puts bold(klass.name)
-        grouped[klass].each do |method|
-          header = method.name_with_owner
-          output.puts header + additional_info(header, method)
-        end
-      end
-
-      # Return the matched lines of method source if `-c` is given or ""
-      # if `-c` was not given
-      def additional_info(header, method)
-        if opts.content?
-          ': ' + colorize_code(matched_method_lines(header, method))
-        else
-          ""
-        end
-      end
-
-      def matched_method_lines(header, method)
-        method.source.split(/\n/).select { |x| x =~ pattern }.join(
-          "\n#{' ' * header.length}"
-        )
-      end
-
-      # Run the given block against every constant in the provided namespace.
-      #
-      # @param [Module] klass The namespace in which to start the search.
-      # @param [Hash<Module,Boolean>] done The namespaces we've already visited (private)
-      # @yieldparam klass Each class/module in the namespace.
-      #
-      def recurse_namespace(klass, done = {}, &block)
-        return if !klass.is_a?(Module) || done[klass]
-
-        done[klass] = true
-
-        yield klass
-
-        klass.constants.each do |name|
-          next if klass.autoload?(name)
-
-          begin
-            const = klass.const_get(name)
-          rescue RescuableException # rubocop:disable Lint/HandleExceptions
-            # constant loading is an inexact science at the best of times,
-            # this often happens when a constant was .autoload? but someone
-            # tried to load it. It's now not .autoload? but will still raise
-            # a NameError when you access it.
-          else
-            recurse_namespace(const, done, &block)
-          end
-        end
-      end
-
-      # Gather all the methods in a namespace that pass the given block.
-      #
-      # @param [Module] namespace The namespace in which to search.
-      # @yieldparam [Method] method The method to test
-      # @yieldreturn [Boolean]
-      # @return [Array<Method>]
-      #
-      def search_all_methods(namespace)
-        done = Hash.new { |h, k| h[k] = {} }
-        matches = []
-
-        recurse_namespace(namespace) do |klass|
-          methods = Pry::Method.all_from_class(klass) + Pry::Method.all_from_obj(klass)
-          methods.each do |method|
-            next if done[method.owner][method.name]
-
-            done[method.owner][method.name] = true
-
-            matches << method if yield method
-          end
-        end
-
-        matches
-      end
-
-      # Search for all methods with a name that matches the given regex
-      # within a namespace.
-      #
-      # @param [Module] namespace The namespace to search
-      # @return [Array<Method>]
-      #
-      def name_search(namespace)
-        search_all_methods(namespace) do |meth|
-          meth.name =~ pattern
-        end
-      end
-
-      # Search for all methods who's implementation matches the given regex
-      # within a namespace.
-      #
-      # @param [Module] namespace The namespace to search
-      # @return [Array<Method>]
-      #
-      def content_search(namespace)
-        search_all_methods(namespace) do |meth|
-          begin
-            meth.source =~ pattern
-          rescue RescuableException
-            false
-          end
-        end
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::FindMethod)
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.13.1/lib/pry/commands/ls/constants.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class Ls < Pry::ClassCommand
-      class Constants < Pry::Command::Ls::Formatter
-        DEPRECATED_CONSTANTS = [
-          :Data, :Fixnum, :Bignum, :TimeoutError, :NIL, :FALSE, :TRUE
-        ].tap do |constants|
-          constants << :JavaPackageModuleTemplate if Helpers::Platform.jruby?
-        end
-        include Pry::Command::Ls::Interrogatable
-
-        def initialize(interrogatee, no_user_opts, opts, pry_instance)
-          super(pry_instance)
-          @interrogatee = interrogatee
-          @no_user_opts = no_user_opts
-          @default_switch = opts[:constants]
-          @verbose_switch = opts[:verbose]
-          @dconstants = opts.dconstants?
-        end
-
-        def correct_opts?
-          super || (@no_user_opts && interrogating_a_module?)
-        end
-
-        def output_self
-          mod = interrogatee_mod
-          constants = WrappedModule.new(mod).constants(@verbose_switch)
-          output_section('constants', grep.regexp[format(mod, constants)])
-        end
-
-        private
-
-        def show_deprecated_constants?
-          @dconstants == true
-        end
-
-        def format(mod, constants)
-          constants.sort_by(&:downcase).map do |name|
-            if Object.respond_to?(:deprecate_constant) &&
-               DEPRECATED_CONSTANTS.include?(name) &&
-               !show_deprecated_constants?
-              next
-            end
-
-            if (const = (begin
-                           !mod.autoload?(name) && (mod.const_get(name) || true)
-                         rescue StandardError
-                           nil
-                         end))
-              if begin
-                   const < Exception
-                 rescue StandardError
-                   false
-                 end
-                color(:exception_constant, name)
-              elsif begin
-                      mod.const_get(name).is_a?(Module)
-                    rescue StandardError
-                      false
-                    end
-                color(:class_constant, name)
-              else
-                color(:constant, name)
-              end
-            else
-              color(:unloaded_constant, name)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.13.1/lib/pry/commands/ls.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Command
-    class Ls < Pry::ClassCommand
-      DEFAULT_OPTIONS = {
-        heading_color: :bright_blue,
-        public_method_color: :default,
-        private_method_color: :blue,
-        protected_method_color: :blue,
-        method_missing_color: :bright_red,
-        local_var_color: :yellow,
-        pry_var_color: :default, # e.g. _, pry_instance, _file_
-        instance_var_color: :blue, # e.g. @foo
-        class_var_color: :bright_blue, # e.g. @@foo
-        global_var_color: :default, # e.g. $CODERAY_DEBUG, $eventmachine_library
-        builtin_global_color: :cyan, # e.g. $stdin, $-w, $PID
-        pseudo_global_color: :cyan, # e.g. $~, $1..$9, $LAST_MATCH_INFO
-        constant_color: :default, # e.g. VERSION, ARGF
-        class_constant_color: :blue, # e.g. Object, Kernel
-        exception_constant_color: :magenta, # e.g. Exception, RuntimeError
-        unloaded_constant_color: :yellow, # Any constant that is still in .autoload? state
-        separator: "  ",
-        ceiling: [Object, Module, Class]
-      }.freeze
-
-      match 'ls'
-      group 'Context'
-      description 'Show the list of vars and methods in the current scope.'
-      command_options shellwords: false, interpolate: false
-
-      banner <<-'BANNER'
-        Usage: ls [-m|-M|-p|-pM] [-q|-v] [-c|-i] [Object]
-               ls [-g] [-l]
-
-        ls shows you which methods, constants and variables are accessible to Pry. By
-        default it shows you the local variables defined in the current shell, and any
-        public methods or instance variables defined on the current object.
-
-        The colours used are configurable using Pry.config.ls.*_color, and the separator
-        is Pry.config.ls.separator.
-
-        Pry.config.ls.ceiling is used to hide methods defined higher up in the
-        inheritance chain, this is by default set to [Object, Module, Class] so that
-        methods defined on all Objects are omitted. The -v flag can be used to ignore
-        this setting and show all methods, while the -q can be used to set the ceiling
-        much lower and show only methods defined on the object or its direct class.
-
-        Also check out `find-method` command (run `help find-method`).
-      BANNER
-
-      def options(opt)
-        opt.on :m, :methods, "Show public methods defined on the Object"
-        opt.on :M, "instance-methods", "Show public methods defined in a " \
-                                       "Module or Class"
-        opt.on :p, :ppp, "Show public, protected (in yellow) and private " \
-                         "(in green) methods"
-        opt.on :q, :quiet, "Show only methods defined on object.singleton_class " \
-                           "and object.class"
-        opt.on :v, :verbose, "Show methods and constants on all super-classes " \
-                             "(ignores Pry.config.ls.ceiling)"
-        opt.on :g, :globals, "Show global variables, including those builtin to " \
-                             "Ruby (in cyan)"
-        opt.on :l, :locals, "Show hash of local vars, sorted by descending size"
-        opt.on :c, :constants, "Show constants, highlighting classes (in blue), " \
-                               "and exceptions (in purple).\n" \
-                               "#{' ' * 32}Constants that are pending autoload? " \
-                               "are also shown (in yellow)"
-        opt.on :i, :ivars, "Show instance variables (in blue) and class " \
-                           "variables (in bright blue)"
-        opt.on :G, :grep, "Filter output by regular expression", argument: true
-
-        if Object.respond_to?(:deprecate_constant)
-          opt.on :d, :dconstants, "Show deprecated constants"
-        end
-
-        return unless Helpers::Platform.jruby?
-
-        opt.on :J, "all-java", "Show all the aliases for methods from java " \
-                               "(default is to show only prettiest)"
-      end
-
-      # Exclude -q, -v and --grep because they,
-      # don't specify what the user wants to see.
-      def no_user_opts?
-        !(opts[:methods] || opts['instance-methods'] || opts[:ppp] ||
-          opts[:globals] || opts[:locals] || opts[:constants] || opts[:ivars])
-      end
-
-      def process
-        @interrogatee = args.empty? ? target_self : target.eval(args.join(' '))
-        raise_errors_if_arguments_are_weird
-        ls_entity = LsEntity.new(
-          interrogatee: @interrogatee,
-          no_user_opts: no_user_opts?,
-          opts: opts,
-          args: args,
-          pry_instance: pry_instance
-        )
-
-        pry_instance.pager.page ls_entity.entities_table
-      end
-
-      private
-
-      def error_list
-        any_args = args.any?
-        # rubocop:disable Style/CaseEquality
-        non_mod_interrogatee = !(Module === @interrogatee)
-        # rubocop:enable Style/CaseEquality
-        [
-          ['-l does not make sense with a specified Object', :locals, any_args],
-          ['-g does not make sense with a specified Object', :globals, any_args],
-          ['-q does not make sense with -v', :quiet, opts.present?(:verbose)],
-          [
-            '-M only makes sense with a Module or a Class', 'instance-methods',
-            non_mod_interrogatee
-          ],
-          [
-            '-c only makes sense with a Module or a Class', :constants,
-            any_args && non_mod_interrogatee
-          ]
-        ]
-      end
-
-      def raise_errors_if_arguments_are_weird
-        error_list.each do |message, option, invalid_expr|
-          raise Pry::CommandError, message if opts.present?(option) && invalid_expr
-        end
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::Ls)
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.13.1/lib/pry/commands/raise_up.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  # N.B. using a regular expresion here so that "raise-up 'foo'" does the right thing.
-  class Command
-    class RaiseUp < Pry::ClassCommand
-      match(/raise-up(!?\b.*)/)
-      group 'Context'
-      description 'Raise an exception out of the current pry instance.'
-      command_options listing: 'raise-up'
-
-      banner <<-BANNER
-        Raise up, like exit, allows you to quit pry. Instead of returning a value
-        however, it raises an exception. If you don't provide the exception to be
-        raised, it will use the most recent exception (in pry `_ex_`).
-
-        When called as raise-up! (with an exclamation mark), this command raises the
-        exception through any nested prys you have created by "cd"ing into objects.
-
-        raise-up "get-me-out-of-here"
-
-        # This is equivalent to the command above.
-        raise "get-me-out-of-here"
-        raise-up
-      BANNER
-
-      def process
-        return _pry.pager.page help if captures[0] =~ /(-h|--help)\b/
-
-        # Handle 'raise-up', 'raise-up "foo"', 'raise-up RuntimeError, 'farble'
-        # in a rubyesque manner
-        target.eval("pry_instance.raise_up#{captures[0]}")
-      end
-    end
-
-    Pry::Commands.add_command(Pry::Command::RaiseUp)
-  end
-end