byebug 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ce377f1e91c98824d4b2f13186abca18ae9916f
-  data.tar.gz: e8225ad23bd321ce9fa0373a2d30fb7b6fa9fad8
+  metadata.gz: f8478138d1bb0441775054b1f4ba7feb59429a60
+  data.tar.gz: 1404c249bcc849e2b9ae0240617ef590e88b8b96
 SHA512:
-  metadata.gz: e24e6c9e24efbd1e88f298c5a091af7348ad679f2ef2945b4b5e46ad3db2ea7da123dc0bc41d3e4696bd68a8b371694266480a16bda074f7b6de17188e926013
-  data.tar.gz: a6e0cda3871f5555ea1ab7b025a1c47af188573172d83e87eb5966bf091419cb2a7e16bcc0de65abce2677b11475d585ed922044838c7b4a4969bf6e5e4e3b45
+  metadata.gz: 1cc5b019263bc58a174d59b5ad8829dc8781e53722b3742091e879122916484d3ef73e46be20f20cbb72359a0cee62843ca8cfde9676ff15a1101f0c27519914
+  data.tar.gz: 46c6792714d460d1aaaf99cc487da5a8d0f0a72c81253e3c6e0d98df1af90358be796ef1de87ce7f1e43f44e4f6d1f575896683acde1e4811325c5c5c0511236

data/.gitignore

@@ -15,3 +15,4 @@ doc
 Gemfile.lock
 
 lib/byebug.so
+lib/byebug.bundle

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 2.2.0
+
+* Small fixes in stack_size calculations
+* Warning free byebug
+* Add `verbose` setting for TracePoint API event inspection
+* Fix setting `post_mortem` mode
+* Allow `edit <filename>` without a line number
+
+
 # 2.1.1
 
 * Fix bug when debugging code inside '-e' flag

data/CONTRIBUTING.md

