pry 0.9.7.4-i386-mingw32 → 0.9.8-i386-mingw32

data/lib/pry/helpers/options_helpers.rb

@@ -3,55 +3,24 @@ class Pry
     module OptionsHelpers
       module_function
 
-      # Use Slop to parse the arguments given.
-      #
-      # @param [Array] args  The options are stripped out by Slop.
-      # @param [*Symbol] extras  Extra features you want returned.
-      # @param [&Block]  used to add custom arguments to Slop.
-      #
-      # @option [Extra] :method_object Returns a method object.
-      #
-      # @return Slop::Options iff you don't pass any extras.
-      # @return [Array]  If you do pass extras, an array is returned where the first argument is the
-      # Slop::Options object, and the remainder are the extras you requested in order.
-      #
-      def parse_options!(args, *extras, &block)
-        opts = Slop.parse!(args) do |opt|
-          extras.each{ |extra| send(:"add_#{extra}_options", opt) }
-
-          yield opt
-
-          opt.on :h, :help, "This message" do
-            output.puts opt
-            throw :command_done
-          end
-        end
-
-        if extras.empty?
-          opts
-        else
-          [opts] + extras.map{ |extra| send(:"process_#{extra}_options", args, opts) }
-        end
-      end
-
-      # Add the method object options to an unused Slop instance.
-      def add_method_object_options(opt)
+      # Add method options to the 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."
+        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.", true do |context|
           @method_target = Pry.binding_for(target.eval(context))
         end
       end
 
-      # Add the derived :method_object option to a used Slop instance.
-      def process_method_object_options(args, opts)
-        opts[:instance] = opts['instance-methods'] if opts.m?
-        # TODO: de-hack when we upgrade Slop: https://github.com/injekt/slop/pull/30
-        opts.options[:super].force_argument_value opts.options[:super].count if opts.super?
-
-        get_method_or_raise(args.empty? ? nil : args.join(" "), @method_target, opts.to_hash(true))
+      # 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

data/lib/pry/helpers/text.rb

@@ -1,7 +1,7 @@
 class Pry
   module Helpers
 
-    # The methods defined on {Text} are available to custom commands via {Pry::CommandContext#text}.
+    # The methods defined on {Text} are available to custom commands via {Pry::Command#text}.
     module Text
 
       COLORS =
@@ -61,11 +61,23 @@ class Pry
         # @param [Proc]
         # @return [void]
         def no_color &block
-          boolean = Pry.color
-          Pry.color = false
+          boolean = Pry.config.color
+          Pry.config.color = false
           yield
         ensure
-          Pry.color = boolean
+          Pry.config.color = boolean
+        end
+
+        # Executes _block_ with _Pry.config.pager_ set to false.
+        #
+        # @param [Proc]
+        # @return [void]
+        def no_pager &block
+          boolean = Pry.config.pager
+          Pry.config.pager = false
+          yield
+        ensure
+          Pry.config.pager = boolean
         end
 
         # Returns _text_ in a numbered list, beginning at _offset_.
@@ -81,6 +93,14 @@ class Pry
             "#{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

data/lib/pry/history.rb

@@ -1,61 +1,99 @@
 class Pry
   # The History class is responsible for maintaining the user's input history, both
-  # internally and within Readline::HISTORY.
+  # internally and within Readline.
   class History
+    attr_accessor :loader, :saver, :pusher, :clearer
+
     def initialize
       @history = []
       @saved_lines = 0
+      restore_default_behavior
+    end
+
+    # Assign the default methods for loading, saving, pushing, and clearing.
+    def restore_default_behavior
+      @loader  = method(:read_from_file)
+      @saver   = method(:write_to_file)
+      @pusher  = method(:push_to_readline)
+      @clearer = method(:clear_readline)
     end
 
-    # Loads a file's contents into the input history.
-    # @param [String] filename
+    # Load the input history using `History.loader`.
     # @return [Integer] The number of lines loaded
-    def load(filename)
-      File.foreach(filename) do |line|
-        Readline::HISTORY << line.chomp
+    def load
+      @loader.call do |line|
+        @pusher.call(line.chomp)
         @history << line.chomp
       end
       @saved_lines = @history.length
     end
 
-    # Appends input history from this session to a file.
-    # @param [String] filename
+    # Write this session's history using `History.saver`.
     # @return [Integer] The number of lines saved
-    def save(filename)
+    def save
       history_to_save = @history[@saved_lines..-1]
-      File.open(filename, 'a') do |f|
-        history_to_save.each { |ln| f.puts ln }
-      end
+      @saver.call(history_to_save)
       @saved_lines = @history.length
       history_to_save.length
     end
 
