chess_engine 0.0.1

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

@@ -0,0 +1,122 @@
+class Pry
+  class PluginManager
+    PRY_PLUGIN_PREFIX = /^pry-/
+
+    # Placeholder when no associated gem found, displays warning
+    class NoPlugin
+      def initialize(name)
+        @name = name
+      end
+
+      def method_missing(*_args)
+        warn "Warning: The plugin '#{@name}' was not found! (no gem found)"
+      end
+    end
+
+    class Plugin
+      attr_accessor :name, :gem_name, :enabled, :spec, :active
+
+      def initialize(name, gem_name, spec, enabled)
+        @name, @gem_name, @enabled, @spec = name, gem_name, enabled, spec
+      end
+
+      # Disable a plugin. (prevents plugin from being loaded, cannot
+      # disable an already activated plugin)
+      def disable!
+        self.enabled = false
+      end
+
+      # Enable a plugin. (does not load it immediately but puts on
+      # 'white list' to be loaded)
+      def enable!
+        self.enabled = true
+      end
+
+      # Load the Command line options defined by this plugin (if they exist)
+      def load_cli_options
+        cli_options_file = File.join(spec.full_gem_path, "lib/#{spec.name}/cli.rb")
+        return unless File.exist?(cli_options_file)
+
+        cli_options_file = File.realpath(cli_options_file) if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.4.4")
+        require cli_options_file
+      end
+
+      # Activate the plugin (require the gem - enables/loads the
+      # plugin immediately at point of call, even if plugin is
+      # disabled)
+      # Does not reload plugin if it's already active.
+      def activate!
+        # Create the configuration object for the plugin.
+        Pry.config.send("#{gem_name.gsub('-', '_')}=", Pry::Config.from_hash({}))
+
+        begin
+          require gem_name if !active?
+        rescue LoadError => e
+          warn "Found plugin #{gem_name}, but could not require '#{gem_name}'"
+          warn e
+        rescue => e
+          warn "require '#{gem_name}' # Failed, saying: #{e}"
+        end
+
+        self.active = true
+        self.enabled = true
+      end
+
+      alias active? active
+      alias enabled? enabled
+
+      def supported?
+        pry_version = Gem::Version.new(VERSION)
+        spec.dependencies.each do |dependency|
+          if dependency.name == "pry"
+            return dependency.requirement.satisfied_by?(pry_version)
+          end
+        end
+        true
+      end
+    end
+
+    def initialize
+      @plugins = []
+    end
+
+    # Find all installed Pry plugins and store them in an internal array.
+    def locate_plugins
+      gem_list.each do |gem|
+        next if gem.name !~ PRY_PLUGIN_PREFIX
+
+        plugin_name = gem.name.split('-', 2).last
+        plugin = Plugin.new(plugin_name, gem.name, gem, false)
+        @plugins << plugin.tap(&:enable!) if plugin.supported? && !plugin_located?(plugin)
+      end
+      @plugins
+    end
+
+    # @return [Hash] A hash with all plugin names (minus the 'pry-') as
+    #   keys and Plugin objects as values.
+    def plugins
+      h = Hash.new { |_, key| NoPlugin.new(key) }
+      @plugins.each do |plugin|
+        h[plugin.name] = plugin
+      end
+      h
+    end
+
+    # Require all enabled plugins, disabled plugins are skipped.
+    def load_plugins
+      @plugins.each do |plugin|
+        plugin.activate! if plugin.enabled?
+      end
+    end
+
+    private
+    def plugin_located?(plugin)
+      @plugins.any? { |existing| existing.gem_name == plugin.gem_name }
+    end
+
+    def gem_list
+      Gem.refresh
+      Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+class Pry
+  # Prompt represents the Pry prompt, which can be used with Readline-like
+  # libraries. It defines a few default prompts (default prompt, simple prompt,
+  # etc) and also provides an API to add custom prompts.
+  #
+  # @example
+  #   Pry::Prompt.add(
+  #     :ipython,
+  #     'IPython-like prompt', [':', '...:']
+  #   ) do |_context, _nesting, _pry_, sep|
+  #     sep == ':' ? "In [#{_pry_.input_ring.count}]: " : '   ...: '
+  #   end
+  #
+  #   # Produces:
+  #   # In [3]: def foo
+  #   #    ...:   puts 'foo'
+  #   #    ...: end
+  #   # => :foo
+  #   # In [4]:
+  # @since v0.11.0
+  # @api public
+  module Prompt
+    # @return [String]
+    DEFAULT_NAME = 'pry'.freeze
+
+    # @return [Array<Object>] the list of objects that are known to have a
+    #   1-line #inspect output suitable for prompt
+    SAFE_CONTEXTS = [String, Numeric, Symbol, nil, true, false].freeze
+
+    # @deprecated Use {Pry::Prompt.add} instead.
+    MAP = {}
+    deprecate_constant(:MAP) if respond_to?(:deprecate_constant)
+
+    # A Hash that holds all prompts. The keys of the Hash are prompt
+    # names, the values are Hash instances of the format {:description, :value}.
+    @prompts = {}
+
+    class << self
+      # Retrieves a prompt.
+      #
+      # @example
+      #   Prompt[:my_prompt][:value]
+      #
+      # @param [Symbol] prompt_name The name of the prompt you want to access
+      # @return [Hash{Symbol=>Object}]
+      # @since v0.12.0
+      def [](prompt_name)
+        @prompts[prompt_name.to_s]
+      end
+
+      # @return [Hash{Symbol=>Hash}] the duplicate of the internal prompts hash
+      # @note Use this for read-only operations
+      # @since v0.12.0
+      def all
+        @prompts.dup
+      end
+
+      # Adds a new prompt to the prompt hash.
+      #
+      # @param [Symbol] prompt_name
+      # @param [String] description
+      # @param [Array<String>] separators The separators to differentiate
+      #   between prompt modes (default mode and class/method definition mode).
+      #   The Array *must* have a size of 2.
+      # @yield [context, nesting, _pry_, sep]
+      # @yieldparam context [Object] the context where Pry is currently in
+      # @yieldparam nesting [Integer] whether the context is nested
+      # @yieldparam _pry_ [Pry] the Pry instance
+      # @yieldparam separator [String] separator string
+      # @return [nil]
+      # @raise [ArgumentError] if the size of `separators` is not 2
+      # @since v0.12.0
+      def add(prompt_name, description = '', separators = %w[> *])
+        unless separators.size == 2
+          raise ArgumentError, "separators size must be 2, given #{separators.size}"
+        end
+
+        @prompts[prompt_name.to_s] = {
+          description: description,
+          value: separators.map do |sep|
+            proc { |context, nesting, _pry_| yield(context, nesting, _pry_, sep) }
+          end
+        }
+
+        nil
+      end
+
+      private
+
+      def prompt_name(name)
+        return name unless name.is_a?(Pry::Config::Lazy)
+
+        name.call
+      end
+    end
+
+    add(:default, <<DESC) do |context, nesting, _pry_, sep|
+The default Pry prompt. Includes information about the current expression
+number, evaluation context, and nesting level, plus a reminder that you're
+using Pry.
+DESC
+      format(
+        "[%<in_count>s] %<name>s(%<context>s)%<nesting>s%<separator>s ",
+        in_count: _pry_.input_ring.count,
+        name: prompt_name(_pry_.config.prompt_name),
+        context: Pry.view_clip(context),
+        nesting: (nesting > 0 ? ":#{nesting}" : ''),
+        separator: sep
+      )
+    end
+
+    add(:simple, "A simple `>>`.\n", ['>> ', ' | ']) do |_, _, _, sep|
+      sep
+    end
+
+    add(:nav, <<DESC, %w[> *]) do |context, nesting, _pry_, sep|
+A prompt that displays the binding stack as a path and includes information
+about #{Helpers::Text.bold('_in_')} and #{Helpers::Text.bold('_out_')}.
+DESC
+      tree = _pry_.binding_stack.map { |b| Pry.view_clip(b.eval('self')) }
+      format(
+        "[%<in_count>s] (%<name>s) %<tree>s: %<stack_size>s%<separator>s ",
+        in_count: _pry_.input_ring.count,
+        name: prompt_name(_pry_.config.prompt_name),
+        tree: tree.join(' / '),
+        stack_size: _pry_.binding_stack.size - 1,
+        separator: sep
+      )
+    end
+
+    add(:shell, <<DESC, %w[$ *]) do |context, nesting, _pry_, sep|
+A prompt that displays `$PWD` as you change it.
+DESC
+      format(
+        "%<name>s %<context>s:%<pwd>s %<separator>s ",
+        name: prompt_name(_pry_.config.prompt_name),
+        context: Pry.view_clip(context),
+        pwd: Dir.pwd,
+        separator: sep
+      )
+    end
+
+    add(:none, 'Wave goodbye to the Pry prompt.', Array.new(2)) { '' }
+  end
+end

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

