pry 0.11.3 → 0.12.0

data/lib/pry/helpers/text.rb

@@ -18,11 +18,11 @@ class Pry
 
       COLORS.each_pair do |color, value|
         define_method color do |text|
-          "\033[0;#{30+value}m#{text}\033[0m"
+          "\033[0;#{30 + value}m#{text}\033[0m"
         end
 
         define_method "bright_#{color}" do |text|
-          "\033[1;#{30+value}m#{text}\033[0m"
+          "\033[1;#{30 + value}m#{text}\033[0m"
         end
 
         COLORS.each_pair do |bg_color, bg_value|
@@ -60,7 +60,6 @@ class Pry
       def default(text)
         text.to_s
       end
-      alias_method :bright_default, :bold
 
       #
       # @yield
@@ -95,7 +94,7 @@ class Pry
       # @param  [#each_line] text
       # @param  [Fixnum] offset
       # @return [String]
-      def with_line_numbers(text, offset, color=:blue)
+      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|

data/lib/pry/history.rb

@@ -7,7 +7,7 @@ class Pry
     # @return [Fixnum] Number of lines in history when Pry first loaded.
     attr_reader :original_lines
 
-    def initialize(options={})
+    def initialize(options = {})
       @history = []
       @original_lines = 0
       @file_path = options[:file_path]
@@ -25,8 +25,8 @@ class Pry
         @pusher  = method(:push_to_readline)
         @clearer = method(:clear_readline)
       else
-        @pusher  = proc { }
-        @clearer = proc { }
+        @pusher  = proc {}
+        @clearer = proc {}
       end
     end
 
@@ -34,6 +34,8 @@ class Pry
     # @return [Integer] The number of lines loaded
     def load
       @loader.call do |line|
+        next if invalid_readline_line?(line)
+
         @pusher.call(line.chomp)
         @history << line.chomp
         @original_lines += 1
@@ -44,7 +46,9 @@ class Pry
     # @param [String] line
     # @return [String] The same line that was passed in
     def push(line)
-      unless line.empty? || (@history.last && line == @history.last)
+      empty_or_invalid_line = line.empty? || invalid_readline_line?(line)
+
+      unless empty_or_invalid_line || (@history.last && line == @history.last)
         @pusher.call(line)
         @history << line
         if !should_ignore?(line) && Pry.config.history.should_save
@@ -107,8 +111,8 @@ class Pry
       if File.exist?(path)
         File.foreach(path) { |line| yield(line) }
       end
-    rescue => error
-      warn "History file not loaded: #{error.message}"
+    rescue SystemCallError => error
+      warn "Unable to read history file: #{error.message}"
     end
 
     # The default pusher. Appends the given line to Readline::HISTORY.
@@ -132,17 +136,26 @@ class Pry
       if defined?(@history_file)
         @history_file
       else
+        unless File.exist?(history_file_path)
+          FileUtils.mkdir_p(File.dirname(history_file_path))
+        end
         @history_file = File.open(history_file_path, 'a', 0600).tap do |file|
           file.sync = true
         end
       end
-    rescue Errno::EACCES
-      warn 'History not saved; unable to open your history file for writing.'
+    rescue SystemCallError => error
+      warn "Unable to write history file: #{error.message}"
       @history_file = false
     end
 
     def history_file_path
       File.expand_path(@file_path || Pry.config.history.file)
     end
+
+    def invalid_readline_line?(line)
+      # `Readline::HISTORY << line` raises an `ArgumentError` if `line`
+      # includes a null byte
+      line.include?("\0")
+    end
   end
 end

data/lib/pry/hooks.rb

@@ -15,7 +15,7 @@ class Pry
     end
 
     # Ensure that duplicates have their @hooks object.
-    def initialize_copy(orig)
+    def initialize_copy(_orig)
       hooks_dup = @hooks.dup
       @hooks.each do |k, v|
         hooks_dup[k] = v.dup
@@ -32,7 +32,7 @@ class Pry
     #
     # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
     # @return [Pry:Hooks] The receiver.
-    # @see {#merge}
+    # @see #merge
     def merge!(other)
       @hooks.merge!(other.dup.hooks) do |key, array, other_array|
         temp_hash, output = {}, []
@@ -65,7 +65,7 @@ class Pry
     # @param [#call] callable The callable.
     # @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)
+    def add_hook(event_name, hook_name, callable = nil, &block)
       event_name = event_name.to_s
 
       # do not allow duplicates, but allow multiple `nil` hooks

data/lib/pry/indent.rb

@@ -143,10 +143,9 @@ class Pry
       prefix = indent_level
 
       input.lines.each do |line|
-
         if in_string?
           tokens = tokenize("#{open_delimiters_line}\n#{line}")
-          tokens = tokens.drop_while{ |token, type| !(String === token && token.include?("\n")) }
+          tokens = tokens.drop_while { |token, type| !(String === token && token.include?("\n")) }
           previously_in_string = true
         else
           tokens = tokenize(line)
@@ -155,7 +154,7 @@ class Pry
 
         before, after = indentation_delta(tokens)
 
-        before.times{ prefix.sub! SPACES, '' }
+        before.times { prefix.sub! SPACES, '' }
         new_prefix = prefix + SPACES * after
 
         line = prefix + line.lstrip unless previously_in_string
@@ -215,7 +214,7 @@ class Pry
       # If the list of tokens contains a matching closing token the line should
       # not be indented (and thus we should return true).
       tokens.each do |token, kind|
-        is_singleline_if  = (SINGLELINE_TOKENS.include?(token)) && end_of_statement?(last_token, last_kind)
+        is_singleline_if = (SINGLELINE_TOKENS.include?(token)) && end_of_statement?(last_token, last_kind)
         is_optional_do = (token == "do" && seen_for_at.include?(add_after - 1))
 
         last_token, last_kind = token, kind unless kind == :space
@@ -358,7 +357,7 @@ class Pry
     #
     # @param [String] token  a token from Coderay
     # @param [Symbol] kind  the kind of that token
-    def track_module_nesting_end(token, kind=:keyword)
+    def track_module_nesting_end(token, kind = :keyword)
       if kind == :keyword && (token == "class" || token == "module")
         @module_nesting.pop
       end
@@ -382,25 +381,24 @@ class Pry
     # the correct indentation. Mostly useful for fixing 'end'.
     #
     # @param [String] prompt The user's prompt
-    # @param [String] code   The code the user just typed in.
-    # @param [Fixnum] overhang (0) The number of chars to erase afterwards (i.e.,
-    #   the difference in length between the old line and the new one).
-    # @return [String]
-    def correct_indentation(prompt, code, overhang=0)
+    # @param [String] code The code the user just typed in
+    # @param [Integer] overhang The number of characters to erase afterwards (the
+    #   the difference in length between the old line and the new one)
+    #
+    # @return [String] correctly indented line
+    def correct_indentation(prompt, code, overhang = 0)
       prompt = prompt.delete("\001\002")
       line_to_measure = Pry::Helpers::Text.strip_color(prompt) << code
       whitespace = ' ' * overhang
 
-      _, cols = Terminal.screen_size
-
-      cols = cols.to_i
-      lines = (cols != 0 ? (line_to_measure.length / cols + 1) : 1).to_i
+      cols = Terminal.width!
+      lines = cols == 0 ? 1 : (line_to_measure.length / cols + 1).to_i
 
-      if Pry::Helpers::BaseHelpers.windows_ansi?
-        move_up   = "\e[#{lines}F"
+      if Helpers::Platform.windows_ansi?
+        move_up = "\e[#{lines}F"
         move_down = "\e[#{lines}E"
       else
-        move_up   = "\e[#{lines}A\e[0G"
+        move_up = "\e[#{lines}A\e[0G"
         move_down = "\e[#{lines}B\e[0G"
       end
 

data/lib/pry/input_completer.rb

