pry 0.9.12.6-i386-mswin32 → 0.10.0-i386-mswin32

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

@@ -84,14 +84,14 @@ class Object
       # 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
+        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
+      rescue TypeError, Pry::FrozenObjectException
         # class_eval sets the default definee to self.class
-        self.class.class_eval *Pry::BINDING_METHOD_IMPL
+        self.class.class_eval(*Pry::BINDING_METHOD_IMPL)
       end
     end
 
@@ -99,23 +99,33 @@ class Object
   end
 end
 
-# There's a splat bug on jruby in 1.9 emulation mode, which breaks the
-# pp library.
-#
-# * http://jira.codehaus.org/browse/JRUBY-6687
-# * https://github.com/pry/pry/issues/568
-#
-# Until that gets fixed upstream, let's monkey-patch here:
-if [[1, 2]].pretty_inspect == "[1]\n"
-  class Array
-    def pretty_print(q)
-      q.group(1, '[', ']') {
-        i = 0
-        q.seplist(self) { |*|
-          q.pp self[i]
-          i += 1
-        }
-      }
-    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

data/lib/pry/editor.rb

@@ -1,129 +1,133 @@
 class Pry
   class Editor
-    extend Pry::Helpers::BaseHelpers
-    extend Pry::Helpers::CommandHelpers
-
-    class << self
-      def edit_tempfile_with_content(initial_content, line=1)
-        temp_file do |f|
-          f.puts(initial_content)
-          f.flush
-          f.close(false)
-          invoke_editor(f.path, line, true)
-          File.read(f.path)
-        end
+    include Pry::Helpers::BaseHelpers
+    include Pry::Helpers::CommandHelpers
+
+    attr_reader :_pry_
+
+    def initialize(_pry_)
+      @_pry_ = _pry_
+    end
+
+    def edit_tempfile_with_content(initial_content, line=1)
+      temp_file do |f|
+        f.puts(initial_content)
+        f.flush
+        f.close(false)
+        invoke_editor(f.path, line, true)
+        File.read(f.path)
       end
+    end
 
-      def invoke_editor(file, line, blocking=true)
-        raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless Pry.config.editor
+    def invoke_editor(file, line, blocking=true)
+      raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless _pry_.config.editor
 
-        editor_invocation = build_editor_invocation_string(file, line, blocking)
-        return nil unless editor_invocation
+      editor_invocation = build_editor_invocation_string(file, line, blocking)
+      return nil unless editor_invocation
 
-        if jruby?
-          open_editor_on_jruby(editor_invocation)
-        else
-          open_editor(editor_invocation)
-        end
+      if jruby?
+        open_editor_on_jruby(editor_invocation)
+      else
+        open_editor(editor_invocation)
       end
+    end
 
-      private
+    private
 
-      # Generate the string that's used to start the editor. This includes
-      # all the flags we want as well as the file and line number we
-      # want to open at.
-      def build_editor_invocation_string(file, line, blocking)
+    # Generate the string that's used to start the editor. This includes
+    # all the flags we want as well as the file and line number we
+    # want to open at.
+    def build_editor_invocation_string(file, line, blocking)
 
