xaiml 0.1.0

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

@@ -0,0 +1,90 @@
+# coding: utf-8
+class Pry::Terminal
+  class << self
+    # Return a pair of [rows, columns] which gives the size of the window.
+    #
+    # If the window size cannot be determined, return nil.
+    def screen_size
+      rows, cols = actual_screen_size
+      if rows.to_i != 0 && cols.to_i != 0
+        [rows.to_i, cols.to_i]
+      else
+        nil
+      end
+    end
+
+    # Return a screen size or a default if that fails.
+    def size! default = [27, 80]
+      screen_size || default
+    end
+
+    # Return a screen width or the default if that fails.
+    def width!
+      size![1]
+    end
+
+    # Return a screen height or the default if that fails.
+    def height!
+      size![0]
+    end
+
+    def actual_screen_size
+      # The best way, if possible (requires non-jruby ≥1.9 or io-console gem)
+      screen_size_according_to_io_console or
+        # Fall back to the old standby, though it might be stale:
+        screen_size_according_to_env or
+        # Fall further back, though this one is also out of date without something
+        # calling Readline.set_screen_size
+        screen_size_according_to_readline or
+        # Windows users can otherwise run ansicon and get a decent answer:
+        screen_size_according_to_ansicon_env
+    end
+
+    def screen_size_according_to_io_console
+      return if Pry::Helpers::BaseHelpers.jruby?
+
+      begin
+        require 'io/console'
+
+        begin
+          if $stdout.respond_to?(:tty?) && $stdout.tty? && $stdout.respond_to?(:winsize)
+            $stdout.winsize
+          end
+        rescue Errno::EOPNOTSUPP
+          # $stdout is probably a socket, which doesn't support #winsize.
+        end
+      rescue LoadError
+        # They probably don't have the io/console stdlib or the io-console gem.
+        # We'll keep trying.
+      end
+    end
+
+    def screen_size_according_to_env
+      size = [ENV['LINES'] || ENV['ROWS'], ENV['COLUMNS']]
+      size if nonzero_column?(size)
+    end
+
+    def screen_size_according_to_readline
+      if defined?(Readline) && Readline.respond_to?(:get_screen_size)
+        size = Readline.get_screen_size
+        size if nonzero_column?(size)
+      end
+    rescue Java::JavaLang::NullPointerException
+      # This rescue won't happen on jrubies later than:
+      #     https://github.com/jruby/jruby/pull/436
+      nil
+    end
+
+    def screen_size_according_to_ansicon_env
+      return unless ENV['ANSICON'] =~ /\((.*)x(.*)\)/
+      size = [$2, $1]
+      size if nonzero_column?(size)
+    end
+
+    private
+
+    def nonzero_column?(size)
+      size[1].to_i > 0
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Pry::Testable::Evalable
+  def pry_tester(*args, &block)
+    if args.length == 0 || args[0].is_a?(Hash)
+      args.unshift(Pry.toplevel_binding)
+    end
+    Pry::Testable::PryTester.new(*args).tap do |t|
+      t.singleton_class.class_eval(&block) if block
+    end
+  end
+
+  def pry_eval(*eval_strs)
+    b = String === eval_strs.first ? Pry.toplevel_binding : Pry.binding_for(eval_strs.shift)
+    pry_tester(b).eval(*eval_strs)
+  end
+end

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

@@ -0,0 +1,14 @@
+module Pry::Testable::Mockable
+  def mock_command(cmd, args=[], opts={})
+    output = StringIO.new
+    pry = Pry.new(output: output)
+    ret = cmd.new(opts.merge(pry_instance: pry, :output => output)).call_safely(*args)
+    Struct.new(:output, :return).new(output.string, ret)
+  end
+
+  def mock_exception(*mock_backtrace)
+    StandardError.new.tap do |e|
+      e.define_singleton_method(:backtrace) { mock_backtrace }
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+class Pry::Testable::PryTester
+  extend Pry::Forwardable
+  attr_reader :pry, :out
+  def_delegators :@pry, :eval_string, :eval_string=
+
+  def initialize(target = TOPLEVEL_BINDING, options = {})
+    @pry = Pry.new(options.merge(:target => target))
+    @history = options[:history]
+    @pry.inject_sticky_locals!
+    reset_output
+  end
+
+  def eval(*strs)
+    reset_output
+    result = nil
+
+    strs.flatten.each do |str|
+      # Check for space prefix. See #1369.
+      if str !~ /^\s\S/
+        str = "#{str.strip}\n"
+      end
+      @history.push str if @history
+
+      if @pry.process_command(str)
+        result = last_command_result_or_output
+      else
+        result = @pry.evaluate_ruby(str)
+      end
+    end
+
+    result
+  end
+
+  def push(*lines)
+    Array(lines).flatten.each do |line|
+      @pry.eval(line)
+    end
+  end
+
+  def push_binding(context)
+    @pry.push_binding context
+  end
+
+  def last_output
+    @out.string if @out
+  end
+
+  def process_command(command_str)
+    @pry.process_command(command_str) or raise "Not a valid command"
+    last_command_result_or_output
+  end
+
+  def last_command_result
+    result = Pry.current[:pry_cmd_result]
+    result.retval if result
+  end
+
+  protected
+
+  def last_command_result_or_output
+    result = last_command_result
+    if result != Pry::Command::VOID_VALUE
+      result
+    else
+      last_output
+    end
+  end
+
+  def reset_output
+    @out = StringIO.new
+    @pry.output = @out
+  end
+end

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

@@ -0,0 +1,26 @@
+module Pry::Testable::Utility
+  #
+  # Creates a Tempfile then unlinks it after the block has yielded.
+  #
+  # @yieldparam [String] file
+  #   The path of the temp file
+  #
+  # @return [void]
+  #
+  def temp_file(ext='.rb')
+    file = Tempfile.open(['pry', ext])
+    yield file
+  ensure
+    file.close(true) if file
+  end
+
+  def unindent(*args)
+    Pry::Helpers::CommandHelpers.unindent(*args)
+  end
+
+  def inner_scope
+    catch(:inner_scope) do
+      yield ->{ throw(:inner_scope, self) }
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Pry::Testable::Variables
+  #
+  # @example
+  #   temporary_constants(:Foo, :Bar) do
+  #     Foo = Class.new(RuntimeError)
+  #     Bar = Class.new(RuntimeError)
+  #   end
+  #   Foo # => NameError
+  #   Bar # => NameError
+  #
+  # @param [Array<Symbol>] *names
+  #   An array of constant names that be defined by a block,
+  #   and removed by this method afterwards.
+  #
+  # @return [void]
+  #
+  def temporary_constants(*names)
+    names.each do |name|
+      Object.remove_const name if Object.const_defined?(name)
+    end
+    yield
+  ensure
+    names.each do |name|
+      Object.remove_const name if Object.const_defined?(name)
+    end
+  end
+
+  #
+  # @param [String] name
+  #   The name of a variable.
+  #
+  # @param [String] value
+  #   Its value.
+  #
+  # @param [Binding] b
+  #   The binding object to insert a variable into.
+  #
+  # @return [void]
+  #
+  def insert_variable(name, value, b)
+    Pry.current[:pry_local] = value
+    b.eval("#{name} = ::Pry.current[:pry_local]")
+  ensure
+    Pry.current[:pry_local] = nil   
+  end
+end

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

@@ -0,0 +1,70 @@
+# good idea ???
+# if you're testing pry plugin you should require pry by yourself, no?
+require 'pry' if not defined?(Pry)
+
+module Pry::Testable
+  extend self
+  require_relative "testable/pry_tester"
+  require_relative "testable/evalable"
+  require_relative "testable/mockable"
+  require_relative "testable/variables"
+  require_relative "testable/utility"
+
+  #
+  # When {Pry::Testable} is included into another module or class,
+  # the following modules are also included: {Pry::Testable::Mockable},
+  # {Pry::Testable::Evalable}, {Pry::Testable::Variables}, and
+  # {Pry::Testable::Utility}.
+  #
+  # @note
+  #   Each of the included modules mentioned above may also be used
+  #   standalone or in a pick-and-mix fashion.
+  #
+  # @param [Module] mod
+  #   A class or module.
+  #
+  # @return [void]
+  #
+  def self.included(mod)
+    mod.module_eval do
+      include Pry::Testable::Mockable
+      include Pry::Testable::Evalable
+      include Pry::Testable::Variables
+      include Pry::Testable::Utility
+    end
+  end
+
+  TEST_DEFAULTS = {
+    color: false,
+    pager: false,
+    should_load_rc: false,
+    should_load_local_rc: false,
+    correct_indent: false,
+    collison_warning: false,
+    history: {
+      should_load: false,
+      should_save: false
+    }
+  }
+  private_constant :TEST_DEFAULTS
+
+  #
+  # Sets various configuration options that make Pry optimal for a test
+  # environment, see source code for complete details.
+  #
+  # @return [void]
+  #
+  def self.set_testenv_variables
+    Pry.config = Pry::Config.from_hash(TEST_DEFAULTS, Pry::Config::Default.new)
+    Pry.config.hooks = Pry::Hooks.new
+  end
+
+  #
+  # Reset the Pry configuration to their default values.
+  #
+  # @return [void]
+  #
+  def self.unset_testenv_variables
+    Pry.config = Pry::Config.from_hash({}, Pry::Config::Default.new)
+  end
+end

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

@@ -0,0 +1,3 @@
+class Pry
+  VERSION = "0.11.3"
+end

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

@@ -0,0 +1,131 @@
+require 'pry/helpers/documentation_helpers'
+
+class Pry
+  class WrappedModule
+
+    # This class represents a single candidate for a module/class definition.
+    # It provides access to the source, documentation, line and file
+    # for a monkeypatch (reopening) of a class/module.
+    class Candidate
+      include Pry::Helpers::DocumentationHelpers
+      include Pry::CodeObject::Helpers
+      extend Pry::Forwardable
+
+      # @return [String] The file where the module definition is located.
+      attr_reader :file
+      alias_method :source_file, :file
+
+      # @return [Fixnum] The line where the module definition is located.
+      attr_reader :line
+      alias_method :source_line, :line
+
+      # Methods to delegate to associated `Pry::WrappedModule
+      # instance`.
+      private_delegates = [:lines_for_file, :method_candidates, :yard_docs?, :name]
+      public_delegates = [:wrapped, :module?, :class?, :nonblank_name,
+                          :number_of_candidates]
+
+      def_delegators :@wrapper, *public_delegates
+      def_private_delegators :@wrapper, *private_delegates
+
+      # @raise [Pry::CommandError] If `rank` is out of bounds.
+      # @param [Pry::WrappedModule] wrapper The associated
+      #   `Pry::WrappedModule` instance that owns the candidates.
+      # @param [Fixnum] rank The rank of the candidate to
+      #   retrieve. Passing 0 returns 'primary candidate' (the candidate with largest
+      #   number of methods), passing 1 retrieves candidate with
+      #   second largest number of methods, and so on, up to
+      #   `Pry::WrappedModule#number_of_candidates() - 1`
+      def initialize(wrapper, rank)
+        @wrapper = wrapper
+
+        if number_of_candidates <= 0
+          raise CommandError, "Cannot find a definition for #{name} module!"
+        elsif rank > (number_of_candidates - 1)
+          raise CommandError, "No such module candidate. Allowed candidates range is from 0 to #{number_of_candidates - 1}"
+        end
+
+        @source = @source_location = nil
+        @rank = rank
+        @file, @line = source_location
+      end
+
+      # @raise [Pry::CommandError] If source code cannot be found.
+      # @return [String] The source for the candidate, i.e the
+      #   complete module/class definition.
+      def source
+        return nil if file.nil?
+        return @source if @source
+
+        @source ||= strip_leading_whitespace(Pry::Code.from_file(file).expression_at(line, number_of_lines_in_first_chunk))
+      end
+
+      # @raise [Pry::CommandError] If documentation cannot be found.
+      # @return [String] The documentation for the candidate.
+      def doc
+        return nil if file.nil?
+        @doc ||= get_comment_content(Pry::Code.from_file(file).comment_describing(line))
+      end
+
+      # @return [Array, nil] A `[String, Fixnum]` pair representing the
+      #   source location (file and line) for the candidate or `nil`
+      #   if no source location found.
+      def source_location
+        return @source_location if @source_location
+
+        file, line = first_method_source_location
+        return nil if !file.is_a?(String)
+
+        @source_location = [file,  first_line_of_module_definition(file, line)]
+      rescue Pry::RescuableException
+        nil
+      end
+
+      private
+
+      # Locate the first line of the module definition.
+      # @param [String] file The file that contains the module
+      #   definition (somewhere).
+      # @param [Fixnum] line The module definition should appear
+      #   before this line (if it exists).
+      # @return [Fixnum] The line where the module is defined. This
+      #   line number is one-indexed.
+      def first_line_of_module_definition(file, line)
+        searchable_lines = lines_for_file(file)[0..(line - 2)]
+        searchable_lines.rindex { |v| class_regexes.any? { |r| r =~ v } } + 1
+      end
+
+      def class_regexes
+        mod_type_string = wrapped.class.to_s.downcase
+        [/^\s*#{mod_type_string}\s+(?:(?:\w*)::)*?#{wrapped.name.split(/::/).last}/,
+         /^\s*(::)?#{wrapped.name.split(/::/).last}\s*?=\s*?#{wrapped.class}/,
+         /^\s*(::)?#{wrapped.name.split(/::/).last}\.(class|instance)_eval/]
+      end
+
+      # This method is used by `Candidate#source_location` as a
+      # starting point for the search for the candidate's definition.
+      # @return [Array] The source location of the base method used to
+      #   calculate the source location of the candidate.
+      def first_method_source_location
+        @first_method_source_location ||= method_candidates[@rank].first.source_location
+      end
+
+      # @return [Array] The source location of the last method in this
+      #   candidate's module definition.
+      def last_method_source_location
+        @end_method_source_location ||= method_candidates[@rank].last.source_location
+      end
+
+      # Return the number of lines between the start of the class definition
+      # and the start of the last method. We use this value so we can
+      # quickly grab these lines from the file (without having to
+      # check each intervening line for validity, which is expensive) speeding up source extraction.
+      # @return [Fixum] Number of lines.
+      def number_of_lines_in_first_chunk
+        end_method_line = last_method_source_location.last
+
+        end_method_line - line
+      end
+    end
+  end
+end