pry 0.10.0.pre2-universal-mswin32

data/lib/pry/commands/wtf.rb

@@ -0,0 +1,57 @@
+class Pry
+  class Command::Wtf < Pry::ClassCommand
+    match(/wtf([?!]*)/)
+    group 'Context'
+    description 'Show the backtrace of the most recent exception.'
+    options :listing => 'wtf?'
+
+    banner <<-'BANNER'
+      Usage: wtf[?|!]
+
+      Show's a few lines of the backtrace of the most recent exception (also available
+      as `_ex_.backtrace`). If you want to see more lines, add more question marks or
+      exclamation marks.
+
+      wtf?
+      wtf?!???!?!?
+
+      # To see the entire backtrace, pass the `-v` or `--verbose` flag.
+      wtf -v
+    BANNER
+
+    def options(opt)
+      opt.on :v, :verbose, "Show the full backtrace"
+    end
+
+    def process
+      raise Pry::CommandError, "No most-recent exception" unless exception
+
+      output.puts "#{text.bold('Exception:')} #{exception.class}: #{exception}\n--"
+      if opts.verbose?
+        output.puts with_line_numbers(backtrace)
+      else
+        output.puts with_line_numbers(backtrace.first(size_of_backtrace))
+      end
+    end
+
+    private
+
+    def exception
+      _pry_.last_exception
+    end
+
+    def with_line_numbers(bt)
+      Pry::Code.new(bt, 0, :text).with_line_numbers.to_s
+    end
+
+    def backtrace
+      exception.backtrace
+    end
+
+    def size_of_backtrace
+      [captures[0].size, 0.5].max * 10
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Wtf)
+end

data/lib/pry/config.rb

@@ -0,0 +1,24 @@
+class Pry::Config
+  require_relative 'config/behavior'
+  require_relative 'config/default'
+  require_relative 'config/convenience'
+  include Pry::Config::Behavior
+
+  def self.shortcuts
+    Convenience::SHORTCUTS
+  end
+
+  #
+  # FIXME
+  # @param [Pry::Hooks] hooks
+  #
+  def hooks=(hooks)
+    if hooks.is_a?(Hash)
+      warn "Hash-based hooks are now deprecated! Use a `Pry::Hooks` object " \
+           "instead! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
+      self["hooks"] = Pry::Hooks.from_hash(hooks)
+    else
+      self["hooks"] = hooks
+    end
+  end
+end

data/lib/pry/config/behavior.rb

@@ -0,0 +1,139 @@
+module Pry::Config::Behavior
+  ASSIGNMENT     = "=".freeze
+  NODUP          = [TrueClass, FalseClass, NilClass, Symbol, Numeric, Module, Proc].freeze
+  INSPECT_REGEXP = /#{Regexp.escape "default=#<"}/
+
+  module Builder
+    def from_hash(hash, default = nil)
+      new(default).tap do |config|
+        config.merge!(hash)
+      end
+    end
+  end
+
+  def self.included(klass)
+    unless defined?(RESERVED_KEYS)
+      const_set :RESERVED_KEYS, instance_methods(false).map(&:to_s).freeze
+    end
+    klass.extend(Builder)
+  end
+
+  def initialize(default = Pry.config)
+    @default = default
+    @lookup = {}
+  end
+
+  #
+  # @return [Pry::Config::Behavior]
+  #   returns the default used if a matching value for a key isn't found in self
+  #
+  def default
+    @default
+  end
+
+  def [](key)
+    @lookup[key.to_s]
+  end
+
+  def []=(key, value)
+    key = key.to_s
+    if RESERVED_KEYS.include?(key)
+      raise ArgumentError, "few things are reserved by pry, but using '#{key}' as a configuration key is."
+    end
+    @lookup[key] = value
+  end
+
+  def method_missing(name, *args, &block)
+    key = name.to_s
+    if key[-1] == ASSIGNMENT
+      short_key = key[0..-2]
+      self[short_key] = args[0]
+    elsif key?(key)
+      self[key]
+    elsif @default.respond_to?(name)
+      value = @default.public_send(name, *args, &block)
+      # FIXME: refactor Pry::Hook so that it stores config on the config object,
+      # so that we can use the normal strategy.
+      self[key] = value.dup if key == 'hooks'
+      value
+    else
+      nil
+    end
+  end
+
+  def merge!(other)
+    other = try_convert_to_hash(other)
+    raise TypeError, "unable to convert argument into a Hash" unless other
+    other.each do |key, value|
+      self[key] = value
+    end
+  end
+
+  def ==(other)
+    @lookup == try_convert_to_hash(other)
+  end
+  alias_method :eql?, :==
+
+  def respond_to_missing?(key, include_private=false)
+    key?(key) or @default.respond_to?(key) or super(key, include_private)
+  end
+
+  def key?(key)
+    key = key.to_s
+    @lookup.key?(key)
+  end
+
+  def clear
+    @lookup.clear
+    true
+  end
+  alias_method :refresh, :clear
+
+  def forget(key)
+    @lookup.delete(key.to_s)
+  end
+
+  def keys
+    @lookup.keys
+  end
+
+  def to_hash
+    @lookup.dup
+  end
+  alias_method :to_h, :to_hash
+
+
+  def inspect
+    key_str = keys.map { |key| "'#{key}'" }.join(",")
+    "#<#{_clip_inspect(self)} local_keys=[#{key_str}] default=#{@default.inspect}>"
+  end
+
+  def pretty_print(q)
+    q.text inspect[1..-1].gsub(INSPECT_REGEXP, "default=<")
+  end
+
+private
+  def _clip_inspect(obj)
+    "#{obj.class}:0x%x" % obj.object_id << 1
+  end
+
+  def _dup(value)
+    if NODUP.any? { |klass| klass === value }
+      value
+    else
+      value.dup
+    end
+  end
+
+  def try_convert_to_hash(obj)
+    if Hash === obj
+      obj
+    elsif obj.respond_to?(:to_h)
+      obj.to_h
+    elsif obj.respond_to?(:to_hash)
+      obj.to_hash
+    else
+      nil
+    end
+  end
+end

data/lib/pry/config/convenience.rb

@@ -0,0 +1,26 @@
+module Pry::Config::Convenience
+  SHORTCUTS = [
+               :input,
+               :output,
+               :commands,
+               :print,
+               :exception_handler,
+               :quiet?,
+               :hooks,
+               :color,
+               :pager,
+               :editor,
+               :memory_size,
+               :extra_sticky_locals
+              ]
+
+
+  def config_shortcut(*names)
+    names.each do |name|
+      reader = name
+      setter = "#{name}="
+      define_method(reader) { config.public_send(name) }
+      define_method(setter) { |value| config.public_send(setter, value) }
+    end
+  end
+end

data/lib/pry/config/default.rb