@@ -34,7 +34,7 @@ class Pry::InputCompleter
                    "yield" ]
 
   Operators = [
-               "%", "&", "*", "**", "+",  "-",  "/",
+               "%", "&", "*", "**", "+", "-", "/",
                "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
                "[]", "[]=", "^", "!", "!=", "!~"
               ]
@@ -92,7 +92,7 @@ class Pry::InputCompleter
       when SYMBOL_REGEXP # Symbol
         if Symbol.respond_to?(:all_symbols)
           sym        = Regexp.quote($1)
-          candidates = Symbol.all_symbols.collect{|s| ":" << s.id2name}
+          candidates = Symbol.all_symbols.collect { |s| ":" << s.id2name }
           candidates.grep(/^#{sym}/)
         else
           []
@@ -100,7 +100,7 @@ class Pry::InputCompleter
       when TOPLEVEL_LOOKUP_REGEXP # Absolute Constant or class methods
         receiver = $1
         candidates = Object.constants.collect(&:to_s)
-        candidates.grep(/^#{receiver}/).collect{|e| "::" << e}
+        candidates.grep(/^#{receiver}/).collect { |e| "::" << e }
       when CONSTANT_REGEXP # Constant
         message = $1
         begin
@@ -120,7 +120,7 @@ class Pry::InputCompleter
         rescue Pry::RescuableException
           candidates = []
         end
-        candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
+        candidates.grep(/^#{message}/).collect { |e| receiver + "::" + e }
       when SYMBOL_METHOD_CALL_REGEXP # method call on a Symbol
         receiver = $1
         message = Regexp.quote($2)
@@ -167,10 +167,12 @@ class Pry::InputCompleter
           end
         else
           # func1.func2
+          require 'set'
           candidates = Set.new
           to_ignore = ignored_modules
-          ObjectSpace.each_object(Module){|m|
+          ObjectSpace.each_object(Module) { |m|
             next if (to_ignore.include?(m) rescue true)
+
             # jruby doesn't always provide #instance_methods() on each
             # object.
             if m.respond_to?(:instance_methods)
@@ -195,7 +197,7 @@ class Pry::InputCompleter
         if eval("respond_to?(:class_variables)", bind)
           candidates += eval("class_variables", bind).collect(&:to_s)
         end
-        candidates = (candidates|ReservedWords|custom_completions).grep(/^#{Regexp.quote(input)}/)
+        candidates = (candidates | ReservedWords | custom_completions).grep(/^#{Regexp.quote(input)}/)
         candidates.collect(&path)
       end
     rescue Pry::RescuableException
@@ -220,7 +222,8 @@ class Pry::InputCompleter
   # path is a proc that takes an input and builds a full path.
   def build_path(input)
     # check to see if the input is a regex
-    return proc {|i| i.to_s }, input if input[/\/\./]
+    return proc { |i| i.to_s }, input if input[/\/\./]
+
     trailing_slash = input.end_with?('/')
     contexts = input.chomp('/').split(/\//)
     input = contexts[-1]
@@ -241,6 +244,7 @@ class Pry::InputCompleter
 
     scanner = lambda do |m|
       next if s.include?(m) # IRB::ExtendCommandBundle::EXCB recurses.
+
       s << m
       m.constants(false).each do |c|
         value = m.const_get(c)
@@ -251,6 +255,7 @@ class Pry::InputCompleter
     # FIXME: Add Pry here as well?
     [:IRB, :SLex, :RubyLex, :RubyToken].each do |module_name|
       next unless Object.const_defined?(module_name)
+
       scanner.call(Object.const_get(module_name))
     end
 

data/lib/pry/input_lock.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 class Pry
   # There is one InputLock per input (such as STDIN) as two REPLs on the same
   # input makes things delirious. InputLock serializes accesses to the input so

data/lib/pry/last_exception.rb

@@ -23,7 +23,7 @@ class Pry::LastException < BasicObject
     end
   end
 
-  def respond_to_missing?(name, include_all=false)
+  def respond_to_missing?(name, include_all = false)
     @e.respond_to?(name, include_all)
   end
 

data/lib/pry/method.rb

@@ -39,7 +39,7 @@ class Pry
       #   contain any context.
       # @return [Pry::Method, nil] A `Pry::Method` instance containing the requested
       #   method, or `nil` if name is `nil` or no method could be located matching the parameters.
-      def from_str(name, target=TOPLEVEL_BINDING, options={})
+      def from_str(name, target = TOPLEVEL_BINDING, options = {})
         if name.nil?
           nil
         elsif name.to_s =~ /(.+)\#(\S+)\Z/
@@ -56,8 +56,8 @@ class Pry
         elsif options[:methods]
           from_obj(target.eval("self"), name, target)
         else
-          from_str(name, target, :instance => true) or
-            from_str(name, target, :methods => true)
+          from_str(name, target, instance: true) or
+            from_str(name, target, methods: true)
         end
 
       rescue Pry::RescuableException
@@ -101,7 +101,7 @@ class Pry
       # @param [Symbol] method_type The type of method: :method or :instance_method
       # @param [Binding] target The binding where the method is looked up.
       # @return [Method, UnboundMethod] The 'refined' method object.
-      def lookup_method_via_binding(obj, method_name, method_type, target=TOPLEVEL_BINDING)
+      def lookup_method_via_binding(obj, method_name, method_type, target = TOPLEVEL_BINDING)
         Pry.current[:obj] = obj
         Pry.current[:name] = method_name
         receiver = obj.is_a?(Module) ? "Module" : "Kernel"
@@ -118,7 +118,7 @@ class Pry
       # @param [String] name
       # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
-      def from_class(klass, name, target=TOPLEVEL_BINDING)
+      def from_class(klass, name, target = TOPLEVEL_BINDING)
         new(lookup_method_via_binding(klass, name, :instance_method, target)) rescue nil
       end
       alias from_module from_class
@@ -131,7 +131,7 @@ class Pry
       # @param [String] name
       # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
-      def from_obj(obj, name, target=TOPLEVEL_BINDING)
+      def from_obj(obj, name, target = TOPLEVEL_BINDING)
         new(lookup_method_via_binding(obj, name, :method, target)) rescue nil
       end
 
@@ -139,10 +139,10 @@ class Pry
       # @param [Class,Module] klass
       # @param [Boolean] include_super Whether to include methods from ancestors.
       # @return [Array[Pry::Method]]
-      def all_from_class(klass, include_super=true)
+      def all_from_class(klass, include_super = true)
         %w(public protected private).flat_map do |visibility|
           safe_send(klass, :"#{visibility}_instance_methods", include_super).map do |method_name|
-            new(safe_send(klass, :instance_method, method_name), :visibility => visibility.to_sym)
+            new(safe_send(klass, :instance_method, method_name), visibility: visibility.to_sym)
           end
         end
       end
@@ -157,7 +157,7 @@ class Pry
       #
       # @return [Array[Pry::Method]]
       #
-      def all_from_obj(obj, include_super=true)
+      def all_from_obj(obj, include_super = true)
         all_from_class(singleton_class_of(obj), include_super)
       end
 
@@ -166,7 +166,7 @@ class Pry
       #  please use {all_from_obj} instead.
       #  the `method_type` argument is ignored.
       #
-      def all_from_common(obj, method_type = nil, include_super=true)
+      def all_from_common(obj, _method_type = nil, include_super = true)
         all_from_obj(obj, include_super)
       end
 
@@ -233,7 +233,7 @@ class Pry
     # @param [::Method, UnboundMethod, Proc] method
     # @param [Hash] known_info Can be used to pre-cache expensive to compute stuff.
     # @return [Pry::Method]
-    def initialize(method, known_info={})
+    def initialize(method, known_info = {})
       @method = method
       @visibility = known_info[:visibility]
     end
@@ -298,7 +298,8 @@ class Pry
     # @return [String, nil] The documentation for the method, or `nil` if it's
     #   unavailable.
     def doc
-      @doc ||= case source_type
+      @doc ||=
+        case source_type
         when :c
           info = pry_doc_info
           info.docstring if info
@@ -317,7 +318,7 @@ class Pry
     #   `nil` if the filename is unavailable.
     def source_file
       if source_location.nil?
-        if !rbx? and source_type == :c
+        if source_type == :c
           info = pry_doc_info
           info.file if info
         end
@@ -354,20 +355,24 @@ class Pry
 
     # @return [String] A representation of the method's signature, including its
     #   name and parameters. Optional and "rest" parameters are marked with `*`
-    #   and block parameters with `&`. If the parameter names are unavailable,
-    #   they're given numbered names instead.
+    #   and block parameters with `&`. Keyword arguments are shown with `:`
+    #   If the parameter names are unavailable, they're given numbered names instead.
     #   Paraphrased from `awesome_print` gem.
     def signature
       if respond_to?(:parameters)
-        args = parameters.inject([]) do |arr, (typ, nam)|
-          nam ||= (typ == :block ? 'block' : "arg#{arr.size + 1}")
-          arr << case typ
-                 when :req   then nam.to_s
-                 when :opt   then "#{nam}=?"
-                 when :rest  then "*#{nam}"
-                 when :block then "&#{nam}"
-                 else '?'
-                 end
+        args = parameters.inject([]) do |args_array, (arg_type, name)|
+          name ||= (arg_type == :block ? 'block' : "arg#{args_array.size + 1}")
+          args_array.push(
+            case arg_type
+            when :req    then name.to_s
+            when :opt    then "#{name}=?"
+            when :rest   then "*#{name}"
+            when :block  then "&#{name}"
+            when :key    then "#{name}:?"
+            when :keyreq then "#{name}:"
+            else '?'
+            end
+          )
         end
       else
         args = (1..arity.abs).map { |i| "arg#{i}" }
@@ -379,7 +384,7 @@ class Pry
 
     # @return [Pry::Method, nil] The wrapped method that is called when you
     #   use "super" in the body of this method.
-    def super(times=1)
+    def super(times = 1)
       if UnboundMethod === @method
         sup = super_using_ancestors(Pry::Method.instance_resolution_order(owner), times)
       else
@@ -393,6 +398,7 @@ class Pry
     #   before any aliasing, or `nil` if it can't be determined.
     def original_name
       return nil if source_type != :ruby
+
       method_name_from_first_line(source.lines.first)
     end
 
@@ -461,7 +467,7 @@ class Pry
 
     # @param [String, Symbol] method_name
     # @return [Boolean]
-    def respond_to?(method_name, include_all=false)
+    def respond_to?(method_name, include_all = false)
       super or @method.respond_to?(method_name, include_all)
     end
 
@@ -483,7 +489,7 @@ class Pry
         Pry::MethodInfo.info_for(@method) or raise CommandError, "Cannot locate this method: #{name}. (source_location returns nil)"
       else
         fail_msg = "Cannot locate this method: #{name}."
-        if mri?
+        if Helpers::Platform.mri?
           fail_msg += " Invoke the 'gem-install pry-doc' Pry command to get access to Ruby Core documentation.\n"
         end
         raise CommandError, fail_msg
@@ -492,7 +498,7 @@ class Pry
 
     # @param [Class, Module] ancestors The ancestors to investigate
     # @return [Method] The unwrapped super-method
-    def super_using_ancestors(ancestors, times=1)
+    def super_using_ancestors(ancestors, times = 1)
       next_owner = self.owner
       times.times do
         i = ancestors.index(next_owner) + 1
@@ -529,9 +535,9 @@ class Pry
     end
 
     def ruby_source
-      # clone of MethodSource.source_helper that knows to use our
-      # hacked version of source_location for rbx core methods, and
-      # our input buffer for methods defined in (pry)
+      # Clone of `MethodSource.source_helper` that knows to use our
+      # hacked version of `source_location` for our input buffer for methods
+      # defined in `(pry)`.
       file, line = *source_location
       raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file