pry 0.9.12.6-java → 0.10.0-java

data/lib/pry/exceptions.rb

@@ -0,0 +1,77 @@
+class Pry
+
+  # As a REPL, we often want to catch any unexpected exceptions that may have
+  # been raised; however we don't want to go overboard and prevent the user
+  # from exiting Pry when they want to.
+  module RescuableException
+    def self.===(exception)
+      case exception
+        # Catch when the user hits ^C (Interrupt < SignalException), and assume
+        # that they just wanted to stop the in-progress command (just like bash
+        # etc.)
+      when Interrupt
+        true
+        # Don't catch signals (particularly not SIGTERM) as these are unlikely
+        # to be intended for pry itself. We should also make sure that
+        # Kernel#exit works.
+      when *Pry.config.exception_whitelist
+        false
+        # All other exceptions will be caught.
+      else
+        true
+      end
+    end
+  end
+
+  # Catches SecurityErrors if $SAFE is set
+  module Pry::TooSafeException
+    def self.===(exception)
+      $SAFE > 0 && SecurityError === exception
+    end
+  end
+
+  # An Exception Tag (cf. Exceptional Ruby) that instructs Pry to show the error
+  # in a more user-friendly manner. This should be used when the exception
+  # happens within Pry itself as a direct consequence of the user typing
+  # something wrong.
+  #
+  # This allows us to distinguish between the user typing:
+  #
+  # pry(main)> def )
+  # SyntaxError: unexpected )
+  #
+  # pry(main)> method_that_evals("def )")
+  # SyntaxError: (eval):1: syntax error, unexpected ')'
+  # from ./a.rb:2 in `eval'
+  module UserError; end
+
+  # When we try to get a binding for an object, we try to define a method on
+  # that Object's singleton class. This doesn't work for "frozen" Object's, and
+  # the exception is just a vanilla RuntimeError.
+  module FrozenObjectException
+    def self.===(exception)
+      ["can't modify frozen class/module",
+       "can't modify frozen Class",
+      ].include?(exception.message)
+    end
+  end
+
+  # Don't catch these exceptions
+  DEFAULT_EXCEPTION_WHITELIST = [SystemExit,
+                                 SignalException,
+                                 Pry::TooSafeException]
+
+  # CommandErrors are caught by the REPL loop and displayed to the user. They
+  # indicate an exceptional condition that's fatal to the current command.
+  class CommandError < StandardError; end
+  class MethodNotFound < CommandError; end
+
+  # indicates obsolete API
+  class ObsoleteError < StandardError; end
+
+  # This is to keep from breaking under Rails 3.2 for people who are doing that
+  # IRB = Pry thing.
+  module ExtendCommandBundle
+  end
+
+end

data/lib/pry/helpers/base_helpers.rb

@@ -42,25 +42,12 @@ class Pry
         end
       end
 
-      def set_file_and_dir_locals(file_name, _pry_=_pry_(), target=target())
-        return if !target or !file_name
-        _pry_.last_file = File.expand_path(file_name)
-        _pry_.inject_local("_file_", _pry_.last_file, target)
-
-        _pry_.last_dir = File.dirname(_pry_.last_file)
-        _pry_.inject_local("_dir_", _pry_.last_dir, target)
-      end
-
       def use_ansi_codes?
         windows_ansi? || ENV['TERM'] && ENV['TERM'] != "dumb"
       end
 
       def colorize_code(code)
-        if Pry.color
-          CodeRay.scan(code, :ruby).term
-        else
-          code
-        end
+        CodeRay.scan(code, :ruby).term
       end
 
       def highlight(string, regexp, highlight_color=:bright_yellow)
@@ -70,7 +57,7 @@ class Pry
       # formatting
       def heading(text)
         text = "#{text}\n--"
-        Pry.color ? "\e[1m#{text}\e[0m": text
+        "\e[1m#{text}\e[0m"
       end
 
       # have fun on the Windows platform.
@@ -80,7 +67,7 @@ class Pry
 
       # are we able to use ansi on windows?
       def windows_ansi?
-        defined?(Win32::Console) || ENV['ANSICON']
+        defined?(Win32::Console) || ENV['ANSICON'] || (windows? && mri_2?)
       end
 
       def jruby?
@@ -88,113 +75,39 @@ class Pry
       end
 
       def jruby_19?
-        RbConfig::CONFIG['ruby_install_name'] == 'jruby' &&
-          RbConfig::CONFIG['ruby_version'] == '1.9'
+        jruby? && RbConfig::CONFIG['ruby_version'] == '1.9'
       end
 
       def rbx?
         RbConfig::CONFIG['ruby_install_name'] == 'rbx'
       end
 
-      def mri_18?
-        RUBY_VERSION =~ /1.8/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      def mri?
+        RbConfig::CONFIG['ruby_install_name'] == 'ruby'
       end
 
       def mri_19?
-        RUBY_VERSION =~ /1.9/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+        mri? && RUBY_VERSION =~ /^1\.9/
       end
 