@@ -0,0 +1,425 @@
+class Pry
+  HOME_RC_FILE =
+    if ENV.key?('PRYRC')
+      ENV['PRYRC']
+    elsif File.exist?(File.expand_path('~/.pryrc'))
+      '~/.pryrc'
+    elsif ENV.key?('XDG_CONFIG_HOME') && ENV['XDG_CONFIG_HOME'] != ''
+      # See XDG Base Directory Specification at
+      # https://standards.freedesktop.org/basedir-spec/basedir-spec-0.8.html
+      ENV['XDG_CONFIG_HOME'] + '/pry/pryrc'
+    else
+      '~/.config/pry/pryrc'
+    end
+  LOCAL_RC_FILE = "./.pryrc"
+
+  class << self
+    extend Pry::Forwardable
+    attr_accessor :custom_completions
+    attr_accessor :current_line
+    attr_accessor :line_buffer
+    attr_accessor :eval_path
+    attr_accessor :cli
+    attr_accessor :quiet
+    attr_accessor :last_internal_error
+    attr_accessor :config
+    attr_writer :history
+
+    def_delegators :@plugin_manager, :plugins, :load_plugins, :locate_plugins
+
+    extend Pry::Config::Convenience
+    config_shortcut(*Pry::Config.shortcuts)
+
+    def prompt=(value)
+      config.prompt = value
+    end
+
+    def prompt
+      config.prompt
+    end
+
+    def history
+      @history ||= History.new
+    end
+
+    #
+    # @example
+    #  Pry.configure do |config|
+    #     config.eager_load! # optional
+    #     config.input =     # ..
+    #     config.foo = 2
+    #  end
+    #
+    # @yield [config]
+    #   Yields a block with {Pry.config} as its argument.
+    #
+    def configure
+      yield config
+    end
+  end
+
+  #
+  # @return [main]
+  #   returns the special instance of Object, "main".
+  #
+  def self.main
+    @main ||= TOPLEVEL_BINDING.eval "self"
+  end
+
+  #
+  # @return [Pry::Config]
+  #  Returns a value store for an instance of Pry running on the current thread.
+  #
+  def self.current
+    Thread.current[:__pry__] ||= Pry::Config.from_hash({}, nil)
+  end
+
+  # Load the given file in the context of `Pry.toplevel_binding`
+  # @param [String] file The unexpanded file path.
+  def self.load_file_at_toplevel(file)
+    toplevel_binding.eval(File.read(file), file)
+  rescue RescuableException => e
+    puts "Error loading #{file}: #{e}\n#{e.backtrace.first}"
+  end
+
+  # Load HOME_RC_FILE and LOCAL_RC_FILE if appropriate
+  # This method can also be used to reload the files if they have changed.
+  def self.load_rc_files
+    rc_files_to_load.each do |file|
+      critical_section do
+        load_file_at_toplevel(file)
+      end
+    end
+  end
+
+  # Load the local RC file (./.pryrc)
+  def self.rc_files_to_load
+    files = []
+    files << HOME_RC_FILE if Pry.config.should_load_rc
+    files << LOCAL_RC_FILE if Pry.config.should_load_local_rc
+    files.map { |file| real_path_to(file) }.compact.uniq
+  end
+
+  # Expand a file to its canonical name (following symlinks as appropriate)
+  def self.real_path_to(file)
+    Pathname.new(File.expand_path(file)).realpath.to_s
+  rescue Errno::ENOENT, Errno::EACCES
+    nil
+  end
+
+  # Load any Ruby files specified with the -r flag on the command line.
+  def self.load_requires
+    Pry.config.requires.each do |file|
+      require file
+    end
+  end
+
+  # Trap interrupts on jruby, and make them behave like MRI so we can
+  # catch them.
+  def self.load_traps
+    trap('INT') { raise Interrupt }
+  end
+
+  def self.load_win32console
+    begin
+      require 'win32console'
+      # The mswin and mingw versions of pry require win32console, so this should
+      # only fail on jruby (where win32console doesn't work).
+      # Instead we'll recommend ansicon, which does.
+    rescue LoadError
+      warn <<-WARNING if Pry.config.windows_console_warning
+For a better Pry experience on Windows, please use ansicon:
+  https://github.com/adoxa/ansicon
+If you use an alternative to ansicon and don't want to see this warning again,
+you can add "Pry.config.windows_console_warning = false" to your pryrc.
+      WARNING
+    end
+  end
+
+  # Do basic setup for initial session including: loading pryrc, plugins,
+  # requires, and history.
+  def self.initial_session_setup
+    return unless initial_session?
+
+    @initial_session = false
+
+    # note these have to be loaded here rather than in pry_instance as
+    # we only want them loaded once per entire Pry lifetime.
+    load_rc_files
+  end
+
+  def self.final_session_setup
+    return if @session_finalized
+
+    @session_finalized = true
+    load_plugins if Pry.config.should_load_plugins
+    load_requires if Pry.config.should_load_requires
+    load_history if Pry.config.history.should_load
+    load_traps if Pry.config.should_trap_interrupts
+    load_win32console if Helpers::Platform.windows? && !Helpers::Platform.windows_ansi?
+  end
+
+  # Start a Pry REPL.
+  # This method also loads `pryrc` as necessary the first time it is invoked.
+  # @param [Object, Binding] target The receiver of the Pry session
+  # @param [Hash] options
+  # @option options (see Pry#initialize)
+  # @example
+  #   Pry.start(Object.new, :input => MyInput.new)
+  def self.start(target = nil, options = {})
+    return if ENV['DISABLE_PRY']
+    if ENV['FAIL_PRY']
+      raise 'You have FAIL_PRY set to true, which results in Pry calls failing'
+    end
+
+    options = options.to_hash
+
+    if in_critical_section?
+      output.puts "ERROR: Pry started inside Pry."
+      output.puts "This can happen if you have a binding.pry inside a #to_s or #inspect function."
+      return
+    end
+
+    options[:target] = Pry.binding_for(target || toplevel_binding)
+    initial_session_setup
+    final_session_setup
+
+    # Unless we were given a backtrace, save the current one
+    if options[:backtrace].nil?
+      options[:backtrace] = caller
+
+      # If Pry was started via `binding.pry`, elide that from the backtrace
+      if options[:backtrace].first =~ /pry.*core_extensions.*pry/
+        options[:backtrace].shift
+      end
+    end
+
+    driver = options[:driver] || Pry::REPL
+
+    # Enter the matrix
+    driver.start(options)
+  rescue Pry::TooSafeException
+    puts "ERROR: Pry cannot work with $SAFE > 0"
+    raise
+  end
+
+  # Execute the file through the REPL loop, non-interactively.
+  # @param [String] file_name File name to load through the REPL.
+  def self.load_file_through_repl(file_name)
+    require "pry/repl_file_loader"
+    REPLFileLoader.new(file_name).load
+  end
+
+  #
+  # An inspector that clips the output to `max_length` chars.
+  # In case of > `max_length` chars the `#<Object...> notation is used.
+  #
+  # @param [Object] obj
+  #   The object to view.
+  #
+  # @param [Hash] options
+  # @option options [Integer] :max_length (60)
+  #   The maximum number of chars before clipping occurs.
+  #
+  # @option options [Boolean] :id (false)
+  #   Boolean to indicate whether or not a hex reprsentation of the object ID
+  #   is attached to the return value when the length of inspect is greater than
+  #   value of `:max_length`.
+  #
+  # @return [String]
+  #   The string representation of `obj`.
+  #
+  def self.view_clip(obj, options = {})
+    max = options.fetch :max_length, 60
+    id = options.fetch :id, false
+    if obj.kind_of?(Module) && obj.name.to_s != "" && obj.name.to_s.length <= max
+      obj.name.to_s
+    elsif Pry.main == obj
+      # special-case to support jruby.
+      # fixed as of https://github.com/jruby/jruby/commit/d365ebd309cf9df3dde28f5eb36ea97056e0c039
+      # we can drop in the future.
+      obj.to_s
+    elsif Pry.config.prompt_safe_contexts.any? { |v| v === obj } && obj.inspect.length <= max
+      obj.inspect
+    else
+      id == true ? "#<#{obj.class}:0x%x>" % (obj.object_id << 1) : "#<#{obj.class}>"
+    end
+  rescue RescuableException
+    "unknown"
+  end
+
+  # Load Readline history if required.
+  def self.load_history
+    Pry.history.load
+  end
+
+  # @return [Boolean] Whether this is the first time a Pry session has
+  #   been started since loading the Pry class.
+  def self.initial_session?
+    @initial_session
+  end
+
+  # Run a Pry command from outside a session. The commands available are
+  # those referenced by `Pry.config.commands` (the default command set).
+  # @param [String] command_string The Pry command (including arguments,
+  #   if any).
+  # @param [Hash] options Optional named parameters.
+  # @return [nil]
+  # @option options [Object, Binding] :target The object to run the
+  #   command under. Defaults to `TOPLEVEL_BINDING` (main).
+  # @option options [Boolean] :show_output Whether to show command
+  #   output. Defaults to true.
+  # @example Run at top-level with no output.
+  #   Pry.run_command "ls"
+  # @example Run under Pry class, returning only public methods.
+  #   Pry.run_command "ls -m", :target => Pry
+  # @example Display command output.
+  #   Pry.run_command "ls -av", :show_output => true
+  def self.run_command(command_string, options = {})
+    options = {
+      target: TOPLEVEL_BINDING,
+      show_output: true,
+      output: Pry.config.output,
+      commands: Pry.config.commands
+    }.merge!(options)
+
+    # :context for compatibility with <= 0.9.11.4
+    target = options[:context] || options[:target]
+    output = options[:show_output] ? options[:output] : StringIO.new
+
+    pry = Pry.new(output: output, target: target, commands: options[:commands])
+    pry.eval command_string
+    nil
+  end
+
+  def self.default_editor_for_platform
+    return ENV['VISUAL'] if ENV['VISUAL'] and not ENV['VISUAL'].empty?
+    return ENV['EDITOR'] if ENV['EDITOR'] and not ENV['EDITOR'].empty?
+    return 'notepad' if Helpers::Platform.windows?
+
+    %w(editor nano vi).detect do |editor|
+      system("which #{editor} > /dev/null 2>&1")
+    end
+  end
+
+  def self.auto_resize!
+    Pry.config.input # by default, load Readline
+
+    if !defined?(Readline) || Pry.config.input != Readline
+      warn "Sorry, you must be using Readline for Pry.auto_resize! to work."
+      return
+    end
+
+    if Readline::VERSION =~ /edit/i
+      warn <<-EOT
+Readline version #{Readline::VERSION} detected - will not auto_resize! correctly.
+  For the fix, use GNU Readline instead:
+  https://github.com/guard/guard/wiki/Add-proper-Readline-support-to-Ruby-on-Mac-OS-X
+      EOT
+      return
+    end
+
+    trap :WINCH do
+      begin
+        Readline.set_screen_size(*Terminal.size!)
+      rescue => e
+        warn "\nPry.auto_resize!'s Readline.set_screen_size failed: #{e}"
+      end
+      begin
+        Readline.refresh_line
+      rescue => e
+        warn "\nPry.auto_resize!'s Readline.refresh_line failed: #{e}"
+      end
+    end
+  end
+
+  # Set all the configurable options back to their default values
+  def self.reset_defaults
+    @initial_session = true
+    @session_finalized = nil
+
+    self.config = Pry::Config.new Pry::Config::Default.new
+    self.cli = false
+    self.current_line = 1
+    self.line_buffer = [""]
+    self.eval_path = "(pry)"
+  end
+
+  # Basic initialization.
+  def self.init
+    @plugin_manager ||= PluginManager.new
+    reset_defaults
+    locate_plugins
+  end
+
+  # Return a `Binding` object for `target` or return `target` if it is
+  # already a `Binding`.
+  # In the case where `target` is top-level then return `TOPLEVEL_BINDING`
+  # @param [Object] target The object to get a `Binding` object for.
+  # @return [Binding] The `Binding` object.
+  def self.binding_for(target)
+    if Binding === target
+      target
+    else
+      if Pry.main == target
+        TOPLEVEL_BINDING
+      else
+        target.__binding__
+      end
+    end
+  end
+
+  def self.toplevel_binding
+    unless defined?(@toplevel_binding) && @toplevel_binding
+      # Grab a copy of the TOPLEVEL_BINDING without any local variables.
+      # This binding has a default definee of Object, and new methods are
+      # private (just as in TOPLEVEL_BINDING).
+      TOPLEVEL_BINDING.eval <<-RUBY
+        def self.__pry__
+          binding
+        end
+        Pry.toplevel_binding = __pry__
+        class << self; undef __pry__; end
+      RUBY
+    end
+    @toplevel_binding.eval('private')
+    @toplevel_binding
+  end
+
+  def self.toplevel_binding=(binding)
+    @toplevel_binding = binding
+  end
+
+  def self.in_critical_section?
+    Thread.current[:pry_critical_section] ||= 0
+    Thread.current[:pry_critical_section] > 0
+  end
+
+  def self.critical_section
+    Thread.current[:pry_critical_section] ||= 0
+    Thread.current[:pry_critical_section] += 1
+    yield
+  ensure
+    Thread.current[:pry_critical_section] -= 1
+  end
+
+  # Wraps a block in a named block called `Pry::Config::Lazy`. This is used for
+  # dynamic config values, which are calculated every time
+  # {Pry::Config::Lazy#call} is called.
+  #
+  # @example
+  #   # pryrc
+  #   Pry.config.prompt_name = Pry.lazy { rand(100) }
+  #
+  #   # Session
+  #   [1] 96(main)>
+  #   [2] 19(main)>
+  #   [3] 80(main)>
+  #
+  # @return [#call]
+  def self.lazy(&block)
+    Pry::Config::Lazy.new(&block)
+  end
+end
+
+Pry.init