@@ -4,6 +4,18 @@ To make your changes, follow this steps:
 
 * [Fork the project](https://help.github.com/fork-a-repo)
 * Create a topic branch - `git checkout -b my_branch`
-* Insert awesome code
+* Insert awesome code - See below
 * Push your branch to your forked repo - `git push origin my_branch`
 * [Make a pull request](https://help.github.com/articles/using-pull-requests)
+
+How to insert awesome code:
+
+This gem uses `rake-compiler` to build native gems. You can use `rake compile` to build the native gem
+and start the tests using `rake test`
+
+```bash
+rake compile
+rake test
+```
+
+It's appreciated if you add tests for new functionality. Thanks!

data/GUIDE.md

@@ -1,3 +1,155 @@
+### First Steps
+
+A handful of commands are enough to get started using `byebug`. The following
+session illustrates these commands.
+
+```
+$ byebug triangle.rb
+[1, 10] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
+    1: # Compute the n'th triangle number: 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: t = triangle(3)
+(byebug)
+```
+
+We are currently stopped before the first executable line of the program: line 2
+of `triangle.rb`. If you are used to less dynamic languages and have used
+debuggers for more statically compiled languages like C, C++, or Java, it may
+seem odd to be stopped before a function definition but in Ruby line 2 is
+executed.
+
+Byebug's prompt is `(byebug)`. If the program has died and you are in
+post-mortem debugging, `(byebug:post-mortem)` is used instead. If the program
+has terminated normally, the string this position will be `(byebug:ctrl)`. The
+commands available change depending on the program's state.
+
+Byebug automatically lists 10 lines of code centered around the current line
+everytime it is stopped. The current line is marked with `=>`, so the range
+byebug would like to show is [-3..6]. However since there aren't 5 lines before
+the current line, the range is moved _up_ so we can actually display 10 lines
+of code.
+
+Now let us step through the program.
+
+```
+(byebug) step
+[2, 11] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
+    2: def triangle(n)
+    3:   tri = 0
+    4:   0.upto(n) do |i|
+    5:     tri += i
+    6:   end
+    7:   tri
+    8: end
+    9:
+=> 10: t = triangle(3)
+   11: puts t
+(byebug) <RET> # hit enter
+[1, 10] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
+    1: # Compute the n'th triangle number: 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: t = triangle(3)
+(byebug) p tri
+nil
+(byebug) step
+[1, 10] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
+    1: # Compute the n'th triangle number: 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: t = triangle(3)
+(byebug) p tri
+0
+```
+
+The first `step` command runs the script one executable unit. The second command
+we entered was just hitting the return key; `byebug` remembers the last command
+you entered was `step` and it runs it again.
+
+One way to print the values of variables is `p` (there are other ways). When we
+look at the value of `tri` the first time, we see it is `nil`. Again we are
+stopped _before_ the assignment on line 3, and this variable hasn't been set
+previously. However after issuing another `step` command we see that the value
+is 0 as expected. If every time we stop we want to see the value of `tri` to see
+how things are going, there is a better way by setting a display expression:
+
+```
+(byebug) display tri
+1: tri = 0
+```
+
+Now let us run the program until we return from the function. We'll want to see
+which lines get run, so we turn on _line tracing_. If we don't want whole paths
+to be displayed when tracing, we can turn on _basename_.
+
+```
+(byebug) display i
+2: i =
+(byebug) set linetrace on
+line tracing is on.
+(byebug) set basename on
+basename is on.
+(byebug) finish
+Tracing: triangle.rb:5 tri += i
+1: tri = 0
+2: i = 0
+Tracing: triangle.rb:5 tri += i
+1: tri = 0
+2: i = 1
+Tracing: triangle.rb:5 tri += i
+1: tri = 1
+2: i = 2
+Tracing: triangle.rb:5 tri += i
+1: tri = 3
+2: i = 3
+Tracing: triangle.rb:7 tri
+1: tri = 6
+2: i =
+Tracing: triangle.rb:11 puts t
+1: tri =
+2: i =
+[2, 11] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
+    2: def triangle(n)
+    3:   tri = 0
+    4:   0.upto(n) do |i|
+    5:     tri += i
+    6:   end
+    7:   tri
+    8: end
+    9:
+   10: t = triangle(3)
+=> 11: puts t
+1: tri =
+2: i =
+(byebug) quit
+Really quit? (y/n) y
+```
+
+So far, so good. As you can see from the above to get out of `byebug`, one
+can issue a `quit` command (`q` and `exit` are just as good). If you want to
+quit without being prompted, suffix the command with an exclamation mark, e.g.,
+`q!`.
+
+
 ### Second Sample Session: Delving Deeper
 
 In this section we'll introduce breakpoints, the call stack and restarting.
@@ -601,7 +753,6 @@ Options:
     -x, --trace            Turn on line tracing
 
 Common options:
-        --verbose          Turn on verbose mode
         --help             Show this message
         --version          Print program version
     -v                     Print version number, then turn on verbose mode
@@ -1186,3 +1337,32 @@ stopped. Repeating a `list` command with `RET` discards the argument, so it is
 equivalent to typing just `list`.  This is more useful than listing the same
 lines again. An exception is made for an argument of `-`: that argument is
 preserved in repetition so that each repetition moves up in the source file.
+
+### Editing Source files (`edit`)
+
+To edit a source file, use the `edit` command.  The editor of your choice is invoked
+with the current line set to the active line in the program. Alternatively, you can
+give a line specification to specify what part of the file you want to edit.
+
+You can customize `byebug` to use any editor you want by using the `EDITOR`
+environment variable. The only restriction is that your editor (say `ex`) recognizes
+the following command-line syntax:
+```
+ex +nnn file
+```
+
+The optional numeric value `+nnn` specifies the line number in the file where
+you want to start editing. For example, to configure `byebug` to use the `vi` editor,
+you could use these commands with the `sh` shell:
+
+```bash
+EDITOR=/usr/bin/vi
+export EDITOR
+byebug ...
+```
+
+or in the `csh` shell,
+```bash
+setenv EDITOR /usr/bin/vi
+byebug ...
+```

data/README.md

@@ -38,7 +38,7 @@ Simply drop
     byebug
 
 wherever you want to start debugging and the execution will stop there. If you
-are debugging rails, start the server and once the execution get to your
+are debugging rails, start the server and once the execution gets to your
 `byebug` command you will get a debugging prompt.
 
 Former [debugger](https://github.com/cldwalker/debugger) or
@@ -58,15 +58,9 @@ no longer need to set them in the startup file.
 
 * Works on 2.0.0 and it doesn't on 1.9.x.
 * Has no MRI internal source code dependencies, just a clean API.
-* Fixes most of debugger's current open issues:
-  - Post-mortem mode segfaulting.
-  - Line number wrongly shown as zero in backtrace.
-  - Line tracing.
-  - Colon delimited include paths.
-  - Nice markdown guide.
-  - Ruby 2.0 support.
-  - where/bt does not in fact give a backtrace.
-  - `byebug` can now be placed at the end of a block or method call.
+* Fixes all of debugger's open bugs in its issue tracker and provides some
+enhancements, such as a markdown guide or the fact that `byebug` can now be
+placed at the end of a block or method call.
 * Very actively mantained.
 * Editor agnostic: no external editor built-in support.
 * Pry command is built-in. No need of external gem like debugger-pry.
@@ -82,211 +76,67 @@ changes.
 
 Byebug's public API is determined by its set of commands
 
-    +-----------+----------+------------------------------------------------+
-    |  Command  | Aliases  |                  Subcommands                   |
-    +-----------+----------+------------------------------------------------+
-    | backtrace | bt|where |                                                |
-    | break     |          |                                                |
-    | catch     |          |                                                |
-    | condition |          |                                                |
-    | continue  |          |                                                |
-    | delete    |          |                                                |
-    | disable   |          | breakpoints|display                            |
-    | display   |          |                                                |
-    | down      |          |                                                |
-    | edit      |          |                                                |
-    | enable    |          | breakpoints|display                            |
-    | finish    |          |                                                |
-    | frame     |          |                                                |
-    | help      |          |                                                |
-    | info      |          | args|breakpoints|catch|display|file|files      |
-    |           |          | global_variables|instance_variables|line       |
-    |           |          | locals|program|stack|variables                 |
-    | irb       |          |                                                |
-    | kill      |          |                                                |
-    | list      |          |                                                |
-    | method    |          | instance|iv                                    |
-    | next      |          |                                                |
-    | p         | eval     |                                                |
-    | pp        |          |                                                |
-    | pry       |          |                                                |
-    | ps        |          |                                                |
-    | putl      |          |                                                |
-    | quit      | exit     |                                                |
-    | reload    |          |                                                |
-    | restart   |          |                                                |
-    | save      |          |                                                |
-    | set       |          | args|autoeval|autoirb|autolist|autoreload      |
-    |           |          | basename|callstyle|forcestep|fullpath|history  |
-    |           |          | linetrace|linetrace_plus|listsize|post_mortem  |
-    |           |          | stack_trace_on_error|testing|width             |
-    | show      |          | args|autoeval|autoirb|autolist|autoreload      |
-    |           |          | basename|callstyle|commands|forcestep|fullpath |
-    |           |          | history|linetrace|linetrace_plus|listsize      |
-    |           |          | post_mortem|stack_trace_on_error|width         |
-    | skip      |          |                                                |
-    | source    |          |                                                |
-    | step      |          |                                                |
-    | thread    |          | current|list|resume|stop|switch                |
-    | trace     |          |                                                |
-    | undisplay |          |                                                |
-    | up        |          |                                                |
-    | var       |          | class|constant|global|instance|local|ct        |
-    +-----------+----------+------------------------------------------------+
+    Command   | Aliases  | Subcommands
+    ----------|----------|------------------------------------------------------
+    backtrace | bt,where |
+    break     |          |
+    catch     |          |
+    condition |          |
+    continue  |          |
+    delete    |          |
+    disable   |          | breakpoints,display
+    display   |          |
+    down      |          |
+    edit      |          |
+    enable    |          | breakpoints,display
+    finish    |          |
+    frame     |          |
+    help      |          |
+    info      |          | args,breakpoints,catch,display,file,files,...
+    irb       |          |
+    kill      |          |
+    list      |          |
+    method    |          | instance,iv
+    next      |          |
+    p         | eval     |
+    pp        |          |
+    pry       |          |
+    ps        |          |
+    putl      |          |
+    quit      | exit     |
+    reload    |          |
+    restart   |          |
+    save      |          |
+    set       |          | args,autoeval,autoirb,autolist,autoreload,basename...
+    show      |          | args,autoeval,autoirb,autolist,autoreload,basename...
+    skip      |          |
+    source    |          |
+    step      |          |
+    thread    |          | current,list,resume,stop,switch
+    trace     |          |
+    undisplay |          |
+    up        |          |
+    var       |          | class,constant,global,instance,local,ct
+
+Full lists of subcommands:
+
+* info: `args`,`breakpoints`,`catch`,`display`,`file`,`files`,
+`global_variables`,`instance_variables`,`line`,`locals`,`program,stack`,
+`variables`.
+* set: `args`,`autoeval`,`autoirb`,`autolist`,`autoreload`,`basename`,
+`callstyle`,`forcestep`,`fullpath`,`history`,`linetrace`,`linetrace_plus`,
+`listsize`,`post_mortem`,`stack_trace_on_error`,`testing`,`verbose`,`width`.
+* show: `args`,`autoeval`,`autoirb`,`autolist`,`autoreload`,`basename`,
+`callstyle`,`commands`,`forcestep`,`fullpath`,`history`,`linetrace`,
+`linetrace_plus`, `listsize`,`post_mortem`,`stack_trace_on_error`,`verbose`,
+`width`.
 
 
 ## Getting Started
 
-A handful of commands are enough to get started using `byebug`. The following
-session illustrates these commands.
-
-```
-$ byebug triangle.rb
-[1, 10] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
-    1: # Compute the n'th triangle number: 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: t = triangle(3)
-(byebug)
-```
-
-We are currently stopped before the first executable line of the program: line 2
-of `triangle.rb`. If you are used to less dynamic languages and have used
-debuggers for more statically compiled languages like C, C++, or Java, it may
-seem odd to be stopped before a function definition but in Ruby line 2 is
-executed.
-
-Byebug's prompt is `(byebug)`. If the program has died and you are in
-post-mortem debugging, `(byebug:post-mortem)` is used instead. If the program
-has terminated normally, the string this position will be `(byebug:ctrl)`. The
-commands available change depending on the program's state.
-
-Byebug automatically lists 10 lines of code centered around the current line
-everytime it is stopped. The current line is marked with `=>`, so the range
-byebug would like to show is [-3..6]. However since there aren't 5 lines before
-the current line, the range is moved _up_ so we can actually display 10 lines
-of code.
-
-Now let us step through the program.
-
-```
-(byebug) step
-[2, 11] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
-    2: def triangle(n)
-    3:   tri = 0
-    4:   0.upto(n) do |i|
-    5:     tri += i
-    6:   end
-    7:   tri
-    8: end
-    9:
-=> 10: t = triangle(3)
-   11: puts t
-(byebug) <RET> # hit enter
-[1, 10] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
-    1: # Compute the n'th triangle number: 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: t = triangle(3)
-(byebug) p tri
-nil
-(byebug) step
-[1, 10] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
-    1: # Compute the n'th triangle number: 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: t = triangle(3)
-(byebug) p tri
-0
-```
-
-The first `step` command runs the script one executable unit. The second command
-we entered was just hitting the return key; `byebug` remembers the last command
-you entered was `step` and it runs it again.
-
-One way to print the values of variables is `p` (there are other ways). When we
-look at the value of `tri` the first time, we see it is `nil`. Again we are
-stopped _before_ the assignment on line 3, and this variable hasn't been set
-previously. However after issuing another `step` command we see that the value
-is 0 as expected. If every time we stop we want to see the value of `tri` to see
-how things are going, there is a better way by setting a display expression:
-
-```
-(byebug) display tri
-1: tri = 0
-```
-
-Now let us run the program until we return from the function. We'll want to see
-which lines get run, so we turn on _line tracing_. If we don't want whole paths
-to be displayed when tracing, we can turn on _basename_.
-
-```
-(byebug) display i
-2: i =
-(byebug) set linetrace on
-line tracing is on.
-(byebug) set basename on
-basename is on.
-(byebug) finish
-Tracing: triangle.rb:5 tri += i
-1: tri = 0
-2: i = 0
-Tracing: triangle.rb:5 tri += i
-1: tri = 0
-2: i = 1
-Tracing: triangle.rb:5 tri += i
-1: tri = 1
-2: i = 2
-Tracing: triangle.rb:5 tri += i
-1: tri = 3
-2: i = 3
-Tracing: triangle.rb:7 tri
-1: tri = 6
-2: i =
-Tracing: triangle.rb:11 puts t
-1: tri =
-2: i =
-[2, 11] in /home/davidr/Proyectos/byebug/old_doc/triangle.rb
-    2: def triangle(n)
-    3:   tri = 0
-    4:   0.upto(n) do |i|
-    5:     tri += i
-    6:   end
-    7:   tri
-    8: end
-    9:
-   10: t = triangle(3)
-=> 11: puts t
-1: tri =
-2: i =
-(byebug) quit
-Really quit? (y/n) y
-```
-
-So far, so good. As you can see from the above to get out of `byebug`, one
-can issue a `quit` command (`q` and `exit` are just as good). If you want to
-quit without being prompted, suffix the command with an exclamation mark, e.g.,
-`q!`.
-
-### The rest of the tutorial is available [here](https://github.com/deivid-rodriguez/byebug/blob/master/GUIDE.md)
+Read [byebug's markdown
+guide](https://github.com/deivid-rodriguez/byebug/blob/master/GUIDE.md) to get
+started. Proper documentation will be eventually written.
 
 
 ## Related projects
@@ -299,6 +149,12 @@ adds a rake task that restarts Passenger with byebug connected.
 session on minitest failures.
 
 
+## Future (possible) directions
+
+* JRuby support.
+* Libify and test byebug's executable.
+
+
 ## Credits
 
 Everybody who has ever contributed to this forked and reforked piece of