emacs-elpa-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[elpa] externals/objed 589d763 14/16: Update desciptions


From: Clemens Radermacher
Subject: [elpa] externals/objed 589d763 14/16: Update desciptions
Date: Mon, 4 Feb 2019 07:46:32 -0500 (EST)

branch: externals/objed
commit 589d763cd93896d67cc753441209ad569848bae4
Author: Clemens Radermacher <address@hidden>
Commit: Clemens Radermacher <address@hidden>

    Update desciptions
---
 README.asc | 221 ++++++++++++++++++++++++++++++-------------------------------
 1 file changed, 110 insertions(+), 111 deletions(-)

diff --git a/README.asc b/README.asc
index e069eb1..9cc84cb 100644
--- a/README.asc
+++ b/README.asc
@@ -8,46 +8,43 @@
 
 = Objed - The text object editor
 
-A global minor-mode to navigate and edit text objects. Objed enables
-modal editing and composition of commands, too. It combines ideas of
-http://emacs-versor.sourceforge.net/[versor-mode] and other Editors
-like Vim or Kakoune and tries to align them with regular Emacs
-conventions.
+A global minor-mode to navigate and edit text objects. Objed also enables
+modal editing and composition of commands. It combines ideas of
+http://emacs-versor.sourceforge.net/[versor-mode] and other Editors like Vim
+or Kakoune and tries to align them with regular Emacs conventions.
 
-For more information also check my
-https://www.with-emacs.com/categories/objed/[blog]. For changes see
-the https://github.com/clemera/objed/blob/master/News.asc[News] file.
+For more information you can read my
+https://www.with-emacs.com/categories/objed/[posts] about `objed` and for
+changes check the https://github.com/clemera/objed/blob/master/News.asc[News]
+file.
 
 == Introduction
 
-Text objects are textual patterns like a line, a top level definition,
-a word, a sentence or any other unit of text. When `objed-mode` is
-enabled, certain editing commands (configurable) will activate `objed`
-and enable its modal editing features. When active, keys which would
-usually insert a character are mapped to objed commands. Other keys
-and commands will continue to work as they normally would and exit
-this editing state again.
+Text objects are textual patterns like a line, a top level definition, a word,
+a sentence or any other unit of text. When `objed-mode` is enabled, certain
+editing commands (configurable) will activate `objed` and enable its modal
+editing features. When active, keys which would usually insert a character are
+mapped to objed commands. Other keys and commands will continue to work as
+they normally would and exit this editing state again.
 
 By default important editing keys like kbd:[Space], kbd:[DEL] or kbd:[Return]
-are not bound to modal commands and will exit `objed` on insertion. Character
-movement exits `objed`, as well. This makes it convenient to move around and
-continue adding/deleting text.
+are not bound to modal commands and will execute the regular command and exit
+`objed`. Character movement exits `objed`, as well. This makes it convenient
+to move around and continue by adding/deleting text.
 
 With activation `objed` shows the current object type in the `mode-line`. The
 textual content of the object is highlighted visually in the buffer and the
-cursor color is changed, too. The user can now navigate by units of this 
object,
-change the object state or switch to other object types.
+cursor color is changed, too. The user can now navigate by units of this
+object, change the object state or switch to other object types.
 
-The object state is either `inner` or `whole` and is indicated in the
-modeline by `(i)` or `(w)` after the object type. With inner state,
-anything that would be considered delimiters or padding around an
-object is excluded.
+The object state is either `inner` or `whole` and is indicated in the modeline
+by `(i)` or `(w)` after the object type. With inner state, anything that would
+be considered delimiters or padding around an object is excluded.
 
-The user can apply operations to objects. By marking objects before
-applying an operation, s?he can even operate on multiple objects at
-once. This works similar to the way you interact with files in
-`dired`. When marking an object the point moves on to the next object
-of this type.
+The user can apply operations to objects. By marking objects before applying
+an operation, s?he can even operate on multiple objects at once. This works
+similar to the way you interact with files in `dired`. When marking an object
+the point moves on to the next object of this type.
 
 The object type used for initialization is determined by the mapping of the
 entry command (see `objed-cmd-alist`). For example using `beginning-of-defun`
