gitlab-pry-byebug 3.9.0

data/lib/pry-byebug/commands/step.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "pry-byebug/helpers/navigation"
+
+module PryByebug
+  #
+  # Run a number of Ruby statements and then stop again
+  #
+  class StepCommand < Pry::ClassCommand
+    include Helpers::Navigation
+
+    match "step"
+    group "Byebug"
+    description "Step execution into the next line or method."
+
+    banner <<-BANNER
+        Usage: step [TIMES]
+
+        Step execution forward. By default, moves a single step.
+
+        Examples:
+          step   #=> Move a single step forward.
+          step 5 #=> Execute the next 5 steps.
+    BANNER
+
+    def process
+      PryByebug.check_file_context(target)
+
+      breakout_navigation :step, times: args.first
+    end
+  end
+end
+
+Pry::Commands.add_command(PryByebug::StepCommand)

data/lib/pry-byebug/commands/up.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "pry-byebug/helpers/navigation"
+
+module PryByebug
+  #
+  # Travel up the frame stack
+  #
+  class UpCommand < Pry::ClassCommand
+    include Helpers::Navigation
+
+    match "up"
+    group "Byebug"
+
+    description "Move current frame up."
+
+    banner <<-BANNER
+      Usage: up [TIMES]
+
+      Move current frame up. By default, moves by 1 frame.
+
+      Examples:
+        up   #=> Move up 1 frame.
+        up 5 #=> Move up 5 frames.
+    BANNER
+
+    def process
+      PryByebug.check_file_context(target)
+
+      breakout_navigation :up, times: args.first
+    end
+  end
+end
+
+Pry::Commands.add_command(PryByebug::UpCommand)

data/lib/pry-byebug/control_d_handler.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+original_handler = Pry.config.control_d_handler
+
+Pry.config.control_d_handler = proc do |pry_instance|
+  Byebug.stop if Byebug.stoppable?
+
+  original_handler.call(pry_instance)
+end

data/lib/pry-byebug/helpers/breakpoints.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "byebug"
+
+module PryByebug
+  module Helpers
+    #
+    # Common helpers for breakpoint related commands
+    #
+    module Breakpoints
+      #
+      # Byebug's array of breakpoints.
+      #
+      def breakpoints
+        Pry::Byebug::Breakpoints
+      end
+
+      #
+      # Prints a message with bold font.
+      #
+      def bold_puts(msg)
+        output.puts(bold(msg))
+      end
+
+      #
+      # Print out full information about a breakpoint.
+      #
+      # Includes surrounding code at that point.
+      #
+      def print_full_breakpoint(breakpoint)
+        header = "Breakpoint #{breakpoint.id}:"
+        status = breakpoint.enabled? ? "Enabled" : "Disabled"
+        code = breakpoint.source_code.with_line_numbers.to_s
+        condition = if breakpoint.expr
+                      "#{bold('Condition:')} #{breakpoint.expr}\n"
+                    else
+                      ""
+                    end
+
+        output.puts <<-BREAKPOINT.gsub(/ {8}/, "")
+
+          #{bold(header)} #{breakpoint} (#{status}) #{condition}
+
+          #{code}
+
+        BREAKPOINT
+      end
+
+      #
+      # Print out concise information about a breakpoint.
+      #
+      def print_short_breakpoint(breakpoint)
+        id = format("%*d", max_width, breakpoint.id)
+        status = breakpoint.enabled? ? "Yes" : "No "
+        expr = breakpoint.expr ? " #{breakpoint.expr} " : ""
+
+        output.puts("  #{id} #{status}     #{breakpoint}#{expr}")
+      end
+
+      #
+      # Prints a header for the breakpoint list.
+      #
+      def print_breakpoints_header
+        header = "#{' ' * (max_width - 1)}# Enabled At "
+
+        output.puts <<-BREAKPOINTS.gsub(/ {8}/, "")
+
+          #{bold(header)}
+          #{bold('-' * header.size)}
+
+        BREAKPOINTS
+      end
+
+      #
+      # Max width of breakpoints id column
+      #
+      def max_width
+        breakpoints.last ? breakpoints.last.id.to_s.length : 1
+      end
+    end
+  end
+end

