pry 0.10.4 → 0.13.0

data/lib/pry/repl.rb

@@ -1,8 +1,8 @@
-require 'forwardable'
+# frozen_string_literal: true
 
 class Pry
   class REPL
-    extend Forwardable
+    extend Pry::Forwardable
     def_delegators :@pry, :input, :output
 
     # @return [Pry] The instance of {Pry} that the user is controlling.
@@ -21,11 +21,11 @@ class Pry
     # @option options [Object] :target The initial target of the session.
     def initialize(pry, options = {})
       @pry    = pry
-      @indent = Pry::Indent.new
+      @indent = Pry::Indent.new(pry)
 
-      if options[:target]
-        @pry.push_binding options[:target]
-      end
+      @readline_output = nil
+
+      @pry.push_binding options[:target] if options[:target]
     end
 
     # Start the read-eval-print loop.
@@ -47,10 +47,10 @@ class Pry
     def prologue
       pry.exec_hook :before_session, pry.output, pry.current_binding, pry
 
+      return unless pry.config.correct_indent
+
       # Clear the line before starting Pry. This fixes issue #566.
-      if pry.config.correct_indent
-        Kernel.print Pry::Helpers::BaseHelpers.windows_ansi? ? "\e[0F" : "\e[0G"
-      end
+      output.print(Helpers::Platform.windows_ansi? ? "\e[0F" : "\e[0G")
     end
 
     # The actual read-eval-print loop.
@@ -98,16 +98,19 @@ class Pry
       val = read_line("#{current_prompt}#{indentation}")
 
       # Return nil for EOF, :no_more_input for error, or :control_c for <Ctrl-C>
-      return val unless String === val
+      return val unless val.is_a?(String)
 
       if pry.config.auto_indent
         original_val = "#{indentation}#{val}"
         indented_val = @indent.indent(val)
 
-        if output.tty? && pry.config.correct_indent && Pry::Helpers::BaseHelpers.use_ansi_codes?
+        if output.tty? &&
+           pry.config.correct_indent &&
+           Pry::Helpers::BaseHelpers.use_ansi_codes?
           output.print @indent.correct_indentation(
-            current_prompt, indented_val,
-            original_val.length - indented_val.length
+            current_prompt,
+            indented_val,
+            calculate_overhang(current_prompt, original_val, indented_val)
           )
           output.flush
         end
@@ -129,7 +132,7 @@ class Pry
         yield
       rescue EOFError
         pry.config.input = Pry.config.input
-        if !should_retry
+        unless should_retry
           output.puts "Error: Pry ran out of things to read from! " \
             "Attempting to break out of REPL."
           return :no_more_input
@@ -150,9 +153,7 @@ class Pry
         puts "Error: #{e.message}"
         output.puts e.backtrace
         exception_count += 1
-        if exception_count < 5
-          retry
-        end
+        retry if exception_count < 5
         puts "FATAL: Pry failed to get user input using `#{input}`."
         puts "To fix this you may be able to pass input and output file " \
           "descriptors to pry directly. e.g."
@@ -168,27 +169,26 @@ class Pry
     # @return [String?] The next line of input, or `nil` on <Ctrl-D>.
     def read_line(current_prompt)
       handle_read_errors do
-        if defined? Coolline and input.is_a? Coolline
+        if coolline_available?
           input.completion_proc = proc do |cool|
             completions = @pry.complete cool.completed_word
             completions.compact
           end
         elsif input.respond_to? :completion_proc=
-          input.completion_proc = proc do |input|
-            @pry.complete input
+          input.completion_proc = proc do |inp|
+            @pry.complete inp
           end
         end
 
-        if defined?(Readline) and input == Readline
+        if readline_available?
+          set_readline_output
           input_readline(current_prompt, false) # false since we'll add it manually
-        elsif defined? Coolline and input.is_a? Coolline
+        elsif coolline_available?
+          input_readline(current_prompt)
+        elsif input.method(:readline).arity == 1
           input_readline(current_prompt)
         else
-          if input.method(:readline).arity == 1
-            input_readline(current_prompt)
-          else
-            input_readline
-          end
+          input_readline
         end
       end
     end
@@ -198,5 +198,60 @@ class Pry
         input.readline(*args)
       end
     end
