RubyGems - siteimprove_api_client - Versions diffs - 1.0.1 → 1.0.2 - Mend

siteimprove_api_client 1.0.1 → 1.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2745) hide show

data/vendor/bundle/ruby/3.2.0/gems/pry-0.14.2/README.md DELETED Viewed

@@ -1,466 +0,0 @@
-Pry
-===
-[![Pry Build Status](https://github.com/pry/pry/workflows/pry/badge.svg)](https://github.com/pry/pry/actions)
-[![Code Climate](https://codeclimate.com/github/pry/pry.svg)](https://codeclimate.com/github/pry/pry)
-[![Gem Version](https://badge.fury.io/rb/pry.svg)](https://badge.fury.io/rb/pry)
-[![Documentation Status](https://inch-ci.org/github/pry/pry.svg?branch=master)](https://inch-ci.org/github/pry/pry)
-[![Downloads](https://img.shields.io/gem/dt/pry.svg?style=flat)](https://rubygems.org/gems/pry)
-![Pry logo](https://www.dropbox.com/s/zp8o63kquby2rln/pry_logo_350.png?raw=1)
-© John Mair ([banisterfiend](https://twitter.com/banisterfiend)) 2018<br> (Creator)
-© Kyrylo Silin ([kyrylosilin](https://twitter.com/kyrylosilin)) 2018<br> (Maintainer)
-**Alumni:**
-* Conrad Irwin
-* Ryan Fitzgerald
-* Robert Gleeson
-**Links:**
-* https://pry.github.io/
-* [YARD API documentation](https://www.rubydoc.info/gems/pry)
-* [Wiki](https://github.com/pry/pry/wiki)
-Table of Contents
-=================
-* [Introduction](#introduction)
-* [Key features](#key-features)
-* [Installation](#installation)
-* [Overview](#overview)
-   * [Commands](#commands)
-   * [Navigating around state](#navigating-around-state)
-   * [Runtime invocation](#runtime-invocation)
-   * [Command Shell Integration](#command-shell-integration)
-   * [Code Browsing](#code-browsing)
-   * [Documentation Browsing](#documentation-browsing)
-   * [Edit methods](#edit-methods)
-   * [Live Help System](#live-help-system)
-   * [Use Pry as your Rails Console](#use-pry-as-your-rails-console)
-   * [Syntax Highlighting](#syntax-highlighting)
-* [Supported Rubies](#supported-rubies)
-* [Contact](#contact)
-* [License](#license)
-* [Contributors](#contributors)
-Introduction
-------------
-Pry is a runtime developer console and IRB alternative with powerful
-introspection capabilities. Pry aims to be more than an IRB replacement. It is
-an attempt to bring REPL driven programming to the Ruby language.
-Key features
-------------
-* Source code browsing (including core C source with the pry-doc gem)
-* Documentation browsing
-* Live help system
-* Open methods in editors (`edit Class#method`)
-* Syntax highlighting
-* Command shell integration (start editors, run git, and rake from within Pry)
-* Gist integration
-* Navigation around state (`cd`, `ls` and friends)
-* Runtime invocation (use Pry as a developer console or debugger)
-* Exotic object support (BasicObject instances, IClasses, ...)
-* A powerful and flexible command system
-* Ability to view and replay history
-* Many convenience commands inspired by IPython, Smalltalk and other advanced
-  REPLs
-* A wide-range number of
-  [plugins](https://github.com/pry/pry/wiki/Available-plugins) that provide
-  remote sessions, full debugging functionality, and more.
-Installation
-------------
-### Bundler
-```ruby
-gem 'pry', '~> 0.13.1'
-```
-### Manual
-```sh
-gem install pry
-```
-Overview
---------
-Pry is fairly flexible and allows significant user
-[customization](https://github.com/pry/pry/wiki/Customization-and-configuration).
-It is trivial to read from any object that has a `readline` method and
-write to any object that has a `puts` method. Many other aspects of Pry are
-also configurable, making it a good choice for implementing custom shells.
-Pry comes with an executable so it can be invoked at the command line. Just
-enter `pry` to start. A `pryrc` file in `$XDG_CONFIG_HOME/pry/` or the user's
-home directory will be loaded if it exists. Type `pry --help` at the command
-line for more information.
-### Commands
-Nearly every piece of functionality in a Pry session is implemented as a
-command. Commands are not methods and must start at the beginning of a line,
-with no whitespace in between. Commands support a flexible syntax and allow
-'options' in the same way as shell commands, for example the following Pry
-command will show a list of all private instance methods (in scope) that begin
-with 'pa'
-```ruby
-pry(YARD::Parser::SourceParser):5> ls -Mp --grep ^pa
-YARD::Parser::SourceParser#methods: parse  parser_class  parser_type  parser_type=  parser_type_for_filename
-```
-### Navigating around state
-Pry allows us to pop in and out of different scopes (objects) using the `cd`
-command. This enables us to explore the run-time view of a program or
-library. To view which variables and methods are available within a particular
-scope we use the versatile [ls
-command.](https://gist.github.com/c0fc686ef923c8b87715)
-Here we will begin Pry at top-level, then Pry on a class and then on an instance
-variable inside that class:
-```ruby
-pry(main)> class Hello
-pry(main)*   @x = 20
-pry(main)* end
-=> 20
-pry(main)> cd Hello
-pry(Hello):1> ls -i
-instance variables: @x
-pry(Hello):1> cd @x
-pry(20):2> self + 10
-=> 30
-pry(20):2> cd ..
-pry(Hello):1> cd ..
-pry(main)> cd ..
-```
-The number after the `:` in the pry prompt indicates the nesting level. To
-display more information about nesting, use the `nesting` command. E.g
-```ruby
-pry("friend"):3> nesting
-Nesting status:
-0. main (Pry top level)
-1. Hello
-2. 100
-3. "friend"
-=> nil
-```
-We can then jump back to any of the previous nesting levels by using the
-`jump-to` command:
-```ruby
-pry("friend"):3> jump-to 1
-=> 100
-pry(Hello):1>
-```
-### Runtime invocation
-Pry can be invoked in the middle of a running program. It opens a Pry session at
-the point it's called and makes all program state at that point available. It
-can be invoked on any object using the `my_object.pry` syntax or on the current
-binding (or any binding) using `binding.pry`. The Pry session will then begin
-within the scope of the object (or binding). When the session ends the program
-continues with any modifications you made to it.
-This functionality can be used for such things as: debugging, implementing
-developer consoles and applying hot patches.
-code:
-```ruby
-# test.rb
-require 'pry'
-class A
-  def hello() puts "hello world!" end
-end
-a = A.new
-# start a REPL session
-binding.pry
-# program resumes here (after pry session)
-puts "program resumes here."
-```
-Pry session:
-```ruby
-pry(main)> a.hello
-hello world!
-=> nil
-pry(main)> def a.goodbye
-pry(main)*   puts "goodbye cruel world!"
-pry(main)* end
-=> :goodbye
-pry(main)> a.goodbye
-goodbye cruel world!
-=> nil
-pry(main)> exit
-program resumes here.
-```
-### Command Shell Integration
-A line of input that begins with a '.' will be forwarded to the command
-shell. This enables us to navigate the file system, spawn editors, and run git
-and rake directly from within Pry.
-Further, we can use the `shell-mode` command to incorporate the present working
-directory into the Pry prompt and bring in (limited at this stage, sorry) file
-name completion.  We can also interpolate Ruby code directly into the shell by
-using the normal `#{}` string interpolation syntax.
-In the code below we're going to switch to `shell-mode` and edit the `pryrc`
-file. We'll then cat its contents and reload the file.
-```ruby
-pry(main)> shell-mode
-pry main:/home/john/ruby/projects/pry $ .cd ~
-pry main:/home/john $ .emacsclient .pryrc
-pry main:/home/john $ .cat .pryrc
-def hello_world
-  puts "hello world!"
-end
-pry main:/home/john $ load ".pryrc"
-=> true
-pry main:/home/john $ hello_world
-hello world!
-```
-We can also interpolate Ruby code into the shell. In the example below we use
-the shell command `cat` on a random file from the current directory and count
-the number of lines in that file with `wc`:
-```ruby
-pry main:/home/john $ .cat #{Dir['*.*'].sample} | wc -l
-44
-```
-### Code Browsing
-You can browse method source code with the `show-source` command. Nearly all
-Ruby methods (and some C methods, with the pry-doc gem) can have their source
-viewed. Code that is longer than a page is sent through a pager (such as less),
-and all code is properly syntax highlighted (even C code).
-The `show-source` command accepts two syntaxes, the typical ri `Class#method`
-syntax and also simply the name of a method that's in scope. You can optionally
-pass the `-l` option to `show-source` to include line numbers in the output.
-In the following example we will enter the `Pry` class, list the instance
-methods beginning with 'se' and display the source code for the `set_last_result` method:
-```ruby
-pry(main)> cd Pry
-pry(Pry):1> ls -M --grep se
-Pry#methods: raise_up  raise_up!  raise_up_common  reset_eval_string  select_prompt  set_last_result
-pry(Pry):1> show-source set_last_result -l
-From: /home/john/ruby/projects/pry/lib/pry/pry_instance.rb:405:
-Owner: Pry
-Visibility: public
-Signature: set_last_result(result, code=?)
-Number of lines: 6
-405: def set_last_result(result, code = "")
-406:   @last_result_is_exception = false
-407:   @output_ring << result
-408:
-409:   self.last_result = result unless code =~ /\A\s*\z/
-410: end
-```
-Note that we can also view C methods (from Ruby Core) using the
-`pry-doc` plugin; we also show off the alternate syntax for
-`show-source`:
-```ruby
-pry(main)> show-source Array#select
-From: array.c in Ruby Core (C Method):
-Number of lines: 15
-static VALUE
-rb_ary_select(VALUE ary)
-{
-    VALUE result;
-    long i;
-    RETURN_ENUMERATOR(ary, 0, 0);
-    result = rb_ary_new2(RARRAY_LEN(ary));
-    for (i = 0; i < RARRAY_LEN(ary); i++) {
-        if (RTEST(rb_yield(RARRAY_PTR(ary)[i]))) {
-            rb_ary_push(result, rb_ary_elt(ary, i));
-        }
-    }
-    return result;
-}
-```
-### Documentation Browsing
-One use-case for Pry is to explore a program at run-time by `cd`-ing in and out
-of objects and viewing and invoking methods. In the course of exploring it may
-be useful to read the documentation for a specific method that you come
-across. `show-source` command supports two syntaxes - the
-normal `ri` syntax as well as accepting the name of any method that is currently
-in scope.
-The Pry documentation system does not rely on pre-generated `rdoc` or `ri`,
-instead it grabs the comments directly above the method on demand. This results
-in speedier documentation retrieval and allows the Pry system to retrieve
-documentation for methods that would not be picked up by `rdoc`. Pry also has a
-basic understanding of both the rdoc and yard formats and will attempt to syntax
-highlight the documentation appropriately.
-Nonetheless, the `ri` functionality is very good and has an advantage over Pry's
-system in that it allows documentation lookup for classes as well as
-methods. Pry therefore has good integration with `ri` through the `ri`
-command. The syntax for the command is exactly as it would be in command-line -
-so it is not necessary to quote strings.
-In our example we will enter the `Gem` class and view the documentation for the
-`try_activate` method:
-```ruby
-pry(main)> cd Gem
-pry(Gem):1> show-source try_activate -d
-From: /Users/john/rbenv/versions/2.7.1/lib/ruby/2.7.0/rubygems.rb:194:
-Owner: #<Class:Gem>
-Visibility: public
-Signature: try_activate(path)
-Number of lines: 28
-Try to activate a gem containing path. Returns true if
-activation succeeded or wasn't needed because it was already
-activated. Returns false if it can't find the path in a gem.
-def self.try_activate(path)
-  # finds the _latest_ version... regardless of loaded specs and their deps
-  # if another gem had a requirement that would mean we shouldn't
-  # activate the latest version, then either it would already be activated
-  # or if it was ambiguous (and thus unresolved) the code in our custom
-  # require will try to activate the more specific version.
-  spec = Gem::Specification.find_by_path path
-pry(Gem):1>
-```
-We can also use `ri` in the normal way:
-```ruby
-pry(main) ri Array#each
------------------------------------------------------------ Array#each
-     array.each {|item| block }   ->   array
-------------------------------------------------------------------------
-     Calls _block_ once for each element in _self_, passing that element
-     as a parameter.
-        a = [ "a", "b", "c" ]
-        a.each {|x| print x, " -- " }
-     produces:
-        a -- b -- c --
-```
-### Edit methods
-You can use `edit Class#method` or `edit my_method` (if the method is in scope)
-to open a method for editing directly in your favorite editor. Pry has knowledge
-of a few different editors and will attempt to open the file at the line the
-method is defined.
-You can set the editor to use by assigning to the `Pry.editor`
-accessor. `Pry.editor` will default to `$EDITOR` or failing that will use `nano`
-as the backup default. The file that is edited will be automatically reloaded
-after exiting the editor - reloading can be suppressed by passing the
-`--no-reload` option to `edit`
-In the example below we will set our default editor to "emacsclient" and open
-the `Pry#repl` method for editing:
-```ruby
-pry(main)> Pry.editor = "emacsclient"
-pry(main)> edit Pry#repl
-```
-### Live Help System
-Many other commands are available in Pry; to see the full list type `help` at
-the prompt. A short description of each command is provided with basic
-instructions for use; some commands have a more extensive help that can be
-accessed via typing `command_name --help`. A command will typically say in its
-description if the `--help` option is available.
-### Use Pry as your Rails Console
-The recommended way to use Pry as your Rails console is to add [the `pry-rails`
-gem](https://github.com/rweng/pry-rails) to your Gemfile. This replaces the
-default console with Pry, in addition to loading the Rails console helpers and
-adding some useful Rails-specific commands.
-If you don't want to change your Gemfile, you can still run a Pry console in
-your app's environment using Pry's `-r` flag:
-```sh
-pry -r ./config/environment
-```
-Also check out the
-[wiki](https://github.com/pry/pry/wiki/Setting-up-Rails-or-Heroku-to-use-Pry)
-for more information about integrating Pry with Rails.
-### Syntax Highlighting
-Syntax highlighting is on by default in Pry. If you want to change the colors,
-check out the [pry-theme](https://github.com/kyrylo/pry-theme) gem.
-You can toggle the syntax highlighting on and off in a session by using the
-`toggle-color` command. Alternatively, you can turn it off permanently by
-putting the line `Pry.color = false` in your `pryrc` file.
-Supported Rubies
-----------------
-* CRuby >= 2.0.0
-* JRuby >= 9.0
-Contact
--------
-In case you have a problem, question or a bug report, feel free to:
-* ask a question on IRC (#pry on Freenode)
-* [file an issue](https://github.com/pry/pry/issues)
-* [tweet at us](https://twitter.com/pryruby)
-License
--------
-The project uses the MIT License. See LICENSE.md for details.
-Contributors
-------------
-Pry is primarily the work of [John Mair (banisterfiend)](https://github.com/banister), for full list
-of contributors see the
-[contributors graph](https://github.com/pry/pry/graphs/contributors).

data/vendor/bundle/ruby/3.2.0/gems/pry-0.14.2/lib/pry/class_command.rb DELETED Viewed

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-class Pry
-  # A super-class of Commands with structure.
-  #
-  # This class implements the bare-minimum functionality that a command should
-  # have, namely a --help switch, and then delegates actual processing to its
-  # subclasses.
-  #
-  # Create subclasses using {Pry::CommandSet#create_command}, and override the
-  # `options(opt)` method to set up an instance of Pry::Slop, and the `process`
-  # method to actually run the command. If necessary, you can also override
-  # `setup` which will be called before `options`, for example to require any
-  # gems your command needs to run, or to set up state.
-  class ClassCommand < Command
-    class << self
-      # Ensure that subclasses inherit the options, description and
-      # match from a ClassCommand super class.
-      def inherited(klass)
-        klass.match match
-        klass.description description
-        klass.command_options options
-      end
-      def source
-        source_object.source
-      end
-      def doc
-        new.help
-      end
-      def source_location
-        source_object.source_location
-      end
-      def source_file
-        source_object.source_file
-      end
-      alias file source_file
-      def source_line
-        source_object.source_line
-      end
-      alias line source_line
-      private
-      # The object used to extract the source for the command.
-      #
-      # This should be a `Pry::Method(block)` for a command made with `create_command`
-      # and a `Pry::WrappedModule(self)` for a command that's a standard class.
-      # @return [Pry::WrappedModule, Pry::Method]
-      def source_object
-        @source_object ||= if name =~ /^[A-Z]/
-                             Pry::WrappedModule(self)
-                           else
-                             Pry::Method(block)
-                           end
-      end
-    end
-    attr_accessor :opts
-    attr_accessor :args
-    # Set up `opts` and `args`, and then call `process`.
-    #
-    # This method will display help if necessary.
-    #
-    # @param [Array<String>] args The arguments passed
-    # @return [Object] The return value of `process` or VOID_VALUE
-    def call(*args)
-      setup
-      self.opts = slop
-      self.args = opts.parse!(args)
-      if opts.present?(:help)
-        output.puts slop.help
-        void
-      else
-        process(*normalize_method_args(method(:process), args))
-      end
-    end
-    # Return the help generated by Pry::Slop for this command.
-    def help
-      slop.help
-    end
-    # Return an instance of Pry::Slop that can parse either subcommands or the
-    # options that this command accepts.
-    def slop
-      Pry::Slop.new do |opt|
-        opt.banner(unindent(self.class.banner))
-        subcommands(opt)
-        options(opt)
-        opt.on :h, :help, 'Show this message.'
-      end
-    end
-    # Generate shell completions
-    # @param [String] search  The line typed so far
-    # @return [Array<String>]  the words to complete
-    def complete(search)
-      slop.flat_map do |opt|
-        [opt.long && "--#{opt.long} " || opt.short && "-#{opt.short}"]
-      end.compact + super
-    end
-    # A method called just before `options(opt)` as part of `call`.
-    #
-    # This method can be used to set up any context your command needs to run,
-    # for example requiring gems, or setting default values for options.
-    #
-    # @example
-    #   def setup
-    #     require 'gist'
-    #     @action = :method
-    #   end
-    def setup; end
-    # A method to setup Pry::Slop commands so it can parse the subcommands your
-    # command expects. If you need to set up default values, use `setup`
-    # instead.
-    #
-    # @example A minimal example
-    #   def subcommands(cmd)
-    #     cmd.command :download do |opt|
-    #       description 'Downloads a content from a server'
-    #
-    #       opt.on :verbose, 'Use verbose output'
-    #
-    #       run do |options, arguments|
-    #         ContentDownloader.download(options, arguments)
-    #       end
-    #     end
-    #   end
-    #
-    # @example Define the invokation block anywhere you want
-    #   def subcommands(cmd)
-    #     cmd.command :download do |opt|
-    #       description 'Downloads a content from a server'
-    #
-    #       opt.on :verbose, 'Use verbose output'
-    #     end
-    #   end
-    #
-    #   def process
-    #     # Perform calculations...
-    #     opts.fetch_command(:download).run do |options, arguments|
-    #       ContentDownloader.download(options, arguments)
-    #     end
-    #     # More calculations...
-    #   end
-    def subcommands(cmd); end
-    # A method to setup Pry::Slop so it can parse the options your command expects.
-    #
-    # @note Please don't do anything side-effecty in the main part of this
-    # method, as it may be called by Pry at any time for introspection reasons.
-    # If you need to set up default values, use `setup` instead.
-    #
-    # @example
-    #  def options(opt)
-    #    opt.banner "Gists methods or classes"
-    #    opt.on(:c, :class, "gist a class") do
-    #      @action = :class
-    #    end
-    #  end
-    def options(opt); end
-    # The actual body of your command should go here.
-    #
-    # The `opts` mehod can be called to get the options that Pry::Slop has passed,
-    # and `args` gives the remaining, unparsed arguments.
-    #
-    # The return value of this method is discarded unless the command was
-    # created with `:keep_retval => true`, in which case it is returned to the
-    # repl.
-    #
-    # @example
-    #   def process
-    #     if opts.present?(:class)
-    #       gist_class
-    #     else
-    #       gist_method
-    #     end
-    #   end
-    def process
-      raise CommandError, "command '#{command_name}' not implemented"
-    end
-  end
-end