Sync docs on website and commands

Author: 0x2c7

lib/ruby_jard/commands/continue_command.doc.txt

@@ -5,4 +5,4 @@
 │ continue │ F9                  │ c     │ 
 └──────────┴─────────────────────┴───────┘
 
-Continue the execution of your program to the end, or stop at the first dynamic break point or jard attachment command.
+Continue the execution of your program until it finishes, or stop at the first dynamic break point or jard attachment command.

lib/ruby_jard/commands/exit_command.doc.txt

@@ -5,4 +5,4 @@
 │ exit    │                     │       │ 
 └─────────┴─────────────────────┴───────┘
 
-Exit the execution of the program. Interally, when jard receives this command, it removes all debugging hooks, and triggers ::Kernel.exit. Some long-running processes like puma or sidekiq may capture this event, treat it as an error, and recover to keep the processes running. In such cases, it’s recommended to use continue instead.
+Stop the execution of the program. Interally, when jard receives this command, it removes all debugging hooks, and triggers ::Kernel.exit. Some long-running processes like puma or sidekiq may capture this event, treat it as an error, and recover to keep the processes running. In such cases, it’s recommended to use continue instead.

lib/ruby_jard/commands/filter_command.doc.txt

@@ -13,7 +13,7 @@
 │ jard filter switch                                       │                     │       │ 
 └──────────────────────────────────────────────────────────┴─────────────────────┴───────┘
 
-Ruby Jard has a strong filtering system. This system consists of a filter mode, included list, and excluded list. Filter mode is how Ruby Jard reacts to control flow commands. See filter » https://rubyjard.org/docs/guides/filter for more information.
+Ruby Jard has a powerful filtering system. This system consists of a filter mode, include list, and exclude list. Filter mode is how Ruby Jard reacts to control flow commands. See the filter docs » https://rubyjard.org/docs/guides/filter for more information.
 
 Examples:
 

lib/ruby_jard/commands/frame_command.doc.txt

@@ -5,9 +5,9 @@
 │ frame [-h] [frame_id] │                     │       │ 
 └───────────────────────┴─────────────────────┴───────┘
 
-Explore a particular frame with id <frame_id>. It’s faster than up and down. See up for more information.
+Explore a particular frame with id <frame_id>. This is faster than up and down. See the up docs » up for more information.
 
-up, down, and frame commands correlates to filter » https://rubyjard.org/docs/guides/filter. All hidden frames are ignored, all C frames are ignored too.
+up, down, and frame commands respect filter » https://rubyjard.org/docs/guides/filter. All hidden frames are ignored, all C frames are ignored too.
 
 Examples:
 

lib/ruby_jard/commands/list_command.doc.txt

@@ -5,6 +5,6 @@
 │ list    │ F5                  │ l, whereami │ 
 └─────────┴─────────────────────┴─────────────┘
 
-Refresh the whole terminal UI. This command doesn’t move you to other steps, nor change any data in your session. It is useful (or the only way) to get back the beautiful UI if you type too much in the REPL console.
+Refresh the whole terminal UI. This command doesn’t move you to other steps or change any data in your session. It is the only way to reset the UI if you type too much in the REPL console.
 
 

lib/ruby_jard/commands/next_command.doc.txt

@@ -5,7 +5,7 @@
 │ next    │ F8                  │ n     │ 
 └─────────┴─────────────────────┴───────┘
 
-Continue to the next line in the current frame, by pass any steppable method call or blocks in the mid way unless they contains dynamic breakpoint or any jard attachment command. If the current frame already reaches the end, it continues to the next line of upper frame and so on.
+Continue to the next line in the current frame. Bypasses any steppable method call or block in between unless they contain a dynamic breakpoint or a jard attachment command. If execution has reached the end of the current frame, next continues to the next line of the parent frame and so on.
 
 Examples:
 

lib/ruby_jard/commands/output_command.doc.txt

@@ -5,7 +5,7 @@
 │ jard output │                     │       │ 
 └─────────────┴─────────────────────┴───────┘
 
-Show all the program output in a pager, allowing navigation, searching (powered by GNU Less). Note that the output are only captured only after Jard already started. All the previous output could not be captured.
+Show all program output in a pager, allowing navigation and searching (powered by GNU Less). Note that only the output emitted after Jard has started is captured. All the previous output will not be captured.
 
 Examples:
 

lib/ruby_jard/commands/show_command.doc.txt

@@ -5,7 +5,7 @@
 │ jard show [screen] │                     │       │ 
 └────────────────────┴─────────────────────┴───────┘
 
-Show a particular screen on the current interface. This option correlates to recent layout’s screens. If a screen is not available in current layout, it won’t be shown.
+Show a particular screen in the current interface. This option correlates to recent layout’s screens. If a screen is not available in current layout, it won’t be shown.
 
 Examples:
 