@@ -0,0 +1,165 @@
+class Pry::Config::Default
+  include Pry::Config::Behavior
+
+  default = {
+    input: proc {
+      lazy_readline
+    },
+    output: proc {
+      $stdout
+    },
+    commands: proc {
+      Pry::Commands
+    },
+    prompt_name: proc {
+      Pry::DEFAULT_PROMPT_NAME
+    },
+    prompt: proc {
+      Pry::DEFAULT_PROMPT
+    },
+    prompt_safe_objects: proc {
+      Pry::DEFAULT_PROMPT_SAFE_OBJECTS
+    },
+    print: proc {
+      Pry::DEFAULT_PRINT
+    },
+    quiet: proc {
+      false
+    },
+    exception_handler: proc {
+      Pry::DEFAULT_EXCEPTION_HANDLER
+    },
+    exception_whitelist: proc {
+      Pry::DEFAULT_EXCEPTION_WHITELIST
+    },
+    hooks: proc {
+      Pry::DEFAULT_HOOKS
+    },
+    pager: proc {
+      true
+    },
+    system: proc {
+      Pry::DEFAULT_SYSTEM
+    },
+    color: proc {
+      Pry::Helpers::BaseHelpers.use_ansi_codes?
+    },
+    default_window_size: proc {
+      5
+    },
+    editor: proc {
+      Pry.default_editor_for_platform
+    }, # TODO: Pry::Platform.editor
+    should_load_rc: proc {
+      true
+    },
+    should_load_local_rc: proc {
+      true
+    },
+    should_trap_interrupts: proc {
+      Pry::Helpers::BaseHelpers.jruby?
+    }, # TODO: Pry::Platform.jruby?
+    disable_auto_reload: proc {
+      false
+    },
+    command_prefix: proc {
+      ""
+    },
+    auto_indent: proc {
+      Pry::Helpers::BaseHelpers.use_ansi_codes?
+    },
+    correct_indent: proc {
+      true
+    },
+    collision_warning: proc {
+      false
+    },
+    output_prefix: proc {
+      "=> "
+    },
+    requires: proc {
+      []
+    },
+    should_load_requires: proc {
+      true
+    },
+    should_load_plugins: proc {
+      true
+    },
+    windows_console_warning: proc {
+      true
+    },
+    control_d_handler: proc {
+      Pry::DEFAULT_CONTROL_D_HANDLER
+    },
+    memory_size: proc {
+      100
+    },
+    extra_sticky_locals: proc {
+      {}
+    },
+    command_completions: proc {
+      proc { commands.keys }
+    },
+    file_completions: proc {
+      proc { Dir["."] }
+    },
+    ls: proc {
+      Pry::Config.from_hash(Pry::Command::Ls::DEFAULT_OPTIONS)
+    },
+    completer: proc {
+      require "pry/input_completer"
+      Pry::InputCompleter
+    }
+  }
+
+  def initialize
+    super(nil)
+    configure_gist
+    configure_history
+  end
+
+  def quiet?
+    quiet
+  end
+
+  default.each do |key, value|
+    define_method(key) do
+      if default[key].equal?(value)
+        default[key] = instance_eval(&value)
+      end
+      default[key]
+    end
+  end
+
+private
+  # TODO:
+  # all of this configure_* stuff is a relic of old code.
+  # we should try move this code to being command-local.
+  def configure_gist
+    self["gist"] = Pry::Config.from_hash(inspecter: proc(&:pretty_inspect))
+  end
+
+  def configure_history
+    self["history"] = Pry::Config.from_hash "should_save" => true,
+      "should_load" => true
+    history.file = File.expand_path("~/.pry_history") rescue nil
+    if history.file.nil?
+      self.should_load_rc = false
+      history.should_save = false
+      history.should_load = false
+    end
+  end
+
+  def lazy_readline
+    require 'readline'
+    Readline
+  rescue LoadError
+    warn "Sorry, you can't use Pry without Readline or a compatible library."
+    warn "Possible solutions:"
+    warn " * Rebuild Ruby with Readline support using `--with-readline`"
+    warn " * Use the rb-readline gem, which is a pure-Ruby port of Readline"
+    warn " * Use the pry-coolline gem, a pure-ruby alternative to Readline"
+    raise
+  end
+end

data/lib/pry/core_extensions.rb

