pry 0.10.4 → 0.11.0.pre

data/lib/pry/config/default.rb

@@ -1,12 +1,13 @@
 class Pry::Config::Default
   include Pry::Config::Behavior
+  include Pry::Config::Lazy
 
-  default = {
+  lazy_implement({
     input: proc {
       lazy_readline
     },
     output: proc {
-      $stdout
+      $stdout.tap { |out| out.sync = true }
     },
     commands: proc {
       Pry::Commands
@@ -110,43 +111,30 @@ class Pry::Config::Default
     completer: proc {
       require "pry/input_completer"
       Pry::InputCompleter
+    },
+    gist: proc {
+      Pry::Config.from_hash({inspecter: proc(&:pretty_inspect)}, nil)
+    },
+    history: proc {
+      Pry::Config.from_hash({should_save: true, should_load: true}, nil).tap do |history|
+        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
+    },
+    exec_string: proc {
+      ""
     }
-  }
+  })
 
   def initialize
     super(nil)
-    configure_gist
-    configure_history
-  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
 
+  private
   def lazy_readline
     require 'readline'
     Readline

data/lib/pry/config/lazy.rb

@@ -0,0 +1,25 @@
+module Pry::Config::Lazy
+  LAZY_KEYS = Hash.new {|h,k| h[k] = [] }
+
+  module ClassMethods
+    def lazy_implement(method_name_to_func)
+      method_name_to_func.each do |method_name, func|
+        define_method(method_name) do
+          if method_name_to_func[method_name].equal?(func)
+            method_name_to_func[method_name] = instance_eval(&func)
+          end
+          method_name_to_func[method_name]
+        end
+      end
+      LAZY_KEYS[self] |= method_name_to_func.keys
+    end
+  end
+
+  def self.included(includer)
+    includer.extend(ClassMethods)
+  end
+
+  def lazy_keys
+    LAZY_KEYS[self.class]
+  end
+end

data/lib/pry/editor.rb

@@ -44,7 +44,7 @@ class Pry
         _pry_.config.editor.call(*args)
       else
         sanitized_file = if windows?
-                            file.gsub(/\//, '\\')
+                            file
                           else
                             Shellwords.escape(file)
                           end

data/lib/pry/exceptions.rb

@@ -52,7 +52,7 @@ class Pry
     def self.===(exception)
       ["can't modify frozen class/module",
        "can't modify frozen Class",
-       "can't modify frozen object"
+       "can't modify frozen object",
       ].include?(exception.message)
     end
   end

data/lib/pry/helpers/base_helpers.rb

@@ -32,7 +32,7 @@ class Pry
       end
 
       def not_a_real_file?(file)
-        file =~ /(\(.*\))|<.*>/ || file =~ /__unknown__/ || file == "" || file == "-e"
+        file =~ /^(\(.*\))$|^<.*>$/ || file =~ /__unknown__/ || file == "" || file == "-e"
       end
 
       def command_dependencies_met?(options)
@@ -94,19 +94,15 @@ class Pry
         mri? && RUBY_VERSION =~ /^2/
       end
 
-      def mri_20?
-        mri? && RUBY_VERSION =~ /^2\.0/
-      end
-
-      def mri_21?
-        mri? && RUBY_VERSION =~ /^2\.1/
-      end
-
       # Send the given text through the best available pager (if Pry.config.pager is
       # enabled). Infers where to send the output if used as a mixin.
       # DEPRECATED.
       def stagger_output(text, out = nil)
-        Pry.new.pager.page text
+        if _pry_
+          _pry_.pager.page text
+        else
+          Pry.new.pager.page text
+        end
       end
     end
   end

data/lib/pry/helpers/documentation_helpers.rb

@@ -12,6 +12,7 @@ class Pry
         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}`" }

data/lib/pry/helpers/options_helpers.rb

@@ -3,7 +3,7 @@ class Pry
     module OptionsHelpers
       module_function
 
-      # Add method options to the Slop instance
+      # Add method options to the Pry::Slop instance
       def method_options(opt)
         @method_target = target
         opt.on :M, "instance-methods", "Operate on instance methods."

data/lib/pry/helpers/text.rb

@@ -1,9 +1,8 @@
 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,
@@ -17,91 +16,85 @@ class Pry
         "white"   => 7
       }
 
-      class << self
-
-        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 |color, value|
+        define_method color do |text|
+          "\001\033[0;#{30+value}m\002#{text}\001\033[0m\002"
         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(/\e\[.*?(\d)+m/ , '')
+        define_method "bright_#{color}" do |text|
+          "\001\033[1;#{30+value}m\002#{text}\001\033[0m\002"
         end
+      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
+      # 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` 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
-        alias_method :bright_default, :bold
+      # 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
 
-        # Executes the block with `Pry.config.color` set to false.
-        # @yield
-        # @return [void]
-        def no_color(&block)
-          boolean = Pry.config.color
-          Pry.config.color = false
-          yield
-        ensure
-          Pry.config.color = boolean
-        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
+      alias_method :bright_default, :bold
 
-        # Executes the block with `Pry.config.pager` set to false.
-        # @yield
-        # @return [void]
-        def no_pager(&block)
-          boolean = Pry.config.pager
-          Pry.config.pager = false
-          yield
-        ensure
-          Pry.config.pager = boolean
-        end
+      # Executes the block with `Pry.config.color` set to false.
+      # @yield
+      # @return [void]
+      def no_color(&block)
+        boolean = Pry.config.color
+        Pry.config.color = false
+        yield
+      ensure
+        Pry.config.color = 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
+      # Executes the block with `Pry.config.pager` set to false.
+      # @yield
+      # @return [void]
+      def no_pager(&block)
+        boolean = Pry.config.pager
+        Pry.config.pager = false
+        yield
+      ensure
+        Pry.config.pager = boolean
+      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
+      # 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/lib/pry/history.rb

@@ -47,7 +47,9 @@ class Pry
       unless line.empty? || (@history.last && line == @history.last)
         @pusher.call(line)
         @history << line
-        @saver.call(line) if Pry.config.history.should_save
+        if !should_ignore?(line) && Pry.config.history.should_save
+          @saver.call(line)
+        end
       end
       line
     end
@@ -57,6 +59,7 @@ class Pry
     # history file.
     def clear
       @clearer.call
+      @original_lines = 0
       @history = []
     end
 
@@ -77,8 +80,26 @@ class Pry
       @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

data/lib/pry/history_array.rb

@@ -89,7 +89,7 @@ class Pry
       ((@count - size)...@count).map { |n| @hash[n] }
     end
 
-    # Returns [Hash] copy of the internal @hash history
+    # @return [Hash] copy of the internal @hash history
     def to_h
       @hash.dup
     end

data/lib/pry/hooks.rb

@@ -1,36 +1,20 @@
 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.
+  # 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)
-      return hash if hash.instance_of?(self)
-      instance = new
-      hash.each do |k, v|
-        instance.add_hook(k, nil, v)
-      end
-      instance
-    end
-
     def initialize
-      @hooks = {}
+      @hooks = Hash.new { |h, k| h[k] = [] }
     end
 
-    # Ensure that duplicates have their @hooks object
+    # Ensure that duplicates have their @hooks object.
     def initialize_copy(orig)
       hooks_dup = @hooks.dup
       @hooks.each do |k, v|
@@ -40,63 +24,49 @@ class Pry
       @hooks = hooks_dup
     end
 
-    def hooks
-      @hooks
-    end
-    protected :hooks
-
     def errors
       @errors ||= []
     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)