-      # Try to use `less` for paging, if it fails then use
-      # simple_pager. Also do not page if Pry.pager is falsey
-      def stagger_output(text, out = nil)
-        out ||= case
-                when respond_to?(:output)
-                  # Mixin.
-                  output
-                when Pry.respond_to?(:output)
-                  # Parent.
-                  Pry.output
-                else
-                  # Sys.
-                  $stdout
-                end
-
-        if text.lines.count < Pry::Pager.page_size || !Pry.pager
-          out.puts text
-        else
-          Pry::Pager.page(text)
-        end
-      rescue Errno::ENOENT
-        Pry::Pager.page(text, :simple)
-      rescue Errno::EPIPE
-      end
-
-      # @param [String] arg_string The object path expressed as a string.
-      # @param [Pry] _pry_ The relevant Pry instance.
-      # @param [Array<Binding>] old_stack The state of the old binding stack
-      # @return [Array<Array<Binding>, Array<Binding>>] An array
-      #   containing two elements: The new `binding_stack` and the old `binding_stack`.
-      def context_from_object_path(arg_string, _pry_=nil, old_stack=[])
-
-        # Extract command arguments. Delete blank arguments like " ", but
-        # don't delete empty strings like "".
-        path      = arg_string.split(/\//).delete_if { |a| a =~ /\A\s+\z/ }
-        stack     = _pry_.binding_stack.dup
-        state_old_stack = old_stack
-
-        # Special case when we only get a single "/", return to root.
-        if path.empty?
-          state_old_stack = stack.dup unless old_stack.empty?
-          stack = [stack.first]
-        end
+      def mri_2?
+        mri? && RUBY_VERSION =~ /^2/
+      end
 
-        path.each_with_index do |context, i|
-          begin
-            case context.chomp
-            when ""
-              state_old_stack = stack.dup
-              stack = [stack.first]
-            when "::"
-              state_old_stack = stack.dup
-              stack.push(TOPLEVEL_BINDING)
-            when "."
-              next
-            when ".."
-              unless stack.size == 1
-                # Don't rewrite old_stack if we're in complex expression
-                # (e.g.: `cd 1/2/3/../4).
-                state_old_stack = stack.dup if path.first == ".."
-                stack.pop
-              end
-            when "-"
-              unless old_stack.empty?
-                # Interchange current stack and old stack with each other.
-                stack, state_old_stack = state_old_stack, stack
-              end
-            else
-              state_old_stack = stack.dup if i == 0
-              stack.push(Pry.binding_for(stack.last.eval(context)))
-            end
-
-          rescue RescuableException => e
-            # Restore old stack to its initial values.
-            state_old_stack = old_stack
-
-            msg = [
-              "Bad object path: #{arg_string}.",
-              "Failed trying to resolve: #{context}.",
-              e.inspect
-            ].join(' ')
-
-            CommandError.new(msg).tap do |err|
-              err.set_backtrace e.backtrace
-              raise err
-            end
-          end
-        end
-        return stack, state_old_stack
+      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
+      end
     end
   end
 end

data/lib/pry/helpers/command_helpers.rb

@@ -15,14 +15,6 @@ class Pry
         file.close(true) if file
       end
 
-      def render_output(str, opts={})
-        if opts[:flood]
-          output.puts str
-        else
-          stagger_output str
-        end
-      end
-
       def internal_binding?(target)
         m = target.eval("::Kernel.__method__").to_s
         # class_eval is here because of http://jira.codehaus.org/browse/JRUBY-6753
@@ -149,6 +141,16 @@ class Pry
 
         Range.new(a, b)
       end
+
+      def set_file_and_dir_locals(file_name, _pry_=_pry_(), target=target())
+        return if !target or !file_name
+        _pry_.last_file = File.expand_path(file_name)
+        _pry_.inject_local("_file_", _pry_.last_file, target)
+
+        _pry_.last_dir = File.dirname(_pry_.last_file)
+        _pry_.inject_local("_dir_", _pry_.last_dir, target)
+      end
     end
+
   end
 end

data/lib/pry/helpers/documentation_helpers.rb

@@ -8,7 +8,6 @@ class Pry
       module_function
 
       def process_rdoc(comment)
-        return comment unless Pry.color
         comment = comment.dup
         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" }.
@@ -37,7 +36,7 @@ class Pry
         yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
                      "deprecate", "example", "raise"]
         (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
-          gsub(/^@(#{yard_tags.join("|")})/) { Pry.color ? "\e[33m#{$1}\e[0m": $1 }
+          gsub(/^@(#{yard_tags.join("|")})/) { "\e[33m#{$1}\e[0m" }
       end
 
       def process_comment_markup(comment)

data/lib/pry/helpers/text.rb

@@ -21,11 +21,11 @@ class Pry
 
         COLORS.each_pair do |color, value|
           define_method color do |text|
-            Pry.color ? "\033[0;#{30+value}m#{text}\033[0m" : text.to_s
+            "\033[0;#{30+value}m#{text}\033[0m"
           end
 
           define_method "bright_#{color}" do |text|
-            Pry.color ? "\033[1;#{30+value}m#{text}\033[0m" : text.to_s
+            "\033[1;#{30+value}m#{text}\033[0m"
           end
         end
 
@@ -38,12 +38,11 @@ class Pry
         end
 
         # Returns _text_ as bold text for use on a terminal.
-        # _Pry.color_ must be true for this method to perform any transformations.
         #
         # @param [String, #to_s] text
         # @return [String] _text_
         def bold(text)
-          Pry.color ? "\e[1m#{text}\e[0m" : text.to_s
+          "\e[1m#{text}\e[0m"
         end
 
         # Returns `text` in the default foreground colour.
@@ -56,7 +55,7 @@ class Pry
         end
         alias_method :bright_default, :bold
 
-        # Executes the block with `Pry.color` set to false.
+        # Executes the block with `Pry.config.color` set to false.
         # @yield
         # @return [void]
         def no_color(&block)

data/lib/pry/history.rb

@@ -7,19 +7,27 @@ class Pry
     # @return [Fixnum] Number of lines in history when Pry first loaded.
     attr_reader :original_lines
 
-    def initialize
+    def initialize(options={})
       @history = []
-      @saved_lines = 0
       @original_lines = 0
+      @file_path = options[:file_path]
       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)
+      Pry.config.input # force Readline to load if applicable
+
+      @loader = method(:read_from_file)
+      @saver  = method(:save_to_file)
+
+      if defined?(Readline)
+        @pusher  = method(:push_to_readline)
+        @clearer = method(:clear_readline)
+      else
+        @pusher  = proc { }
+        @clearer = proc { }
+      end
     end
 
     # Load the input history using `History.loader`.
@@ -28,17 +36,8 @@ class Pry
       @loader.call do |line|
         @pusher.call(line.chomp)
         @history << line.chomp
+        @original_lines += 1
       end
-      @saved_lines = @original_lines = @history.length
-    end
-
-    # Write this session's history using `History.saver`.
-    # @return [Integer] The number of lines saved
-    def save
-      history_to_save = @history[@saved_lines..-1]
-      @saver.call(history_to_save)
-      @saved_lines = @history.length
-      history_to_save.length
     end
 
     # Add a line to the input history, ignoring blank and duplicate lines.
@@ -48,18 +47,17 @@ class Pry
       unless line.empty? || (@history.last && line == @history.last)
         @pusher.call(line)
         @history << line
+        @saver.call(line) if Pry.config.history.should_save
       end
       line
     end
     alias << push
 
-    # 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.
+    # Clear this session's history. This won't affect the contents of the
+    # history file.
     def clear
       @clearer.call
       @history = []
-      @saved_lines = 0
     end
 
     # @return [Fixnum] The number of lines in history.
@@ -67,6 +65,7 @@ class Pry
       @history.count
     end
 
+    # @return [Fixnum] The number of lines in history from just this session.
     def session_line_count
       @history.count - @original_lines
     end
@@ -79,46 +78,48 @@ class Pry
     end
 
     private
+
     # The default loader. Yields lines from `Pry.history.config.file`.
     def read_from_file
-      begin
-        history_file = File.expand_path(Pry.config.history.file)
-        if File.exists?(history_file)
-          File.foreach(history_file) { |line| yield(line) }
-        end
-      rescue => error
-        unless error.message.empty?
-          warn "History file not loaded, received an error: #{error.message}"
-        end
-      end
-    end
+      filename = File.expand_path(Pry.config.history.file)
 
-    # 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)
-
-      begin
-        File.open(history_file, 'a') do |f|
-          lines.each { |ln| f.puts ln }
-        end
-      rescue Errno::EACCES
-        # We should probably create an option Pry.show_warnings?!?!?!
-        warn 'Unable to write to your history file, history not saved'
+      if File.exists?(filename)
+        File.foreach(filename) { |line| yield(line) }
       end
+    rescue => error
+      warn "History file not loaded: #{error.message}"
     end
 
     # The default pusher. Appends the given line to Readline::HISTORY.
     # @param [String] line
     def push_to_readline(line)
-      Pry.require_readline
       Readline::HISTORY << line
     end
 
     # The default clearer. Clears Readline::HISTORY.
     def clear_readline
-      Pry.require_readline
       Readline::HISTORY.shift until Readline::HISTORY.empty?
     end
+
+    # The default saver. Appends the given line to `Pry.history.config.file`.
+    def save_to_file(line)
+      history_file.puts line if history_file
+    end
+
+    # The history file, opened for appending.
+    def history_file
+      if defined?(@history_file)
+        @history_file
+      else
+        @history_file = File.open(file_path, 'a', 0600).tap { |f| f.sync = true }
+      end
+    rescue Errno::EACCES
+      warn 'History not saved; unable to open your history file for writing.'
+      @history_file = false
+    end
+
+    def file_path
+      @file_path || Pry.config.history.file
+    end
   end
 end