byebug 4.0.5 → 5.0.0

data/lib/byebug/helpers/file.rb

@@ -0,0 +1,46 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for interaction with files
+    #
+    module FileHelper
+      #
+      # Reads lines of source file +filename+ into an array
+      #
+      def get_lines(filename)
+        File.foreach(filename).reduce([]) { |a, e| a << e.chomp }
+      end
+
+      #
+      # Reads line number +lineno+ from file named +filename+
+      #
+      def get_line(filename, lineno)
+        File.open(filename) do |f|
+          f.gets until f.lineno == lineno - 1
+          f.gets
+        end
+      end
+
+      #
+      # Returns the number of lines in file +filename+ in a portable,
+      # one-line-at-a-time way.
+      #
+      def n_lines(filename)
+        File.foreach(filename).reduce(0) { |a, _e| a + 1 }
+      end
+
+      #
+      # Regularize file name.
+      #
+      def normalize(filename)
+        return filename if ['(irb)', '-e'].include?(filename)
+
+        return File.basename(filename) if Setting[:basename]
+
+        path = File.expand_path(filename)
+
+        File.exist?(path) ? File.realpath(path) : filename
+      end
+    end
+  end
+end

data/lib/byebug/helpers/frame.rb

@@ -0,0 +1,76 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist frame navigation
+    #
+    module FrameHelper
+      def switch_to_frame(frame_no)
+        frame_no >= 0 ? frame_no : @state.context.stack_size + frame_no
+      end
+
+      def navigate_to_frame(jump_no)
+        return if jump_no == 0
+
+        current_jumps = 0
+        current_pos = @state.frame
+
+        loop do
+          current_pos += direction(jump_no)
+          break if current_pos < 0 || current_pos >= @state.context.stack_size
+
+          next if @state.c_frame?(current_pos)
+
+          current_jumps += 1
+          break if current_jumps == jump_no.abs
+        end
+
+        current_pos
+      end
+
+      def adjust_frame(frame, absolute)
+        if absolute
+          abs_frame = switch_to_frame(frame)
+          if @state.c_frame?(abs_frame)
+            return errmsg(pr('frame.errors.c_frame'))
+          end
+        else
+          abs_frame = navigate_to_frame(frame)
+        end
+
+        if abs_frame >= @state.context.stack_size
+          return errmsg(pr('frame.errors.too_low'))
+        elsif abs_frame < 0
+          return errmsg(pr('frame.errors.too_high'))
+        end
+
+        @state.frame = abs_frame
+        @state.file = @state.context.frame_file(@state.frame)
+        @state.line = @state.context.frame_line(@state.frame)
+        @state.prev_line = nil
+      end
+
+      def get_pr_arguments(frame_no)
+        file = @state.frame_file(frame_no)
+        full_path = File.expand_path(file)
+        line = @state.frame_line(frame_no)
+        call = @state.frame_call(frame_no)
+        mark = @state.frame_mark(frame_no)
+        pos = @state.frame_pos(frame_no)
+
+        { mark: mark, pos: pos, call: call, file: file, line: line,
+          full_path: full_path }
+      end
+
+      private
+
+      #
+      # @param [Integer] A positive or negative integer
+      #
+      # @return [Integer] +1 if step is positive / -1 if negative
+      #
+      def direction(step)
+        step / step.abs
+      end
+    end
+  end
+end

data/lib/byebug/helpers/parse.rb

