xaiml 0.1.3 → 0.1.4

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

@@ -1,27 +0,0 @@
-class Pry
-  module Helpers
-    module OptionsHelpers
-      module_function
-
-      # Add method options to the Pry::Slop instance
-      def method_options(opt)
-        @method_target = target
-        opt.on :M, "instance-methods", "Operate on instance methods."
-        opt.on :m, :methods, "Operate on methods."
-        opt.on :s, :super, "Select the 'super' method. Can be repeated to traverse the ancestors.", :as => :count
-        opt.on :c, :context, "Select object context to run under.", :argument => true do |context|
-          @method_target = Pry.binding_for(target.eval(context))
-        end
-      end
-
-      # Get the method object parsed by the slop instance
-      def method_object
-        @method_object ||= get_method_or_raise(args.empty? ? nil : args.join(" "), @method_target,
-                            :super => opts[:super],
-                            :instance => opts.present?(:'instance-methods') && !opts.present?(:'methods'),
-                            :methods  => opts.present?(:'methods') && !opts.present?(:'instance-methods')
-                           )
-      end
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-class Pry
-  module Helpers
-    def self.tablify_or_one_line(heading, things)
-      plain_heading = Pry::Helpers::Text.strip_color(heading)
-      attempt = Table.new(things, :column_count => things.size)
-      if attempt.fits_on_line?(Terminal.width! - plain_heading.size - 2)
-        "#{heading}: #{attempt}\n"
-      else
-        "#{heading}: \n#{tablify_to_screen_width(things, :indent => '  ')}\n"
-      end
-    end
-
-    def self.tablify_to_screen_width(things, options = {})
-      things = things.compact
-      if indent = options[:indent]
-        usable_width = Terminal.width! - indent.size
-        tablify(things, usable_width).to_s.gsub(/^/, indent)
-      else
-        tablify(things, Terminal.width!).to_s
-      end
-    end
-
-    def self.tablify(things, line_length)
-      table = Table.new(things, :column_count => things.size)
-      table.column_count -= 1 until 1 == table.column_count or
-        table.fits_on_line?(line_length)
-      table
-    end
-
-    class Table
-      attr_reader :items, :column_count
-      def initialize items, args = {}
-        @column_count = args[:column_count]
-        self.items = items
-      end
-
-      def to_s
-        rows_to_s.join("\n")
-      end
-
-      def rows_to_s style = :color_on
-        widths = columns.map{|e| _max_width(e)}
-        @rows_without_colors.map do |r|
-          padded = []
-          r.each_with_index do |e,i|
-            next unless e
-            item = e.ljust(widths[i])
-            item.sub! e, _recall_color_for(e) if :color_on == style
-            padded << item
-          end
-          padded.join(Pry.config.ls.separator)
-        end
-      end
-
-      def items= items
-        @items = items
-        _rebuild_colorless_cache
-        _recolumn
-        items
-      end
-
-      def column_count= n
-        @column_count = n
-        _recolumn
-      end
-
-      def fits_on_line? line_length
-        _max_width(rows_to_s :no_color) <= line_length
-      end
-
-      def columns
-        @rows_without_colors.transpose
-      end
-
-      def ==(other); items == other.to_a end
-      def to_a; items.to_a end
-
-      private
-      def _max_width(things)
-        things.compact.map(&:size).max || 0
-      end
-
-      def _rebuild_colorless_cache
-        @colorless_cache = {}
-        @plain_items = []
-        items.map do |e|
-          plain = Pry::Helpers::Text.strip_color(e)
-          @colorless_cache[plain] = e
-          @plain_items << plain
-        end
-      end
-
-      def _recolumn
-        @rows_without_colors = []
-        return if items.size.zero?
-        row_count = (items.size.to_f/column_count).ceil
-        row_count.times do |i|
-          row_indices = (0...column_count).map{|e| row_count*e+i}
-          @rows_without_colors << row_indices.map{|e| @plain_items[e]}
-        end
-      end
-
-      def _recall_color_for thing
-        @colorless_cache[thing]
-      end
-    end
-
-  end
-end

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