-    # Adds a line to the input history, ignoring blank and duplicate lines.
+    # 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)
       unless line.empty? || (@history.last && line == @history.last)
-        Readline::HISTORY << line
+        @pusher.call(line)
         @history << line
       end
       line
     end
     alias << push
 
-    # Clears all history. Anything the user entered before this point won't be
+    # Clear all history. Anything the user entered before this point won't be
     # saved, but anything they put in afterwards will still be appended to the
     # history file on exit.
     def clear
-      Readline::HISTORY.shift until Readline::HISTORY.empty?
+      @clearer.call
       @history = []
       @saved_lines = 0
     end
 
-    # Returns an Array containing all stored history.
+    # 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
+
+    private
+    # The default loader. Yields lines from `Pry.history.config.file`.
+    def read_from_file
+      history_file = File.expand_path(Pry.config.history.file)
+
+      if File.exists?(history_file)
+        File.foreach(history_file) { |line| yield(line) }
+      end
+    end
+
+    # The default saver. Appends the given lines to `Pry.history.config.file`.
+    # @param [Array<String>] lines
+    def write_to_file(lines)
+      history_file = File.expand_path(Pry.config.history.file)
+
+      File.open(history_file, 'a') do |f|
+        lines.each { |ln| f.puts ln }
+      end
+    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
   end
 end

data/lib/pry/history_array.rb

@@ -72,6 +72,8 @@ class Pry
     def size
       @count
     end
+    alias count size
+    alias length size
 
     def empty?
       size == 0

data/lib/pry/hooks.rb