@@ -0,0 +1,131 @@
+class Pry
+  # @return [Array] Code of the method used when implementing Pry's
+  #   __binding__, along with line indication to be used with instance_eval (and
+  #   friends).
+  #
+  # @see Object#__binding__
+  BINDING_METHOD_IMPL = [<<-METHOD, __FILE__, __LINE__ + 1]
+    # Get a binding with 'self' set to self, and no locals.
+    #
+    # The default definee is determined by the context in which the
+    # definition is eval'd.
+    #
+    # Please don't call this method directly, see {__binding__}.
+    #
+    # @return [Binding]
+    def __pry__
+      binding
+    end
+  METHOD
+end
+
+class Object
+  # Start a Pry REPL on self.
+  #
+  # If `self` is a Binding then that will be used to evaluate expressions;
+  # otherwise a new binding will be created.
+  #
+  # @param [Object] object  the object or binding to pry
+  #                         (__deprecated__, use `object.pry`)
+  # @param [Hash] hash  the options hash
+  # @example With a binding
+  #    binding.pry
+  # @example On any object
+  #   "dummy".pry
+  # @example With options
+  #   def my_method
+  #     binding.pry :quiet => true
+  #   end
+  #   my_method()
+  # @see Pry.start
+  def pry(object=nil, hash={})
+    if object.nil? || Hash === object
+      Pry.start(self, object || {})
+    else
+      Pry.start(object, hash)
+    end
+  end
+
+  # Return a binding object for the receiver.
+  #
+  # The `self` of the binding is set to the current object, and it contains no
+  # local variables.
+  #
+  # The default definee (http://yugui.jp/articles/846) is set such that:
+  #
+  # * If `self` is a class or module, then new methods created in the binding
+  #   will be defined in that class or module (as in `class Foo; end`).
+  # * If `self` is a normal object, then new methods created in the binding will
+  #   be defined on its singleton class (as in `class << self; end`).
+  # * If `self` doesn't have a  real singleton class (i.e. it is a Fixnum, Float,
+  #   Symbol, nil, true, or false), then new methods will be created on the
+  #   object's class (as in `self.class.class_eval{ }`)
+  #
+  # Newly created constants, including classes and modules, will also be added
+  # to the default definee.
+  #
+  # @return [Binding]
+  def __binding__
+    # If you ever feel like changing this method, be careful about variables
+    # that you use. They shouldn't be inserted into the binding that will
+    # eventually be returning.
+
+    # When you're cd'd into a class, methods you define should be added to it.
+    if is_a?(Module)
+      # class_eval sets both self and the default definee to this class.
+      return class_eval "binding"
+    end
+
+    unless respond_to?(:__pry__)
+      # The easiest way to check whether an object has a working singleton class
+      # is to try and define a method on it. (just checking for the presence of
+      # the singleton class gives false positives for `true` and `false`).
+      # __pry__ is just the closest method we have to hand, and using
+      # it has the nice property that we can memoize this check.
+      begin
+        # instance_eval sets the default definee to the object's singleton class
+        instance_eval(*Pry::BINDING_METHOD_IMPL)
+
+      # If we can't define methods on the Object's singleton_class. Then we fall
+      # back to setting the default definee to be the Object's class. That seems
+      # nicer than having a REPL in which you can't define methods.
+      rescue TypeError, Pry::FrozenObjectException
+        # class_eval sets the default definee to self.class
+        self.class.class_eval(*Pry::BINDING_METHOD_IMPL)
+      end
+    end
+
+    __pry__
+  end
+end
+
+class BasicObject
+  # Return a binding object for the receiver.
+  #
+  # The `self` of the binding is set to the current object, and it contains no
+  # local variables.
+  #
+  # The default definee (http://yugui.jp/articles/846) is set such that new
+  # methods defined will be added to the singleton class of the BasicObject.
+  #
+  # @return [Binding]
+  def __binding__
+    # BasicObjects don't have respond_to?, so we just define the method
+    # every time. As they also don't have `.freeze`, this call won't
+    # fail as it can for normal Objects.
+    (class << self; self; end).class_eval <<-EOF, __FILE__, __LINE__ + 1
+      # Get a binding with 'self' set to self, and no locals.
+      #
+      # The default definee is determined by the context in which the
+      # definition is eval'd.
+      #
+      # Please don't call this method directly, see {__binding__}.
+      #
+      # @return [Binding]
+      def __pry__
+        ::Kernel.binding
+      end
+    EOF
+    self.__pry__
+  end
+end