+
+    def readline_available?
+      defined?(Readline) && input == Readline
+    end
+
+    def coolline_available?
+      defined?(Coolline) && input.is_a?(Coolline)
+    end
+
+    # If `$stdout` is not a tty, it's probably a pipe.
+    # @example
+    #   # `piping?` returns `false`
+    #   % pry
+    #   [1] pry(main)
+    #
+    #   # `piping?` returns `true`
+    #   % pry | tee log
+    def piping?
+      return false unless $stdout.respond_to?(:tty?)
+
+      !$stdout.tty? && $stdin.tty? && !Helpers::Platform.windows?
+    end
+
+    # @return [void]
+    def set_readline_output
+      return if @readline_output
+
+      @readline_output = (Readline.output = Pry.config.output) if piping?
+    end
+
+    # Calculates correct overhang for current line. Supports vi Readline
+    # mode and its indicators such as "(ins)" or "(cmd)".
+    #
+    # @return [Integer]
+    # @note This doesn't calculate overhang for Readline's emacs mode with an
+    #   indicator because emacs is the default mode and it doesn't use
+    #   indicators in 99% of cases.
+    def calculate_overhang(current_prompt, original_val, indented_val)
+      overhang = original_val.length - indented_val.length
+
+      if readline_available? && Readline.respond_to?(:vi_editing_mode?)
+        begin
+          # rb-readline doesn't support this method:
+          # https://github.com/ConnorAtherton/rb-readline/issues/152
+          if Readline.vi_editing_mode?
+            overhang = output.width - current_prompt.size - indented_val.size
+          end
+        rescue NotImplementedError
+          # VI editing mode is unsupported on JRuby.
+          # https://github.com/pry/pry/issues/1840
+          nil
+        end
+      end
+      [0, overhang].max
+    end
   end
 end

data/lib/pry/repl_file_loader.rb

@@ -1,5 +1,6 @@
-class Pry
+# frozen_string_literal: true
 
+class Pry
   # A class to manage the loading of files through the REPL loop.
   # This is an interesting trick as it processes your file as if it
   # was user input in an interactive session. As a result, all Pry
@@ -13,7 +14,7 @@ class Pry
   class REPLFileLoader
     def initialize(file_name)
       full_name = File.expand_path(file_name)
-      raise RuntimeError, "No such file: #{full_name}" if !File.exists?(full_name)
+      raise "No such file: #{full_name}" unless File.exist?(full_name)
 
       define_additional_commands
       @content = File.read(full_name)
@@ -21,34 +22,36 @@ class Pry
 
     # Switch to interactive mode, i.e take input from the user
     # and use the regular print and exception handlers.
-    # @param [Pry] _pry_ the Pry instance to make interactive.
-    def interactive_mode(_pry_)
-      _pry_.config.input = Pry.config.input
-      _pry_.config.print = Pry.config.print
-      _pry_.config.exception_handler = Pry.config.exception_handler
-      Pry::REPL.new(_pry_).start
+    # @param [Pry] pry_instance the Pry instance to make interactive.
+    def interactive_mode(pry_instance)
+      pry_instance.config.input = Pry.config.input
+      pry_instance.config.print = Pry.config.print
+      pry_instance.config.exception_handler = Pry.config.exception_handler
+      Pry::REPL.new(pry_instance).start
     end
 
     # Switch to non-interactive mode. Essentially
     # this means there is no result output
     # and that the session becomes interactive when an exception is encountered.
-    # @param [Pry] _pry_ the Pry instance to make non-interactive.
-    def non_interactive_mode(_pry_, content)
-      _pry_.print = proc {}
-      _pry_.exception_handler = proc do |o, e, _p_|
-        _p_.run_command "cat --ex"
+    # @param [Pry] pry_instance the Pry instance to make non-interactive.
+    def non_interactive_mode(pry_instance, content)
+      pry_instance.print = proc {}
+      pry_instance.exception_handler = proc do |o, _e, p|
+        p.run_command "cat --ex"
         o.puts "...exception encountered, going interactive!"
-        interactive_mode(_pry_)
+        interactive_mode(pry_instance)
       end
 
       content.lines.each do |line|
-        break unless _pry_.eval line, :generated => true
+        break unless pry_instance.eval line, generated: true
       end
 
-      unless _pry_.eval_string.empty?
-        _pry_.output.puts "#{_pry_.eval_string}...exception encountered, going interactive!"
-        interactive_mode(_pry_)
-      end
+      return if pry_instance.eval_string.empty?
+
+      pry_instance.output.puts(
+        "#{pry_instance.eval_string}...exception encountered, going interactive!"
+      )
+      interactive_mode(pry_instance)
     end
 
     # Define a few extra commands useful for flipping back & forth