-        if Pry.config.editor.respond_to?(:call)
-          args = [file, line, blocking][0...(Pry.config.editor.arity)]
-          Pry.config.editor.call(*args)
-        else
-          sanitized_file = if windows?
-                             file.gsub(/\//, '\\')
-                           else
-                             Shellwords.escape(file)
-                           end
+      if _pry_.config.editor.respond_to?(:call)
+        args = [file, line, blocking][0...(_pry_.config.editor.arity)]
+        _pry_.config.editor.call(*args)
+      else
+        sanitized_file = if windows?
+                            file.gsub(/\//, '\\')
+                          else
+                            Shellwords.escape(file)
+                          end
 
-          "#{Pry.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
-        end
+        "#{_pry_.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
       end
+    end
 
-      # Start the editor running, using the calculated invocation string
-      def open_editor(editor_invocation)
-        # Note we dont want to use Pry.config.system here as that
-        # may be invoked non-interactively (i.e via Open4), whereas we want to
-        # ensure the editor is always interactive
-        system(editor_invocation) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
-      end
+    # Start the editor running, using the calculated invocation string
+    def open_editor(editor_invocation)
+      # Note we dont want to use Pry.config.system here as that
+      # may be invoked non-interactively (i.e via Open4), whereas we want to
+      # ensure the editor is always interactive
+      system(*Shellwords.split(editor_invocation)) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
+    end
 
-      # We need JRuby specific code here cos just shelling out using
-      # system() appears to be pretty broken :/
-      def open_editor_on_jruby(editor_invocation)
-        begin
-          require 'spoon'
-          pid = Spoon.spawnp(*editor_invocation.split)
-          Process.waitpid(pid)
-        rescue FFI::NotFoundError
-          system(editor_invocation)
-        end
+    # We need JRuby specific code here cos just shelling out using
+    # system() appears to be pretty broken :/
+    def open_editor_on_jruby(editor_invocation)
+      begin
+        require 'spoon'
+        pid = Spoon.spawnp(*Shellwords.split(editor_invocation))
+        Process.waitpid(pid)
+      rescue FFI::NotFoundError
+        system(editor_invocation)
       end
+    end
 
-      # Some editors that run outside the terminal allow you to control whether or
-      # not to block the process from which they were launched (in this case, Pry).
-      # For those editors, return the flag that produces the desired behavior.
-      def blocking_flag_for_editor(blocking)
-        case editor_name
-        when /^emacsclient/
-          '--no-wait' unless blocking
-        when /^[gm]vim/
-          '--nofork' if blocking
-        when /^jedit/
-          '-wait' if blocking
-        when /^mate/, /^subl/
-          '-w' if blocking
-        end
+    # Some editors that run outside the terminal allow you to control whether or
+    # not to block the process from which they were launched (in this case, Pry).
+    # For those editors, return the flag that produces the desired behavior.
+    def blocking_flag_for_editor(blocking)
+      case editor_name
+      when /^emacsclient/
+        '--no-wait' unless blocking
+      when /^[gm]vim/
+        '--nofork' if blocking
+      when /^jedit/
+        '-wait' if blocking
+      when /^mate/, /^subl/
+        '-w' if blocking
       end
+    end
 
-      # Return the syntax for a given editor for starting the editor
-      # and moving to a particular line within that file
-      def start_line_syntax_for_editor(file_name, line_number)
-        # special case for 1st line
-        return file_name if line_number <= 1
+    # Return the syntax for a given editor for starting the editor
+    # and moving to a particular line within that file
+    def start_line_syntax_for_editor(file_name, line_number)
+      # special case for 1st line
+      return file_name if line_number <= 1
 
-        case editor_name
-        when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
-          "+#{line_number} #{file_name}"
-        when /^mate/, /^geany/
-          "-l #{line_number} #{file_name}"
-        when /^subl/
-          "#{file_name}:#{line_number}"
-        when /^uedit32/
-          "#{file_name}/#{line_number}"
-        when /^jedit/
-          "#{file_name} +line:#{line_number}"
+      case editor_name
+      when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
+        "+#{line_number} #{file_name}"
+      when /^mate/, /^geany/
+        "-l #{line_number} #{file_name}"
+      when /^subl/
+        "#{file_name}:#{line_number}"
+      when /^uedit32/
+        "#{file_name}/#{line_number}"
+      when /^jedit/
+        "#{file_name} +line:#{line_number}"
+      else
+        if windows?
+          "#{file_name}"
         else
-          if windows?
-            "#{file_name}"
-          else
-            "+#{line_number} #{file_name}"
-          end
+          "+#{line_number} #{file_name}"
         end
       end
+    end
 
-      # Get the name of the binary that Pry.config.editor points to.
-      #
-      # This is useful for deciding which flags we pass to the editor as
-      # we can just use the program's name and ignore any absolute paths.
-      #
-      # @example
-      #   Pry.config.editor="/home/conrad/bin/textmate -w"
-      #   editor_name
-      #   # => textmate
-      #
-      def editor_name
-        File.basename(Pry.config.editor).split(" ").first
-      end
-
+    # Get the name of the binary that Pry.config.editor points to.
+    #
+    # This is useful for deciding which flags we pass to the editor as
+    # we can just use the program's name and ignore any absolute paths.
+    #
+    # @example
+    #   Pry.config.editor="/home/conrad/bin/textmate -w"
+    #   editor_name
+    #   # => textmate
+    #
+    def editor_name
+      File.basename(_pry_.config.editor).split(" ").first
     end
+
   end
 end