chess_engine 0.0.1

data/vendor/bundle/gems/pry-0.12.2/lib/pry/commands/clear_screen.rb

@@ -0,0 +1,14 @@
+class Pry::Command::ClearScreen < Pry::ClassCommand
+  match 'clear-screen'
+  group 'Input and Output'
+  description 'Clear the contents of the screen/window Pry is running in.'
+
+  def process
+    if Helpers::Platform.windows?
+      _pry_.config.system.call(_pry_.output, 'cls', _pry_)
+    else
+      _pry_.config.system.call(_pry_.output, 'clear', _pry_)
+    end
+  end
+  Pry::Commands.add_command(self)
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/commands/code_collector.rb

@@ -0,0 +1,167 @@
+class Pry
+  class Command::CodeCollector
+    include Helpers::CommandHelpers
+
+    attr_reader :args
+    attr_reader :opts
+    attr_reader :_pry_
+
+    # The name of the explicitly given file (if any).
+    attr_accessor :file
+
+    class << self
+      attr_accessor :input_expression_ranges
+      attr_accessor :output_result_ranges
+    end
+
+    @input_expression_ranges = []
+    @output_result_ranges = []
+
+    def initialize(args, opts, _pry_)
+      @args = args
+      @opts = opts
+      @_pry_ = _pry_
+    end
+
+    # Add the `--lines`, `-o`, `-i`, `-s`, `-d` options.
+    def self.inject_options(opt)
+      @input_expression_ranges = []
+      @output_result_ranges = []
+
+      opt.on :l, :lines, "Restrict to a subset of lines. Takes a line number or range",
+                         optional_argument: true, as: Range, default: 1..-1
+      opt.on :o, :out,   "Select lines from Pry's output result history. Takes an index or range",
+      optional_argument: true, as: Range, default: -5..-1 do |r|
+        output_result_ranges << (r || (-5..-1))
+      end
+      opt.on :i, :in,    "Select lines from Pry's input expression history. Takes an index or range",
+      optional_argument: true, as: Range, default: -5..-1 do |r|
+        input_expression_ranges << (r || (-5..-1))
+      end
+      opt.on :s, :super, "Select the 'super' method. Can be repeated to traverse the ancestors",
+                         as: :count
+      opt.on :d, :doc,   "Select lines from the code object's documentation"
+    end
+
+    # The content (i.e code/docs) for the selected object.
+    # If the user provided a bare code object, it returns the source.
+    # If the user provided the `-i` or `-o` switches, it returns the
+    # selected input/output lines joined as a string. If the user used
+    # `-d CODE_OBJECT` it returns the docs for that code object.
+    #
+    # @return [String]
+    def content
+      @content ||=
+        begin
+          raise CommandError, "Only one of --out, --in, --doc and CODE_OBJECT may be specified." if bad_option_combination?
+
+          content = case
+                    when opts.present?(:o)
+                      pry_output_content
+                    when opts.present?(:i)
+                      pry_input_content
+                    when opts.present?(:d)
+                      code_object_doc
+                    else
+                      code_object_source_or_file
+                    end
+
+          restrict_to_lines(content, line_range)
+        end
+    end
+
+    # The code object
+    #
+    # @return [Pry::WrappedModule, Pry::Method, Pry::Command]
+    def code_object
+      Pry::CodeObject.lookup(obj_name, _pry_, super: opts[:super])
+    end
+
+    # Given a string and a range, return the `range` lines of that
+    # string.
+    #
+    # @param [String] content
+    # @param [Range, Fixnum] range
+    # @return [String] The string restricted to the given range
+    def restrict_to_lines(content, range)
+      Array(content.lines.to_a[range]).join
+    end
+
+    # The selected `_pry_.output_ring` as a string, as specified by
+    # the `-o` switch.
+    #
+    # @return [String]
+    def pry_output_content
+      pry_array_content_as_string(_pry_.output_ring, self.class.output_result_ranges) do |v|
+        _pry_.config.gist.inspecter.call(v)
+      end
+    end
+
+    # The selected `_pry_.input_ring` as a string, as specified by
+    # the `-i` switch.
+    #
+    # @return [String]
+    def pry_input_content
+      pry_array_content_as_string(_pry_.input_ring, self.class.input_expression_ranges) { |v| v }
+    end
+
+    # The line range passed to `--lines`, converted to a 0-indexed range.
+    def line_range
+      opts.present?(:lines) ? one_index_range_or_number(opts[:lines]) : 0..-1
+    end
+
+    # Name of the object argument
+    def obj_name
+      @obj_name ||= args.empty? ? "" : args.join(" ")
+    end
+
+    private
+
+    def bad_option_combination?
+      [opts.present?(:in), opts.present?(:out),
+       !args.empty?].count(true) > 1
+    end
+
+    def pry_array_content_as_string(array, ranges, &block)
+      all = ''
+      ranges.each do |range|
+        raise CommandError, "Minimum value for range is 1, not 0." if convert_to_range(range).first == 0
+
+        ranged_array = Array(array[range]) || []
+        ranged_array.compact.each { |v| all << block.call(v) }
+      end
+
+      all
+    end
+
+    def code_object_doc
+      (code_object && code_object.doc) or could_not_locate(obj_name)
+    end
+
+    def code_object_source_or_file
+      (code_object && code_object.source) || file_content
+    end
+
+    def file_content
+      if File.exist?(obj_name)
+        # Set the file accessor.
+        self.file = obj_name
+        File.read(obj_name)
+      else
+        could_not_locate(obj_name)
+      end
+    end
+
+    def could_not_locate(name)
+      raise CommandError, "Cannot locate: #{name}!"
+    end
+
+    def convert_to_range(n)
+      if !n.is_a?(Range)
+        (n..n)
+      else
+        n
+      end
+    end
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/commands/disable_pry.rb