@@ -57,11 +60,13 @@ class Pry
       s = self
 
       Pry::Commands.command "make-interactive", "Make the session interactive" do
-        s.interactive_mode(_pry_)
+        s.interactive_mode(pry_instance)
       end
 
-      Pry::Commands.command "load-file", "Load another file through the repl" do |file_name|
-        s.non_interactive_mode(_pry_, File.read(File.expand_path(file_name)))
+      Pry::Commands.command(
+        "load-file", "Load another file through the repl"
+      ) do |file_name|
+        s.non_interactive_mode(pry_instance, File.read(File.expand_path(file_name)))
       end
     end
 

data/lib/pry/ring.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class Pry
+  # A ring is a thread-safe fixed-capacity array to which you can only add
+  # elements. Older entries are overwritten as you add new elements, so that the
+  # ring can never contain more than `max_size` elemens.
+  #
+  # @example
+  #   ring = Pry::Ring.new(3)
+  #   ring << 1 << 2 << 3
+  #   ring.to_a #=> [1, 2, 3]
+  #   ring << 4
+  #   ring.to_a #=> [2, 3, 4]
+  #
+  #   ring[0] #=> 2
+  #   ring[-1] #=> 4
+  #   ring.clear
+  #   ring[0] #=> nil
+  #
+  # @api public
+  # @since v0.12.0
+  class Ring
+    # @return [Integer] maximum buffer size
+    attr_reader :max_size
+
+    # @return [Integer] how many objects were added during the lifetime of the
+    #   ring
+    attr_reader :count
+    alias size count
+
+    # @param [Integer] max_size Maximum buffer size. The buffer will start
+    #   overwriting elements once its reaches its maximum capacity
+    def initialize(max_size)
+      @max_size = max_size
+      @mutex = Mutex.new
+      clear
+    end
+
+    # Push `value` to the current index.
+    #
+    # @param [Object] value
+    # @return [self]
+    def <<(value)
+      @mutex.synchronize do
+        @buffer[count % max_size] = value
+        @count += 1
+        self
+      end
+    end
+
+    # Read the value stored at `index`.
+    #
+    # @param [Integer, Range] index The element (if Integer) or elements
+    #   (if Range) associated with `index`
+    # @return [Object, Array<Object>, nil] element(s) at `index`, `nil` if none
+    #   exist
+    def [](index)
+      @mutex.synchronize do
+        return @buffer[(count + index) % max_size] if index.is_a?(Integer)
+        return @buffer[index] if count <= max_size
+
+        transpose_buffer_tail[index]
+      end
+    end
+
+    # @return [Array<Object>] the buffer as unwinded array
+    def to_a
+      return @buffer.dup if count <= max_size
+
+      transpose_buffer_tail
+    end
+
+    # Clear the buffer and reset count.
+    # @return [void]
+    def clear
+      @mutex.synchronize do
+        @buffer = []
+        @count = 0
+      end
+    end
+
+    private
+
+    def transpose_buffer_tail
+      tail = @buffer.slice(count % max_size, @buffer.size)
+      tail.concat @buffer.slice(0, count % max_size)
+    end
+  end
+end