@@ -0,0 +1,74 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist command parsing
+    #
+    module ParseHelper
+      #
+      # Parses +str+ of command +cmd+ as an integer between +min+ and +max+.
+      #
+      # If either +min+ or +max+ is nil, that value has no bound.
+      #
+      # TODO: Remove the `cmd` parameter. It has nothing to do with the methods
+      # purpose.
+      #
+      def get_int(str, cmd, min = nil, max = nil)
+        if str !~ /\A-?[0-9]+\z/
+          err = pr('parse.errors.int.not_number', cmd: cmd, str: str)
+          return nil, errmsg(err)
+        end
+
+        int = str.to_i
+        if min && int < min
+          err = pr('parse.errors.int.too_low', cmd: cmd, str: str, min: min)
+          return min, errmsg(err)
+        elsif max && int > max
+          err = pr('parse.errors.int.too_high', cmd: cmd, str: str, max: max)
+          return max, errmsg(err)
+        end
+
+        int
+      end
+
+      #
+      # @return true if code is syntactically correct for Ruby, false otherwise
+      #
+      def syntax_valid?(code)
+        return true unless code
+
+        without_stderr do
+          begin
+            RubyVM::InstructionSequence.compile(code)
+            true
+          rescue SyntaxError
+            false
+          end
+        end
+      end
+
+      #
+      # Temporarily disable output to $stderr
+      #
+      def without_stderr
+        stderr = $stderr
+        $stderr.reopen(IO::NULL)
+
+        yield
+      ensure
+        $stderr.reopen(stderr)
+      end
+
+      #
+      # @return +str+ as an integer or 1 if +str+ is empty.
+      #
+      def parse_steps(str, cmd)
+        return 1 unless str
+
+        steps, err = get_int(str, cmd, 1)
+        return nil, err unless steps
+
+        steps
+      end
+    end
+  end
+end

data/lib/byebug/helpers/string.rb

@@ -0,0 +1,24 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for interaction with strings
+    #
+    module StringHelper
+      #
+      # Converts +str+ from an_underscored-or-dasherized_string to
+      # ACamelizedString.
+      #
+      def camelize(str)
+        str.dup.split(/[_-]/).map(&:capitalize).join('')
+      end
+
+      #
+      # Improves indentation and spacing in +str+ for readability in Byebug's
+      # command prompt.
+      #
+      def prettify(str)
+        "\n" + str.gsub(/^ {6}/, '') + "\n"
+      end
+    end
+  end
+end

data/lib/byebug/helpers/thread.rb

@@ -0,0 +1,53 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for thread subcommands
+    #
+    module ThreadHelper
+      def display_context(context)
+        puts pr('thread.context', thread_arguments(context))
+      end
+
+      def thread_arguments(context)
+        status_flag = if context.suspended?
+                        '$'
+                      else
+                        context.thread == Thread.current ? '+' : ' '
+                      end
+        debug_flag = context.ignored? ? '!' : ' '
+
+        if context == Byebug.current_context
+          file_line = "#{@state.file}:#{@state.line}"
+        else
+          backtrace = context.thread.backtrace_locations
+          if backtrace && backtrace[0]
+            file_line = "#{backtrace[0].path}:#{backtrace[0].lineno}"
+          end
+        end
+
+        {
+          status_flag: status_flag,
+          debug_flag: debug_flag,
+          id: context.thnum,
+          thread: context.thread.inspect,
+          file_line: file_line || '',
+          pid: Process.pid,
+          status: context.thread.status,
+          current: (context.thread == Thread.current)
+        }
+      end
+
+      def context_from_thread(thnum)
+        ctx = Byebug.contexts.find { |c| c.thnum.to_s == thnum }
+
+        err = case
+              when ctx.nil? then pr('thread.errors.no_thread')
+              when ctx == @state.context then pr('thread.errors.current_thread')
+              when ctx.ignored? then pr('thread.errors.ignored', arg: thnum)
+              end
+
+        [ctx, err]
+      end
+    end
+  end
+end

data/lib/byebug/helpers/toggle.rb

@@ -0,0 +1,56 @@
+require 'byebug/helpers/parse'
+
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist breakpoint/display enabling/disabling.
+    #
+    module ToggleHelper
+      include ParseHelper
+
+      def enable_disable_breakpoints(is_enable, args)
+        return errmsg(pr('toggle.errors.no_breakpoints')) if Breakpoint.none?
+
+        all_breakpoints = Byebug.breakpoints.sort_by(&:id)
+        if args.nil?
+          selected_breakpoints = all_breakpoints
+        else
+          selected_ids = []
+          args.split(/ +/).each do |pos|
+            last_id = all_breakpoints.last.id
+            pos, err = get_int(pos, "#{is_enable} breakpoints", 1, last_id)
+            return errmsg(err) unless pos
+
+            selected_ids << pos
+          end
+          selected_breakpoints = all_breakpoints.select do |b|
+            selected_ids.include?(b.id)
+          end
+        end
+
+        selected_breakpoints.each do |b|
+          enabled = ('enable' == is_enable)
+          if enabled && !syntax_valid?(b.expr)
+            return errmsg(pr('toggle.errors.expression', expr: b.expr))
+          end
+
+          b.enabled = enabled
+        end
+      end
+
+      def enable_disable_display(is_enable, args)
+        display = @state.display
+        return errmsg(pr('toggle.errors.no_display')) if 0 == display.size
+
+        selected_displays = args.nil? ? [1..display.size + 1] : args.split(/ +/)
+
+        selected_displays.each do |pos|
+          pos, err = get_int(pos, "#{is_enable} display", 1, display.size)
+          return errmsg(err) unless err.nil?
+
+          display[pos - 1][0] = ('enable' == is_enable)
+        end
+      end
+    end
+  end
+end

