xaiml 0.1.3 → 0.1.4

data/vendor/bundle/ruby/2.5.0/gems/pry-0.11.3/lib/pry/command_set.rb

@@ -1,450 +0,0 @@
-class Pry
-  class NoCommandError < StandardError
-    def initialize(match, owner)
-      super "Command '#{match}' not found in command set #{owner}"
-    end
-  end
-
-  # This class is used to create sets of commands. Commands can be imported from
-  # different sets, aliased, removed, etc.
-  class CommandSet
-    include Enumerable
-    include Pry::Helpers::BaseHelpers
-    attr_reader :helper_module
-
-    # @param [Array<Commandset>] imported_sets
-    #   Sets which will be imported automatically
-    # @yield Optional block run to define commands
-    def initialize(*imported_sets, &block)
-      @commands      = {}
-      @helper_module = Module.new
-      import(*imported_sets)
-      instance_eval(&block) if block
-    end
-
-    # Defines a new Pry command.
-    # @param [String, Regexp] match The start of invocations of this command.
-    # @param [String] description A description of the command.
-    # @param [Hash] options The optional configuration parameters.
-    # @option options [Boolean] :keep_retval Whether or not to use return value
-    #   of the block for return of `command` or just to return `nil`
-    #   (the default).
-    # @option options [Array<String>] :requires_gem Whether the command has
-    #   any gem dependencies, if it does and dependencies not met then
-    #   command is disabled and a stub proc giving instructions to
-    #   install command is provided.
-    # @option options [Boolean] :interpolate Whether string #{} based
-    #   interpolation is applied to the command arguments before
-    #   executing the command. Defaults to true.
-    # @option options [String] :listing The listing name of the
-    #   command. That is the name by which the command is looked up by
-    #   help and by show-command. Necessary for commands with regex matches.
-    # @option options [Boolean] :use_prefix Whether the command uses
-    #   `Pry.config.command_prefix` prefix (if one is defined). Defaults
-    #   to true.
-    # @option options [Boolean] :shellwords Whether the command's arguments
-    #   should be split using Shellwords instead of just split on spaces.
-    #   Defaults to true.
-    # @yield The action to perform. The parameters in the block
-    #   determines the parameters the command will receive. All
-    #   parameters passed into the block will be strings. Successive
-    #   command parameters are separated by whitespace at the Pry prompt.
-    # @example
-    #   MyCommands = Pry::CommandSet.new do
-    #     command "greet", "Greet somebody" do |name|
-    #       puts "Good afternoon #{name.capitalize}!"
-    #     end
-    #   end
-    #
-    #   # From pry:
-    #   # pry(main)> _pry_.commands = MyCommands
-    #   # pry(main)> greet john
-    #   # Good afternoon John!
-    #   # pry(main)> help greet
-    #   # Greet somebody
-    # @example Regexp command
-    #   MyCommands = Pry::CommandSet.new do
-    #     command /number-(\d+)/, "number-N regex command", :listing => "number" do |num, name|
-    #       puts "hello #{name}, nice number: #{num}"
-    #     end
-    #   end
-    #
-    #   # From pry:
-    #   # pry(main)> _pry_.commands = MyCommands
-    #   # pry(main)> number-10 john
-    #   # hello john, nice number: 10
-    #   # pry(main)> help number
-    #   # number-N regex command
-    def block_command(match, description="No description.", options={}, &block)
-      description, options = ["No description.", description] if description.is_a?(Hash)
-      options = Pry::Command.default_options(match).merge!(options)
-
-      @commands[match] = Pry::BlockCommand.subclass(match, description, options, helper_module, &block)
-    end
-    alias_method :command, :block_command
-
-    # Defines a new Pry command class.
-    #
-    # @param [String, Regexp] match The start of invocations of this command.
-    # @param [String] description A description of the command.
-    # @param [Hash] options The optional configuration parameters, see {#command}
-    # @yield The class body's definition.
-    #
-    # @example
-    #   Pry::Commands.create_command "echo", "echo's the input", :shellwords => false do
-    #     def options(opt)
-    #       opt.banner "Usage: echo [-u | -d] <string to echo>"
-    #       opt.on :u, :upcase, "ensure the output is all upper-case"
-    #       opt.on :d, :downcase, "ensure the output is all lower-case"
-    #     end
-    #
-    #     def process
-    #       raise Pry::CommandError, "-u and -d makes no sense" if opts.present?(:u) && opts.present?(:d)
-    #       result = args.join(" ")
-    #       result.downcase! if opts.present?(:downcase)
-    #       result.upcase! if opts.present?(:upcase)
-    #       output.puts result
-    #     end
-    #   end
-    #
-    def create_command(match, description="No description.", options={}, &block)
-      description, options = ["No description.", description] if description.is_a?(Hash)
-      options = Pry::Command.default_options(match).merge!(options)
-
-      @commands[match] = Pry::ClassCommand.subclass(match, description, options, helper_module, &block)
-      @commands[match].class_eval(&block)
-      @commands[match]
-    end
-
-    # Execute a block of code before a command is invoked. The block also
-    # gets access to parameters that will be passed to the command and
-    # is evaluated in the same context.
-    # @param [String, Regexp] search The match or listing of the command.
-    # @yield The block to be run before the command.
-    # @example Display parameter before invoking command
-    #   Pry.config.commands.before_command("whereami") do |n|
-    #     output.puts "parameter passed was #{n}"
-    #   end
-    # @deprecated Use {Pry::Hooks#add_hook} instead.
-    def before_command(search, &block)
-      cmd = find_command_by_match_or_listing(search)
-      cmd.hooks.add_hook("before_#{cmd.command_name}", random_hook_name, block)
-    end
-
-    # Execute a block of code after a command is invoked. The block also
-    # gets access to parameters that will be passed to the command and
-    # is evaluated in the same context.
-    # @param [String, Regexp] search The match or listing of the command.
-    # @yield The block to be run after the command.
-    # @example Display text 'command complete' after invoking command
-    #   Pry.config.commands.after_command("whereami") do |n|
-    #     output.puts "command complete!"
-    #   end
-    # @deprecated Use {Pry::Hooks#add_hook} instead.
-    def after_command(search, &block)
-      cmd = find_command_by_match_or_listing(search)
-      cmd.hooks.add_hook("after_#{cmd.command_name}", random_hook_name, block)
-    end
-
-    def random_hook_name
-      (0...8).map { ('a'..'z').to_a[rand(26)] }.join
-    end
-    private :random_hook_name
-
-    def each(&block)
-      @commands.each(&block)
-    end
-
-    # Removes some commands from the set
-    # @param [Array<String>] searches the matches or listings of the commands to remove
-    def delete(*searches)
-      searches.each do |search|
-        cmd = find_command_by_match_or_listing(search)
-        @commands.delete cmd.match
-      end
-    end
-
-    # Imports all the commands from one or more sets.
-    # @param [Array<CommandSet>] sets Command sets, all of the commands of which
-    #   will be imported.
-    # @return [Pry::CommandSet] Returns the reciever (a command set).
-    def import(*sets)
-      sets.each do |set|
-        @commands.merge! set.to_hash
-        helper_module.send :include, set.helper_module
-      end
-      self
-    end
-
-    # Imports some commands from a set
-    # @param [CommandSet] set Set to import commands from
-    # @param [Array<String>] matches Commands to import
-    # @return [Pry::CommandSet] Returns the reciever (a command set).
-    def import_from(set, *matches)
-      helper_module.send :include, set.helper_module
-      matches.each do |match|
-        cmd = set.find_command_by_match_or_listing(match)
-        @commands[cmd.match] = cmd
-      end
-      self
-    end
-
-    # @param [String, Regexp] match_or_listing The match or listing of a command.
-    #   of the command to retrieve.
-    # @return [Command] The command object matched.
-    def find_command_by_match_or_listing(match_or_listing)
-      cmd = (@commands[match_or_listing] ||
-        Pry::Helpers::BaseHelpers.find_command(match_or_listing, @commands))
-      cmd or raise ArgumentError, "Cannot find a command: '#{match_or_listing}'!"
-    end
-
-    # Aliases a command
-    # @param [String, Regex] match The match of the alias (can be a regex).
-    # @param [String] action The action to be performed (typically
-    #   another command).
-    # @param [Hash] options The optional configuration parameters,
-    #   accepts the same as the `command` method, but also allows the
-    #   command description to be passed this way too as `:desc`
-    # @example Creating an alias for `ls -M`
-    #   Pry.config.commands.alias_command "lM", "ls -M"
-    # @example Pass explicit description (overriding default).
-    #   Pry.config.commands.alias_command "lM", "ls -M", :desc => "cutiepie"
-    def alias_command(match, action,  options={})
-      cmd = find_command(action) or fail "Command: `#{action}` not found"
-      original_options = cmd.options.dup
-
-      options = original_options.merge!({
-                                          :desc => "Alias for `#{action}`",
-                                          :listing => match
-                                        }).merge!(options)
-
-      # ensure default description is used if desc is nil
-      desc = options.delete(:desc).to_s
-
-      c = block_command match, desc, options do |*args|
-        run action, *args
-      end
-
-      c.class_eval do
-        define_method(:complete) do |input|
-          cmd.new(context).complete(input)
-        end
-      end
-
-      c.group "Aliases"
-
-      c
-    end
-
-    # Rename a command. Accepts either match or listing for the search.
-    #
-    # @param [String, Regexp] new_match The new match for the command.
-    # @param [String, Regexp] search The command's current match or listing.
-    # @param [Hash] options The optional configuration parameters,
-    #   accepts the same as the `command` method, but also allows the
-    #   command description to be passed this way too.
-    # @example Renaming the `ls` command and changing its description.
-    #   Pry.config.commands.rename "dir", "ls", :description => "DOS friendly ls"
-    def rename_command(new_match, search, options={})
-      cmd = find_command_by_match_or_listing(search)
-
-      options = {
-        :listing     => new_match,
-        :description => cmd.description
-      }.merge!(options)
-
-      @commands[new_match] = cmd.dup
-      @commands[new_match].match = new_match
-      @commands[new_match].description = options.delete(:description)
-      @commands[new_match].options.merge!(options)
-      @commands.delete(cmd.match)
-    end
-
-    def disabled_command(name_of_disabled_command, message, matcher=name_of_disabled_command)
-      create_command name_of_disabled_command do
-        match matcher
-        description ""
-
-        define_method(:process) do
-          output.puts "DISABLED: #{message}"
-        end
-      end
-    end
-
-    # Sets or gets the description for a command (replacing the old
-    # description). Returns current description if no description
-    # parameter provided.
-    # @param [String, Regexp] search The command match.
-    # @param [String?] description (nil) The command description.
-    # @example Setting
-    #   MyCommands = Pry::CommandSet.new do
-    #     desc "help", "help description"
-    #   end
-    # @example Getting
-    #   Pry.config.commands.desc "amend-line"
-    def desc(search, description=nil)
-      cmd = find_command_by_match_or_listing(search)
-      return cmd.description if !description
-
-      cmd.description = description
-    end
-
-    # Defines helpers methods for this command sets.
-    # Those helpers are only defined in this command set.
-    #
-    # @yield A block defining helper methods
-    # @example
-    #   helpers do
-    #     def hello
-    #       puts "Hello!"
-    #     end
-    #
-    #     include OtherModule
-    #   end
-    def helpers(&block)
-      helper_module.class_eval(&block)
-    end
-
-
-    # @return [Array]
-    #   The list of commands provided by the command set.
-    def list_commands
-      @commands.keys
-    end
-    alias_method :keys, :list_commands
-
-    def to_hash
-      @commands.dup
-    end
-    alias_method :to_h, :to_hash
-
-    # Find a command that matches the given line
-    # @param [String] pattern The line that might be a command invocation
-    # @return [Pry::Command, nil]
-    def [](pattern)
-      @commands.values.select do |command|
-        command.matches?(pattern)
-      end.sort_by do |command|
-        command.match_score(pattern)
-      end.last
-    end
-    alias_method :find_command, :[]
-
-    #
-    # Re-assign the command found at _pattern_ with _command_.
-    #
-    # @param [Regexp, String] pattern
-    #   The command to add or replace(found at _pattern_).
-    #
-    # @param [Pry::Command] command
-    #   The command to add.
-    #
-    # @return [Pry::Command]
-    #   Returns the new command (matched with "pattern".)
-    #
-    # @example
-    #   Pry.config.commands["help"] = MyHelpCommand
-    #
-    def []=(pattern, command)
-      if command.equal?(nil)
-        return @commands.delete(pattern)
-      end
-      unless Class === command && command < Pry::Command
-        raise TypeError, "command is not a subclass of Pry::Command"
-      end
-      bind_command_to_pattern = pattern != command.match
-      if bind_command_to_pattern
-        command_copy = command.dup
-        command_copy.match = pattern
-        @commands[pattern] = command_copy
-      else
-        @commands[pattern] = command
-      end
-    end
-
-    #
-    # Add a command to set.
-    #
-    # @param [Command] command
-    #   a subclass of Pry::Command.
-    #
-    def add_command(command)
-      self[command.match] = command
-    end
-
-    # Find the command that the user might be trying to refer to.
-    # @param [String] search The user's search.
-    # @return [Pry::Command?]
-    def find_command_for_help(search)
-      find_command(search) || (begin
-        find_command_by_match_or_listing(search)
-      rescue ArgumentError
-        nil
-      end)
-    end
-
-    # Is the given line a command invocation?
-    # @param [String] val
-    # @return [Boolean]
-    def valid_command?(val)
-      !!find_command(val)
-    end
-
-    # Process the given line to see whether it needs executing as a command.
-    # @param [String] val The line to execute
-    # @param [Hash] context The context to execute the commands with
-    # @return [CommandSet::Result]
-    def process_line(val, context={})
-      if command = find_command(val)
-        context = context.merge(:command_set => self)
-        retval = command.new(context).process_line(val)
-        Result.new(true, retval)
-      else
-        Result.new(false)
-      end
-    end
-
-    # @private (used for testing)
-    def run_command(context, match, *args)
-      command = @commands[match] or raise NoCommandError.new(match, self)
-      command.new(context).call_safely(*args)
-    end
-
-    # Generate completions for the user's search.
-    # @param [String] search The line to search for
-    # @param [Hash] context  The context to create the command with
-    # @return [Array<String>]
-    def complete(search, context={})
-      if command = find_command(search)
-        command.new(context).complete(search)
-      else
-        @commands.keys.select do |key|
-          String === key && key.start_with?(search)
-        end.map{ |key| key + " " }
-      end
-    end
-  end
-
-  # Wraps the return result of process_commands, indicates if the
-  # result IS a command and what kind of command (e.g void)
-  class Result
-    attr_reader :retval
-
-    def initialize(is_command, retval = nil)
-      @is_command, @retval = is_command, retval
-    end
-
-    # Is the result a command?
-    # @return [Boolean]
-    def command?
-      @is_command
-    end
-
-    # Is the result a command and if it is, is it a void command?
-    # (one that does not return a value)
-    # @return [Boolean]
-    def void_command?
-      retval == Command::VOID_VALUE
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.11.3/lib/pry/commands/amend_line.rb