data/lib/pry/slop/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Lee Jarvis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/pry/slop/commands.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+class Pry
+  class Slop
+    class Commands
+      include Enumerable
+
+      attr_reader :config, :commands, :arguments
+      attr_writer :banner
+
+      # Create a new instance of Slop::Commands and optionally build
+      # Slop instances via a block. Any configuration options used in
+      # this method will be the default configuration options sent to
+      # each Slop object created.
+      #
+      # config - An optional configuration Hash.
+      # block  - Optional block used to define commands.
+      #
+      # Examples:
+      #
+      #   commands = Slop::Commands.new do
+      #     on :new do
+      #       on '-o', '--outdir=', 'The output directory'
+      #       on '-v', '--verbose', 'Enable verbose mode'
+      #     end
+      #
+      #     on :generate do
+      #       on '--assets', 'Generate assets', :default => true
+      #     end
+      #
+      #     global do
+      #       on '-D', '--debug', 'Enable debug mode', :default => false
+      #     end
+      #   end
+      #
+      #   commands[:new].class #=> Slop
+      #   commands.parse
+      #
+      def initialize(config = {}, &block)
+        @config = config
+        @commands = {}
+        @banner = nil
+        @triggered_command = nil
+
+        warn "[DEPRECATED] Slop::Commands is deprecated and will be removed in "\
+          "Slop version 4. Check out http://injekt.github.com/slop/#commands for "\
+          "a new implementation of commands."
+
+        return unless block_given?
+
+        block.arity == 1 ? yield(self) : instance_eval(&block)
+      end
+
+      # Optionally set the banner for this command help output.
+      #
+      # banner - The String text to set the banner.
+      #
+      # Returns the String banner if one is set.
+      def banner(banner = nil)
+        @banner = banner if banner
+        @banner
+      end
+
+      # Add a Slop instance for a specific command.
+      #
+      # command - A String or Symbol key used to identify this command.
+      # config  - A Hash of configuration options to pass to Slop.
+      # block   - An optional block used to pass options to Slop.
+      #
+      # Returns the newly created Slop instance mapped to command.
+      def on(command, config = {}, &block)
+        commands[command.to_s] = Slop.new(@config.merge(config), &block)
+      end
+
+      # Add a Slop instance used when no other commands exist.
+      #
+      # config - A Hash of configuration options to pass to Slop.
+      # block  - An optional block used to pass options to Slop.
+      #
+      # Returns the newly created Slop instance mapped to default.
+      def default(config = {}, &block)
+        on('default', config, &block)
+      end
+
+      # Add a global Slop instance.
+      #
+      # config - A Hash of configuration options to pass to Slop.
+      # block  - An optional block used to pass options to Slop.
+      #
+      # Returns the newly created Slop instance mapped to global.
+      def global(config = {}, &block)
+        on('global', config, &block)
+      end
+
+      # Fetch the instance of Slop tied to a command.
+      #
+      # key - The String or Symbol key used to locate this command.
+      #
+      # Returns the Slop instance if this key is found, nil otherwise.
+      def [](key)
+        commands[key.to_s]
+      end
+      alias get []
+
+      # Check for a command presence.
+      #
+      # Examples:
+      #
+      #   cmds.parse %w( foo )
+      #   cmds.present?(:foo) #=> true
+      #   cmds.present?(:bar) #=> false
+      #
+      # Returns true if the given key is present in the parsed arguments.
+      def present?(key)
+        key.to_s == @triggered_command
+      end
+
+      # Enumerable interface.
+      def each(&block)
+        @commands.each(&block)
+      end
+
+      # Parse a list of items.
+      #
+      # items - The Array of items to parse.
+      #
+      # Returns the original Array of items.
+      def parse(items = ARGV)
+        parse! items.dup
+        items
+      end
+
+      # Parse a list of items, removing any options or option arguments found.
+      #
+      # items - The Array of items to parse.
+      #
+      # Returns the original Array of items with options removed.
+      def parse!(items = ARGV)
+        if (opts = commands[items[0].to_s])
+          @triggered_command = items.shift
+          execute_arguments! items
+          opts.parse! items
+        elsif (opts = commands['default'])
+          opts.parse! items
+        elsif config[:strict] && items[0]
+          raise InvalidCommandError, "Unknown command `#{items[0]}`"
+        end
+        execute_global_opts! items
+        items
+      end
+
+      # Returns a nested Hash with Slop options and values. See Slop#to_hash.
+      def to_hash
+        Hash[commands.map { |k, v| [k.to_sym, v.to_hash] }]
+      end
+
+      # Returns the help String.
+      def to_s
+        defaults = commands.delete('default')
+        globals = commands.delete('global')
+        helps = commands.reject { |_, v| v.options.none? }
+        helps['Global options'] = globals.to_s if globals && globals.options.any?
+        helps['Other options'] = defaults.to_s if defaults && defaults.options.any?
+        banner = @banner ? "#{@banner}\n" : ""
+        banner + helps.map { |key, opts| "  #{key}\n#{opts}" }.join("\n\n")
+      end
+      alias help to_s
+
+      # Returns the inspection String.
+      def inspect
+        "#<Slop::Commands #{config.inspect} #{commands.values.map(&:inspect)}>"
+      end
+
+      private
+
+      # Returns nothing.
+      def execute_arguments!(items)
+        @arguments = items.take_while { |arg| !arg.start_with?('-') }
+        items.shift @arguments.size
+      end
+
+      # Returns nothing.
+      def execute_global_opts!(items)
+        return unless (global_opts = commands['global'])
+
+        global_opts.parse!(items)
+      end
+    end
+  end
+end