data/lib/pry-byebug/helpers/location.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module PryByebug
+  module Helpers
+    #
+    # Compatibility helper to handle source location
+    #
+    module Location
+      module_function
+
+      #
+      # Current file in the target binding. Used as the default breakpoint
+      # location.
+      #
+      def current_file(source = target)
+        # Guard clause for Ruby >= 2.6 providing now Binding#source_location ...
+        return source.source_location[0] if source.respond_to?(:source_location)
+
+        # ... to avoid warning: 'eval may not return location in binding'
+        source.eval("__FILE__")
+      end
+    end
+  end
+end

data/lib/pry-byebug/helpers/multiline.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module PryByebug
+  module Helpers
+    #
+    # Helpers to help handling multiline inputs
+    #
+    module Multiline
+      #
+      # Returns true if we are in a multiline context and, as a side effect,
+      # updates the partial evaluation string with the current input.
+      #
+      # Returns false otherwise
+      #
+      def check_multiline_context
+        return false if eval_string.empty?
+
+        eval_string.replace("#{eval_string}#{match} #{arg_string}\n")
+        true
+      end
+    end
+  end
+end

data/lib/pry-byebug/helpers/navigation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PryByebug
+  module Helpers
+    #
+    # Helpers to aid breaking out of the REPL loop
+    #
+    module Navigation
+      #
+      # Breaks out of the REPL loop and signals tracer
+      #
+      def breakout_navigation(action, options = {})
+        pry_instance.binding_stack.clear
+
+        throw :breakout_nav, action: action, options: options, pry: pry_instance
+      end
+    end
+  end
+end

data/lib/pry-byebug/pry_ext.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "byebug/processors/pry_processor"
+require "byebug/processors/pry_remote_processor"
+
+class << Pry
+  alias start_without_pry_byebug start
+
+  def start_with_pry_byebug(target = TOPLEVEL_BINDING, options = {})
+    if target.is_a?(Binding) && PryByebug.file_context?(target) && !ENV["DISABLE_PRY"]
+      run_remote? ? Byebug::PryRemoteProcessor.start : Byebug::PryProcessor.start
+    else
+      # No need for the tracer unless we have a file context to step through
+      start_without_pry_byebug(target, options)
+    end
+  end
+
+  def run_remote?
+    PryByebug.current_remote_server
+  end
+
+  alias start start_with_pry_byebug
+end

data/lib/pry-byebug/pry_remote_ext.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "pry-remote"
+
+module PryRemote
+  #
+  # Overrides PryRemote::Server
+  #
+  class Server
+    #
+    # Override the call to Pry.start to save off current Server, and not
+    # teardown the server right after Pry.start finishes.
+    #
+    def run
+      raise("Already running a pry-remote session!") if
+        PryByebug.current_remote_server
+
+      PryByebug.current_remote_server = self
+
+      setup
+      Pry.start @object, input: client.input_proxy, output: client.output
+    end
+
+    #
+    # Override to reset our saved global current server session.
+    #
+    alias teardown_without_pry_byebug teardown
+    def teardown_with_pry_byebug
+      return if @torn
+
+      teardown_without_pry_byebug
+      PryByebug.current_remote_server = nil
+      @torn = true
+    end
+    alias teardown teardown_with_pry_byebug
+  end
+end
+
+# Ensure cleanup when a program finishes without another break. For example,
+# 'next' on the last line of a program won't hit Byebug::PryProcessor#run,
+# which normally handles cleanup.
+at_exit do
+  PryByebug.current_remote_server&.teardown
+end

data/lib/pry-byebug/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+#
+# Main container module for Pry-Byebug functionality
+#
+module PryByebug
+  VERSION = "3.9.0"
+end

