chess_engine 0.0.1

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

@@ -0,0 +1,37 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class LocalVars < Pry::Command::Ls::Formatter
+      def initialize(opts, _pry_)
+        super(_pry_)
+        @default_switch = opts[:locals]
+        @sticky_locals = _pry_.sticky_locals
+      end
+
+      def output_self
+        name_value_pairs = @target.eval('local_variables').reject { |e|
+          @sticky_locals.keys.include?(e.to_sym)
+        }.map { |name|
+          [name, (@target.eval(name.to_s))]
+        }
+        format(name_value_pairs).join('')
+      end
+
+      private
+
+      def format(name_value_pairs)
+        name_value_pairs.sort_by { |name, value|
+          value.to_s.size
+        }.reverse.map { |name, value|
+          colorized_assignment_style(name, format_value(value))
+        }
+      end
+
+      def colorized_assignment_style(lhs, rhs, desired_width = 7)
+        colorized_lhs = color(:local_var, lhs)
+        color_escape_padding = colorized_lhs.size - lhs.size
+        pad = desired_width + color_escape_padding
+        "%-#{pad}s = %s" % [color(:local_var, colorized_lhs), rhs]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'pry/commands/ls/grep'
+require 'pry/commands/ls/formatter'
+require 'pry/commands/ls/globals'
+require 'pry/commands/ls/constants'
+require 'pry/commands/ls/methods'
+require 'pry/commands/ls/self_methods'
+require 'pry/commands/ls/instance_vars'
+require 'pry/commands/ls/local_names'
+require 'pry/commands/ls/local_vars'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class LsEntity
+      attr_reader :_pry_
+
+      def initialize(opts)
+        @interrogatee = opts[:interrogatee]
+        @no_user_opts = opts[:no_user_opts]
+        @opts = opts[:opts]
+        @args = opts[:args]
+        @grep = Grep.new(Regexp.new(opts[:opts][:G] || '.'))
+        @_pry_ = opts.delete(:_pry_)
+      end
+
+      def entities_table
+        entities.map(&:write_out).reject { |o| !o }.join('')
+      end
+
+      private
+
+      def grep(entity)
+        entity.tap { |o| o.grep = @grep }
+      end
+
+      def globals
+        grep Globals.new(@opts, _pry_)
+      end
+
+      def constants
+        grep Constants.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def methods
+        grep(Methods.new(@interrogatee, @no_user_opts, @opts, _pry_))
+      end
+
+      def self_methods
+        grep SelfMethods.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def instance_vars
+        grep InstanceVars.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def local_names
+        grep LocalNames.new(@no_user_opts, @args, _pry_)
+      end
+
+      def local_vars
+        LocalVars.new(@opts, _pry_)
+      end
+
+      def entities
+        [globals, constants, methods, self_methods, instance_vars, local_names,
+          local_vars]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'pry/commands/ls/methods_helper'
+require 'pry/commands/ls/interrogatable'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Methods < Pry::Command::Ls::Formatter
+      include Pry::Command::Ls::Interrogatable
+      include Pry::Command::Ls::MethodsHelper
+
+      def initialize(interrogatee, no_user_opts, opts, _pry_)
+        super(_pry_)
+        @interrogatee = interrogatee
+        @no_user_opts = no_user_opts
+        @default_switch = opts[:methods]
+        @instance_methods_switch = opts['instance-methods']
+        @ppp_switch = opts[:ppp]
+        @jruby_switch = opts['all-java']
+        @quiet_switch = opts[:quiet]
+        @verbose_switch = opts[:verbose]
+      end
+
+      def output_self
+        methods = all_methods.group_by(&:owner)
+        # Reverse the resolution order so that the most useful information
+        # appears right by the prompt.
+        resolution_order.take_while(&below_ceiling).reverse.map do |klass|
+          methods_here = (methods[klass] || []).select { |m| grep.regexp[m.name] }
+          heading = "#{ Pry::WrappedModule.new(klass).method_prefix }methods"
+          output_section(heading, format(methods_here))
+        end.join('')
+      end
+
+      private
+
+      def correct_opts?
+        super || @instance_methods_switch || @ppp_switch || @no_user_opts
+      end
+
+      # Get a lambda that can be used with `take_while` to prevent over-eager
+      # traversal of the Object's ancestry graph.
+      def below_ceiling
+        ceiling = if @quiet_switch
+                    [Pry::Method.safe_send(interrogatee_mod, :ancestors)[1]] +
+                      _pry_.config.ls.ceiling
+                  elsif @verbose_switch
+                    []
+                  else
+                    _pry_.config.ls.ceiling.dup
+                  end
+        lambda { |klass| !ceiling.include?(klass) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'pry/commands/ls/jruby_hacks'
+
+module Pry::Command::Ls::MethodsHelper
+
+  include Pry::Command::Ls::JRubyHacks
+
+  private
+
+  # Get all the methods that we'll want to output.
+  def all_methods(instance_methods = false)
+    methods = if instance_methods || @instance_methods_switch
+                Pry::Method.all_from_class(@interrogatee)
+              else
+                Pry::Method.all_from_obj(@interrogatee)
+              end
+
+    if Pry::Helpers::Platform.jruby? && !@jruby_switch
+      methods = trim_jruby_aliases(methods)
+    end
+
+    methods.select { |method| @ppp_switch || method.visibility == :public }
+  end
+
+  def resolution_order
+    if @instance_methods_switch
+      Pry::Method.instance_resolution_order(@interrogatee)
+    else
+      Pry::Method.resolution_order(@interrogatee)
+    end
+  end
+
+  def format(methods)
+    methods.sort_by(&:name).map do |method|
+      if method.name == 'method_missing'
+        color(:method_missing, 'method_missing')
+      elsif method.visibility == :private
+        color(:private_method, method.name)
+      elsif method.visibility == :protected
+        color(:protected_method, method.name)
+      else
+        color(:public_method, method.name)
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,33 @@
+require 'pry/commands/ls/interrogatable'
+require 'pry/commands/ls/methods_helper'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class SelfMethods < Pry::Command::Ls::Formatter
+      include Pry::Command::Ls::Interrogatable
+      include Pry::Command::Ls::MethodsHelper
+
+      def initialize(interrogatee, no_user_opts, opts, _pry_)
+        super(_pry_)
+        @interrogatee = interrogatee
+        @no_user_opts = no_user_opts
+        @ppp_switch = opts[:ppp]
+        @jruby_switch = opts['all-java']
+      end
+
+      def output_self
+        methods = all_methods(true).select do |m|
+          m.owner == @interrogatee && grep.regexp[m.name]
+        end
+        heading = "#{ Pry::WrappedModule.new(@interrogatee).method_prefix }methods"
+        output_section(heading, format(methods))
+      end
+
+      private
+
+      def correct_opts?
+        @no_user_opts && interrogating_a_module?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+require 'pry/commands/ls/ls_entity'
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    DEFAULT_OPTIONS = {
+      heading_color: :bright_blue,
+      public_method_color: :default,
+      private_method_color: :blue,
+      protected_method_color: :blue,
+      method_missing_color: :bright_red,
+      local_var_color: :yellow,
+      pry_var_color: :default, # e.g. _, _pry_, _file_
+      instance_var_color: :blue, # e.g. @foo
+      class_var_color: :bright_blue, # e.g. @@foo
+      global_var_color: :default, # e.g. $CODERAY_DEBUG, $eventmachine_library
+      builtin_global_color: :cyan, # e.g. $stdin, $-w, $PID
+      pseudo_global_color: :cyan, # e.g. $~, $1..$9, $LAST_MATCH_INFO
+      constant_color: :default, # e.g. VERSION, ARGF
+      class_constant_color: :blue, # e.g. Object, Kernel
+      exception_constant_color: :magenta, # e.g. Exception, RuntimeError
+      unloaded_constant_color: :yellow, # Any constant that is still in .autoload? state
+      separator: "  ",
+      ceiling: [Object, Module, Class]
+    }
+
+    match 'ls'
+    group 'Context'
+    description 'Show the list of vars and methods in the current scope.'
+    command_options shellwords: false, interpolate: false
+
+    banner <<-'BANNER'
+      Usage: ls [-m|-M|-p|-pM] [-q|-v] [-c|-i] [Object]
+             ls [-g] [-l]
+
+      ls shows you which methods, constants and variables are accessible to Pry. By
+      default it shows you the local variables defined in the current shell, and any
+      public methods or instance variables defined on the current object.
+
+      The colours used are configurable using Pry.config.ls.*_color, and the separator
+      is Pry.config.ls.separator.
+
+      Pry.config.ls.ceiling is used to hide methods defined higher up in the
+      inheritance chain, this is by default set to [Object, Module, Class] so that
+      methods defined on all Objects are omitted. The -v flag can be used to ignore
+      this setting and show all methods, while the -q can be used to set the ceiling
+      much lower and show only methods defined on the object or its direct class.
+
+      Also check out `find-method` command (run `help find-method`).
+    BANNER
+
+    def options(opt)
+      opt.on :m, :methods, "Show public methods defined on the Object"
+      opt.on :M, "instance-methods", "Show public methods defined in a Module or Class"
+      opt.on :p, :ppp,       "Show public, protected (in yellow) and private (in green) methods"
+      opt.on :q, :quiet,     "Show only methods defined on object.singleton_class and object.class"
+      opt.on :v, :verbose,   "Show methods and constants on all super-classes (ignores Pry.config.ls.ceiling)"
+      opt.on :g, :globals,   "Show global variables, including those builtin to Ruby (in cyan)"
+      opt.on :l, :locals,    "Show hash of local vars, sorted by descending size"
+      opt.on :c, :constants, "Show constants, highlighting classes (in blue), and exceptions (in purple).\n" <<
+      " " * 32 <<            "Constants that are pending autoload? are also shown (in yellow)"
+      opt.on :i, :ivars,     "Show instance variables (in blue) and class variables (in bright blue)"
+      opt.on :G, :grep,      "Filter output by regular expression", argument: true
+      if Object.respond_to?(:deprecate_constant)
+        opt.on :d, :dconstants, "Show deprecated constants"
+      end
+      if Helpers::Platform.jruby?
+        opt.on :J, "all-java", "Show all the aliases for methods from java (default is to show only prettiest)"
+      end
+    end
+
+    # Exclude -q, -v and --grep because they,
+    # don't specify what the user wants to see.
+    def no_user_opts?
+      !(opts[:methods] || opts['instance-methods'] || opts[:ppp] ||
+        opts[:globals] || opts[:locals] || opts[:constants] || opts[:ivars])
+    end
+
+    def process
+      @interrogatee = args.empty? ? target_self : target.eval(args.join(' '))
+      raise_errors_if_arguments_are_weird
+      ls_entity = LsEntity.new({
+        interrogatee: @interrogatee,
+        no_user_opts: no_user_opts?,
+        opts: opts,
+        args: args,
+        _pry_: _pry_
+      })
+
+      _pry_.pager.page ls_entity.entities_table
+    end
+
+    private
+
+    def error_list
+      any_args = args.any?
+      non_mod_interrogatee = !(Module === @interrogatee)
+      [
+        ['-l does not make sense with a specified Object', :locals, any_args],
+        ['-g does not make sense with a specified Object', :globals, any_args],
+        ['-q does not make sense with -v',                 :quiet, opts.present?(:verbose)],
+        ['-M only makes sense with a Module or a Class',   'instance-methods', non_mod_interrogatee],
+        ['-c only makes sense with a Module or a Class',   :constants, any_args && non_mod_interrogatee]
+      ]
+    end
+
+    def raise_errors_if_arguments_are_weird
+      error_list.each do |message, option, invalid_expr|
+        raise Pry::CommandError, message if opts.present?(option) && invalid_expr
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Ls)
+end

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