@@ -0,0 +1,252 @@
+class Pry
+
+  # Implements a hooks system for Pry. A hook is a callable that is
+  # associated with an event. A number of events are currently
+  # provided by Pry, these include: `:when_started`, `:before_session`, `:after_session`.
+  # A hook must have a name, and is connected with an event by the
+  # `Pry::Hooks#add_hook` method.
+  # @example Adding a hook for the `:before_session` event.
+  #   Pry.config.hooks.add_hook(:before_session, :say_hi) do
+  #     puts "hello"
+  #   end
+  class Hooks
+
+    # Converts a hash to a `Pry::Hooks` instance. All hooks defined
+    # this way are anonymous. This functionality is primarily to
+    # provide backwards-compatibility with the old hash-based hook
+    # system in Pry versions < 0.9.8
+    # @param [Hash] hash The hash to convert to `Pry::Hooks`.
+    # @return [Pry::Hooks] The resulting `Pry::Hooks` instance.
+    def self.from_hash(hash)
+      instance = new
+      hash.each do |k, v|
+        instance.add_hook(k, nil, v)
+      end
+
+      instance
+    end
+
+    def initialize
+      @hooks = {}
+    end
+
+    # Ensure that duplicates have their @hooks object
+    def initialize_copy(orig)
+      hooks_dup = @hooks.dup
+      @hooks.each do |k, v|
+        hooks_dup[k] = v.dup
+      end
+
+      @hooks = hooks_dup
+    end
+
+    def hooks
+      @hooks
+    end
+    protected :hooks
+
+    def errors
+      @errors ||= []
+    end
+
+    # FIXME:
+    # This is a hack to alert people of the new API.
+    def [](event_name)
+      warn "`Pry.hooks[]` is deprecated! Please use the new `Pry::Hooks` API! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
+
+      get_hook(event_name, nil)
+    end
+
+    # FIXME:
+    # This is a hack to alert people of the new API.
+    def []=(event_name, callable)
+      warn "`Pry.hooks[]=` is deprecated! Please use the new `Pry::Hooks` API! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
+
+      add_hook(event_name, nil, callable)
+    end
+
+    # Destructively merge the contents of two `Pry:Hooks` instances.
+    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
+    # @return [Pry:Hooks] Returns the receiver.
+    # @example
+    #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   Pry::Hooks.new.merge!(hooks)
+    def merge!(other)
+      @hooks.merge!(other.dup.hooks) do |key, v1, v2|
+        merge_arrays(v1, v2)
+      end
+
+      self
+    end
+
+    def merge_arrays(array1, array2)
+      uniq_keeping_last(array1 + array2, &:first)
+    end
+    private :merge_arrays
+
+    def uniq_keeping_last(input, &block)
+      hash, output = {}, []
+      input.reverse.each{ |i| hash[block[i]] ||= (output.unshift i) }
+      output
+    end
+    private :uniq_keeping_last
+
+    # Return a new `Pry::Hooks` instance containing a merge of the contents of two `Pry:Hooks` instances,
+    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
+    # @return [Pry::Hooks] The new hash.
+    # @example
+    #   hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   Pry::Hooks.new.merge(hooks)
+    def merge(other)
+      self.dup.tap do |v|
+        v.merge!(other)
+      end
+    end
+
+    # Add a new hook to be executed for the `name` even.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook.
+    # @param [#call] callable The callable.
+    # @yield The block to use as the callable (if `callable` parameter not provided)
+    # @return [Pry:Hooks] Returns the receiver.
+    # @example
+    #   Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    def add_hook(event_name, hook_name, callable=nil, &block)
+      @hooks[event_name] ||= []
+
+      # do not allow duplicates, but allow multiple `nil` hooks
+      # (anonymous hooks)
+      if hook_exists?(event_name, hook_name) && !hook_name.nil?
+        raise ArgumentError, "Hook with name '#{hook_name}' already defined!"
+      end
+
+      if !block && !callable
+        raise ArgumentError, "Must provide a block or callable."
+      end
+
+      # ensure we only have one anonymous hook
+      @hooks[event_name].delete_if { |h, k| h.nil? } if hook_name.nil?
+
+      if block
+        @hooks[event_name] << [hook_name, block]
+      elsif callable
+        @hooks[event_name] << [hook_name, callable]
+      end
+
+      self
+    end
+
+    # Execute the list of hooks for the `event_name` event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Array] args The arguments to pass to each hook function.
+    # @return [Object] The return value of the last executed hook.
+    # @example
+    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   my_hooks.exec_hook(:before_session) #=> OUTPUT: "hi!"
+    def exec_hook(event_name, *args, &block)
+      @hooks[event_name] ||= []
+
+      # silence warnings to get rid of 1.8's "warning: multiple values
+      # for a block parameter" warnings
+      Pry::Helpers::BaseHelpers.silence_warnings do
+        @hooks[event_name].map do |hook_name, callable|
+          begin
+            callable.call(*args, &block)
+          rescue RescuableException => e
+            errors << e
+            e
+          end
+        end.last
+      end
+    end
+
+    # Return the number of hook functions registered for the `event_name` event.
+    # @param [Symbol] event_name The name of the event.
+    # @return [Fixnum] The number of hook functions for `event_name`.
+    # @example
+    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   my_hooks.count(:before_session) #=> 1
+    def hook_count(event_name)
+      @hooks[event_name] ||= []
+      @hooks[event_name].size
+    end
+
+    # Return a specific hook for a given event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol[ hook_name The name of the hook
+    # @return [#call] The requested hook.
+    # @example
+    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   my_hooks.get_hook(:before_session, :say_hi).call #=> "hi!"
+    def get_hook(event_name, hook_name)
+      @hooks[event_name] ||= []
+      hook = @hooks[event_name].find { |current_hook_name, callable| current_hook_name == hook_name }
+      hook.last if hook
+    end
+
+    # Return the hash of hook names / hook functions for a
+    # given event. (Note that modifying the returned hash does not
+    # alter the hooks, use add_hook/delete_hook for that).
+    # @param [Symbol] event_name The name of the event.
+    # @return [Hash] The hash of hook names / hook functions.
+    # @example
+    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   my_hooks.get_hooks(:before_session) #=> {:say_hi=>#<Proc:0x00000101645e18@(pry):9>}
+    def get_hooks(event_name)
+      @hooks[event_name] ||= []
+      Hash[@hooks[event_name]]
+    end
+
+    # Delete a hook for an event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook.
+    #   to delete.
+    # @return [#call] The deleted hook.
+    # @example
+    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   my_hooks.delete_hook(:before_session, :say_hi)
+    def delete_hook(event_name, hook_name)
+      @hooks[event_name] ||= []
+      deleted_callable = nil
+
+      @hooks[event_name].delete_if do |current_hook_name, callable|
+        if current_hook_name == hook_name
+          deleted_callable = callable
+          true
+        else
+          false
+        end
+      end
+      deleted_callable
+    end
+
+    # Clear all hooks functions for a given event.
+    # @param [String] event_name The name of the event.
+    # @example
+    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   my_hooks.delete_hook(:before_session)
+    def delete_hooks(event_name)
+      @hooks[event_name] = []
+    end
+
+    alias_method :clear, :delete_hooks
+
+    # Remove all events and hooks, clearing out the Pry::Hooks
+    # instance completely.
+    # @example
+    #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   my_hooks.clear_all
+    def clear_all
+      @hooks = {}
+    end
+
+    # @param [Symbol] event_name Name of the event.
+    # @param [Symbol] hook_name Name of the hook.
+    # @return [Boolean] Whether the hook by the name `hook_name`
+    def hook_exists?(event_name, hook_name)
+      !!@hooks[event_name].find { |name, _| name == hook_name }
+    end
+    private :hook_exists?
+
+  end
+end