byebug 3.5.1 → 4.0.0

data/lib/byebug/commands/break.rb

@@ -1,3 +1,5 @@
+require 'byebug/command'
+
 module Byebug
   #
   # Implements breakpoint functionality
@@ -6,78 +8,77 @@ module Byebug
     self.allow_in_post_mortem = false
     self.allow_in_control = true
 
-    POSITION_REGEXP = '(?:(\d+)|(.+?)[:.#]([^.:\s]+))'
-
     def regexp
-      /^\s* b(?:reak)? (?:\s+ #{POSITION_REGEXP})? (?:\s+(.+))? \s*$/x
+      /^\s* b(?:reak)? (?:\s+ (\S+))? (?:\s+ if \s+(.+))? \s*$/x
     end
 
     def execute
-      return puts(self.class.help) if self.class.names.include?(@match[0])
+      return puts(self.class.help) unless @match[1]
 
-      if @match[1]
-        line, _, _, expr = @match.captures
-      else
-        _, file, line, expr = @match.captures
+      brkpt = line_breakpoint(@match[1]) || method_breakpoint(@match[1])
+      if syntax_valid?(@match[2])
+        return puts(
+          pr('break.created', id: brkpt.id, file: brkpt.source, line: brkpt.pos)
+        )
       end
 
-      if expr && file.nil? && line.nil?
-        return errmsg("Invalid breakpoint location: #{expr}")
-      elsif expr && expr !~ /^\s*if\s+(.+)/
-        return errmsg("Expecting \"if\" in breakpoint condition, got: #{expr}")
-      else
-        expr = $1
+      errmsg(pr('break.errors.expression', expr: @match[2]))
+      brkpt.enabled = false
+    rescue => e
+      errmsg(e.message)
+    end
+
+    class << self
+      def names
+        %w(break)
       end
 
-      if file.nil? && !@state.context
-        return errmsg('We are not in a state that has an associated file')
+      def description
+        prettify <<-EOD
+          b[reak] [file:]line [if expr]
+          b[reak] [module::...]class(.|#)method [if expr]
+
+          Set breakpoint to some position, (optionally) if expr == true
+        EOD
       end
+    end
 
-      file = @state.file if file.nil?
-      line = @state.line.to_s if line.nil?
+    private
 
-      if line =~ /^\d+$/
-        path = CommandProcessor.canonic_file(file)
-        return errmsg("No file named #{path}") unless File.exist?(file)
+    def line_breakpoint(loc)
+      line, file_line = loc.match(/^(\d+)$/), loc.match(/^([^:]+):(\d+)$/)
+      return nil unless line || file_line
 
-        l, n = line.to_i, File.foreach(file).count
-        return errmsg("There are only #{n} lines in file #{path}") if l > n
+      f, l = line ? [@state.file, line[1]] : [file_line[1], file_line[2]]
 
-        autoreload = Setting[:autoreload]
-        possible_lines = LineCache.trace_line_numbers(file, autoreload)
-        unless possible_lines.member?(l)
-          return errmsg("Line #{l} is not a valid breakpoint in file #{path}")
-        end
+      check_errors(f, l.to_i)
 
-        b = Breakpoint.add(file, l, expr)
-        puts "Created breakpoint #{b.id} at #{path}:#{l}"
+      Breakpoint.add(File.expand_path(f), l.to_i, @match[2])
+    end
 
-        unless syntax_valid?(expr)
-          errmsg("Incorrect expression \"#{expr}\"; breakpoint disabled.")
-          b.enabled = false
-        end
+    def method_breakpoint(location)
+      location.match(/([^.#]+)[.#](.+)/) do |match|
+        k, m = bb_warning_eval(match[1]), match[2]
 
-      else
-        kl = bb_warning_eval(file)
-        return errmsg("Unknown class #{file}") unless kl && kl.is_a?(Module)
+        klass = k && k.is_a?(Module) ? k.name : match[1]
+        method = m.intern
 
-        class_name, method = kl.name, line.intern
-        b = Breakpoint.add(class_name, method, expr)
-        puts "Created breakpoint #{b.id} at #{class_name}::#{method}"
+        Breakpoint.add(klass, method, @match[2])
       end
     end
 
-    class << self
-      def names
-        %w(break)
-      end
+    def check_errors(file, line)
+      path, deco_path = File.expand_path(file), normalize(file)
 
-      def description
-        %{b[reak] file:line [if expr]
-          b[reak] class(.|#)method [if expr]
+      fail(pr('break.errors.source', file: deco_path)) unless File.exist?(path)
 
-          Set breakpoint to some position, (optionally) if expr == true}
+      if line > n_lines(file)
+        fail(pr('break.errors.far_line', lines: n_lines(file), file: deco_path))
       end
+
+      return if Breakpoint.potential_line?(path, line)
+
+      fail(pr('break.errors.line', file: deco_path, line: line))
     end
   end
 end

data/lib/byebug/commands/catch.rb

@@ -0,0 +1,64 @@
+require 'byebug/command'
+
+module Byebug
+  #
+  # Implements exception catching.
+  #
+  # Enables the user to catch unhandled assertion when they happen.
+  #
+  class CatchCommand < Command
+    self.allow_in_control = false
+
+    def regexp
+      /^\s* cat(?:ch)? (?:\s+(\S+))? (?:\s+(off))? \s*$/x
+    end
+
+    def execute
+      ex = @match[1]
+      return info_catch unless ex
+
+      cmd = @match[2]
+      unless cmd
+        if 'off' == ex
+          Byebug.catchpoints.clear if
+            confirm(pr('catch.confirmations.delete_all'))
+
+          return
+        end
+
+        is_class = bb_eval("#{ex.is_a?(Class)}")
+        puts pr('catch.errors.not_class', class: ex) unless is_class
+
+        Byebug.add_catchpoint(ex)
+        return puts pr('catch.catching', exception: ex)
+      end
+
+      if cmd == 'off'
+        exists = Byebug.catchpoints.member?(ex)
+        return errmsg pr('catch.errors.not_found', exception: ex) unless exists
+
+        Byebug.catchpoints.delete(ex)
+        return errmsg pr('catch.errors.removed', exception: ex)
+      end
+
+      errmsg pr('catch.errors.off', off: cmd)
+    end
+
+    class << self
+      def names
+        %w(catch)
+      end
+
+      def description
+        prettify <<-EOD
+          cat[ch][ (off|<exception>[ off])]
+
+          "catch" lists catchpoints.
+          "catch off" deletes all catchpoints.
+          "catch <exception>" enables handling <exception>.
+          "catch <exception> off" disables handling <exception>.
+        EOD
+      end
+    end
+  end
+end

data/lib/byebug/commands/condition.rb

@@ -1,3 +1,5 @@
+require 'byebug/command'
+
 module Byebug
   #
   # Implements conditions on breakpoints.
@@ -12,20 +14,20 @@ module Byebug
     end
 
     def execute
-      return puts(ConditionCommand.help) unless @match[1]
+      return puts(self.class.help) unless @match[1]
 
-      breakpoints = Byebug.breakpoints.sort_by { |b| b.id }
-      return errmsg('No breakpoints have been set') unless breakpoints.any?
+      breakpoints = Byebug.breakpoints.sort_by(&:id)
+      return errmsg(pr('condition.errors.no_breakpoints')) if breakpoints.empty?
 
       pos, err = get_int(@match[1], 'Condition', 1)
       return errmsg(err) if err
 
       breakpoint = breakpoints.find { |b| b.id == pos }
-      return errmsg('Invalid breakpoint id. Use "info breakpoint" to find ' \
-                    'out the correct id') unless breakpoint
+      return errmsg(pr('break.errors.no_breakpoint')) unless breakpoint
 
-      return errmsg("Incorrect expression \"#{@match[2]}\", " \
-                    'breakpoint not changed') unless syntax_valid?(@match[2])
+      unless syntax_valid?(@match[2])
+        return errmsg(pr('break.errors.not_changed', expr: @match[2]))
+      end
 
       breakpoint.expr = @match[2]
     end
@@ -36,12 +38,14 @@ module Byebug
       end
 
       def description
-        %(cond[ition] <n>[ expr]
+        prettify <<-EOD
+          cond[ition] <n>[ expr]
 
           Specify breakpoint number <n> to break only if <expr> is true. <n> is
           an integer and <expr> is an expression to be evaluated whenever
           breakpoint <n> is reached. If no expression is specified, the
-          condition is removed.)
+          condition is removed.
+        EOD
       end
     end
   end

data/lib/byebug/commands/continue.rb

@@ -1,3 +1,5 @@
+require 'byebug/command'
+
 module Byebug
   #
   # Implements the continue command.
@@ -16,8 +18,8 @@ module Byebug
         return errmsg(err) unless num
 
         filename = File.expand_path(@state.file)
-        unless LineCache.trace_line_numbers(filename).member?(num)
-          return errmsg("Line #{num} is not a valid stopping point in file")
+        unless Breakpoint.potential_line?(filename, num)
+          return errmsg(pr('continue.errors.unstopped_line', line: num))
         end
 
         Breakpoint.add(filename, num)
@@ -32,9 +34,11 @@ module Byebug
       end
 
       def description
-        %(c[ont[inue]][ <n>]
+        prettify <<-EOD
+          c[ont[inue]][ <n>]
 
-          Run until program ends, hits a breakpoint or reaches line <n>.)
+          Run until program ends, hits a breakpoint or reaches line <n>.
+        EOD
       end
     end
   end

data/lib/byebug/commands/delete.rb

@@ -1,3 +1,5 @@
+require 'byebug/command'
+
 module Byebug
   #
   # Implements breakpoint deletion.
@@ -12,7 +14,9 @@ module Byebug
 
     def execute
       unless @match[1]
-        Byebug.breakpoints.clear if confirm('Delete all breakpoints? (y/n) ')
+        if confirm(pr('break.confirmations.delete_all'))
+          Byebug.breakpoints.clear
+        end
 
         return nil
       end
@@ -23,7 +27,7 @@ module Byebug
         return errmsg(err) unless pos
 
         unless Breakpoint.remove(pos)
-          return errmsg("No breakpoint number #{pos}")
+          return errmsg(pr('break.errors.no_breakpoint_delete', pos: pos))
         end
       end
     end
@@ -34,10 +38,12 @@ module Byebug
       end
 
       def description
-        %(del[ete][ nnn...]
+        prettify <<-EOD
+          del[ete][ nnn...]
 
           Without and argument, deletes all breakpoints. With integer
-          arguments, it deletes specific breakpoints.)
+          arguments, it deletes specific breakpoints.
+        EOD
       end
     end
   end

data/lib/byebug/commands/display.rb

@@ -1,25 +1,6 @@
-module Byebug
-  #
-  # Custom display utilities.
-  #
-  module DisplayFunctions
-    def display_expression(exp)
-      "#{exp} = #{bb_warning_eval(exp).inspect}"
-    end
-
-    def active_display_expressions?
-      @state.display.select { |d| d[0] }.size > 0
-    end
-
-    def print_display_expressions
-      n = 1
-      @state.display.each do |d|
-        puts "#{n}: #{display_expression(d[1])}" if d[0]
-        n += 1
-      end
-    end
-  end
+require 'byebug/command'
 
+module Byebug
   #
   # Implements the functionality of adding custom expressions to be displayed
   # every time the debugger stops.
@@ -34,7 +15,7 @@ module Byebug
     def execute
       exp = @match[1]
       @state.display.push [true, exp]
-      puts "#{@state.display.size}: #{display_expression(exp)}"
+      display_expression(exp)
     end
 
     class << self
@@ -43,11 +24,22 @@ module Byebug
       end
 
       def description
-        %(disp[lay] <expression>
+        prettify <<-EOD
+          disp[lay] <expression>
 
-          Add <expression> into display expression list.)
+          Add <expression> into display expression list.
+        EOD
       end
     end
+
+    private
+
+    def display_expression(exp)
+      print pr('display.result',
+               n: @state.display.size,
+               exp: exp,
+               result: bb_warning_eval(exp).inspect)
+    end
   end
 
   #
@@ -74,8 +66,24 @@ module Byebug
       end
 
       def description
-        %(disp[lay]        Display expression list.)
+        prettify <<-EOD
+          disp[lay] Display expression list.
+        EOD
+      end
+    end
+
+    private
+
+    def print_display_expressions
+      result = prc('display.result', @state.display) do |item, index|
+        is_active, expression = item
+        if is_active
+          { n: index + 1,
+            exp: expression,
+            result: bb_warning_eval(expression).inspect }
+        end
       end
+      print result
     end
   end
 end

data/lib/byebug/commands/edit.rb

@@ -1,3 +1,5 @@
+require 'byebug/command'
+
 module Byebug
   #
   # Edit a file from byebug's prompt.
@@ -11,27 +13,28 @@ module Byebug
 
     def execute
       if !@match[1]
-        unless @state.file
-          return errmsg "We are not in a state that has an associated file.\n"
-        end
+        return errmsg(pr('edit.errors.state')) unless @state.file
         file = @state.file
         line = @state.line if @state.line
       elsif (@pos_match = /([^:]+)[:]([0-9]+)/.match(@match[1]))
         file, line = @pos_match.captures
-      elsif File.exist?(@match[1])
-        file = @match[1]
       else
-        return errmsg "Invalid file[:line] number specification: #{@match[1]}\n"
+        file = @match[1]
       end
 
       editor = ENV['EDITOR'] || 'vim'
+      file = File.expand_path(file)
 
-      if File.readable?(file)
-        system("#{editor} +#{line} #{file}") if line
-        system("#{editor} #{file}") unless line
-      else
-        errmsg "File \"#{file}\" is not readable.\n"
+      unless File.exist?(file)
+        return errmsg(pr('edit.errors.not_exist', file: file))
       end
+      unless File.readable?(file)
+        return errmsg(pr('edit.errors.not_readable', file: file))
+      end
+
+      cmd = line ? "#{editor} +#{line} #{file}" : "#{editor} #{file}"
+
+      system(cmd)
     end
 
     class << self
@@ -40,11 +43,13 @@ module Byebug
       end
 
       def description
-        %(edit[ file:lineno]        Edit specified files.
+        prettify <<-EOD
+          edit[ file:lineno] Edit specified files.
 
           With no argument, edits file containing most recent line listed.
           Editing targets can also be specified to start editing at a specific
-          line in a specific file.)
+          line in a specific file.
+        EOD
       end
     end
   end