byebug 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 489c114f27cc5006d198149fccf0ff0e6390cd2a
-  data.tar.gz: be024abb6bfc9d9f989e29e9f97da9cdca1a1daf
+  metadata.gz: c36e72ad4ee68660bcdc6d5b7e1b053abe9846c5
+  data.tar.gz: efa45e7ec838ec213867c8b1543fef5846589681
 SHA512:
-  metadata.gz: da63414df26b9564f6818645b1451f8780fcb324c7b30916675841b053fbfee0070f3e6c0a7d420e21fff5c07a0dd8a7c20b99cf1ed4dbba869d84c4089ea957
-  data.tar.gz: 4f5c740d9b6ea6e41115b43e982a2a1b1fc28b4c0baefa12ce0c796d005cd23e07df3fc5f43f539a9edc790385a7e4978e06d1dcf065c81f3210c6cc0fa6e37c
+  metadata.gz: 796c8e489b574c80dba56c3898ab54831b7ead9fb15579336cbb2331831e52267fce12b0c96aff3c1116ae6ee421bcfdef55c2fb8e81238c2c5dcf85555f4e3a
+  data.tar.gz: b665b2c10ad39cec530808dc30a016d45198706c4737d752de4c6557d398626305833e0f4a18bfc1a7963abb1cfe8c6dfc5410a5e5a9a618e4d1b709326474cc

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.8.0
+
+* Remote debugging support
+
+
 ## 1.7.0
 
 * Callstack display: specifically mark c-frames

data/GUIDE.md

@@ -673,7 +673,7 @@ puts "rocky's byebugrc run"
 
 Here are the default values in `options`
 
-```ruby
+```
 #<OpenStruct annotate=nil, nx=false, quit=true, restart_script=nil, script=nil,
              stop=true, tracing=false, verbose_long=false>
 ```
@@ -907,3 +907,257 @@ Status of user-settable breakpoints.
 Without argument, list info about all breakpoints.
 With an integer argument, list info on that breakpoint.
 ```
+
+### Control Commands: quit, restart, source
+
+#### Quit
+
+To exit `byebug`, type `quit` (abbreviated `q` and aliased `exit`). Normally if
+you are in an interactive session, this command will prompt you to confirm you
+really want to quit. If you don't want any questions asked, enter
+`quit unconditionally` (abbreviated `q!`).
+
+#### Restart
+
+To restart the program, use the `restart|r` command. This is a re-exec - all
+`byebug` state is lost. If command arguments are passed, those are used.
+Otherwise program arguments from the last invocation are used.
+
+You won't be able to restart your program in all cases. First, the program
+should have been invoked at the outset rather than having been called from
+inside your program or invoked as a result of post-mortem handling.
+
+#### Source
+
+You can run `byebug` commands inside a file, using the command `source <file>`.
+The lines in a command file are executed sequentially. They are not printed as
+they are executed. If there is an error, execution proceeds to the next command
+in the file. For information about command files that get run automatically on
+startup see [Command Files]().
+
+
+### Display Commands: display, undisplay
+
+#### Display
+
+If you find that you want to print the value of an expression frequently (to see
+how it changes), you might want to add it to the *automatic display list** so
+that `byebug` evaluates it each time your program stops or after a line is
+printed if line tracing is enabled. Each expression added to the list is given a
+number to identify it; to remove an expression from the list, you specify that
+number. The automatic display looks like this:
+
+```bash
+(byebug) display n
+1: n = 3
+```
+
+This display shows item numbers, expressions and their current values. If the
+expression is undefined or illegal the expression will be printed but no value
+will appear.
+
+```bash
+(byebug) display undefined_variable
+2: undefined_variable =
+(byebug) display 1/0
+3: 1/0 =
+```
+
+If you use `display` with no argument, `byebug` will display the current values
+of the expressions in the list, just as it is done when your program stops.
+Using `info display` has the same effect.
+
+#### Undisplay
+
+To remove an item from the list, use `undisplay` followed by the number
+identifying the expression you want to remove. `undisplay` does not repeat if
+you press `<RET>`after using it (otherwise you would just get the error _No
+display number n_)
+
+You can also temporarily disable or enable display expressions, so that the will
+not be printed but they won't be forgotten either, so you can toggle them again
+later. To do that, use `disable display` or `enable display` followed by the
+expression number.
+
+
+### Print Commands
+
+One way to examine and change data in your script is with the `eval` command
+(abbreviated `p`). `byebug` by default evaluates any input that is not
+recognized as a command, so in most situations `eval` is not necessary and
+`byebug` will work like a REPL. One case where it's necessary could be when
+trying to print a variable called `n`. In this case, you have no choice because
+typing just `n` will execute `byebug`'s command `next`.
+
+A similar command to `eval|p` is `pp` which tries to pretty print the result.
+
+If the value you want to print is an array, sometimes a columnized list looks
+nicer. Use `putl` for that. Notice however that entries are sorted to run down
+first rather than across. If the value is not an array `putl` will just call
+pretty-print.
+
+Sometimes you may want to print the array not only columnized, but sorted as
+well. The list of byebug help commands appears this way, and so does the output
+of the `method` commands. Use `ps` for that. If the value is not an array `ps`
+will just call pretty-print.
+
+```bash
+(byebug) Kernel.instance_methods
+[:nil?, :===, :=~, :!~, :eql?, :hash, :<=>, :class, :singleton_class, :clone,
+:dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :freeze,
+:frozen?, :to_s, :inspect, :methods, :singleton_methods, :protected_methods,
+:private_methods, :public_methods, :instance_variables, :instance_variable_get,
+:instance_variable_set, :instance_variable_defined?, :remove_instance_variable,
+:instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?,
+:extend, :display, :method, :public_method, :define_singleton_method,
+:object_id, :to_enum, :enum_for, :gem, :pretty_inspect, :byebug]
+(byebug) p Kernel.instance_methods
+[:nil?, :===, :=~, :!~, :eql?, :hash, :<=>, :class, :singleton_class, :clone,
+:dup, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :freeze,
+:frozen?, :to_s, :inspect, :methods, :singleton_methods, :protected_methods,
+:private_methods, :public_methods, :instance_variables, :instance_variable_get,
+:instance_variable_set, :instance_variable_defined?, :remove_instance_variable,
+:instance_of?, :kind_of?, :is_a?, :tap, :send, :public_send, :respond_to?,
+:extend, :display, :method, :public_method, :define_singleton_method,
+:object_id, :to_enum, :enum_for, :gem, :pretty_inspect, :byebug]
+(byebug) pp Kernel.instance_methods
+[:nil?,
+ :===,
+ :=~,
+ :!~,
+ :eql?,
+ :hash,
+ :<=>,
+ :class,
+ :singleton_class,
+ :clone,
+ :dup,
+ :taint,
+ :tainted?,
+ :untaint,
+ :untrust,
+ :untrusted?,
+ :trust,
+ :freeze,
+ :frozen?,
+ :to_s,
+ :inspect,
+ :methods,
+ :singleton_methods,
+ :protected_methods,
+ :private_methods,
+ :public_methods,
+ :instance_variables,
+ :instance_variable_get,
+ :instance_variable_set,
+ :instance_variable_defined?,
+ :remove_instance_variable,
+ :instance_of?,
+ :kind_of?,
+ :is_a?,
+ :tap,
+ :send,
+ :public_send,
+ :respond_to?,
+ :extend,
+ :display,
+ :method,
+ :public_method,
+ :define_singleton_method,
+ :object_id,
+ :to_enum,
+ :enum_for,
+ :gem,
+ :pretty_inspect,
+ :byebug]
+(byebug) putl Kernel.instance_methods
+nil?  <=>              tainted?    frozen?            private_methods             remove_instance_variable  public_send    define_singleton_method  byebug
+===   class            untaint     to_s               public_methods              instance_of?              respond_to?    object_id
+=~    singleton_class  untrust     inspect            instance_variables          kind_of?                  extend         to_enum
+!~    clone            untrusted?  methods            instance_variable_get       is_a?                     display        enum_for
+eql?  dup              trust       singleton_methods  instance_variable_set       tap                       method         gem
+hash  taint            freeze      protected_methods  instance_variable_defined?  send                      public_method  pretty_inspect
+(byebug) ps Kernel.instance_methods
+!~      clone                    extend   instance_of?                kind_of?        private_methods           respond_to?        tap      untrusted?
+<=>     define_singleton_method  freeze   instance_variable_defined?  method          protected_methods         send               to_enum
+===     display                  frozen?  instance_variable_get       methods         public_method             singleton_class    to_s   
+=~      dup                      gem      instance_variable_set       nil?            public_methods            singleton_methods  trust  
+byebug  enum_for                 hash     instance_variables          object_id       public_send               taint              untaint
+class   eql?                     inspect  is_a?                       pretty_inspect  remove_instance_variable  tainted?           untrust
+```
+
+Finally, if you need more advanced functionality from REPL's, you can enter
+`irb` or `pry` using `irb` or `pry` commands. The bindings environment will be
+set to the current state in the program.  When you leave the repl and go back to
+`byebug`'s command prompt we show the file, line and text position of the
+program. If you issue a `list` without location information, the default
+location used is the current line rather than the current position that may have
+got updated via a prior `list` command.
+
+```
+$ byebug triangle.rb
+[1, 10] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
+    1: # Compute the n'th triangle number, the hard way: triangle(n) == (n*(n+1))/2
+=>  2: def triangle(n)
+    3:   tri = 0
+    4:   0.upto(n) do |i|
+    5:     tri += i
+    6:   end
+    7:   tri
+    8: end
+    9:
+   10: if __FILE__ == $0
+(byebug) irb
+2.0.0-p247 :001 > (0..6).inject{|sum, i| sum +=i}
+ => 21
+2.0.0-p247 :002 > exit
+/home/davidr/Proyectos/byebug/old_doc/triangle.rb @ 2
+def triangle(n)
+(byebug) list # same line range as before going into irb
+[1, 10] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
+    1: # Compute the n'th triangle number, the hard way: triangle(n) == (n*(n+1))/2
+=>  2: def triangle(n)
+    3:   tri = 0
+    4:   0.upto(n) do |i|
+    5:     tri += i
+    6:   end
+    7:   tri
+    8: end
+    9:
+   10: if __FILE__ == $0
+(byebug)
+```
+
+### Printing variables
+
+Byebug can print many different information about variables. Such as
+* `var const <object>`. Show the constants of `<object>`. This is basically
+listing variables and their values in `<object>.constant`.
+* `var instance <object>`. Show the instance variables of `<object>`. This is
+basically listing `<object>.instance_variables`.
+* `info instance_variables`. Show instance_variables of `self`.
+* `info locals`. Show local variables.
+* `info globals`. Show global variables.
+* `info variables`. Show local and instance variables of `self`.
+* `method instance <object>`. Show methods of `<object>`. Basically this is the
+same as running `ps <object>.instance_methods(false)`.
+* `method iv <object>`. Show method instance variables of `object`. Basically
+this is the same as running
+```
+  <object>.instance_variables.each do |v|
+     puts "%s = %s\n" % [v, <object>.instance_variable_get(v)]
+  end
+```
+* `signature <object>`. Show signature of method `<object>`. _This command is
+available only if the nodewrap gem is installed_.
+
+```ruby
+  def mymethod(a, b=5, &bock)
+  end
+  (byebug) method sig mymethod
+  Mine#mymethod(a, b=5, &bock)
+```
+
+* `method <class-or-module>`. Show methods of the class or module
+`<class-or-module>`. Basically this is the same as running
+`ps <class-or-module>.methods`.

data/README.md

@@ -89,8 +89,7 @@ because it is a default option in byebug.
 ## Getting Started
 
 A handful of commands are enough to get started using `byebug`. The following
-session illustrates these commands. Below is Ruby code to compute a triangle
-number of a given length (there are shorter ways to do it, of course).
+session illustrates these commands.
 
 ```
 $ byebug triangle.rb

data/byebug.gemspec

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/lib/byebug/version'
 Gem::Specification.new do |s|
   s.name        = 'byebug'
   s.version     = Byebug::VERSION
-  s.authors     = ['David Rodríguez', 'Kent Sibilev', 'Mark Moseley']
+  s.authors     = ['David Rodriguez', 'Kent Sibilev', 'Mark Moseley']
   s.email       = 'deivid.rodriguez@mail.com'
   s.license     = 'BSD'
   s.homepage    = 'http://github.com/deivid-rodriguez/byebug'
@@ -27,6 +27,6 @@ Gem::Specification.new do |s|
   s.add_dependency "debugger-linecache", '~> 1.2.0'
 
   s.add_development_dependency 'rake', '~> 10.1.0'
-  s.add_development_dependency 'rake-compiler', '~> 0.8.3'
+  s.add_development_dependency 'rake-compiler', '~> 0.9.1'
   s.add_development_dependency 'mocha', '~> 0.14.0'
 end

data/lib/byebug.rb

@@ -2,9 +2,7 @@ require_relative 'byebug.so'
 require_relative 'byebug/version'
 require_relative 'byebug/context'
 require_relative 'byebug/processor'
-require 'pp'
-require 'stringio'
-require 'socket'
+require_relative 'byebug/remote'
 require 'linecache19'
 
 module Byebug
@@ -33,9 +31,6 @@ module Byebug
     # gdb-style annotation mode. Used in GNU Emacs interface
     attr_accessor :annotate
 
-    # If in remote mode, wait for the remote connection
-    attr_accessor :wait_connection
-
     def source_reload
       Object.send(:remove_const, "SCRIPT_LINES__") if
         Object.const_defined?("SCRIPT_LINES__")

data/lib/byebug/command.rb

@@ -175,8 +175,8 @@ module Byebug
     register_setting_var(:listsize, 10)
     register_setting_var(:stack_trace_on_error, false)
     register_setting_var(:tracing_plus, false)
-    cols = terminal_width || 80
-    register_setting_var(:width, cols > 10 ? cols : 80)
+    cols = terminal_width || 160
+    register_setting_var(:width, cols > 10 ? cols : 160)
     Byebug::ARGV = ARGV.clone unless defined? Byebug::ARGV
     register_setting_var(:argv, Byebug::ARGV)
 

data/lib/byebug/commands/eval.rb

@@ -1,5 +1,6 @@
-module Byebug
+require 'pp'
 
+module Byebug
   module EvalFunctions
     def run_with_binding
       binding = get_binding
@@ -136,8 +137,6 @@ module Byebug
     include Columnize
     self.allow_in_control = true
 
-    include EvalFunctions
-
     def regexp
       /^\s*ps\s+/
     end

data/lib/byebug/commands/frame.rb

@@ -104,7 +104,13 @@ module Byebug
     end
 
     def print_backtrace
-      (0...@state.context.stack_size).each do |idx|
+      realsize = caller.drop_while {|e| e[/\(eval\)|byebug/] }.size
+      if @state.context.stack_size != realsize
+        errmsg "Warning, Byebug's stacksize (#{@state.context.stack_size}) is" \
+               " incorrect (must be #{realsize}). This might be a bug in " \
+               "byebug or ruby's debugging API's\n"
+      end
+      (0...realsize).each do |idx|
         print_frame(idx)
       end
     end

data/lib/byebug/remote.rb

@@ -0,0 +1,95 @@
+require 'socket'
+
+module Byebug
+
+  # Port number used for remote debugging
+  PORT = 8989 unless defined?(PORT)
+
+  class << self
+
+    # If in remote mode, wait for the remote connection
+    attr_accessor :wait_connection
+
+    #
+    # Starts a remote byebug
+    #
+    def start_server(host = nil, port = PORT)
+      return if @thread
+
+      self.interface = nil
+      start
+
+      if port.kind_of?(Array)
+        cmd_port, ctrl_port = port
+      else
+        cmd_port, ctrl_port = port, port + 1
+      end
+
+      ctrl_port = start_control(host, ctrl_port)
+
+      yield if block_given?
+
+      mutex = Mutex.new
+      proceed = ConditionVariable.new
+
+      server = TCPServer.new(host, cmd_port)
+      @cmd_port = cmd_port = server.addr[1]
+      @thread = Thread.new do
+        while (session = server.accept)
+          self.interface = RemoteInterface.new(session)
+          if wait_connection
+            mutex.synchronize do
+              proceed.signal
+            end
+          end
+        end
+      end
+      if wait_connection
+        mutex.synchronize do
+          proceed.wait(mutex)
+        end
+      end
+    end
+
+    def start_control(host = nil, ctrl_port = PORT + 1)
+      return @ctrl_port if defined?(@control_thread) && @control_thread
+      server = TCPServer.new(host, ctrl_port)
+      @ctrl_port = server.addr[1]
+      @control_thread = Thread.new do
+        while (session = server.accept)
+          interface = RemoteInterface.new(session)
+          processor = ControlCommandProcessor.new(interface)
+          processor.process_commands
+        end
+      end
+      @ctrl_port
+    end
+
+    #
+    # Connects to the remote byebug
+    #
+    def start_client(host = 'localhost', port = PORT)
+      interface = Byebug::LocalInterface.new
+      socket = TCPSocket.new(host, port)
+      puts "Connected."
+
+      catch(:exit) do
+        while (line = socket.gets)
+          case line
+          when /^PROMPT (.*)$/
+            input = interface.read_command($1)
+            throw :exit unless input
+            socket.puts input
+          when /^CONFIRM (.*)$/
+            input = interface.confirm($1)
+            throw :exit unless input
+            socket.puts input
+          else
+            print line
+          end
+        end
+      end
+      socket.close
+    end
+  end
+end

data/lib/byebug/version.rb

@@ -1,3 +1,3 @@
 module Byebug
-  VERSION = '1.7.0'
+  VERSION = '1.8.0'
 end

data/test/info_test.rb

@@ -3,15 +3,15 @@ require_relative 'test_helper'
 class TestInfo < TestDsl::TestCase
   include Columnize
 
-   describe 'Args info' do
-     temporary_change_hash Byebug::Command.settings, :width, 15
-
-     it 'must show info about all args' do
-       enter 'break 3', 'cont', 'info args'
-       debug_file 'info'
-       check_output_includes 'a = "aaaaaaa...', 'b = "b"'
-     end
-   end
+  describe 'Args info' do
+    temporary_change_hash Byebug::Command.settings, :width, 15
+
+    it 'must show info about all args' do
+      enter 'break 3', 'cont', 'info args'
+      debug_file 'info'
+      check_output_includes 'a = "aaaaaaa...', 'b = "b"'
+    end
+  end
 
   describe 'Breakpoints info' do
     it 'must show info about all breakpoints' do

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: byebug
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
-- David Rodríguez
+- David Rodriguez
 - Kent Sibilev
 - Mark Moseley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-03 00:00:00.000000000 Z
+date: 2013-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: columnize
@@ -60,14 +60,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.9.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.9.1
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -147,6 +147,7 @@ files:
 - lib/byebug/helper.rb
 - lib/byebug/interface.rb
 - lib/byebug/processor.rb
+- lib/byebug/remote.rb
 - lib/byebug/version.rb
 - logo.png
 - old_doc/byebug.1
@@ -314,4 +315,3 @@ test_files:
 - test/test_helper.rb
 - test/trace_test.rb
 - test/variables_test.rb
-has_rdoc: