chess_engine 0.0.1

data/vendor/bundle/gems/pry-0.12.2/lib/pry/helpers/documentation_helpers.rb

@@ -0,0 +1,76 @@
+class Pry
+  module Helpers
+
+    # This class contains methods useful for extracting
+    # documentation from methods and classes.
+    module DocumentationHelpers
+
+      module_function
+
+      def process_rdoc(comment)
+        comment = comment.dup
+        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { CodeRay.scan($1, :ruby).term }.
+          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { "\e[1m#{$1}\e[0m" }.
+          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { "\e[1m#{$1}\e[0m" }.
+          gsub(/<tt>(?:\s*\n)?(.*?)\s*<\/tt>/m) { CodeRay.scan($1, :ruby).term }.
+          gsub(/\B\+(\w+?)\+\B/) { "\e[32m#{$1}\e[0m" }.
+          gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/) { CodeRay.scan($1, :ruby).term }.
+          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{CodeRay.scan($1, :ruby).term}`" }
+      end
+
+      def process_yardoc_tag(comment, tag)
+        in_tag_block = nil
+        comment.lines.map do |v|
+          if in_tag_block && v !~ /^\S/
+            Pry::Helpers::Text.strip_color Pry::Helpers::Text.strip_color(v)
+          elsif in_tag_block
+            in_tag_block = false
+            v
+          else
+            in_tag_block = true if v =~ /^@#{tag}/
+            v
+          end
+        end.join
+      end
+
+      def process_yardoc(comment)
+        yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
+                     "deprecate", "example", "raise"]
+        (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
+          gsub(/^@(#{yard_tags.join("|")})/) { "\e[33m#{$1}\e[0m" }
+      end
+
+      def process_comment_markup(comment)
+        process_yardoc process_rdoc(comment)
+      end
+
+      # @param [String] code
+      # @return [String]
+      def strip_comments_from_c_code(code)
+        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
+      end
+
+      # Given a string that makes up a comment in a source-code file parse out the content
+      # that the user is intended to read. (i.e. without leading indentation, #-characters
+      # or shebangs)
+      #
+      # @param [String] comment
+      # @return [String]
+      def get_comment_content(comment)
+        comment = comment.dup
+        # Remove #!/usr/bin/ruby
+        comment.gsub!(/\A\#!.*$/, '')
+        # Remove leading empty comment lines
+        comment.gsub!(/\A\#+?$/, '')
+        comment.gsub!(/^\s*#/, '')
+        strip_leading_whitespace(comment)
+      end
+
+      # @param [String] text
+      # @return [String]
+      def strip_leading_whitespace(text)
+        Pry::Helpers::CommandHelpers.unindent(text)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/helpers/options_helpers.rb

@@ -0,0 +1,27 @@
+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/gems/pry-0.12.2/lib/pry/helpers/platform.rb

@@ -0,0 +1,58 @@
+class Pry
+  module Helpers
+    # Contains methods for querying the platform that Pry is running on
+    # @api public
+    # @since v0.12.0
+    # rubocop:disable Style/DoubleNegation
+    module Platform
+      # @return [Boolean]
+      def self.mac_osx?
+        !!(RbConfig::CONFIG['host_os'] =~ /\Adarwin/i)
+      end
+
+      # @return [Boolean]
+      def self.linux?
+        !!(RbConfig::CONFIG['host_os'] =~ /linux/i)
+      end
+
+      # @return [Boolean] true when Pry is running on Windows with ANSI support,
+      #   false otherwise
+      def self.windows?
+        !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/)
+      end
+
+      # @return [Boolean]
+      def self.windows_ansi?
+        return false unless windows?
+
+        !!(defined?(Win32::Console) || ENV['ANSICON'] || mri_2?)
+      end
+
+      # @return [Boolean]
+      def self.jruby?
+        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
+      end
+
+      # @return [Boolean]
+      def self.jruby_19?
+        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
+      end
+
+      # @return [Boolean]
+      def self.mri?
+        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      end
+
+      # @return [Boolean]
+      def self.mri_19?
+        !!(mri? && RUBY_VERSION.start_with?('1.9'))
+      end
+
+      # @return [Boolean]
+      def self.mri_2?
+        !!(mri? && RUBY_VERSION.start_with?('2'))
+      end
+    end
+    # rubocop:enable Style/DoubleNegation
+  end
+end

data/vendor/bundle/gems/pry-0.12.2/lib/pry/helpers/table.rb

@@ -0,0 +1,114 @@
+class Pry
+  module Helpers
+    def self.tablify_or_one_line(heading, things, config = Pry.config)
+      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: '  ' }, config)}\n"
+      end
+    end
+
+    def self.tablify_to_screen_width(things, options, config = Pry.config)
+      options ||= {}
+      things = things.compact
+      if (indent = options[:indent])
+        usable_width = Terminal.width! - indent.size
+        tablify(things, usable_width, config).to_s.gsub(/^/, indent)
+      else
+        tablify(things, Terminal.width!, config).to_s
+      end
+    end
+
+    def self.tablify(things, line_length, config = Pry.config)
+      table = Table.new(things, { column_count: things.size }, config)
+      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, config = Pry.config)
+        @column_count = args[:column_count]
+        @config = config
+        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(@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/gems/pry-0.12.2/lib/pry/helpers/text.rb

@@ -0,0 +1,115 @@
+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
+
+      #
+      # @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/gems/pry-0.12.2/lib/pry/helpers.rb

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

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

@@ -0,0 +1,161 @@
+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|
+        next if invalid_readline_line?(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)
+      empty_or_invalid_line = line.empty? || invalid_readline_line?(line)
+
+      unless empty_or_invalid_line || (@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 SystemCallError => error
+      warn "Unable to read history file: #{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
+        unless File.exist?(history_file_path)
+          FileUtils.mkdir_p(File.dirname(history_file_path))
+        end
+        @history_file = File.open(history_file_path, 'a', 0600).tap do |file|
+          file.sync = true
+        end
+      end
+    rescue SystemCallError => error
+      warn "Unable to write history file: #{error.message}"
+      @history_file = false
+    end
+
+    def history_file_path
+      File.expand_path(@file_path || Pry.config.history.file)
+    end
+
+    def invalid_readline_line?(line)
+      # `Readline::HISTORY << line` raises an `ArgumentError` if `line`
+      # includes a null byte
+      line.include?("\0")
+    end
+  end
+end