@@ -1,116 +0,0 @@
-class Pry
-  module Helpers
-    # The methods defined on {Text} are available to custom commands via {Pry::Command#text}.
-    module Text
-      extend self
-      COLORS =
-      {
-        "black"   => 0,
-        "red"     => 1,
-        "green"   => 2,
-        "yellow"  => 3,
-        "blue"    => 4,
-        "purple"  => 5,
-        "magenta" => 5,
-        "cyan"    => 6,
-        "white"   => 7
-      }
-
-      COLORS.each_pair do |color, value|
-        define_method color do |text|
-          "\033[0;#{30+value}m#{text}\033[0m"
-        end
-
-        define_method "bright_#{color}" do |text|
-          "\033[1;#{30+value}m#{text}\033[0m"
-        end
-
-        COLORS.each_pair do |bg_color, bg_value|
-          define_method "#{color}_on_#{bg_color}" do |text|
-            "\033[0;#{30 + value};#{40 + bg_value}m#{text}\033[0m"
-          end
-
-          define_method "bright_#{color}_on_#{bg_color}" do |text|
-            "\033[1;#{30 + value};#{40 + bg_value}m#{text}\033[0m"
-          end
-        end
-      end
-
-      # Remove any color codes from _text_.
-      #
-      # @param  [String, #to_s] text
-      # @return [String] _text_ stripped of any color codes.
-      def strip_color(text)
-        text.to_s.gsub(/(\001)?\e\[.*?(\d)+m(\002)?/ , '')
-      end
-
-      # Returns _text_ as bold text for use on a terminal.
-      #
-      # @param [String, #to_s] text
-      # @return [String] _text_
-      def bold(text)
-        "\e[1m#{text}\e[0m"
-      end
-
-      # Returns `text` in the default foreground colour.
-      # Use this instead of "black" or "white" when you mean absence of colour.
-      #
-      # @param [String, #to_s] text
-      # @return [String]
-      def default(text)
-        text.to_s
-      end
-      alias_method :bright_default, :bold
-
-      #
-      # @yield
-      #   Yields a block with color turned off.
-      #
-      # @return [void]
-      #
-      def no_color
-        boolean = Pry.config.color
-        Pry.config.color = false
-        yield
-      ensure
-        Pry.config.color = boolean
-      end
-
-      #
-      # @yield
-      #   Yields a block with paging turned off.
-      #
-      # @return [void]
-      #
-      def no_pager
-        boolean = Pry.config.pager
-        Pry.config.pager = false
-        yield
-      ensure
-        Pry.config.pager = boolean
-      end
-
-      # Returns _text_ in a numbered list, beginning at _offset_.
-      #
-      # @param  [#each_line] text
-      # @param  [Fixnum] offset
-      # @return [String]
-      def with_line_numbers(text, offset, color=:blue)
-        lines = text.each_line.to_a
-        max_width = (offset + lines.count).to_s.length
-        lines.each_with_index.map do |line, index|
-          adjusted_index = (index + offset).to_s.rjust(max_width)
-          "#{self.send(color, adjusted_index)}: #{line}"
-        end.join
-      end
-
-      # Returns _text_ indented by _chars_ spaces.
-      #
-      # @param [String] text
-      # @param [Fixnum] chars
-      def indent(text, chars)
-        text.lines.map { |l| "#{' ' * chars}#{l}" }.join
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-require "pry/helpers/base_helpers"
-require "pry/helpers/options_helpers"
-require "pry/helpers/command_helpers"
-require "pry/helpers/text"
-require "pry/helpers/table"

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

@@ -1,148 +0,0 @@
-class Pry
-  # The History class is responsible for maintaining the user's input history,
-  # both internally and within Readline.
-  class History
-    attr_accessor :loader, :saver, :pusher, :clearer
-
-    # @return [Fixnum] Number of lines in history when Pry first loaded.
-    attr_reader :original_lines
-
-    def initialize(options={})
-      @history = []
-      @original_lines = 0
-      @file_path = options[:file_path]
-      restore_default_behavior
-    end
-
-    # Assign the default methods for loading, saving, pushing, and clearing.
-    def restore_default_behavior
-      Pry.config.input # force Readline to load if applicable
-
-      @loader = method(:read_from_file)
-      @saver  = method(:save_to_file)
-
-      if defined?(Readline)
-        @pusher  = method(:push_to_readline)
-        @clearer = method(:clear_readline)
-      else
-        @pusher  = proc { }
-        @clearer = proc { }
-      end
-    end
-
-    # Load the input history using `History.loader`.
-    # @return [Integer] The number of lines loaded
-    def load
-      @loader.call do |line|
-        @pusher.call(line.chomp)
-        @history << line.chomp
-        @original_lines += 1
-      end
-    end
-
-    # Add a line to the input history, ignoring blank and duplicate lines.
-    # @param [String] line
-    # @return [String] The same line that was passed in
-    def push(line)
-      unless line.empty? || (@history.last && line == @history.last)
-        @pusher.call(line)
-        @history << line
-        if !should_ignore?(line) && Pry.config.history.should_save
-          @saver.call(line)
-        end
-      end
-      line
-    end
-    alias << push
-
-    # Clear this session's history. This won't affect the contents of the
-    # history file.
-    def clear
-      @clearer.call
-      @original_lines = 0
-      @history = []
-    end
-
-    # @return [Fixnum] The number of lines in history.
-    def history_line_count
-      @history.count
-    end
-
-    # @return [Fixnum] The number of lines in history from just this session.
-    def session_line_count
-      @history.count - @original_lines
-    end
-
-    # Return an Array containing all stored history.
-    # @return [Array<String>] An Array containing all lines of history loaded
-    #   or entered by the user in the current session.
-    def to_a
-      @history.dup
-    end
-
-    # Filter the history with the histignore options
-    # @return [Array<String>] An array containing all the lines that are not
-    #   included in the histignore.
-    def filter(history)
-      history.select { |l| l unless should_ignore?(l) }
-    end
-
-    private
-
-    # Check if the line match any option in the histignore
-    # [Pry.config.history.histignore]
-    # @return [Boolean] a boolean that notifies if the line was found in the
-    #   histignore array.
-    def should_ignore?(line)
-      hist_ignore = Pry.config.history.histignore
-      return false if hist_ignore.nil? || hist_ignore.empty?
-
-      hist_ignore.any? { |p| line.to_s.match(p) }
-    end
-
-    # The default loader. Yields lines from `Pry.history.config.file`.
-    def read_from_file
-      path = history_file_path
-
-      if File.exist?(path)
-        File.foreach(path) { |line| yield(line) }
-      end
-    rescue => error
-      warn "History file not loaded: #{error.message}"
-    end
-
-    # The default pusher. Appends the given line to Readline::HISTORY.
-    # @param [String] line
-    def push_to_readline(line)
-      Readline::HISTORY << line
-    end
-
-    # The default clearer. Clears Readline::HISTORY.
-    def clear_readline
-      Readline::HISTORY.shift until Readline::HISTORY.empty?
-    end
-
-    # The default saver. Appends the given line to `Pry.history.config.file`.
-    def save_to_file(line)
-      history_file.puts line if history_file
-    end
-
-    # The history file, opened for appending.
-    def history_file
-      if defined?(@history_file)
-        @history_file
-      else
-        @history_file = File.open(history_file_path, 'a', 0600).tap do |file|
-          file.sync = true
-        end
-      end
-    rescue Errno::EACCES
-      warn 'History not saved; unable to open your history file for writing.'
-      @history_file = false
-    end
-
-    def history_file_path
-      File.expand_path(@file_path || Pry.config.history.file)
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-class Pry
-  # A history array is an array to which you can only add elements. Older
-  # entries are removed progressively, so that the array never contains more than
-  # N elements.
-  #
-  # History arrays are used by Pry to store the output of the last commands.
-  #
-  # @example
-  #   ary = Pry::HistoryArray.new 10
-  #   ary << 1 << 2 << 3
-  #   ary[0] # => 1
-  #   ary[1] # => 2
-  #   10.times { |n| ary << n }
-  #   ary[0] # => nil
-  #   ary[-1] # => 9
-  class HistoryArray
-    include Enumerable
-
-    # @param [Integer] size Maximum amount of objects in the array
-    def initialize(size)
-      @max_size = size
-
-      @hash  = {}
-      @count = 0
-    end
-
-    # Pushes an object at the end of the array
-    # @param [Object] value Object to be added
-    def <<(value)
-      @hash[@count] = value
-
-      if @hash.size > max_size
-        @hash.delete(@count - max_size)
-      end
-
-      @count += 1
-
-      self
-    end
-
-    # @overload [](index)
-    #   @param [Integer] index Index of the item to access.
-    #   @return [Object, nil] Item at that index or nil if it has been removed.
-    # @overload [](index, size)
-    #   @param [Integer] index Index of the first item to access.
-    #   @param [Integer] size Amount of items to access
-    #   @return [Array, nil] The selected items. Nil if index is greater than
-    #     the size of the array.
-    # @overload [](range)
-    #   @param [Range<Integer>] range Range of indices to access.
-    #   @return [Array, nil] The selected items. Nil if index is greater than
-    #     the size of the array.
-    def [](index_or_range, size = nil)
-      if index_or_range.is_a? Integer
-        index = convert_index(index_or_range)
-
-        if size
-          end_index = index + size
-          index > @count ? nil : (index...[end_index, @count].min).map do |n|
-            @hash[n]
-          end
-        else
-          @hash[index]
-        end
-      else
-        range = convert_range(index_or_range)
-        range.begin > @count ? nil : range.map { |n| @hash[n] }
-      end
-    end
-
-    # @return [Integer] Amount of objects in the array
-    def size
-      @count
-    end
-    alias count size
-    alias length size
-
-    def empty?
-      size == 0
-    end
-
-    def each
-      ((@count - size)...@count).each do |n|
-        yield @hash[n]
-      end
-    end
-
-    def to_a
-      ((@count - size)...@count).map { |n| @hash[n] }
-    end
-
-    # @return [Hash] copy of the internal @hash history
-    def to_h
-      @hash.dup
-    end
-
-    def pop!
-      @hash.delete @count - 1
-      @count -= 1
-    end
-
-    def inspect
-      "#<#{self.class} size=#{size} first=#{@count - size} max_size=#{max_size}>"
-    end
-
-    # @return [Integer] Maximum amount of objects in the array
-    attr_reader :max_size
-
-    private
-    def convert_index(n)
-      n >= 0 ? n : @count + n
-    end
-
-    def convert_range(range)
-      end_index = convert_index(range.end)
-      end_index += 1 unless range.exclude_end?
-
-      Range.new(convert_index(range.begin), [end_index, @count].min, true)
-    end
-  end
-end

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

@@ -1,171 +0,0 @@
-class Pry
-  # Implements a hooks system for Pry. A hook is a callable that is associated
-  # with an event. A number of events are currently provided by Pry, these
-  # include: `:when_started`, `:before_session`, `:after_session`.  A hook must
-  # have a name, and is connected with an event by the `Pry::Hooks#add_hook`
-  # method.
-  #
-  # @example Adding a hook for the `:before_session` event.
-  #   Pry.config.hooks.add_hook(:before_session, :say_hi) do
-  #     puts "hello"
-  #   end
-  class Hooks
-    def initialize
-      @hooks = Hash.new { |h, k| h[k] = [] }
-    end
-
-    # Ensure that duplicates have their @hooks object.
-    def initialize_copy(orig)
-      hooks_dup = @hooks.dup
-      @hooks.each do |k, v|
-        hooks_dup[k] = v.dup
-      end
-
-      @hooks = hooks_dup
-    end
-
-    def errors
-      @errors ||= []
-    end
-
-    # Destructively merge the contents of two `Pry:Hooks` instances.
-    #
-    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
-    # @return [Pry:Hooks] The receiver.
-    # @see {#merge}
-    def merge!(other)
-      @hooks.merge!(other.dup.hooks) do |key, array, other_array|
-        temp_hash, output = {}, []
-
-        (array + other_array).reverse_each do |pair|
-          temp_hash[pair.first] ||= output.unshift(pair)
-        end
-
-        output
-      end
-
-      self
-    end
-
-    # @example
-    #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
-    #   Pry::Hooks.new.merge(hooks)
-    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
-    # @return [Pry::Hooks] a new `Pry::Hooks` instance containing a merge of the
-    #   contents of two `Pry:Hooks` instances.
-    def merge(other)
-      self.dup.tap do |v|
-        v.merge!(other)
-      end
-    end
-
-    # Add a new hook to be executed for the `event_name` event.
-    # @param [Symbol] event_name The name of the event.
-    # @param [Symbol] hook_name The name of the hook.
-    # @param [#call] callable The callable.
-    # @yield The block to use as the callable (if no `callable` provided).
-    # @return [Pry:Hooks] The receiver.
-    def add_hook(event_name, hook_name, callable=nil, &block)
-      event_name = event_name.to_s
-
-      # do not allow duplicates, but allow multiple `nil` hooks
-      # (anonymous hooks)
-      if hook_exists?(event_name, hook_name) && !hook_name.nil?
-        raise ArgumentError, "Hook with name '#{hook_name}' already defined!"
-      end
-
-      if !block && !callable
-        raise ArgumentError, "Must provide a block or callable."
-      end
-
-      # ensure we only have one anonymous hook
-      @hooks[event_name].delete_if { |h, k| h.nil? } if hook_name.nil?
-
-      if block
-        @hooks[event_name] << [hook_name, block]
-      elsif callable
-        @hooks[event_name] << [hook_name, callable]
-      end
-
-      self
-    end
-
-    # Execute the list of hooks for the `event_name` event.
-    # @param [Symbol] event_name The name of the event.
-    # @param [Array] args The arguments to pass to each hook function.
-    # @return [Object] The return value of the last executed hook.
-    def exec_hook(event_name, *args, &block)
-      @hooks[event_name.to_s].map do |hook_name, callable|
-        begin
-          callable.call(*args, &block)
-        rescue RescuableException => e
-          errors << e
-          e
-        end
-      end.last
-    end
-
-    # @param [Symbol] event_name The name of the event.
-    # @return [Fixnum] The number of hook functions for `event_name`.
-    def hook_count(event_name)
-      @hooks[event_name.to_s].size
-    end
-
-    # @param [Symbol] event_name The name of the event.
-    # @param [Symbol] hook_name The name of the hook
-    # @return [#call] a specific hook for a given event.
-    def get_hook(event_name, hook_name)
-      hook = @hooks[event_name.to_s].find do |current_hook_name, callable|
-        current_hook_name == hook_name
-      end
-      hook.last if hook
-    end
-
-    # @param [Symbol] event_name The name of the event.
-    # @return [Hash] The hash of hook names / hook functions.
-    # @note Modifying the returned hash does not alter the hooks, use
-    # `add_hook`/`delete_hook` for that.
-    def get_hooks(event_name)
-      Hash[@hooks[event_name.to_s]]
-    end
-
-    # @param [Symbol] event_name The name of the event.
-    # @param [Symbol] hook_name The name of the hook.
-    #   to delete.
-    # @return [#call] The deleted hook.
-    def delete_hook(event_name, hook_name)
-      deleted_callable = nil
-
-      @hooks[event_name.to_s].delete_if do |current_hook_name, callable|
-        if current_hook_name == hook_name
-          deleted_callable = callable
-          true
-        else
-          false
-        end
-      end
-      deleted_callable
-    end
-
-    # Clear all hooks functions for a given event.
-    #
-    # @param [String] event_name The name of the event.
-    # @return [void]
-    def clear_event_hooks(event_name)
-      @hooks[event_name.to_s] = []
-    end
-
-    # @param [Symbol] event_name Name of the event.
-    # @param [Symbol] hook_name Name of the hook.
-    # @return [Boolean] Whether the hook by the name `hook_name`.
-    def hook_exists?(event_name, hook_name)
-      @hooks[event_name.to_s].map(&:first).include?(hook_name)
-    end
-
-    protected
-
-    def hooks
-      @hooks
-    end
-  end
-end