@@ -57,42 +54,38 @@ activate `objed` without movement you can use 
`objed-activate`, bound to
 kbd:[M-SPC] by default. It uses the last command and its mapping in
 `objed-command-alist` to choose the initial object.
 
-Objeds modal state provides basic movement commands which move by line, sexp or
-word. Those switch automatically to the corresponding object type, otherwise
-they work the same as the regular Emacs movement commands. Other commands only
-activate the part between the initial position and the new position moved to. 
By
-repeating commands you can often expand/proceed to other objects. This way you
-can compose movement and editing operations very efficiently.
-
-The expansion commands distinguish between block objects (objects
-built out of lines of text) and context objects (programming
-constructs like strings, brackets or textual components like
-sentences). This way you can quickly expand to the desired objects.
-
-For example to move to the end of the paragraph, the user would first
-move to the end of the line with kbd:[Ctrl - e]. This would activate
-`objed` using the line object with the text moved over. The user can
-now continue to the end of the paragraph by pressing kbd:[e] again.
-Now s?he is able to proceed even further by pressing kbd:[e] again OR
-to continue by adding new text to the end of the paragraph OR to
-continue by acting on the text moved over, for example killing it by
-pressing kbd:[k].
-
-To kill text from point upto a closing parentheses or string quote
-etc. you would use kbd:[u] followed by kbd:[k]
-
-As often with text editing, the explanation sounds more complicated
-than using it. To get a better impression of the editing workflow with
-`objed` I have added some animated demos below.
+Objeds modal state provides basic movement commands which move by line, sexp
+or word. Those switch automatically to the corresponding object type. Other
+commands only activate the part between the initial position and the new
+position moved to. By repeating commands you can often expand/proceed to other
+objects. This way you can compose movement and editing operations very
+efficiently.
+
+The expansion commands distinguish between block objects (objects built out of
+lines of text) and context objects (programming constructs like strings,
+brackets or textual components like sentences). This way you can quickly
+expand to the desired objects.
+
+For example to move to the end of the paragraph, the user would first move to
+the end of the line with kbd:[Ctrl - e]. This would activate `objed` using the
+line object with the text moved over. The user can now continue to the end of
+the paragraph by pressing kbd:[e] again. Now s?he is able to proceed even
+further by pressing kbd:[e] again OR to continue by adding new text to the end
+of the paragraph OR to continue by acting on the text moved over, for example
+killing it by pressing kbd:[k].
+
+As often with text editing, the explanation sounds more complicated than using
+it. To get a better impression of the editing workflow with `objed` I have
+added some animated demos below.
 
 To learn more about available features and commands have a look at the
-descriptions below, the commentary section or the docstrings and
-bindings defined in `objed-map`. To define your own operations and
-text objects see `objed-define-op` and `objed-define-object`.
+descriptions below, the commentary section or the docstrings and bindings
+defined in `objed-map`. To define your own operations and text objects see
+`objed-define-op` and `objed-define-object`.
 
-Note that `objed` is *still evolving*, some *bindings might change*
-in this process. Because of that the following screencasts might not
-always show up to date key bindings.
+Note that `objed` is *still evolving*, some *bindings might change* in this
+process. Because of that the following screencasts might not always show up to
+date key bindings.
 
 
 ## Examples of usage
@@ -155,27 +148,33 @@ image::./images/output_occur.gif[Navigate and search 
output object]
 
 ## Keys
 
-Although some features are still experimental the basic user interface
-will stay the same. The following gives an overview of available keys
-and commands. If commands allow for numeric arguments you can input
-them without the use of kbd:[Ctrl] or kbd:[Meta]. kbd:[0] can be used
-as an alternative for the universal argument (kbd:[C-u]).
+Although some features are still experimental the basic user interface will
+stay the same. The following gives an overview of available keys and commands.
+If commands allow for numeric arguments you can input them without the use of
+kbd:[Ctrl] or kbd:[Meta]. kbd:[0] can be used as an alternative for the
+universal argument (kbd:[C-u]).
 
-In addition to the commands configured in `objed-cmd-alist` you can
-use the following commands to enter objed:
+In addition to the commands configured in `objed-cmd-alist` you can use the
+following commands to enter objed (those bindings are only active if you are
+using `objed-mode`, if you choose to activate objed always manually you have
+to bind those commands in you `global-map`):
 
+[`objed-mode-map`]
 |===
 |Shortcut |Purpose
-|kbd:[M-n/p]
-|Move to next/previous identifier using commands `objed-next-identifier` and 
`objed-prev-identifier`. Not bound by default, recommended to bind in 
`global-map`.
+|kbd:[C-,/C-.]
+|Move to previous/next identifier and activate `identifier` object.
+
+|kbd:[M-[]
+|Activate object at point (determined from context) and move to its start.
+
+|kbd:[M-\]]
+|Activate object at point (determined from context) and move to its end.
 
 |kbd:[M-SPC]
-|Activate objed, choosing initial object based on `last-command`. Bound in 
`objed-mode-map` by default.
+|Activate objed, choosing initial object based on `last-command` and 
`objed-cmd-alist`.
 |===
 
-If you don't like the automatic activation provided by `objed-mode` I
-recommend to bind `objed-activate` to kbd:[M-SPC] in your `global-map`.
-
 Basic movement commands (switch the object type on movement):
 
 [`objed-map`]
@@ -208,36 +207,38 @@ Commands for block objects (objects built out of lines of 
text):
 |Move to end of line and activate the text moved over. On repeat proceed to 
end of blocks like explained above.
 |===
 
-Commands for context objects. Those objects are common programming
-constructs like defuns, strings, parentheses but also sentences inside
-comments for example. Any whitespace after point is skipped before
-determining the context:
+Commands for context objects. Those objects are common programming constructs
+like defuns, strings, parentheses but also sentences inside comments for
+example. Any whitespace after point is skipped before determining the context:
 
 [`objed-map`]
 |===
 |Shortcut |Purpose
 
-|kbd:[[/\]]
-|If coming from basic movement the object at point is guessed based on 
context. Point is moved  to the beginning/end of object. This is useful to 
"jump out" of the current context. On repeat move to the previous/next instance 
of current object type
-
-|kbd:[</>]
-|Goto first/last instance of current object type 
(https://with-emacs.com/posts/objed/spotlight-objed-move-to-first-or-last-instance/[blog]).
-
 |kbd:[o]
 |Activate the inner part of the object at point and move to the start. This is 
useful to act on the content of the string, brackets and so on. On repeat 
expand to other objects around current position.
 
-|kbd:[u]
-|Move to end of the inner object at point and activate the text moved over. On 
repeat toggle between beginning/end inside the object.
-
 |kbd:[j]
 |Move point to the other side of the current object.
 
 |kbd:[t]
 |Toggle the state of the current object (inner/whole).
+
+|kbd:[[/\]]
+|If coming from basic movement the object at point is guessed based on 
context. Point is moved  to the beginning/end of object at point. This is 
useful to "jump out" of the current context. On repeat move to the 
previous/next instance of current object type
+
+|kbd:[(/)]
+|Move to inner beginning/end of the object at point and activate the text 
moved over.
+
+|kbd:[{/}]
+|Move forward/backward paragraph and switch to paragraph object
+
+|kbd:[</>]
+|Goto first/last instance of current object type 
(https://with-emacs.com/posts/objed/spotlight-objed-move-to-first-or-last-instance/[blog]).
 |===
 
-Commands to switch objects (and move point to its start, repeating an
-object command mark all instances in current defun/buffer):
+Commands to switch objects (and move point to its start, repeating an object
+command mark all instances in current defun/buffer):
 
 [`objed-map`]
 |===
@@ -269,25 +270,20 @@ Indent/Move objects around:
 |kbd:[M-left/M-right]
 |Move/indent all lines in object to right/leftward to tab stop.
 
-|kbd:[S-left/S-right]
-|Move current object forward/backward 
(https://with-emacs.com/posts/i-like-to-move-it-emacs-version/[blog]).
-
-|kbd:[F/B]
-|Switch to char object and move it forward/backward.
+|kbd:[S-left/S-right/S-up/S-down/F/B]
+|Move current object type forward/backward 
(https://with-emacs.com/posts/i-like-to-move-it-emacs-version/[blog]).
 
 |kbd:[S/R]
 |Switch to word object and move it forward/backward.
 
 |kbd:[N/P]
 |Switch to line object and move it forward/backward.
-
 |===
 
 
-Commands to edit objects (applying operations to them). When the
-region is active the operation acts on the current region. To act on
-multiple objects at once you can mark them first (see the "Misc
-commands" below):
+Commands to edit objects (applying operations to them). When the region is
+active the operation acts on the current region. To act on multiple objects at
+once you can mark them first (see the "Misc commands" below):
 
 [`objed-map`]
 |===
@@ -327,7 +323,7 @@ commands" below):
 |Incrementally construct command chain to replace text 
(https://with-emacs.com/posts/objed/incremental-construction-of-command-chains-to-replace-text/[blog]).
 
 |kbd:[Ctrl - RET]
-|Evaluate current object using `eval-in-repl`.
+|Evaluate current object in REPL (need `eval-in-repl` to be installed).
 
 |kbd:[M - RET]
 |Insert new (empty) instance of current object type. This inserts the current 
object without the inner content.
@@ -364,7 +360,7 @@ Misc commands:
 |kbd:[M-o]
 |Choose an instance of current object type with completion, using the contents 
of the first line for completion.
 
-|kbd:[z]
+|kbd:[`]
 |Choose an instance of current object type on the screen with `avy` 
(https://with-emacs.com/posts/objed/jump-around-emacs-version/[blog]).
 
 |kbd:[m]
@@ -374,14 +370,14 @@ Misc commands:
 |Add/Remove current object to marked objects and move to previous.
 
 |kbd:[v]
-|Lock current object and include other ones (extend current object).
-
-|kbd:[/]
-|Undo last edit command.
+|Activate region with current object (extend current object).
 
 |kbd:[Ctrl - Space]
 |Set mark.
 
+|kbd:[/]
+|Undo last edit command.
+
 |kbd:[?]
 |Get key binding help (uses `which-key` if available).
 
@@ -403,12 +399,12 @@ You can add your own prefix bindings using 
`objed-define-dispatch`.
 |kbd:[#]
 |Switch to another object using `avy`.
 
-|kbd:[(]
-|Activate part from point backward until boundary of some object.
-
-|kbd:[)]
+|kbd:[u]
 |Activate part from point forward until boundary of some object.
 
+|kbd:[z]
+|Activate part from point backward until boundary of some object.
+
 |kbd:[-/+]
 |Extend current object forward/backward by including leading/trailing 
whitespace.
 |===
@@ -422,6 +418,8 @@ You can add your own prefix bindings using 
`objed-define-dispatch`.
 ```emacs
 M-x package-refresh-contents RET
 M-x package-install RET objed RET
+;; activate objed-mode in you init
+(objed-mode)
 ```
 For manual installation:
 
@@ -435,7 +433,8 @@ Add this to your init file:
 (require 'objed)
 (objed-mode)
 ;; activating the mode is optional, you can activate objed
-;; always manually using `objed-activate' for example:
+;; always manually using `objed-activate' the other
+;; commands bound in `objed-mode-map`, for example:
 ;; (global-set-key (kbd "M-SPC") 'objed-activate)
 ```
 



reply via email to

[Prev in Thread] Current Thread [Next in Thread]