lib/ruby_jard/commands/skip_command.doc.txt

@@ -5,14 +5,14 @@
 │ skip [-a -all] │                     │       │ 
 └────────────────┴─────────────────────┴───────┘
 
-Continue the execution of your program to the end, and skip one, or more next breakpoints it meets. This command is useful when you puts jard command in an iteration or a nested method calls.
+Continue the execution of your program to the end, and skip one or more next breakpoints along the way. This command is useful when you put the jard command in an iteration or a nested method call.
 
 Note:
-Ruby Jard resets skipping list in next attachment, or when your program exits. If you are running a web server, or background jobs that prevent your program from stopping, and you already skip all breakpoints, your program may not stop, and requires a restart to attach again.
+Ruby Jard resets the skip list in the next attachment or when your program exits. If you are running a web server or a background job that prevents your program from stopping (and you have already skipped all breakpoints), your program may not stop and may require a restart to attach again.
 
 Examples:
 
 skip      # Continue and skip the first breakpoint
-skip 2    # Continue and skip the first 2 breakpoints it meets
+skip 2    # Continue and skip the first 2 breakpoints
 skip -a    # Continue and skip all breakpoints
 skip --all # Continue and skip all breakpoints

lib/ruby_jard/commands/step_command.doc.txt

@@ -5,7 +5,7 @@
 │ step    │ F7                  │ s     │ 
 └─────────┴─────────────────────┴───────┘
 
-Detect and step into a method call or block in the current line. If there isn’t anything to step in, the program continues to next line. In case there are multiple methods on the same line, Jard hornors Ruby’s execution order.
+Detect and step into a method call or block on the current line. If there isn’t anything to step into, the program will continue to the next line. If there are multiple methods on the same line, Jard hornors Ruby’s execution order.
 
 Examples:
 

lib/ruby_jard/commands/step_out_command.doc.txt

@@ -5,9 +5,9 @@
 │ step-out │ Shift + F7          │ so    │ 
 └──────────┴─────────────────────┴───────┘
 
-The opposite of step. This command is used to finish the execution of current frame, and jump to the next line of upper frame. In other words, this command is equivalent to the sequence up and next. If the neighbor frame already finishes, it continues with even higher frame.
+The opposite of step. This command is used to finish the execution of the current frame and jump to the next line of the parent frame. In other words, this command is equivalent to the sequence up and next. If the parent frame has already finished, Jard continues to the next line in that frame’s parent and so on.
 
-This command is useful when you loose your interest in frame, and want to quickly go up again. One example is that you accidentally step into a longgggg loop with nothing useful. Another example is that you step into the library source code and don’t really care what it does underlying.
+This command is useful when you lose interest in a frame and want to easily return to the parent. For example, you might have accidentally stepped into a longgggg loop or into library source code.
 
 Examples:
 

lib/ruby_jard/commands/up_command.doc.txt

@@ -5,11 +5,11 @@
 │ up      │ F6                  │       │ 
 └─────────┴─────────────────────┴───────┘
 
-Explore the upper frame. When you use this command, all associated displaying screens will be updated accordingly, but your program current position is still at the latest frame. This command is mostly used to explore, and view the trace, input parameters, or how your program stops at the current position. When use this command, you should have a glance at Variable panel, and Source panel to see the variables at destination frame.
+Explore the parent frame. When you use this command, all associated display screens will be updated accordingly, but your program’s current position is still the latest frame. This command is mostly used to explore and introspect the stack, input parameters, or how your program has stopped at the current position. When using this command, take a look at the Variable and Source panels to see the variables defined in the current frame.
 
-You can combine with next or step to perform powerful execution redirection at the destination frame. Let’s look at an example. You are debugging a chain of 10 rack middlewares, you go deep into the #9 middleware, found something, then want to go back to #5 middleware. It’s pretty boring and frustrated to just use next or step-out and hope it eventually goes back. Now use up for some times (or frame, described below) to go to your desired frame, and use next there. Tada, it’s magical, just like teleport.
+You can combine up with next or step to perform powerful execution redirection at from the current frame. Let’s look at an example. You are debugging a chain of 10 rack middlewares and you go deep into the ninth middleware. You find something and want to go back to the fifth middleware. It’s pretty tedious and frustrating to use next or step-out and hope you eventually end up in the right place. Consider using up a few times (or frame, described below) to go to the desired frame, then use next. Tada! It’s magical, like teleporting yourself to the right position.
 
-up, down, and frame commands correlates to filter » https://rubyjard.org/docs/guides/filter. All hidden frames are ignored, all C frames are ignored too.
+up, down, and frame commands respect filter » https://rubyjard.org/docs/guides/filter. All hidden frames and C frames are ignored.
 
 Examples: