byebug 3.0.0 → 3.1.0

data/lib/byebug/commands/set.rb

@@ -1,132 +1,44 @@
 module Byebug
 
-  # Mix-in module to setting settings
-  module SetFunctions
-
-    def set_setting(setting_name, setting_value, setting_args)
-      case setting_name
-      when /^args$/
-        if defined?(Byebug::BYEBUG_SCRIPT)
-          Command.settings[:argv][1..-1] = setting_args
-        else
-          Command.settings[:argv] = setting_args
-        end
-      when /^autoirb$/
-        Command.settings[:autoirb] = (setting_value ? 1 : 0)
-      when /^autolist$/
-        Command.settings[:autolist] = (setting_value ? 1 : 0)
-      when /^callstyle$/
-        if setting_args[0] and ['short', 'long'].include?(setting_args[0])
-          Command.settings[:callstyle] = setting_args[0].to_sym
-        else
-          print "Invalid callstyle. Should be one of: \"short\" or \"long\"\n"
-        end
-      when /^verbose$/
-        Byebug.verbose = setting_value
-      when /^histfile$/
-        return print 'You need to specify a filename' unless setting_args[0]
-        Byebug::History.file = File.expand_path(setting_args[0])
-      when /^histsize$/
-        return print 'You need to specify the history size' unless setting_args[0]
-        Byebug::History.max_size = get_int(setting_args[0], "Set histsize")
-      when /^linetrace$/
-        Byebug.tracing = setting_value
-      when /^listsize$/
-        listsize = get_int(setting_args[0], 'Set listsize', 1, nil, 10)
-        return unless listsize
-        Command.settings[:listsize] = listsize
-      when /^width$/
-        return unless width = get_int(setting_args[0], 'Set width', 10, nil, 80)
-        Command.settings[:width] = width
-      when /^post_mortem$/
-        if setting_value == true
-          Byebug.post_mortem
-        else
-          Byebug.post_mortem = false
-        end
-      when /^autoeval|autoreload|autosave|basename|forcestep|fullpath|
-             linetrace_plus|testing|stack_on_error$/x
-        Command.settings[setting_name.to_sym] = setting_value
-      else
-        return print "Unknown setting #{@match[1]}.\n"
-      end
-    end
-  end
-
   # Implements byebug "set" command.
   class SetCommand < Command
-    Subcmd2 = Struct.new(:name, :min, :is_bool, :help) unless defined?(Subcmd2)
-
-    Subcommands = [
-      ['args'          , 2 , false, 'Set argument list to the program '    \
-                                    'being debugged when it is started'       ],
-      ['autoeval'      , 5 , true , 'Evaluate every unrecognized command'     ],
-      ['autolist'      , 5 , true , 'Execute "list" command on every '     \
-                                    'breakpoint'                              ],
-      ['autoirb'       , 5 , true , 'Invoke IRB on every stop'                ],
-      ['autoreload'    , 5 , true , 'Reload source code when changed'         ],
-      ['autosave'      , 5 , true , 'Automatically save command history '  \
-                                    'record on exit'                          ],
-      ['basename'      , 1 , true , 'Set filename display style'              ],
-      ['callstyle'     , 2 , false, 'Set how you want call parameters '    \
-                                    'displayed'                               ],
-      ['forcestep'     , 2 , true , 'Make sure "next/step" commands always' \
-                                    'move to a new line'                      ],
-      ['fullpath'      , 2 , true , 'Display full file names in frames'       ],
-      ['histfile'      , 5 , false, 'Customize file where history is '      \
-                                    'loaded from and saved to. By '         \
-                                    'default, .byebug_hist'                   ],
-      ['histsize'      , 5 , false, 'Customize maximum number of commands ' \
-                                    'that are stored in byebug history '    \
-                                    'record. By default, 256'                 ],
-      ['linetrace'     , 3 , true , 'Enable line execution tracing'           ],
-      ['linetrace_plus', 10, true , 'Set line execution tracing to show'    \
-                                    'different lines'                         ],
-      ['listsize'      , 3 , false, 'Set number of source lines to list by' \
-                                    'default'                                 ],
-      ['post_mortem'   , 2 , true , 'Enable post-mortem mode'                 ],
-      ['stack_on_error', 1 , true , 'Display stack trace when "eval" '      \
-                                    'raises exception'                        ],
-      ['testing'       , 2 , false, 'Used when testing byebug'                ],
-      ['verbose'       , 1 , true , 'Enable verbose output of TracePoint '  \
-                                    'API events is enabled'                   ],
-      ['width'         , 1 , false, 'Number of characters per line for '    \
-                                    'byebug\'s output'                        ]
-    ].map do |name, min, is_bool, help|
-      Subcmd2.new(name, min, is_bool, help)
-    end unless defined?(Subcommands)
-
     self.allow_in_control = true
 
     def regexp
-      /^\s* set (?:\s+(.*))? \s*$/x
+      /^\s* set (?:\s+(?<setting>\w+))? (?:\s+(?<value>\S+))? \s*$/x
     end
 
     def execute
-      return print SetCommand.help(nil) if SetCommand.names.include?(@match[0])
-
-      args = @match[1].split(/[ \t]+/)
-      try_subcmd = args.shift
-      try_subcmd.downcase!
-      if try_subcmd =~ /^no/i
-        set_on = false
-        try_subcmd = try_subcmd[2..-1]
-      else
-        set_on = true
-      end
+      key, value = @match[:setting], @match[:value]
+      return print SetCommand.help if key.nil? && value.nil?
 
-      subcmd = Command.find(Subcommands, try_subcmd)
-      return print "Unknown set command \"#{try_subcmd}\"\n" unless subcmd
+      full_key = Setting.find(key)
+      return print "Unknown setting :#{key}\n" unless full_key
 
-      begin
-        set_on = get_onoff(args[0]) if subcmd.is_bool and args.size > 0
-      rescue RuntimeError
-        return
+      if !Setting.boolean?(full_key) && value.nil?
+        return print "You must specify a value for setting :#{key}\n"
+      elsif Setting.boolean?(full_key)
+        value = get_onoff(value, key =~ /^no/ ? false : true)
+      elsif Setting.integer?(full_key)
+        return unless value = get_int(value, full_key, 1, 300)
       end
 
-      set_setting(subcmd.name, set_on, args)
+      Setting[full_key.to_sym] = value
+
+      return print Setting.settings[full_key.to_sym].to_s
+    end
 
-      return print "#{show_setting(subcmd.name)}\n"
+    def get_onoff(arg, default)
+      return default if arg.nil?
+      case arg
+      when '1', 'on'
+        return true
+      when '0', 'off'
+        return false
+      else
+        print "Expecting 'on', 1, 'off', or 0. Got: #{arg}.\n"
+        raise RuntimeError
+      end
     end
 
     class << self
@@ -135,8 +47,25 @@ module Byebug
       end
 
       def description
-        %{Modifies parts of byebug environment. Boolean values take on, off, 1
-          or 0. You can see these environment settings with the "show" command.}
+        <<-EOD.gsub(/^        /, '')
+
+          set <setting> <value>
+
+          Modifies parts of byebug environment.
+
+          Boolean values take "on", "off", "true", "false", "1" or "0". If you
+          don't specify a value, the boolean setting will be enabled.
+          Conversely, you can use "set no<setting> to disable them.
+
+          You can see these environment settings with the "show" command.
+
+        EOD
+      end
+
+      def help(setting = nil)
+        return "set #{setting.to_sym} <value>\n\n#{setting.help}" if setting
+
+        description + Setting.format()
       end
     end
   end

data/lib/byebug/commands/show.rb

@@ -1,139 +1,22 @@
 module Byebug
 
-  # Mix-in module to showing settings
-  module ShowFunctions
-
-    def show_setting(setting_name)
-      case setting_name
-      when /^args$/
-        if Command.settings[:argv] and Command.settings[:argv].size > 0
-          if defined?(Byebug::BYEBUG_SCRIPT)
-            # byebug was called initially. 1st arg is script name.
-            args = Command.settings[:argv][1..-1].join(' ')
-          else
-            # byebug wasn't called initially. 1st arg is not script name.
-            args = Command.settings[:argv].join(' ')
-          end
-        else
-          args = ''
-        end
-        "Argument list to give program being debugged when it is started is \"#{args}\"."
-      when /^autolist$/
-        "autolist is #{show_onoff(Command.settings[:autolist] > 0)}."
-      when /^autoirb$/
-        "autoirb is #{show_onoff(Command.settings[:autoirb] > 0)}."
-      when /^autosave$/
-        "Saving history is #{show_onoff(Command.settings[:autosave])}."
-      when /^callstyle$/
-        "Frame call-display style is #{Command.settings[:callstyle]}."
-      when /^commands(:?\s+(\d+))?$/
-        if Command.settings[:autosave]
-          history = Byebug::History
-          args = @match[1].split
-          if args[1]
-            size = get_int(args[1], 'show commands', 1, history.max_size)
-          end
-          size ? history.to_s(size) : history.to_s
-        else
-          'Not currently saving history. Enable it with "set autosave"'
-        end
-      when /^testing$/
-        "Currently testing byebug is #{show_onoff(Command.settings[:testing])}."
-      when /^forcestep$/
-        "force-stepping is #{show_onoff(Command.settings[:forcestep])}."
-      when /^fullpath$/
-        "Displaying frame's full file names is #{show_onoff(Command.settings[:fullpath])}."
-      when /^histfile$/
-        "The command history file is \"#{Byebug::History.file}\""
-      when /^histsize$/
-        "Byebug history's maximum size is #{Byebug::History.max_size}"
-      when /^linetrace$/
-        "line tracing is #{show_onoff(Byebug.tracing?)}."
-      when /^linetrace_plus$/
-        if Command.settings[:linetrace_plus]
-          'line tracing style is every line.'
-        else
-          'line tracing style is different consecutive lines.'
-        end
-      when /^listsize$/
-        "Number of source lines to list is #{Command.settings[:listsize]}."
-      when /^post_mortem$/
-        "Post-mortem mode is #{show_onoff(Byebug.post_mortem?)}"
-      when /^stack_on_error$/
-        "Displaying stack trace is #{show_onoff(Command.settings[:stack_on_error])}."
-      when /^verbose$/
-        "Verbose output of TracePoint API events is #{show_onoff(Byebug.verbose)}."
-      when /^version$/
-        "Byebug #{Byebug::VERSION}"
-      when /^width$/
-        "Width is #{Command.settings[:width]}."
-      when /^autoeval|autoreload|basename$/x
-        "#{setting_name} is #{show_onoff(Command.settings[setting_name.to_sym])}."
-      else
-        "Unknown show subcommand #{setting_name}."
-      end
-    end
-  end
-
   # Implements byebug "show" command.
   class ShowCommand < Command
-
-    Subcommands = [
-      ['args'          , 2 , 'Show argument list to the program being '     \
-                             'debugged when it is started'                    ],
-      ['autoeval'      , 5 , 'Show whether unrecognized commands are '      \
-                             'evaluated'                                      ],
-      ['autolist'      , 5 , 'Show whether "list" command is run on stopping' ],
-      ['autoirb'       , 5 , 'Show whether IRB is invoked on stopping'        ],
-      ['autoreload'    , 5 , 'Show whether source code is reloaded when '   \
-                             'changed'                                        ],
-      ['autosave'      , 5 , 'Show whether command history is '             \
-                             'automatically saved on exit'                    ],
-      ['basename'      , 1 , 'Show whether basename is used when reporting' \
-                             ' files'                                         ],
-      ['callstyle'     , 2 , 'Show parameter style used when showing call'  \
-                             ' frames'                                        ],
-      ['commands'      , 2 , 'Show the history of commands you typed. You ' \
-                             'can supply a command number to start with'      ],
-      ['forcestep'     , 1 , 'Show whether "next/step" commands are set to' \
-                             ' always move to a line'                         ],
-      ['fullpath'      , 2 , 'Show whether full paths are displayed in frames'],
-      ['histfile'      , 5 , 'File where byebug save history of commands'     ],
-      ['histsize'      , 5 , 'Maximum number of commands stored in '        \
-                             'byebug\'s history'                              ],
-      ['linetrace'     , 3 , 'Show line execution tracing status'             ],
-      ['linetrace_plus', 10, 'Show whether different consecutive lines are' \
-                             ' shown in tracing'                              ],
-      ['listsize'      , 3 , 'Show number of source lines to list by default' ],
-      ['post_mortem'   , 3 , 'Show whether we should go into post-mortem '  \
-                             'debugging on an uncaught exception'             ],
-      ['stack_on_error', 1 , 'Show whether a stack trace is displayed when' \
-                             ' "eval" raises an exception'                    ],
-      ['verbose'       , 4 , 'Show whether verbose output for debugging '   \
-                             'byebug itself is enabled'                       ],
-      ['version'       , 1 , 'Show byebug\'s version'                         ],
-      ['width'         , 1 , 'Show the number of characters per line for '  \
-                             'byebug'                                         ]
-    ].map do |name, min, help|
-      Subcmd.new(name, min, help)
-    end unless defined?(Subcommands)
-
     self.allow_in_control = true
 
     def regexp
-      /^\s* show (?:\s+(.+))? \s*$/x
+      /^\s* show (?:\s+(?<setting>\w+))? \s*$/x
     end
 
     def execute
-      return print ShowCommand.help(nil) unless @match[1]
+      key = @match[:setting]
+      return print ShowCommand.help if key.nil?
 
-      args = @match[1].split(/[ \t]+/)
-      param = args.shift
-      subcmd = Command.find(Subcommands, param)
-      if subcmd
-        print "%s\n" % show_setting(subcmd.name)
+      full_key = Setting.find(key)
+      if full_key
+        print Setting.settings[full_key.to_sym].to_s
       else
-        print "Unknown show command #{param}\n"
+        print "Unknown setting :#{key}\n"
       end
     end
 
@@ -143,9 +26,22 @@ module Byebug
       end
 
       def description
-        %{Generic command for showing things about byebug.}
+        <<-EOD.gsub(/^        /, '')
+
+          show <setting> <value>
+
+          Generic command for showing byebug settings. You can change them with
+          the "set" command.
+
+        EOD
       end
-    end
 
+      def help(setting = nil)
+        return "show #{setting.to_sym} <value>\n\n#{setting.help}" if setting
+
+        description + Setting.format()
+      end
+    end
   end
+
 end

data/lib/byebug/commands/stepping.rb

@@ -4,7 +4,7 @@ module Byebug
   module SteppingFunctions
     def parse_stepping_args(command_name, match)
       if match[1].nil?
-        force = Command.settings[:forcestep]
+        force = Setting[:forcestep]
       elsif match[1] == '+'
         force = true
       elsif match[1] == '-'

data/lib/byebug/commands/trace.rb

@@ -2,36 +2,26 @@ module Byebug
 
   class TraceCommand < Command
     def regexp
-      /^\s* tr(?:ace)? (?: \s+ (\S+))   # on | off | var(iable)
-                       (?: \s+ (\S+))?  # (variable-name)?
-                       (?: \s+ (\S+))?  # (stop | nostop)?
+      /^\s* tr(?:acevar)? (?: \s+ (\S+))?  # (variable-name)?
+                          (?: \s+ (\S+))?  # (stop | nostop)?
        \s*$/x
     end
 
     def execute
-      if @match[1] =~ /on|off/
-        onoff = 'on' == @match[1]
-        Byebug.tracing = onoff
-        print "#{show_setting('linetrace')}\n"
-      elsif @match[1] =~ /var(?:iable)?/
-        varname = @match[2]
-        if global_variables.include?("$#{varname}".to_sym)
-          if @match[3] && @match[3] !~ /(:?no)?stop/
-            errmsg "expecting \"stop\" or \"nostop\"; got \"#{@match[3]}\"\n"
-          else
-            dbg_cmd = (@match[3] && @match[3] !~ /nostop/) ? 'byebug(1, false)' : ''
-          end
-          eval("trace_var(:\"\$#{varname}\") do |val|
-                  print \"traced global variable '#{varname}' has value '\#{val}'\"\n
-                  #{dbg_cmd}
-                end")
-          print "Tracing global variable \"#{varname}\".\n"
+      varname = @match[1]
+      if global_variables.include?("$#{varname}".to_sym)
+        if @match[2] && @match[2] !~ /(:?no)?stop/
+          errmsg "expecting \"stop\" or \"nostop\"; got \"#{@match[2]}\"\n"
         else
-          errmsg "'#{varname}' is not a global variable.\n"
+          dbg_cmd = (@match[2] && @match[2] !~ /nostop/) ? 'byebug(1, false)' : ''
         end
+        eval("trace_var(:\"\$#{varname}\") do |val|
+                print \"traced global variable '#{varname}' has value '\#{val}'\"\n
+                #{dbg_cmd}
+              end")
+        print "Tracing global variable \"#{varname}\".\n"
       else
-        errmsg "expecting \"on\", \"off\", \"var\" or \"variable\"; got: " \
-               "\"#{@match[1]}\"\n"
+        errmsg "'#{varname}' is not a global variable.\n"
       end
     end
 
@@ -41,8 +31,7 @@ module Byebug
       end
 
       def description
-        %{tr[ace] (on|off)\tset trace mode
-          tr[ace] var(iable) VARNAME [stop|nostop]\tset trace variable on VARNAME}
+        %{tr[acevar] VARNAME [stop|nostop]\tset trace variable on VARNAME}
       end
     end
   end

data/lib/byebug/commands/variables.rb

@@ -1,5 +1,4 @@
 module Byebug
-
   module VarFunctions
     def var_list(ary, b = get_binding)
       ary.sort!
@@ -13,14 +12,16 @@ module Byebug
             s = "*Error in evaluation*"
           end
         end
-        pad_with_dots(s)
+        s[Setting[:width]-3..-1] = "..." if s.size > Setting[:width]
         print "#{v} = #{s}\n"
       end
     end
+
     def var_class_self
       obj = bb_eval('self')
       var_list(obj.class.class_variables, get_binding)
     end
+
     def var_global
       var_list(global_variables.reject { |v| [:$=, :$KCODE, :$-K].include?(v) })
     end
@@ -147,43 +148,4 @@ module Byebug
       end
     end
   end
-
-  begin
-    require 'classtree'
-    have_classtree = true
-  rescue LoadError
-    have_classtree = false
-  end
-
-  # Implements byebug's 'var inherit' command
-  class VarInheritCommand < Command
-    def regexp
-      /^\s* v(?:ar)? \s+ ct \s*$/x
-    end
-
-    def execute
-      unless @state.context
-        errmsg "can't get object inheritance.\n"
-        return
-      end
-      puts @match.post_match
-      obj = bb_eval("#{@match.post_match}.classtree")
-      if obj
-        print obj
-      else
-        errmsg "Trouble getting object #{@match.post_match}\n"
-      end
-    end
-
-    class << self
-      def names
-        %w(var)
-      end
-
-      def description
-        %{v[ar] ct\t\t\tshow class heirarchy of object}
-      end
-    end
-  end if have_classtree
-
 end