vimniscient 0.2.0__tar.gz → 0.2.1__tar.gz

{vimniscient-0.2.0 → vimniscient-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vimniscient
-Version: 0.2.0
+Version: 0.2.1
 Summary: Get fluent in Vim in fifteen minutes a day, in your own Neovim.
 Project-URL: Homepage, https://vimniscient.com
 Project-URL: Source, https://github.com/dialectmaterial/Vimniscient

{vimniscient-0.2.0 → vimniscient-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vimniscient"
-version = "0.2.0"
+version = "0.2.1"
 description = "Get fluent in Vim in fifteen minutes a day, in your own Neovim."
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/answer.py

@@ -40,7 +40,7 @@ def _norm_token(match: re.Match) -> str:
 
 def norm_keys(text: str, case_sensitive: bool = True) -> str:
     s = text.strip()
-    s = re.sub(r"(?i)^(leader|space|spc)(\s+|$)", "<leader>", s)
+    s = re.sub(r"(?i)^(leader|space|spc)(\s*\+\s*|\s+|$)", "<leader>", s)
     s = re.sub(r"(?i)(?<![<\w])space(?![>\w])", "<Space>", s)
     s = re.sub(r"(?i)\b(?:ctrl|control)[-+ ]+(\S)", lambda m: f"<C-{m.group(1)}>", s)
     s = re.sub(r"(?i)\b(?:alt|meta)[-+ ]+(\S)", lambda m: f"<M-{m.group(1)}>", s)
@@ -55,7 +55,7 @@ _MOD_ALIASES = {
     "SUPER": "SUPER", "WIN": "SUPER", "CMD": "SUPER", "MOD": "SUPER", "LOGO": "SUPER",
     "CTRL": "CTRL", "CONTROL": "CTRL", "CTL": "CTRL",
     "ALT": "ALT", "OPT": "ALT", "OPTION": "ALT", "MOD1": "ALT", "META": "ALT",
-    "SHIFT": "SHIFT", "PREFIX": "PREFIX", "COPYMODE": "COPYMODE",
+    "SHIFT": "SHIFT", "PREFIX": "PREFIX", "LEADER": "PREFIX", "COPYMODE": "COPYMODE",
 }
 _KEY_ALIASES = {
     "ENTER": "RETURN", "CR": "RETURN", "ESC": "ESCAPE", "DEL": "DELETE", "INS": "INSERT",

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/cards/lazyvim.yaml

@@ -12,7 +12,7 @@ cards:
   - {prompt: Grep the project (root dir), answer: [<leader>/, <leader>sg]}
   - {prompt: Switch buffer, answer: ['<leader>,', '<leader>fb']}
   - {prompt: Recent files, answer: [<leader>fr]}
-  - {prompt: File explorer (neo-tree), answer: [<leader>e]}
+  - {prompt: File explorer (neo-tree), answer: [<leader>e], note: 'e is explorer.'}
   - {prompt: Next buffer, answer: [<S-l>, ']b']}
   - {prompt: Previous buffer, answer: [<S-h>, '[b']}
   - {prompt: Delete the buffer, answer: [<leader>bd]}

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/cards/shell.yaml

@@ -5,9 +5,9 @@ case_sensitive: false
 note: Readline keys work in bash and in most terminal prompts.
 cards:
   - {prompt: Search back through your command history, answer: [<C-r>]}
-  - {prompt: Jump to the start of the line, answer: [<C-a>, <Home>]}
-  - {prompt: Jump to the end of the line, answer: [<C-e>, <End>]}
-  - {prompt: Delete the word before the cursor, answer: [<C-w>]}
+  - {prompt: Jump to the start of the line, answer: [<C-a>, <Home>], note: 'a is the start of the alphabet. The shell isn’t Vim: 0 and $ just type themselves.'}
+  - {prompt: Jump to the end of the line, answer: [<C-e>, <End>], note: 'e is end. The shell isn’t Vim: $ just types itself.'}
+  - {prompt: Delete the word before the cursor, answer: [<C-w>], note: 'w is word.'}
   - {prompt: Delete from the cursor to the start of the line, answer: [<C-u>]}
   - {prompt: Delete from the cursor to the end of the line, answer: [<C-k>]}
   - {prompt: Paste what you just deleted with Ctrl-w/u/k, answer: [<C-y>]}

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/cards/vim.yaml

@@ -7,8 +7,8 @@ case_sensitive: true
 cards:
   # week 1: text objects, find/till, lines, counts
   - {week: 1, day: 1, prompt: 'Change the whole word under the cursor, wherever in it the cursor is', answer: [ciw], note: 'cw only changes from the cursor to the end of the word.'}
-  - {week: 1, day: 1, prompt: Delete a word and the space after it, answer: [daw]}
-  - {week: 1, day: 1, prompt: 'Change a WORD (space to space, punctuation included)', answer: [ciW]}
+  - {week: 1, day: 1, id: 'vim:Delete a word and the space after it', prompt: 'Delete the whole word under the cursor, wherever in it the cursor is, and the space after it', answer: [daw], note: 'dw only deletes from the cursor on.'}
+  - {week: 1, day: 1, id: 'vim:Change a WORD (space to space, punctuation included)', prompt: 'Change the whole WORD under the cursor (space to space, punctuation included), keeping the space after it', answer: [ciW]}
   - {week: 1, day: 1, prompt: Yank the word under the cursor, answer: [yiw]}
   - {week: 1, day: 2, prompt: Change everything inside the double quotes, answer: ['ci"']}
   - {week: 1, day: 2, prompt: Delete the quotes and what is inside them, answer: ['da"']}

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/cards.py

@@ -77,7 +77,7 @@ def _static_decks() -> dict[str, Deck]:
             deck.cards.append(
                 Card(
                     deck=deck.id,
-                    id=f"{deck.id}:{c['prompt']}",
+                    id=c.get("id", f"{deck.id}:{c['prompt']}"),  # `id` keeps a reworded card's history
                     prompt=c["prompt"],
                     answers=[str(a) for a in c["answer"]],
                     style=data.get("style", "keys"),

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/generate.py

@@ -6,8 +6,8 @@ practised on sentences you haven't seen. The same seed always gives the same
 task, so a run can be replayed and every kind can be checked in Neovim
 (tests/check_generate.py).
 
-The sentences stay mnemonic: they're the hooks from mnemonics.yaml (what keys
-stand for) and facts from lessons/sources.md.
+The sentences stay mnemonic: they're the hooks from mnemonics.yaml, what keys
+stand for.
 
 Kinds, all word text objects (w1d1):
   ciw-typo    two letters of a word swapped; ciw and type it right
@@ -25,31 +25,11 @@ from vimniscient.mnemonics import _tables
 
 KINDS = ("ciw-typo", "daw-double", "ciW-dotted")
 
-# Facts from lessons/sources.md, one sentence each.
-FACTS = [
-    "Ebbinghaus tested himself on nonsense syllables and published his results in 1885.",
-    "Forgetting is steepest right after learning, then the curve levels off.",
-    "Miller wrote about the magical number seven, plus or minus two.",
-    "Cowan later argued that short-term memory holds about four chunks.",
-    "Retrieval practice beat restudying on a test a week later.",
-    "Restudying looked better after five minutes, which is why it feels like it works.",
-    "Spacing reviews out is among the best replicated findings about memory.",
-    "Sleep after learning helps new memories stabilise.",
-    "Rereading makes text feel familiar, and people mistake that for knowing it.",
-    "Words read aloud are remembered better than words read silently.",
-    "Mixed practice feels harder than blocked practice but tests better later.",
-    "Practising with variation helps a skill carry over to new conditions.",
-    "Trying to recall an answer before seeing it helps you remember it later.",
-    "Fitts and Posner described three stages of skill: cognitive, associative and autonomous.",
-    "Desirable difficulties make learning feel harder but make it last.",
-]
-
-
 @cache
 def sentences() -> list[str]:
     hooks = list(dict.fromkeys(hook for table in _tables()[:2] for hook in table.values()))
     # as written: a capital would change the key ("u is down" is not "U is down")
-    return [h + ("" if h.endswith(".") else ".") for h in hooks] + FACTS
+    return [h + ("" if h.endswith(".") else ".") for h in hooks]
 
 
 _WORD = re.compile(r"(?<![\w'.-])[A-Za-z]{4,}(?![\w'-])")

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/habits.py

@@ -15,6 +15,7 @@ from pathlib import Path
 
 from vimniscient.cards import Card, Deck
 from vimniscient.keys import split_keys
+from vimniscient.mnemonics import OPERATORS
 
 LOG = Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local/state")) / "nvim" / "hardtime.nvim.log"
 
@@ -91,7 +92,7 @@ def habit_deck() -> Deck:
                 answers=[better],
                 style="keys",
                 case_sensitive=True,
-                note=f"hardtime caught this {habit.total}×.",
+                note=f"{'Verb first, then the motion. ' if better[0] in OPERATORS else ''}hardtime caught this {habit.total}×.",
                 order=i,
             )
         )

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/lessons/sources.md

@@ -1,8 +1,8 @@
 # Sources for the facts in the lesson texts
 
-The lesson texts are mnemonic: they describe the key being practised (see
-`../mnemonics.yaml`), and the rest is about the science of learning and memory.
-Every factual claim in them should trace back to one of these.
+Lesson practice texts are mnemonic: each one is about the keys it practises (see
+`../mnemonics.yaml`). Memory science belongs in lesson intros, where it explains
+why the training works. Every factual claim there should trace back to one of these.
 
 - **Atkinson & Raugh (1975).** An application of the mnemonic keyword method to
   the acquisition of a Russian vocabulary. *JEP: Human Learning and Memory*

{vimniscient-0.2.0 → vimniscient-0.2.1}/src/vimniscient/lessons/w1d1-words.yaml

@@ -32,12 +32,6 @@ tasks:
         target: |-
           Change inner word: c is the verb, iw the noun, and the cursor sits anywhere in it.
         solution: 'ciwanywhere<Esc>'
-      - goal: 'Fix "memroy" to "memory" (the cursor is in the middle of the word).'
-        start: |-
-          Testing yourself beats rereading: type ciw from mem▮roy, not from the page.
-        target: |-
-          Testing yourself beats rereading: type ciw from memory, not from the page.
-        solution: 'ciwmemory<Esc>'
       - goal: 'Fix "undersocres" to "underscores" (the cursor is in the middle of the word).'
         start: |-
           In ciw, the w is a word: letters, digits and under▮socres, nothing else.
@@ -64,11 +58,6 @@ tasks:
           daw takes a word and what is around it, its ▮its trailing space.
         target: |-
           daw takes a word and what is around it, its trailing space.
-      - goal: 'Delete one "himself".'
-        start: |-
-          Ebbinghaus tested ▮himself himself on nonsense syllables; daw cuts the echo.
-        target: |-
-          Ebbinghaus tested himself on nonsense syllables; daw cuts the echo.
       - goal: 'Delete one "so".'
         start: |-
           With daw, a means around: the word goes, and ▮so so does one space.
@@ -101,12 +90,6 @@ tasks:
         target: |-
           ciW sees a path as one WORD, slashes and all.
         solution: 'ciWa path<Esc>'
-      - goal: 'Replace "Fitts&Posner(1967)" with "Fitts-and-Posner".'
-        start: |-
-          ciW: from space to space, Fitts&Pos▮ner(1967) counts as one WORD.
-        target: |-
-          ciW: from space to space, Fitts-and-Posner counts as one WORD.
-        solution: 'ciWFitts-and-Posner<Esc>'
   - goal: 'Spell the function name out as change_inner_word.'
     ft: python
     start: |-
@@ -180,18 +163,6 @@ tasks:
         target: |-
           viwp swaps a selection for the yank, so select, then put the yank
         solution: 'yiw$viwp'
-      - goal: 'Copy "spaced" over "massed".'
-        start: |-
-          ▮spaced reviews beat massed ones, so keep them massed
-        target: |-
-          spaced reviews beat massed ones, so keep them spaced
-        solution: 'yiw$viwp'
-      - goal: 'Copy "mixed" over the last "blocked".'
-        start: |-
-          Rohrer and Taylor: blocked practice feels better than ▮mixed, yet scores below blocked
-        target: |-
-          Rohrer and Taylor: blocked practice feels better than mixed, yet scores below mixed
-        solution: 'yiw$viwp'
   - goal: 'Delete the doubled "the".'
     start: |-
       daw: delete a word, and ▮the the space after it.
@@ -206,16 +177,6 @@ tasks:
           Doubled words ▮like like this one are what daw is for.
         target: |-
           Doubled words like this one are what daw is for.
-      - goal: 'Delete the doubled "four".'
-        start: |-
-          Cowan put short-term memory at about ▮four four chunks.
-        target: |-
-          Cowan put short-term memory at about four chunks.
-      - goal: 'Delete the doubled "familiar".'
-        start: |-
-          Rereading builds a fluency illusion: the text feels ▮familiar familiar, not known.
-        target: |-
-          Rereading builds a fluency illusion: the text feels familiar, not known.
       - goal: 'Delete the doubled "and".'
         start: |-
           daw: d for delete, a for a word ▮and and its space.

vimniscient-0.2.1/src/vimniscient/lessons/w1d2-pairs.yaml

@@ -0,0 +1,101 @@
+week: 1
+day: 2
+title: Quotes, brackets and tags
+intro: |
+  The same `i`/`a` trick works on pairs, and the noun is simply the pair's own
+  sign: `i"` is inside the quotes, `a"` takes the quotes too. Brackets name
+  themselves the same way: `i(` `i[` `i{` `i<`. `t` is for *tag*: `it` is
+  inside an HTML tag. For quotes the cursor doesn't even have to be inside:
+  `ci"` jumps to the next quoted string on the line.
+keys: ['ci"', 'da"', 'di(', 'da(', 'di[', 'cit']
+tasks:
+  - goal: 'Set the string to "change inside".'
+    ft: python
+    start: |-
+      ci_quote = "▮delete outside"
+    target: |-
+      ci_quote = "change inside"
+    solution: 'ci"change inside<Esc>'
+    hint: 'c changes, i keeps it inside, " names the pair: ci".'
+    variants:
+      - goal: 'Set the string to "the quote names the pair".'
+        start: |-
+          quote_object = "▮brackets name it"
+        target: |-
+          quote_object = "the quote names the pair"
+        solution: 'ci"the quote names the pair<Esc>'
+      - goal: 'Set the string to "without the quotes".'
+        start: |-
+          inner_quote = "▮with the quotes"
+        target: |-
+          inner_quote = "without the quotes"
+        solution: 'ci"without the quotes<Esc>'
+  - goal: 'Change the string to "the quotes", starting from the beginning of the line.'
+    ft: python
+    start: |-
+      ▮ci_quote_keeps = "nothing"
+    target: |-
+      ci_quote_keeps = "the quotes"
+    solution: 'ci"the quotes<Esc>'
+    hint: 'You don''t have to move first. ci" finds the next quotes on the line.'
+    variants:
+      - goal: 'Change the string to "the next quotes", starting from the beginning of the line.'
+        start: |-
+          ▮ci_quote_finds = "nothing"
+        target: |-
+          ci_quote_finds = "the next quotes"
+        solution: 'ci"the next quotes<Esc>'
+  - goal: 'Empty the inner parentheses.'
+    ft: python
+    start: |-
+      di_paren(empties(▮this_part))
+    target: |-
+      di_paren(empties())
+    solution: 'di('
+    hint: 'di( deletes inside the innermost parentheses around the cursor.'
+    variants:
+      - start: |-
+          inner_paren(keeps(▮only_the_brackets))
+        target: |-
+          inner_paren(keeps())
+  - goal: 'Delete the argument list, parentheses included.'
+    ft: python
+    start: |-
+      da = deletes(▮around, it) + parens
+    target: |-
+      da = deletes + parens
+    solution: 'da('
+    hint: 'a is around: da( deletes the parentheses too. (dab is the same thing.)'
+    variants:
+      - start: |-
+          parens_go = da(▮inside, and, out) + too
+        target: |-
+          parens_go = da + too
+  - goal: 'Empty the list.'
+    ft: python
+    start: |-
+      di_bracket_leaves = [▮"just", "the", "brackets"]
+    target: |-
+      di_bracket_leaves = []
+    solution: 'di['
+    hint: 'di[ works like di(: the bracket names the pair.'
+    variants:
+      - start: |-
+          bracket_names_the_pair = [▮"square", "ones"]
+        target: |-
+          bracket_names_the_pair = []
+  - goal: 'Change the text inside the tag to "t is for tag".'
+    ft: html
+    start: |-
+      <b>t is for ti▮tle</b>
+    target: |-
+      <b>t is for tag</b>
+    solution: 'citt is for tag<Esc>'
+    hint: 't is the tag object. cit changes the tag''s content and keeps the tags.'
+    variants:
+      - goal: 'Change the text inside the tag to "the tags stay".'
+        start: |-
+          <b>the tags ▮go</b>
+        target: |-
+          <b>the tags stay</b>
+        solution: 'citthe tags stay<Esc>'

vimniscient-0.2.1/src/vimniscient/lessons/w1d3-sentences.yaml

@@ -0,0 +1,115 @@
+week: 1
+day: 3
+title: Sentences and paragraphs
+intro: |
+  Bigger nouns: `s` is a *sentence* and `p` a *paragraph* (a block of lines
+  between empty lines). `is`/`ip` are the thing itself; `as`/`ap` take the
+  space or empty line after it too, so `dap` leaves no gap. Any verb works on
+  them, including `>` (the arrow points the way the text moves) and `y`.
+keys: [dap, yap, cis, das, ">ip"]
+tasks:
+  - goal: 'Delete the middle paragraph.'
+    start: |-
+      dap deletes a paragraph.
+
+      This paragraph ▮is padding.
+      It can go.
+
+      It leaves no double gap behind.
+    target: |-
+      dap deletes a paragraph.
+
+      It leaves no double gap behind.
+    solution: 'dap'
+    hint: 'd deletes, a takes the empty line after it, p is the paragraph.'
+    variants:
+      - start: |-
+          a is around: the paragraph and the blank line after it.
+
+          This line ▮is filler.
+          So is this one.
+
+          One gap stays.
+        target: |-
+          a is around: the paragraph and the blank line after it.
+
+          One gap stays.
+  - goal: 'Duplicate the first paragraph.'
+    start: |-
+      ▮yap yanks a paragraph; P puts it above.
+
+      Done.
+    target: |-
+      yap yanks a paragraph; P puts it above.
+
+      yap yanks a paragraph; P puts it above.
+
+      Done.
+    solution: 'yapP'
+    hint: 'yap yanks a paragraph with its empty line; P puts it above the cursor.'
+    variants:
+      - start: |-
+          ▮P puts above, p puts below.
+
+          Done.
+        target: |-
+          P puts above, p puts below.
+
+          P puts above, p puts below.
+
+          Done.
+  - goal: 'Fix the wrong sentence: it should say "A sentence ends at a full stop."'
+    start: |-
+      s is for sentence. A sentence ends at a ▮comma. cis changes just one.
+    target: |-
+      s is for sentence. A sentence ends at a full stop. cis changes just one.
+    solution: 'cisA sentence ends at a full stop.<Esc>'
+    hint: 'cis changes the inner sentence and leaves the spaces around it.'
+    variants:
+      - goal: 'Fix the wrong sentence: it should say "The i means inner."'
+        start: |-
+          cis keeps the spaces. The i means ▮around. das takes one along.
+        target: |-
+          cis keeps the spaces. The i means inner. das takes one along.
+        solution: 'cisThe i means inner.<Esc>'
+  - goal: 'Delete the middle sentence.'
+    start: |-
+      das deletes a sentence. This one ▮is wrong. Its space goes too.
+    target: |-
+      das deletes a sentence. Its space goes too.
+    solution: 'das'
+    hint: 'das deletes a sentence plus the space after it.'
+    variants:
+      - start: |-
+          a is around: a sentence and its space. This sentence ▮is spare. The next one moves up.
+        target: |-
+          a is around: a sentence and its space. The next one moves up.
+  - goal: 'Indent the three lines.'
+    start: |-
+      What ip covers:
+
+      ▮this line
+      this line
+      and this one
+    target: |-
+      What ip covers:
+
+          this line
+          this line
+          and this one
+    solution: '>ip'
+    hint: '> points right, ip is the inner paragraph. (Indent here is 4 spaces.)'
+    variants:
+      - goal: 'Indent the three lines.'
+        start: |-
+          > pushes right:
+
+          ▮one
+          two
+          three
+        target: |-
+          > pushes right:
+
+              one
+              two
+              three

vimniscient-0.2.1/src/vimniscient/lessons/w1d4-find.yaml

@@ -0,0 +1,90 @@
+week: 1
+day: 4
+title: Find and till on a line
+intro: |
+  `f{char}` *finds* the next {char} on the line and lands *on* it; `t{char}`
+  goes *till* it and stops just before. Capital `F` and `T` look backwards.
+  `;` repeats the last one (a semicolon says *and so on*), `,` repeats it the
+  other way (a comma steps back). With a verb they become precise: `dt,`
+  deletes till the comma, `ct;` changes till the semicolon.
+keys: [f, t, F, T, ";", ",", dt, ct]
+tasks:
+  - goal: 'Delete everything up to "just".'
+    start: |-
+      t means till: it stops ▮way way just before the letter.
+    target: |-
+      t means till: it stops just before the letter.
+    solution: 'dtj'
+    hint: 'dtj deletes till the next j after the cursor; "way way" has none.'
+    variants:
+      - goal: 'Delete everything up to "just".'
+        start: |-
+          dt stops ▮a bit early: just before the letter.
+        target: |-
+          dt stops just before the letter.
+        solution: 'dtj'
+  - goal: 'Change the value to "till" (keep the semicolon).'
+    start: |-
+      let t = ▮"through"; let f = "find";
+    target: |-
+      let t = "till"; let f = "find";
+    solution: 'ct;"till"<Esc>'
+    hint: 'ct; changes till, not including, the semicolon.'
+    variants:
+      - goal: 'Change the value to "find" (keep the semicolon).'
+        start: |-
+          let f = ▮"till"; let t = "till";
+        target: |-
+          let f = "find"; let t = "till";
+        solution: 'ct;"find"<Esc>'
+  - goal: 'Keep only the folder path: delete the file name.'
+    start: |-
+      lessons/week-1/till/backwards.ya▮ml
+    target: |-
+      lessons/week-1/till/
+    solution: 'T/D'
+    hint: 'Capital T goes backwards: T/ stops just after the last slash; D deletes to the end of the line.'
+    variants:
+      - start: |-
+          vim/motions/capital-T/goes-back.tx▮t
+        target: |-
+          vim/motions/capital-T/
+  - goal: 'Turn the third comma into a semicolon.'
+    start: |-
+      ▮count, then f, then the comma, done
+    target: |-
+      count, then f, then the comma; done
+    solution: '3f,r;'
+    hint: 'f, then ; ; walks comma by comma ("and so on"). A count is shorter: 3f, and then r; replaces the character.'
+    variants:
+      - start: |-
+          ▮f, t, F, T
+        target: |-
+          f, t, F; T
+  - goal: 'Replace the whole before(char) call with on_it.'
+    ft: python
+    start: |-
+      f_lands = ▮before(char)  # t stops before it
+    target: |-
+      f_lands = on_it  # t stops before it
+    solution: 'ct on_it<Esc>'
+    hint: 't works with a space too. ct<Space> changes till the next space.'
+    variants:
+      - goal: 'Replace the whole at(char) call with till.'
+        start: |-
+          t_stops = ▮at(char)  # one short of it
+        target: |-
+          t_stops = till  # one short of it
+        solution: 'ct till<Esc>'
+  - goal: 'Delete the part in brackets: from the cursor up to and including the ")".'
+    start: |-
+      f lands on▮ (not before) the letter.
+    target: |-
+      f lands on the letter.
+    solution: 'df)'
+    hint: 'f finds and lands on the ), so df) deletes the bracket too.'
+    variants:
+      - start: |-
+          F finds backwards▮ (to the left) on the line.
+        target: |-
+          F finds backwards on the line.

vimniscient-0.2.1/src/vimniscient/lessons/w1d5-lines.yaml

@@ -0,0 +1,132 @@
+week: 1
+day: 5
+title: Whole lines and line ends
+intro: |
+  Capitals go big: `D` deletes to the end of the line, `C` changes to the end.
+  Doubling a verb means the whole line: `dd` deletes it, `cc` changes it. `J`
+  *joins* the next line on. `A` *appends* at the end and `I` *inserts* at the
+  first non-blank character. `ddp` swaps two lines: cut, then put back one
+  further down.
+keys: [D, C, cc, dd, J, ddp, A, I]
+tasks:
+  - goal: 'Delete the rest of the line.'
+    start: |-
+      D is a big d: it deletes to the end.▮ Everything after the cursor goes.
+    target: |-
+      D is a big d: it deletes to the end.
+    solution: 'D'
+    hint: 'D deletes from the cursor to the end of the line.'
+    variants:
+      - start: |-
+          D deletes from the cursor to the end.▮ This part goes.
+        target: |-
+          D deletes from the cursor to the end.
+      - start: |-
+          Capital D goes big.▮ All of this disappears at once.
+        target: |-
+          Capital D goes big.
+  - goal: 'Change the rest of the line to "the end of the line".'
+    start: |-
+      C changes to: ▮somewhere in the middle
+    target: |-
+      C changes to: the end of the line
+    solution: 'Cthe end of the line<Esc>'
+    hint: 'C changes from the cursor to the end of the line.'
+    variants:
+      - goal: 'Change the rest of the line to "the rest of the line".'
+        start: |-
+          C is a big c: it changes ▮just a word
+        target: |-
+          C is a big c: it changes the rest of the line
+        solution: 'Cthe rest of the line<Esc>'
+  - goal: 'Replace the middle line with "cc changes a line".'
+    start: |-
+      c changes
+      ▮typo
+      c twice, a whole line
+    target: |-
+      c changes
+      cc changes a line
+      c twice, a whole line
+    solution: 'cccc changes a line<Esc>'
+    hint: 'cc, the doubled verb, changes the whole line, wherever the cursor is.'
+    variants:
+      - goal: 'Replace the middle line with "cc changes a line".'
+        start: |-
+          dd deletes a line
+          ▮xx changes a line
+          yy yanks a line
+        target: |-
+          dd deletes a line
+          cc changes a line
+          yy yanks a line
+        solution: 'cccc changes a line<Esc>'
+  - goal: 'Join the two lines.'
+    start: |-
+      ▮J joins this line
+      and the next one.
+    target: |-
+      J joins this line and the next one.
+    solution: 'J'
+    hint: 'J joins the next line onto this one, with one space.'
+    variants:
+      - start: |-
+          ▮gJ joins with no space;
+          J adds one.
+        target: |-
+          gJ joins with no space; J adds one.
+  - goal: 'Put the steps in order: delete first.'
+    start: |-
+      ▮then p puts
+      dd deletes
+      and the lines swap
+    target: |-
+      dd deletes
+      then p puts
+      and the lines swap
+    solution: 'ddp'
+    hint: 'dd cuts the line, p puts it below the next one.'
+    variants:
+      - goal: 'Put the steps of ddp in order: cut first.'
+        start: |-
+          ▮put
+          cut
+          and that is ddp
+        target: |-
+          cut
+          put
+          and that is ddp
+  - goal: 'Add a semicolon at the end.'
+    start: |-
+      ▮console.log("A appends at the end")
+    target: |-
+      console.log("A appends at the end");
+    solution: 'A;<Esc>'
+    hint: 'A appends at the end of the line, wherever the cursor is.'
+    variants:
+      - goal: 'Add a semicolon at the end.'
+        start: |-
+          ▮return "A is for append"
+        target: |-
+          return "A is for append";
+      - start: |-
+          ▮let append = "A"
+        target: |-
+          let append = "A";
+      - start: |-
+          ▮print("A goes to the end")
+        target: |-
+          print("A goes to the end");
+  - goal: 'Comment the line out with "# ".'
+    ft: python
+    start: |-
+      insert = ▮"I puts you at the start"
+    target: |-
+      # insert = "I puts you at the start"
+    solution: 'I# <Esc>'
+    hint: 'I inserts at the start of the line.'
+    variants:
+      - start: |-
+          start = ▮"I goes to the first letter"
+        target: |-
+          # start = "I goes to the first letter"