@@ -1,99 +0,0 @@
-class Pry
-  class Command::AmendLine < Pry::ClassCommand
-    match(/amend-line(?: (-?\d+)(?:\.\.(-?\d+))?)?/)
-    group 'Editing'
-    description 'Amend a line of input in multi-line mode.'
-    command_options :interpolate => false, :listing => 'amend-line'
-
-    banner <<-'BANNER'
-      Amend a line of input in multi-line mode. `amend-line N`, where the N represents
-      line to replace. Can also specify a range of lines using `amend-line N..M`
-      syntax. Passing "!" as replacement content deletes the line(s) instead.
-
-      amend-line 1 puts 'new'    # replace line 1
-      amend-line 1..4 !          # delete lines 1..4
-      amend-line 3 >puts 'bye'   # insert before line 3
-      amend-line puts 'appended' # no line number modifies immediately preceding line
-    BANNER
-
-    def process
-      raise CommandError, "No input to amend." if eval_string.empty?
-
-      eval_string.replace amended_input(eval_string)
-      run "fix-indent"
-      run "show-input"
-    end
-
-    private
-
-    # @param [String] string The string to amend.
-    # @return [String] A new string with the amendments applied to it.
-    def amended_input(string)
-      input_array = eval_string.each_line.to_a
-
-      if arg_string == "!"
-        delete_from_array(input_array, line_range)
-      elsif arg_string.start_with?(">")
-        insert_into_array(input_array, line_range)
-      else
-        replace_in_array(input_array, line_range)
-      end
-
-      input_array.join
-    end
-
-    def delete_from_array(array, range)
-      array.slice!(range)
-    end
-
-    def insert_into_array(array, range)
-      insert_slot = Array(range).first
-      array.insert(insert_slot, arg_string[1..-1] << "\n")
-    end
-
-    def replace_in_array(array, range)
-      array[range] = arg_string + "\n"
-    end
-
-    # @return [Fixnum] The number of lines currently in `eval_string` (the input buffer).
-    def line_count
-      eval_string.lines.count
-    end
-
-    # Returns the (one-indexed) start and end lines given by the user.
-    # The lines in this range will be affected by the `amend-line`.
-    # Returns `nil` if no lines were specified by the user.
-    # @return [Array<Fixnum>, nil]
-    def start_and_end_line_number
-      start_line_number, end_line_number = args
-      end_line_number ||= start_line_number.to_i
-
-      [start_line_number.to_i, end_line_number.to_i] if start_line_number
-    end
-
-    # Takes two numbers that are 1-indexed, and returns a range (or
-    # number) that is 0-indexed. 1-indexed means the first element is
-    # indentified by 1 rather than by 0 (as is the case for Ruby arrays).
-    # @param [Fixnum] start_line_number One-indexed number.
-    # @param [Fixnum] end_line_number One-indexed number.
-    # @return [Range] The zero-indexed range.
-    def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number)
-      # FIXME: one_index_number is a horrible name for this method
-      one_index_number(start_line_number)..one_index_number(end_line_number)
-    end
-
-    # The lines (or line) that will be modified by the `amend-line`.
-    # @return [Range, Fixnum] The lines or line.
-    def line_range
-      start_line_number, end_line_number = start_and_end_line_number
-      if start_line_number
-        zero_indexed_range_from_one_indexed_numbers(start_line_number,
-                                                    end_line_number)
-      else
-        line_count - 1
-      end
-    end
-  end
-
-  Pry::Commands.add_command(Pry::Command::AmendLine)
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.11.3/lib/pry/commands/bang.rb