data/lib/byebug/helpers/var.rb

@@ -0,0 +1,45 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities for variable subcommands
+    #
+    module VarHelper
+      def var_list(ary, b = get_binding)
+        vars = ary.sort.map do |v|
+          s = begin
+            b.eval(v.to_s).inspect
+          rescue
+            begin
+              b.eval(v.to_s).to_s
+            rescue
+              '*Error in evaluation*'
+            end
+          end
+          [v, s]
+        end
+        puts prv(vars, 'instance')
+      end
+
+      def var_global
+        globals = global_variables.reject do |v|
+          [:$IGNORECASE, :$=, :$KCODE, :$-K, :$binding].include?(v)
+        end
+
+        var_list(globals)
+      end
+
+      def var_instance(str)
+        obj = bb_warning_eval(str || 'self')
+
+        var_list(obj.instance_variables, obj.instance_eval { binding })
+      end
+
+      def var_local
+        locals = @state.context.frame_locals
+        cur_self = @state.context.frame_self(@state.frame)
+        locals[:self] = cur_self unless cur_self.to_s == 'main'
+        puts prv(locals.keys.sort.map { |k| [k, locals[k]] }, 'instance')
+      end
+    end
+  end
+end

data/lib/byebug/history.rb

@@ -27,7 +27,7 @@ module Byebug
     def restore
       return unless File.exist?(Setting[:histfile])
 
-      File.readlines(Setting[:histfile]).reverse.each { |l| push(l.chomp) }
+      File.readlines(Setting[:histfile]).reverse_each { |l| push(l.chomp) }
     end
 
     #
@@ -85,9 +85,7 @@ module Byebug
     # Array of ids of the last n commands.
     #
     def last_ids(n)
-      from, to = 1 + self.size - n, self.size
-
-      (from..to).to_a
+      (1 + size - n..size).to_a
     end
 
     #

data/lib/byebug/interface.rb

@@ -1,5 +1,5 @@
 require 'byebug/history'
-require 'byebug/helper'
+require 'byebug/helpers/file'
 
 #
 # Namespace for all of byebug's code
@@ -11,11 +11,14 @@ module Byebug
   # Contains common functionality to all implemented interfaces.
   #
   class Interface
+    include Helpers::FileHelper
+
     attr_accessor :command_queue, :history
     attr_reader :input, :output, :error
 
     def initialize
-      @command_queue, @history = [], History.new
+      @command_queue = []
+      @history = History.new
     end
 
     #
@@ -31,7 +34,6 @@ module Byebug
       command_queue.shift
     end
 
-    include FileFunctions
     #
     # Pushes lines in +filename+ to the command queue.
     #

data/lib/byebug/interfaces/local_interface.rb

@@ -5,7 +5,9 @@ module Byebug
   class LocalInterface < Interface
     def initialize
       super()
-      @input, @output, @error = STDIN, STDOUT, STDERR
+      @input = STDIN
+      @output = STDOUT
+      @error = STDERR
     end
 
     #

data/lib/byebug/interfaces/remote_interface.rb

@@ -7,7 +7,9 @@ module Byebug
   class RemoteInterface < Interface
     def initialize(socket)
       super()
-      @input, @output, @error = socket, socket, socket
+      @input = socket
+      @output = socket
+      @error = socket
     end
 
     def read_command(prompt)