Merge pull request #76 from camertron/copy_editing

Edit the documentation for spelling and grammar

Author: 0x2c7

website/docs/commands/continue.md

@@ -7,4 +7,4 @@ slug: continue
 | ------- | ------------------- | ----- |
 | `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.

website/docs/commands/exit.md

@@ -7,4 +7,4 @@ slug: exit
 | ------- | ------------------- | ----- |
 | `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](/docs/commands/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](/docs/commands/continue) instead.

website/docs/commands/filter.md

@@ -12,7 +12,7 @@ import {LinkedImage} from '../../src/components/LinkedImage'
 | `jard filter clear` | | |
 | `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](/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](/docs/guides/filter) for more information.
 
 **Examples:**
 

website/docs/commands/frame.md

@@ -7,9 +7,9 @@ slug: frame
 | ------- | ------------------- | ----- |
 | `frame [-h] [frame_id]` ||  |
 
-Explore a particular frame with id `<frame_id>`. It's faster than `up` and `down`. See [up](/docs/commands/up) for more information.
+Explore a particular frame with id `<frame_id>`. This is faster than `up` and `down`. See the [up docs](/docs/commands/up) for more information.
 
-[up](/docs/commands/up), [down](/docs/commands/down), and [frame](/docs/commands/frame) commands correlates to [filter](/docs/guides/filter). All hidden frames are ignored, all C frames are ignored too.
+[up](/docs/commands/up), [down](/docs/commands/down), and [frame](/docs/commands/frame) commands respect [filter](/docs/guides/filter). All hidden frames are ignored, all C frames are ignored too.
 
 **Examples:**
 

website/docs/commands/list.md

@@ -8,6 +8,6 @@ import {LinkedImage} from '../../src/components/LinkedImage'
 | ------- | ------------------- | ----- |
 | `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.
 
 <LinkedImage link="/img/commands/list.gif" alt="List example"/>

website/docs/commands/next.md

@@ -7,7 +7,7 @@ slug: next
 | ------- | ------------------- | ----- |
 | `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:**
 

website/docs/commands/output.md

@@ -8,7 +8,7 @@ import {LinkedImage} from '../../src/components/LinkedImage'
 | ------- | ------------------- | ----- |
 | `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:**
 

website/docs/commands/show.md

@@ -7,7 +7,7 @@ slug: show
 | ------- | ------------------- | ----- |
 | `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:**
 

website/docs/commands/skip.md

@@ -8,10 +8,10 @@ import {LinkedImage} from '../../src/components/LinkedImage'
 | ------- | ------------------- | ----- |
 | `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:**
 
@@ -21,7 +21,7 @@ skip      # Continue and skip the first breakpoint
 <LinkedImage link="/img/commands/skip.gif" alt="Skip example"/>
 
 ```
-skip 2    # Continue and skip the first 2 breakpoints it meets
+skip 2    # Continue and skip the first 2 breakpoints
 ```
 <LinkedImage link="/img/commands/skip-2.gif" alt="Multiple skip example"/>
 

website/docs/commands/step.md

@@ -7,7 +7,7 @@ slug: step
 | ------- | ------------------- | ----- |
 | `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:**
 

website/docs/commands/step_out.md

@@ -8,9 +8,9 @@ import {LinkedImage} from '../../src/components/LinkedImage'
 | ------- | ------------------- | ----- |
 | `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:**
 

website/docs/commands/up.md

@@ -8,11 +8,11 @@ import {LinkedImage} from '../../src/components/LinkedImage'
 | ------- | ------------------- | ----- |
 | `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](/docs/commands/up), [down](/docs/commands/down), and [frame](/docs/commands/frame) commands correlates to [filter](/docs/guides/filter). All hidden frames are ignored, all C frames are ignored too.
+[up](/docs/commands/up), [down](/docs/commands/down), and [frame](/docs/commands/frame) commands respect [filter](/docs/guides/filter). All hidden frames and C frames are ignored.
 
 **Examples:**
 

website/docs/guides/backtrace_screen.md

@@ -7,19 +7,19 @@ import {LinkedImage} from '../../src/components/LinkedImage'
 
 <LinkedImage link="/img/guides/backtrace-screen-1.png" alt="Backtrace screen"/>
 
-This screen describes the current backtrace of the current thread your program is stopping. Each line of this screen describes the current Frame. What is frame and backtrace by the way? Let's step back a little bit at how Ruby executes your code. Internally, Ruby uses an interpreter to read and execute your code, line by line (technically, YARD instructions, but let's go with a simple version). When it meets a chunk of code that needs to open a new scope, like method calls or inline-block call, the interpreter creates a new structure to store the current context so that it can link to the next scope and go back later. This data structure is call Frame. The interpreter pushes frame into a stack, called backtrace (or stack trace, or call stack, whatever), and continues to execute your code. Each thread has a separate backtrace. To understand deeply, you may be interested in this wonderful slide: [Grow and Shrink - Dynamically Extending the Ruby VM Stack](https://www.slideshare.net/KeitaSugiyama1/grow-and-shrink-dynamically-extending-the-ruby-vm-stack).
+This screen describes the backtrace of the current thread your program has stopped in. Each line of this screen describes the current Frame. What are frame and backtrace by the way? Let's step back a little bit and look at how Ruby executes your code. Internally, Ruby uses an interpreter to read and execute your code, line by line (technically it executes YARV instructions, but let's keep things simple). When it encounters a chunk of code that opens a new scope like a method call or inline block call, the interpreter creates a new structure to store the current context so that it can link to the next scope and go back later. This data structure is called a Frame. The interpreter pushes the frame onto a stack called the backtrace (or stack trace, or call stack, etc), and continues to execute your code. Each thread has a separate backtrace. To understand more deeply, you may be interested in this wonderful slide deck: [Grow and Shrink - Dynamically Extending the Ruby VM Stack](https://www.slideshare.net/KeitaSugiyama1/grow-and-shrink-dynamically-extending-the-ruby-vm-stack).
 
-Overall, the whole backtrace screen lets you know where you are stopping at, the trace of how your program is running. When combining with other tools and other screens, you will be surprised by how much information the bugger can help you when you encounter your bugs.
+Overall, the whole backtrace screen lets you know where you've stopped, and shows you the trace of how your program is running. When combined with other tools and screens, you'll be surprised by how much information the debugger can give you when you're trying to track down a challenging bug.
 
 Each frame includes the following information:
 
-- Frame ID: incremental, can be used to jump to an arbitrary frame with frame command.
+- Frame ID: incremental, can be used to jump to an arbitrary frame with the frame command.
 - Location label: a class name and method name of the method covers its frame.
 - Physical location: exact file name and line number.
   - If a frame is allocated in a gem, the physical location shows a gem name and version only. For example: `Calendar::GeneratedAssociationMethods in events in <activerecord 6.0.3.1>`.
-  - If there is a `[c]` prefix in front of a class name, it means that the method is provided by Ruby, implemented in C, and impossible to peek, for example. For example: `[c] Range in each at test5.rb:11`.
-  - If a frame is from standardlib, the location has `stdlib` prefix. For example: `Random::Formatter in uuid in <stdlib:securerandom>`
+  - If there is a `[c]` prefix in front of a class name, it means that the method is provided by Ruby, implemented in C, and impossible to peek at. For example: `[c] Range in each at test5.rb:11`.
+  - If a frame is from standard library, the location has the `stdlib` prefix. For example: `Random::Formatter in uuid in <stdlib:securerandom>`
 
-If a frame is filtered out, it won't be displayed. The top title displays overall hidden frames. To navigate through the backtrace, you can use [filter feature](/docs/guides/filter) combine with [up command](/docs/commands/up), [down command](/docs/commands/down), and [frame command](/docs/commands/frame).
+If a frame is filtered out, it won't be displayed. The top title displays overall hidden frames. To navigate through the backtrace, you can use the [filter feature](/docs/guides/filter) combined with the [up command](/docs/commands/up), [down command](/docs/commands/down), and [frame command](/docs/commands/frame).
 
 <LinkedImage link="/img/guides/backtrace-screen-2.gif" alt="Navigate and explore backtrace"/>

website/docs/guides/color_schemes.md

@@ -3,10 +3,10 @@ id: Color schemes
 slug: color-schemes
 ---
 
-Ruby Jard bundles 6 built-in schemes, 4 dark ones, and 2 light ones. You can use [color scheme commands](/docs/commands/color-scheme) to up the flight, or define in [configuration file](/docs/guides/configurations).
+Ruby Jard bundles 6 built-in schemes: 4 dark ones and 2 light ones. You can use [color scheme commands](/docs/commands/color-scheme) to set the current scheme, or define in [configuration file](/docs/guides/configurations).
 
 ### 256
-Default scheme, 256 basic colors, supported by all terminals
+Default scheme. 256 basic colors, supported by all terminals
 
 ![256 Color scheme](/img/color_schemes/256.png)
 
@@ -33,7 +33,7 @@ Light 256 basic colors
 
 ### Your custom theme
 
-Add those lines into your [configuration file](/docs/guides/configurations). Ruby Jard supports two types of colors: 24-bit color or [ANSI 8-bit color](https://en.wikipedia.org/wiki/ANSI_escape_code).
+Add these lines into your [configuration file](/docs/guides/configurations). Ruby Jard supports two types of colors: 24-bit color and [ANSI 8-bit color](https://en.wikipedia.org/wiki/ANSI_escape_code).
 
 ```ruby
 class MyColorScheme < ColorScheme

website/docs/guides/configurations.md

@@ -3,19 +3,19 @@ id: Configurations
 slug: configurations
 ---
 
-Ruby Jard supports customization via pre-loaded configuration files. You can configure Jard both globally, and per-project.
+Ruby Jard supports customization via preloaded configuration files. You can configure Jard both globally and on a per-project basis.
 
-- If `JARD_CONFIG_FILE` environment variable is available, Jard uses that file.
+- If the `JARD_CONFIG_FILE` environment variable is available, Jard uses that file.
 - The global configuration file is located at `~/.jardrc`.
-- The project configuration file is located at `.jardrc` in working directory when you start Ruby Jard. Per-project ones override the global one.
+- The project configuration file is located at `.jardrc` in the current working directory when you start Ruby Jard. Per-project configs override the global one.
 
-There are some supported configurations:
+Here are some supported configurations:
 
 | Name                | Description                                                  | Default | Values |
 | ------------------- | ------------------------------------------------------------ | ------- | ------ |
 | `color_scheme`      | Choose your favorite color scheme. See [color schemes page](/docs/guides/color-schemes) for more information.| `256`   | See [color-scheme command](/docs/commands/color-scheme) |
 | `layout`      | By default, Ruby Jard chooses the layout based on current window size. This option allows you to force a layout. | `nil`   | `nil`, `tiny`, `wide`, `narrow-vertical`, `narrow-horizontal` |
-| `enabled_screens` | Force display a subset of screens. This option correlates with recent layout's screens. | `[]`   | `backtrace`, `menu`, `source`, `threads`, `variables`|
+| `enabled_screens` | Force display of a subset of screens. This option correlates with the recent layout's screens. | `[]`   | `backtrace`, `menu`, `source`, `threads`, `variables`|
 | `filter` | Filter mode. See [filter page](/docs/guides/filter) for more information | `:application`   | `:everything`, `:gems`, `:application`, `:source_tree`|
 | `filter_included` | Filter included pattern. See [filter page](/docs/guides/filter) for more information | `[]`   | |
 | `filter_excluded` | Filter excluded pattern. See [filter page](/docs/guides/filter) for more information | `[]`   | |