data/lib/pry/byebug/breakpoints.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+class Pry
+  module Byebug
+    #
+    # Wrapper for Byebug.breakpoints that respects our Processor and has better
+    # failure behavior. Acts as an Enumerable.
+    #
+    module Breakpoints
+      extend Enumerable
+      extend self
+
+      #
+      # Breakpoint in a file:line location
+      #
+      class FileBreakpoint < SimpleDelegator
+        def source_code
+          Pry::Code.from_file(source).around(pos, 3).with_marker(pos)
+        end
+
+        def to_s
+          "#{source} @ #{pos}"
+        end
+      end
+
+      #
+      # Breakpoint in a Class#method location
+      #
+      class MethodBreakpoint < SimpleDelegator
+        def initialize(byebug_bp, method)
+          __setobj__ byebug_bp
+          @method = method
+        end
+
+        def source_code
+          Pry::Code.from_method(Pry::Method.from_str(@method))
+        end
+
+        def to_s
+          @method
+        end
+      end
+
+      def breakpoints
+        @breakpoints ||= []
+      end
+
+      #
+      # Adds a method breakpoint.
+      #
+      def add_method(method, expression = nil)
+        validate_expression expression
+        owner, name = method.split(/[\.#]/)
+        byebug_bp = ::Byebug::Breakpoint.add(owner, name.to_sym, expression)
+        bp = MethodBreakpoint.new byebug_bp, method
+        breakpoints << bp
+        bp
+      end
+
+      #
+      # Adds a file breakpoint.
+      #
+      def add_file(file, line, expression = nil)
+        real_file = (file != Pry.eval_path)
+        raise(ArgumentError, "Invalid file!") if real_file && !File.exist?(file)
+
+        validate_expression expression
+
+        path = (real_file ? File.expand_path(file) : file)
+        bp = FileBreakpoint.new ::Byebug::Breakpoint.add(path, line, expression)
+        breakpoints << bp
+        bp
+      end
+
+      #
+      # Changes the conditional expression for a breakpoint.
+      #
+      def change(id, expression = nil)
+        validate_expression expression
+
+        breakpoint = find_by_id(id)
+        breakpoint.expr = expression
+        breakpoint
+      end
+
+      #
+      # Deletes an existing breakpoint with the given ID.
+      #
+      def delete(id)
+        deleted =
+          ::Byebug::Breakpoint.remove(id) &&
+          breakpoints.delete(find_by_id(id))
+
+        raise(ArgumentError, "No breakpoint ##{id}") unless deleted
+      end
+
+      #
+      # Deletes all breakpoints.
+      #
+      def delete_all
+        @breakpoints = []
+        ::Byebug.breakpoints.clear
+      end
+
+      #
+      # Enables a disabled breakpoint with the given ID.
+      #
+      def enable(id)
+        change_status id, true
+      end
+
+      #
+      # Disables a breakpoint with the given ID.
+      #
+      def disable(id)
+        change_status id, false
+      end
+
+      #
+      # Disables all breakpoints.
+      #
+      def disable_all
+        each do |breakpoint|
+          breakpoint.enabled = false
+        end
+      end
+
+      def to_a
+        breakpoints
+      end
+
+      def size
+        to_a.size
+      end
+
+      def each(&block)
+        to_a.each(&block)
+      end
+
+      def last
+        to_a.last
+      end
+
+      def find_by_id(id)
+        breakpoint = find { |b| b.id == id }
+        raise(ArgumentError, "No breakpoint ##{id}!") unless breakpoint
+
+        breakpoint
+      end
+
+      private
+
+      def change_status(id, enabled = true)
+        breakpoint = find_by_id(id)
+        breakpoint.enabled = enabled
+        breakpoint
+      end
+
+      def validate_expression(exp)
+        valid = exp && (exp.empty? || !Pry::Code.complete_expression?(exp))
+        return unless valid
+
+        raise("Invalid breakpoint conditional: #{expression}")
+      end
+    end
+  end
+end