chess_engine 0.0.1

data/vendor/bundle/gems/pry-0.12.2/lib/pry/object_path.rb

@@ -0,0 +1,83 @@
+class Pry
+  # `ObjectPath` implements the resolution of "object paths", which are strings
+  # that are similar to filesystem paths but meant for traversing Ruby objects.
+  # Examples of valid object paths include:
+  #
+  #     x
+  #     @foo/@bar
+  #     "string"/upcase
+  #     Pry/Method
+  #
+  # Object paths are mostly relevant in the context of the `cd` command.
+  # @see https://github.com/pry/pry/wiki/State-navigation
+  class ObjectPath
+    SPECIAL_TERMS = ["", "::", ".", ".."]
+
+    # @param [String] path_string The object path expressed as a string.
+    # @param [Array<Binding>] current_stack The current state of the binding
+    #   stack.
+    def initialize(path_string, current_stack)
+      @path_string   = path_string
+      @current_stack = current_stack
+    end
+
+    # @return [Array<Binding>] a new stack resulting from applying the given
+    #   path to the current stack.
+    def resolve
+      scanner = StringScanner.new(@path_string.strip)
+      stack   = @current_stack.dup
+
+      begin
+        next_segment = ""
+
+        loop do
+          # Scan for as long as we don't see a slash
+          next_segment << scanner.scan(/[^\/]*/)
+
+          if complete?(next_segment) || scanner.eos?
+            scanner.getch # consume the slash
+            break
+          else
+            next_segment << scanner.getch # append the slash
+          end
+        end
+
+        case next_segment.chomp
+        when ""
+          stack = [stack.first]
+        when "::"
+          stack.push(TOPLEVEL_BINDING)
+        when "."
+          next
+        when ".."
+          stack.pop unless stack.size == 1
+        else
+          stack.push(Pry.binding_for(stack.last.eval(next_segment)))
+        end
+      rescue RescuableException => e
+        return handle_failure(next_segment, e)
+      end until scanner.eos?
+
+      stack
+    end
+
+    private
+
+    def complete?(segment)
+      SPECIAL_TERMS.include?(segment) || Pry::Code.complete_expression?(segment)
+    end
+
+    def handle_failure(context, err)
+      msg = [
+        "Bad object path: #{@path_string.inspect}",
+        "Failed trying to resolve: #{context.inspect}",
+        "Exception: #{err.inspect}"
+      ].join("\n")
+
+      command_error = CommandError.new(msg)
+      command_error.set_backtrace(err.backtrace)
+
+      raise command_error
+    end
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/output.rb

@@ -0,0 +1,50 @@
+class Pry::Output
+  attr_reader :_pry_
+
+  def initialize(_pry_)
+    @_pry_ = _pry_
+    @boxed_io = _pry_.config.output
+  end
+
+  def puts(*objs)
+    return print "\n" if objs.empty?
+
+    objs.each do |obj|
+      if (ary = Array.try_convert(obj))
+        puts(*ary)
+      else
+        print "#{obj.to_s.chomp}\n"
+      end
+    end
+    nil
+  end
+
+  def print(*objs)
+    objs.each do |obj|
+      @boxed_io.print decolorize_maybe(obj.to_s)
+    end
+    nil
+  end
+  alias << print
+  alias write print
+
+  def tty?
+    @boxed_io.respond_to?(:tty?) and @boxed_io.tty?
+  end
+
+  def method_missing(name, *args, &block)
+    @boxed_io.__send__(name, *args, &block)
+  end
+
+  def respond_to_missing?(m, include_all = false)
+    @boxed_io.respond_to?(m, include_all)
+  end
+
+  def decolorize_maybe(str)
+    if _pry_.config.color
+      str
+    else
+      Pry::Helpers::Text.strip_color str
+    end
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/pager.rb

@@ -0,0 +1,250 @@
+require 'pry/terminal'
+
+# A pager is an `IO`-like object that accepts text and either prints it
+# immediately, prints it one page at a time, or streams it to an external
+# program to print one page at a time.
+class Pry
+  class Pager
+    class StopPaging < StandardError
+    end
+
+    attr_reader :_pry_
+
+    def initialize(_pry_)
+      @_pry_ = _pry_
+    end
+
+    # Send the given text through the best available pager (if
+    # `Pry.config.pager` is enabled). If you want to send text through in
+    # chunks as you generate it, use `open` to get a writable object
+    # instead.
+    #
+    # @param [String] text
+    #   Text to run through a pager.
+    #
+    def page(text)
+      open do |pager|
+        pager << text
+      end
+    end
+
+    # Yields a pager object (`NullPager`, `SimplePager`, or `SystemPager`).
+    # All pagers accept output with `#puts`, `#print`, `#write`, and `#<<`.
+    def open
+      pager = best_available
+      yield pager
+    rescue StopPaging
+    ensure
+      pager.close if pager
+    end
+
+    private
+
+    def enabled?; !!@enabled; end
+
+    def output; @output; end
+
+    # Return an instance of the "best" available pager class --
+    # `SystemPager` if possible, `SimplePager` if `SystemPager` isn't
+    # available, and `NullPager` if the user has disabled paging. All
+    # pagers accept output with `#puts`, `#print`, `#write`, and `#<<`. You
+    # must call `#close` when you're done writing output to a pager, and
+    # you must rescue `Pry::Pager::StopPaging`. These requirements can be
+    # avoided by using `.open` instead.
+    def best_available
+      if !_pry_.config.pager
+        NullPager.new(_pry_.output)
+      elsif !SystemPager.available? || Helpers::Platform.jruby?
+        SimplePager.new(_pry_.output)
+      else
+        SystemPager.new(_pry_.output)
+      end
+    end
+
+    # `NullPager` is a "pager" that actually just prints all output as it
+    # comes in. Used when `Pry.config.pager` is false.
+    class NullPager
+      def initialize(out)
+        @out = out
+      end
+
+      def puts(str)
+        print "#{str.chomp}\n"
+      end
+
+      def print(str)
+        write str
+      end
+      alias << print
+
+      def write(str)
+        @out.write str
+      end
+
+      def close
+      end
+
+      private
+
+      def height
+        @height ||= Pry::Terminal.height!
+      end
+
+      def width
+        @width ||= Pry::Terminal.width!
+      end
+    end
+
+    # `SimplePager` is a straightforward pure-Ruby pager. We use it on
+    # JRuby and when we can't find a usable external pager.
+    class SimplePager < NullPager
+      def initialize(*)
+        super
+        @tracker = PageTracker.new(height - 3, width)
+      end
+
+      def write(str)
+        str.lines.each do |line|
+          @out.print line
+          @tracker.record line
+
+          if @tracker.page?
+            @out.print "\n"
+            @out.print "\e[0m"
+            @out.print "<page break> --- Press enter to continue " \
+                       "( q<enter> to break ) --- <page break>\n"
+            raise StopPaging if Readline.readline("").chomp == "q"
+
+            @tracker.reset
+          end
+        end
+      end
+    end
+
+    # `SystemPager` buffers output until we're pretty sure it's at least a
+    # page long, then invokes an external pager and starts streaming output
+    # to it. If `#close` is called before then, it just prints out the
+    # buffered content.
+    class SystemPager < NullPager
+      def self.default_pager
+        pager = ENV["PAGER"] || ""
+
+        # Default to less, and make sure less is being passed the correct
+        # options
+        if pager.strip.empty? or pager =~ /^less\b/
+          pager = "less -R -F -X"
+        end
+
+        pager
+      end
+
+      @system_pager = nil
+
+      def self.available?
+        if @system_pager.nil?
+          @system_pager = begin
+            pager_executable = default_pager.split(' ').first
+            if Helpers::Platform.windows? || Helpers::Platform.windows_ansi?
+              `where /Q #{pager_executable}`
+            else
+              `which #{pager_executable}`
+            end
+            $?.success?
+          rescue
+            false
+          end
+        else
+          @system_pager
+        end
+      end
+
+      def initialize(*)
+        super
+        @tracker = PageTracker.new(height, width)
+        @buffer  = ""
+        @pager   = nil
+      end
+
+      def write(str)
+        if invoked_pager?
+          write_to_pager str
+        else
+          @tracker.record str
+          @buffer << str
+
+          if @tracker.page?
+            write_to_pager @buffer
+          end
+        end
+      rescue Errno::EPIPE
+        raise StopPaging
+      end
+
+      def close
+        if invoked_pager?
+          pager.close
+        else
+          @out.puts @buffer
+        end
+      end
+
+      private
+
+      def write_to_pager(text)
+        pager.write @out.decolorize_maybe(text)
+      end
+
+      def invoked_pager?
+        @pager
+      end
+
+      def pager
+        @pager ||= IO.popen(self.class.default_pager, 'w')
+      end
+    end
+
+    # `PageTracker` tracks output to determine whether it's likely to take
+    # up a whole page. This doesn't need to be super precise, but we can
+    # use it for `SimplePager` and to avoid invoking the system pager
+    # unnecessarily.
+    #
+    # One simplifying assumption is that we don't need `#page?` to return
+    # `true` on the basis of an incomplete line. Long lines should be
+    # counted as multiple lines, but we don't have to transition from
+    # `false` to `true` until we see a newline.
+    class PageTracker
+      def initialize(rows, cols)
+        @rows, @cols = rows, cols
+        reset
+      end
+
+      def record(str)
+        str.lines.each do |line|
+          if line.end_with? "\n"
+            @row += ((@col + line_length(line) - 1) / @cols) + 1
+            @col  = 0
+          else
+            @col += line_length(line)
+          end
+        end
+      end
+
+      def page?
+        @row >= @rows
+      end
+
+      def reset
+        @row = 0
+        @col = 0
+      end
+
+      private
+
+      # Approximation of the printable length of a given line, without the
+      # newline and without ANSI color codes.
+      def line_length(line)
+        line.chomp.gsub(/\e\[[\d;]*m/, '').length
+      end
+    end
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/platform.rb

@@ -0,0 +1,91 @@
+class Pry
+  module Platform
+    extend self
+
+    #
+    # @return [Boolean]
+    #  Returns true if Pry is running on Mac OSX.
+    #
+    # @note
+    #   Queries RbConfig::CONFIG['host_os'] with a best guess.
+    #
+    def mac_osx?
+      !!(RbConfig::CONFIG['host_os'] =~ /\Adarwin/i)
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true if Pry is running on Linux.
+    #
+    # @note
+    #   Queries RbConfig::CONFIG['host_os'] with a best guess.
+    #
+    def linux?
+      !!(RbConfig::CONFIG['host_os'] =~ /linux/i)
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true if Pry is running on Windows.
+    #
+    # @note
+    #   Queries RbConfig::CONFIG['host_os'] with a best guess.
+    #
+    def windows?
+      !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/)
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true when Pry is running on Windows with ANSI support.
+    #
+    def windows_ansi?
+      return false if not windows?
+
+      !!(defined?(Win32::Console) or ENV['ANSICON'] or mri_2?)
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true when Pry is being run from JRuby.
+    #
+    def jruby?
+      RbConfig::CONFIG['ruby_install_name'] == 'jruby'
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true when Pry is being run from JRuby in 1.9 mode.
+    #
+    def jruby_19?
+      jruby? and RbConfig::CONFIG['ruby_version'] == '1.9'
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true when Pry is being run from MRI (CRuby).
+    #
+    def mri?
+      RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true when Pry is being run from MRI v1.9+ (CRuby).
+    #
+    def mri_19?
+      !!(mri? and RUBY_VERSION =~ /\A1\.9/)
+    end
+
+    #
+    # @return [Boolean]
+    #   Returns true when Pry is being run from MRI v2+ (CRuby).
+    #
+    def mri_2?
+      !!(mri? and RUBY_VERSION =~ /\A2/)
+    end
+  end
+
+  # Not supported on MRI 2.2 and lower.
+  deprecate_constant(:Platform) if respond_to?(:deprecate_constant)
+end