@@ -1,20 +0,0 @@
-class Pry
-  class Command::Bang < Pry::ClassCommand
-    match(/^\s*!\s*$/)
-    group 'Editing'
-    description 'Clear the input buffer.'
-    command_options :use_prefix => false
-
-    banner <<-'BANNER'
-      Clear the input buffer. Useful if the parsing process goes wrong and you get
-      stuck in the read loop.
-    BANNER
-
-    def process
-      output.puts 'Input buffer cleared!'
-      eval_string.replace('')
-    end
-  end
-
-  Pry::Commands.add_command(Pry::Command::Bang)
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.11.3/lib/pry/commands/bang_pry.rb

@@ -1,17 +0,0 @@
-class Pry
-  class Command::BangPry < Pry::ClassCommand
-    match '!pry'
-    group 'Navigating Pry'
-    description 'Start a Pry session on current self.'
-
-    banner <<-'BANNER'
-      Start a Pry session on current self. Also works mid multi-line expression.
-    BANNER
-
-    def process
-      target.pry
-    end
-  end
-
-  Pry::Commands.add_command(Pry::Command::BangPry)
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.11.3/lib/pry/commands/cat/abstract_formatter.rb

@@ -1,27 +0,0 @@
-class Pry
-  class Command::Cat
-    class AbstractFormatter
-      include Pry::Helpers::CommandHelpers
-      include Pry::Helpers::BaseHelpers
-
-      private
-      def decorate(content)
-        content.code_type = code_type
-        content.between(*between_lines).
-          with_line_numbers(use_line_numbers?).highlighted
-      end
-
-      def code_type
-        opts[:type] || :ruby
-      end
-
-      def use_line_numbers?
-        opts.present?(:'line-numbers') || opts.present?(:ex)
-      end
-
-      def between_lines
-        [opts[:start] || 1, opts[:end] || -1]
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/gems/pry-0.11.3/lib/pry/commands/cat/exception_formatter.rb