@@ -0,0 +1,27 @@
+class Pry
+  class Command::DisablePry < Pry::ClassCommand
+    match 'disable-pry'
+    group 'Navigating Pry'
+    description 'Stops all future calls to pry and exits the current session.'
+
+    banner <<-'BANNER'
+      Usage: disable-pry
+
+      After this command is run any further calls to pry will immediately return `nil`
+      without interrupting the flow of your program. This is particularly useful when
+      you've debugged the problem you were having, and now wish the program to run to
+      the end.
+
+      As alternatives, consider using `exit!` to force the current Ruby process
+      to quit immediately; or using `edit-method -p` to remove the `binding.pry`
+      from the code.
+    BANNER
+
+    def process
+      ENV['DISABLE_PRY'] = 'true'
+      _pry_.run_command "exit"
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::DisablePry)
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/commands/disabled_commands.rb

@@ -0,0 +1,2 @@
+Pry::Commands.disabled_command("edit-method", "Use `edit` instead.")
+Pry::Commands.disabled_command("show-command", "Use show-source [command_name] instead.")

data/vendor/bundle/gems/pry-0.12.2/lib/pry/commands/easter_eggs.rb

@@ -0,0 +1,112 @@
+class Pry
+  Pry::Commands.instance_eval do
+    command "nyan-cat", "", requires_gem: ["nyancat"] do
+      run ".nyancat"
+    end
+
+    command(/!s\/(.*?)\/(.*?)/, "") do |source, dest|
+      eval_string.gsub!(/#{source}/) { dest }
+      run "show-input"
+    end
+
+    command "get-naked", "" do
+      txt = %{
+  --
+  We dont have to take our clothes off to have a good time.
+  We could dance & party all night And drink some cherry wine.
+  -- Jermaine Stewart }
+      output.puts txt
+      txt
+    end
+
+    command "east-coker", "" do
+      txt = %{
+  --
+  Now the light falls
+  Across the open field, leaving the deep lane
+  Shuttered with branches, dark in the afternoon,
+  Where you lean against a bank while a van passes,
+  And the deep lane insists on the direction
+  Into the village, in the electric heat
+  Hypnotised. In a warm haze the sultry light
+  Is absorbed, not refracted, by grey stone.
+  The dahlias sleep in the empty silence.
+  Wait for the early owl.
+                -- T.S Eliot
+          }
+      output.puts txt
+      txt
+    end
+
+    command "cohen-poem", "" do
+      txt = %{
+  --
+  When this American woman,
+  whose thighs are bound in casual red cloth,
+  comes thundering past my sitting place
+  like a forest-burning Mongol tribe,
+  the city is ravished
+  and brittle buildings of a hundred years
+  splash into the street;
+  and my eyes are burnt
+  for the embroidered Chinese girls,
+  already old,
+  and so small between the thin pines
+  on these enormous landscapes,
+  that if you turn your head
+  they are lost for hours.
+                -- Leonard Cohen
+              }
+      output.puts txt
+      txt
+    end
+
+    command "pessoa-poem", "" do
+      output.puts <<-TEXT
+  --
+  I've gone to bed with every feeling,
+  I've been the pimp of every emotion,
+  All felt sensations have bought me drinks,
+  I've traded glances with every motive for every act,
+  I've held hands with every urge to depart,
+  ..
+  Rage, foam, the vastness that doesn't fit in my handkerchief,
+  The dog in heat howling in the night,
+  The pond from the farm going in circles around my insomnia,
+  The woods as they were, on our late-afternoon walks, the rose,
+  The indifferent tuft of hair, the moss, the pines,
+  The rage of not containing all this, not retaining all this,
+  O abstract hunger for things, impotent libido for moments,
+  Intellectual orgy of feeling life!
+                -- Fernando Pessoa
+TEXT
+    end
+
+    command "test-ansi", "" do
+      prev_color = _pry_.config.color
+      _pry_.config.color = true
+
+      picture = unindent <<-'EOS'.gsub(/[[:alpha:]!]/) { |s| red(s) }
+         ____      _______________________
+        /    \    |  A         W     G    |
+       / O  O \   |   N    I    O   N !   |
+      |        |  |    S    S    R I   !  |
+       \ \__/ / __|     I         K     ! |
+        \____/   \________________________|
+      EOS
+
+      if Helpers::Platform.windows_ansi?
+        move_up = proc { |n| "\e[#{n}F" }
+      else
+        move_up = proc { |n| "\e[#{n}A\e[0G" }
+      end
+
+      output.puts "\n" * 6
+      output.puts picture.lines.map(&:chomp).reverse.join(move_up[1])
+      output.puts "\n" * 6
+      output.puts "** ENV['TERM'] is #{ENV['TERM']} **\n\n"
+
+      _pry_.config.color = prev_color
+    end
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/commands/edit/exception_patcher.rb

@@ -0,0 +1,25 @@
+class Pry
+  class Command::Edit
+    class ExceptionPatcher
+      attr_accessor :_pry_
+      attr_accessor :state
+      attr_accessor :file_and_line
+
+      def initialize(_pry_, state, exception_file_and_line)
+        @_pry_ = _pry_
+        @state = state
+        @file_and_line = exception_file_and_line
+      end
+
+      # perform the patch
+      def perform_patch
+        file_name, _ = file_and_line
+        lines = state.dynamical_ex_file || File.read(file_name)
+
+        source = Pry::Editor.new(_pry_).edit_tempfile_with_content(lines)
+        _pry_.evaluate_ruby source
+        state.dynamical_ex_file = source.split("\n")
+      end
+    end
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/commands/edit/file_and_line_locator.rb

@@ -0,0 +1,36 @@
+class Pry
+  class Command::Edit
+    module FileAndLineLocator
+      class << self
+        def from_binding(target)
+          [target.eval("__FILE__"), target.eval("__LINE__")]
+        end
+
+        def from_code_object(code_object, filename_argument)
+          if File.exist?(code_object.source_file.to_s)
+            [code_object.source_file, code_object.source_line]
+          else
+            raise CommandError, "Cannot find a file for #{filename_argument}!"
+          end
+        end
+
+        def from_exception(exception, backtrace_level)
+          raise CommandError, "No exception found." if exception.nil?
+
+          file_name, line = exception.bt_source_location_for(backtrace_level)
+          raise CommandError, "Exception has no associated file." if file_name.nil?
+          raise CommandError, "Cannot edit exceptions raised in REPL." if Pry.eval_path == file_name
+
+          [file_name, line]
+        end
+
+        # when file and line are passed as a single arg, e.g my_file.rb:30
+        def from_filename_argument(filename_argument)
+          f = File.expand_path(filename_argument)
+          l = f.sub!(/:(\d+)$/, "") ? $1.to_i : 1
+          [f, l]
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/commands/edit.rb

@@ -0,0 +1,200 @@
+class Pry
+  class Command::Edit < Pry::ClassCommand
+    require 'pry/commands/edit/exception_patcher'
+    require 'pry/commands/edit/file_and_line_locator'
+
+    match 'edit'
+    group 'Editing'
+    description 'Invoke the default editor on a file.'
+
+    banner <<-'BANNER'
+      Usage: edit [--no-reload|--reload|--patch] [--line LINE] [--temp|--ex|FILE[:LINE]|OBJECT|--in N]
+
+      Open a text editor. When no FILE is given, edits the pry input buffer.
+      When a method/module/command is given, the code is opened in an editor.
+      Ensure `Pry.config.editor` or `_pry_.config.editor` is set to your editor of choice.
+
+      edit sample.rb                edit -p MyClass#my_method
+      edit sample.rb --line 105     edit MyClass
+      edit MyClass#my_method        edit --ex
+      edit --method                 edit --ex -p
+
+      https://github.com/pry/pry/wiki/Editor-integration#wiki-Edit_command
+    BANNER
+
+    def options(opt)
+      opt.on :e, :ex,      "Open the file that raised the most recent exception (_ex_.file)",
+                           optional_argument: true, as: Integer
+      opt.on :i, :in,      "Open a temporary file containing the Nth input expression. N may be a range",
+                           optional_argument: true, as: Range, default: -1..-1
+      opt.on :t, :temp,    "Open an empty temporary file"
+      opt.on :l, :line,    "Jump to this line in the opened file",
+                           argument: true, as: Integer
+      opt.on :n, :"no-reload", "Don't automatically reload the edited file"
+      opt.on :c, :current, "Open the current __FILE__ and at __LINE__ (as returned by `whereami`)"
+      opt.on :r, :reload,  "Reload the edited code immediately (default for ruby files)"
+      opt.on :p, :patch,   "Instead of editing the object's file, try to edit in a tempfile and apply as a monkey patch"
+      opt.on :m, :method,  "Explicitly edit the _current_ method (when inside a method context)."
+    end
+
+    def process
+      if bad_option_combination?
+        raise CommandError, "Only one of --ex, --temp, --in, --method and FILE may be specified."
+      end
+
+      if repl_edit?
+        # code defined in pry, eval'd within pry.
+        repl_edit
+      elsif runtime_patch?
+        # patch code without persisting changes, implies future changes are patches
+        apply_runtime_patch
+      else
+        # code stored in actual files, eval'd at top-level
+        file_edit
+      end
+    end
+
+    def repl_edit?
+      !opts.present?(:ex) && !opts.present?(:current) && !opts.present?(:method) &&
+        filename_argument.empty?
+    end
+
+    def repl_edit
+      content = Pry::Editor.new(_pry_).edit_tempfile_with_content(initial_temp_file_content,
+                                                       initial_temp_file_content.lines.count)
+      silence_warnings do
+        eval_string.replace content
+      end
+      Pry.history.push(content)
+    end
+
+    def file_based_exception?
+      opts.present?(:ex) && !opts.present?(:patch)
+    end
+
+    def runtime_patch?
+       !file_based_exception? && (opts.present?(:patch) || previously_patched?(code_object) || pry_method?(code_object))
+    end
+
+    def apply_runtime_patch
+      if patch_exception?
+        ExceptionPatcher.new(_pry_, state, file_and_line_for_current_exception).perform_patch
+      else
+        if code_object.is_a?(Pry::Method)
+          code_object.redefine Pry::Editor.new(_pry_).edit_tempfile_with_content(code_object.source)
+        else
+          raise NotImplementedError, "Cannot yet patch #{code_object} objects!"
+        end
+      end
+    end
+
+    def ensure_file_name_is_valid(file_name)
+      raise CommandError, "Cannot find a valid file for #{filename_argument}" if !file_name
+      raise CommandError, "#{file_name} is not a valid file name, cannot edit!" if not_a_real_file?(file_name)
+    end
+
+    def file_and_line_for_current_exception
+      FileAndLineLocator.from_exception(_pry_.last_exception, opts[:ex].to_i)
+    end
+
+    def file_and_line
+      file_name, line = if opts.present?(:current)
+                          FileAndLineLocator.from_binding(target)
+                        elsif opts.present?(:ex)
+                          file_and_line_for_current_exception
+                        elsif code_object
+                          FileAndLineLocator.from_code_object(code_object, filename_argument)
+                        else
+                          # when file and line are passed as a single arg, e.g my_file.rb:30
+                          FileAndLineLocator.from_filename_argument(filename_argument)
+                        end
+
+      [file_name, opts.present?(:line) ? opts[:l].to_i : line]
+    end
+
+    def file_edit
+      file_name, line = file_and_line
+
+      ensure_file_name_is_valid(file_name)
+
+      Pry::Editor.new(_pry_).invoke_editor(file_name, line, reload?(file_name))
+      set_file_and_dir_locals(file_name)
+
+      if reload?(file_name)
+        silence_warnings do
+          load file_name
+        end
+      end
+    end
+
+    def filename_argument
+      args.join(' ')
+    end
+
+    def code_object
+      @code_object ||= !probably_a_file?(filename_argument) &&
+        Pry::CodeObject.lookup(filename_argument, _pry_)
+    end
+
+    def pry_method?(code_object)
+      code_object.is_a?(Pry::Method) &&
+        code_object.pry_method?
+    end
+
+    def previously_patched?(code_object)
+      code_object.is_a?(Pry::Method) && Pry::Method::Patcher.code_for(code_object.source_location.first)
+    end
+
+    def patch_exception?
+      opts.present?(:ex) && opts.present?(:patch)
+    end
+
+    def bad_option_combination?
+      [opts.present?(:ex), opts.present?(:temp),
+       opts.present?(:in), opts.present?(:method), !filename_argument.empty?].count(true) > 1
+    end
+
+    def input_expression
+      case opts[:i]
+      when Range
+        (_pry_.input_ring[opts[:i]] || []).join
+      when Integer
+        _pry_.input_ring[opts[:i]] || ""
+      else
+        raise Pry::CommandError, "Not a valid range: #{opts[:i]}"
+      end
+    end
+
+    def reloadable?
+      opts.present?(:reload) || opts.present?(:ex)
+    end
+
+    def never_reload?
+      opts.present?(:'no-reload') || _pry_.config.disable_auto_reload
+    end
+
+    def reload?(file_name = "")
+      (reloadable? || file_name.end_with?(".rb")) && !never_reload?
+    end
+
+    def initial_temp_file_content
+      case
+      when opts.present?(:temp)
+        ""
+      when opts.present?(:in)
+        input_expression
+      when eval_string.strip != ""
+        eval_string
+      else
+        _pry_.input_ring.to_a.reverse_each.find { |x| x && x.strip != "" } || ""
+      end
+    end
+
+    def probably_a_file?(str)
+      [".rb", ".c", ".py", ".yml", ".gemspec"].include?(File.extname(str)) ||
+        str =~ /\/|\\/
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Edit)
+end