+    # @return [Pry:Hooks] The receiver.
+    # @see {#merge}
     def merge!(other)
-      @hooks.merge!(other.dup.hooks) do |key, v1, v2|
-        merge_arrays(v1, v2)
-      end
+      @hooks.merge!(other.dup.hooks) do |key, array, other_array|
+        temp_hash, output = {}, []
 
-      self
-    end
+        (array + other_array).reverse_each do |pair|
+          temp_hash[pair.first] ||= output.unshift(pair)
+        end
 
-    def merge_arrays(array1, array2)
-      uniq_keeping_last(array1 + array2, &:first)
-    end
-    private :merge_arrays
+        output
+      end
 
-    def uniq_keeping_last(input, &block)
-      hash, output = {}, []
-      input.reverse.each{ |i| hash[block[i]] ||= (output.unshift i) }
-      output
+      self
     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)
+    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
+    # @return [Pry::Hooks] a new `Pry::Hooks` instance containing a merge of the
+    #   contents of two `Pry:Hooks` instances.
     def merge(other)
       self.dup.tap do |v|
         v.merge!(other)
       end
     end
 
-    # Add a new hook to be executed for the `name` even.
+    # Add a new hook to be executed for the `event_name` event.
     # @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!" }
+    # @yield The block to use as the callable (if no `callable` provided).
+    # @return [Pry:Hooks] The receiver.
     def add_hook(event_name, hook_name, callable=nil, &block)
-      @hooks[event_name] ||= []
+      event_name = event_name.to_s
 
       # do not allow duplicates, but allow multiple `nil` hooks
       # (anonymous hooks)
@@ -124,13 +94,8 @@ class Pry
     # @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] ||= []
-
-      @hooks[event_name].map do |hook_name, callable|
+      @hooks[event_name.to_s].map do |hook_name, callable|
         begin
           callable.call(*args, &block)
         rescue RescuableException => e
@@ -140,56 +105,38 @@ class Pry
       end.last
     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
+      @hooks[event_name.to_s].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!"
+    # @return [#call] a specific hook for a given event.
     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 = @hooks[event_name.to_s].find do |current_hook_name, callable|
+        current_hook_name == hook_name
+      end
       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>}
+    # @note Modifying the returned hash does not alter the hooks, use
+    # `add_hook`/`delete_hook` for that.
     def get_hooks(event_name)
-      @hooks[event_name] ||= []
-      Hash[@hooks[event_name]]
+      Hash[@hooks[event_name.to_s]]
     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|
+      @hooks[event_name.to_s].delete_if do |current_hook_name, callable|
         if current_hook_name == hook_name
           deleted_callable = callable
           true
@@ -201,30 +148,24 @@ class Pry
     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 = {}
+    # @return [void]
+    def clear_event_hooks(event_name)
+      @hooks[event_name.to_s] = []
     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`
+    # @return [Boolean] Whether the hook by the name `hook_name`.
     def hook_exists?(event_name, hook_name)
-      !!(@hooks[event_name] && @hooks[event_name].find { |name, _| name == hook_name })
+      @hooks[event_name.to_s].map(&:first).include?(hook_name)
+    end
+
+    protected
+
+    def hooks
+      @hooks
     end
   end
 end