@@ -1,78 +0,0 @@
-class Pry
-  class Command::Cat
-    class ExceptionFormatter < AbstractFormatter
-      attr_reader :ex
-      attr_reader :opts
-      attr_reader :_pry_
-
-      def initialize(exception, _pry_, opts)
-        @ex = exception
-        @opts = opts
-        @_pry_ = _pry_
-      end
-
-      def format
-        check_for_errors
-        set_file_and_dir_locals(backtrace_file, _pry_, _pry_.current_context)
-        code = decorate(Pry::Code.from_file(backtrace_file).
-                                    between(*start_and_end_line_for_code_window).
-                                    with_marker(backtrace_line))
-        "#{header}#{code}"
-      end
-
-      private
-
-      def code_window_size
-        _pry_.config.default_window_size || 5
-      end
-
-      def backtrace_level
-        @backtrace_level ||=
-          begin
-            bl =  if opts[:ex].nil?
-                    ex.bt_index
-                  else
-                    ex.bt_index = absolute_index_number(opts[:ex], ex.backtrace.size)
-                  end
-
-            increment_backtrace_level
-            bl
-          end
-      end
-
-      def increment_backtrace_level
-        ex.inc_bt_index
-      end
-
-      def backtrace_file
-        Array(ex.bt_source_location_for(backtrace_level)).first
-      end
-
-      def backtrace_line
-        Array(ex.bt_source_location_for(backtrace_level)).last
-      end
-
-      def check_for_errors
-        raise CommandError, "No exception found." unless ex
-        raise CommandError, "The given backtrace level is out of bounds." unless backtrace_file
-      end
-
-      def start_and_end_line_for_code_window
-        start_line = backtrace_line - code_window_size
-        start_line = 1 if start_line < 1
-
-        [start_line, backtrace_line + code_window_size]
-      end
-
-      def header
-        unindent %{
-        #{Helpers::Text.bold 'Exception:'} #{ex.class}: #{ex.message}
-        --
-        #{Helpers::Text.bold('From:')} #{backtrace_file} @ line #{backtrace_line} @ #{Helpers::Text.bold("level: #{backtrace_level}")} of backtrace (of #{ex.backtrace.size - 1}).
-
-      }
-      end
-
-    end
-  end
-end