@@ -0,0 +1,25 @@
+class Pry
+  class Command::Nesting < Pry::ClassCommand
+    match 'nesting'
+    group 'Navigating Pry'
+    description 'Show nesting information.'
+
+    banner <<-'BANNER'
+      Show nesting information.
+    BANNER
+
+    def process
+      output.puts 'Nesting status:'
+      output.puts '--'
+      _pry_.binding_stack.each_with_index do |obj, level|
+        if level == 0
+          output.puts "#{level}. #{Pry.view_clip(obj.eval('self'))} (Pry top level)"
+        else
+          output.puts "#{level}. #{Pry.view_clip(obj.eval('self'))}"
+        end
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Nesting)
+end

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

@@ -0,0 +1,102 @@
+class Pry
+  class Command::Play < Pry::ClassCommand
+    match 'play'
+    group 'Editing'
+    description 'Playback a string variable, method, line, or file as input.'
+
+    banner <<-'BANNER'
+      Usage: play [OPTIONS] [--help]
+
+      The play command enables you to replay code from files and methods as if they
+      were entered directly in the Pry REPL.
+
+      play --lines 149..153   # assumes current context
+      play -i 20 --lines 1..3 # assumes lines of the input expression at 20
+      play -o 4               # the output of an expression at 4
+      play Pry#repl -l 1..-1  # play the contents of Pry#repl method
+      play -e 2               # play from specified line until end of valid expression
+      play hello.rb           # play a file
+      play Rakefile -l 5      # play line 5 of a file
+      play -d hi              # play documentation of hi method
+      play hi --open          # play hi method and leave it open
+
+      https://github.com/pry/pry/wiki/User-Input#wiki-Play
+    BANNER
+
+    def options(opt)
+      CodeCollector.inject_options(opt)
+
+      opt.on :open, 'Plays the selected content except the last line. Useful' \
+                    ' for replaying methods and leaving the method definition' \
+                    ' "open". `amend-line` can then be used to' \
+                    ' modify the method.'
+
+      opt.on :e, :expression=, 'Executes until end of valid expression', as: Integer
+      opt.on :p, :print, 'Prints executed code'
+    end
+
+    def process
+      @cc = CodeCollector.new(args, opts, _pry_)
+
+      perform_play
+      show_input
+    end
+
+    def perform_play
+      eval_string << content_after_options
+      run "fix-indent"
+    end
+
+    def show_input
+      if opts.present?(:print) or !Pry::Code.complete_expression?(eval_string)
+        run "show-input"
+      end
+    end
+
+    def content_after_options
+      if opts.present?(:open)
+        restrict_to_lines(content, (0..-2))
+      elsif opts.present?(:expression)
+        content_at_expression
+      else
+        content
+      end
+    end
+
+    def content_at_expression
+      code_object.expression_at(opts[:expression])
+    end
+
+    def code_object
+      Pry::Code.new(content)
+    end
+
+    def should_use_default_file?
+      !args.first && !opts.present?(:in) && !opts.present?(:out)
+    end
+
+    def content
+      if should_use_default_file?
+        file_content
+      else
+        @cc.content
+      end
+    end
+
+    # The file to play from when no code object is specified.
+    # e.g `play --lines 4..10`
+    def default_file
+      target.eval("__FILE__") && File.expand_path(target.eval("__FILE__"))
+    end
+
+    def file_content
+      if default_file && File.exist?(default_file)
+        @cc.restrict_to_lines(File.read(default_file), @cc.line_range)
+      else
+        raise CommandError, "File does not exist! File was: #{default_file.inspect}"
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Play)
+end