Changes Introduced

• Adds support for defining theme in the header of a slideshow
• Support for default,dark, and light themes
• Adds theme header type and helper functions to read theme name but allow for more metadata if you'd like to add it later

The themes can be specified like this:

---
theme: "default"
---

---
theme: "dark"
---

---
theme: "light"
---

Adds support for issue https://github.com/maaslalani/slides/issues/1 with custom user themes

https://user-images.githubusercontent.com/61225/175433829-90b402ce-7673-4fe4-8e8a-4d0dee827ba8.mp4

System:
    OS: Linux 5.18 Fedora Linux 35 (Workstation Edition)
    CPU: (8) x64 Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
    Memory: 24.64 GB / 31.10 GB
    Container: Yes
    Shell: 5.8.1 - /bin/zsh
  Binaries:
    Node: 17.7.1 - ~/.asdf/installs/nodejs/17.7.1/bin/node
    Yarn: 1.22.15 - ~/.asdf/installs/nodejs/17.7.1/bin/yarn
    npm: 8.5.2 - ~/.asdf/installs/nodejs/17.7.1/bin/npm
  Managers:
    pip3: 22.1.2 - ~/.asdf/shims/pip3
    Yum: 4.13.0 - /usr/bin/yum
  Utilities:
    Make: 4.3 - /usr/bin/make
    GCC: 11.3.1 - /usr/lib64/ccache/gcc
    Git: 2.35.3 - /usr/bin/git
    FFmpeg: 4.4.2 - /usr/bin/ffmpeg
  Servers:
    Apache: 2.4.53 - /usr/sbin/apachectl
  Virtualization:
    Docker: 20.10.14 - /usr/bin/docker
  SDKs:
    Android SDK:
      API Levels: 28, 29, 30
      Build Tools: 28.0.3, 29.0.2, 29.0.3, 30.0.2, 30.0.3
      System Images: android-22 | Google APIs Intel x86 Atom, android-24 | Google Play Intel x86 Atom, android-29 | Google Play Intel x86 Atom, android-30 | Google APIs Intel x86 Atom
  IDEs:
    Nano: 5.8 - /usr/bin/nano
    Sublime Text: 4134 - /usr/bin/subl
    VSCode: 1.67.2 - /usr/bin/code
  Languages:
    Bash: 5.1.8 - /usr/bin/bash
    Go: 1.18 - /home/zenobius/.asdf/shims/go
    Java: 1.8.0_322 - /home/zenobius/.asdf/shims/javac
    Perl: 5.34.1 - /usr/bin/perl
    Python: 3.9.5 - /home/zenobius/.asdf/shims/python
    Python3: 3.9.5 - /home/zenobius/.asdf/shims/python3
  Databases:
    PostgreSQL: 13.4 - /usr/bin/postgres
    SQLite: 3.36.0 - /usr/bin/sqlite3
  Browsers:
    Brave Browser: 100.1.37.116
    Chrome: 101.0.4951.41
    Firefox: 101.0.1

(heavily inspired by https://github.com/maaslalani/slides/pull/108)

Changes Introduced

I found @stoovon's idea very cool as a vim user. Now I took his idea one step further, and added a vim-like search. You can start the search with '/' and then search for a heading (for example 'Java' for 'Javascript'), if you press enter you will get to a slide with a matching heading.

SEARCH-DEMO:

https://user-images.githubusercontent.com/71837281/138121171-a92ad630-6c1f-4b81-84e8-318b5916c1a9.mov

What do you think of this, @maaslalani? I thought I'd just try it out and then create a PR here, but of course I understand if this functionality doesn't fit into your "concept" :)

EDIT: removed command part

Implements #104

Changes Introduced

The problem with Rust: unfortunately you can't (anymore) compile and run a program with just one command (something like rustc --run file.rs), and apparently without additional dependencies, like cargo scripts there is no easy way to start a file without a cargo structure.

So I rewrote the code execution system a bit, which now allows to execute multiple steps. The implentation for Go looks like this:

Go: {
	Extension: "go",
	Cmds:      base{"go", "run"}, // base means: append the filename
},

For Rust however:

Rust: {
	Extension: "rs",
	Cmds: multi{ // multi means: execute multiple commands
		// compile code
		// placeholders <file>, <name> and <path> supported
		{ just "rustc", "<file>", "-o", "<path>/<name>.run"}, 
		// grant execute permissions
		{ "chmod", "+x", "<path>/<name>.run"},
		// run compiled file
		{"<path>/<name>.run"},
	},
},

Currently it seems to be the only practical solution, but it feels very "hacky". Maybe someone has an idea how to improve the whole thing?

I also don't think this works on Windows (unfortunately I can't test it right now), since I use chmod +x <file> to give the output file execute permissions

Fixes #51

Changes Introduced

• Allow arbitrary commands to be executed for pre-processing slides

• This allows for embedding graphs, diagrams, any output of any command, really

• This is a bit different than code execution because it entirely replaces the block of code with the output of the command with the input in the block.

Fixes #9

Changes Introduced

• Allows any (ruby) code blocks to be executed if one is found by pressing the e key.

(Just a prototype, this solution probably won't work for most lanugages. Going to try a different approach with writing files and creating a code package to make it easier to add support for more languages)

Description The current method for parsing pre-processed data doesn't handle newlines in process stdout, resulting in everything being on the same line.

Reproducing Taking the example in the pre-processing example slide:

~~~graph-easy --as=boxart
[ A ] - to -> [ B ]
~~~

Produces:

┌───┐  to   ┌───┐ │ A │ ────> │ B │ └───┘       └───┘

Explanation The output of the command being run is just added to the Block representing the whole slide (internal/process/process.go:68), which then all gets parsed by the markdown renderer (the newlines remain intact until internal/model/model.go:183). As a markdown newline is two newlines, and processes just output single newlines, the renderer interprets the process output with no newlines.

Temporary Solution I didn't open a PR because my solution is quite hacky and probably breaks some cases, but you can wrap the process output in a markdown code block so the renderer interprets it as plain text. There's almost certainly a more elegant way to do it :'D

See here: https://github.com/Thomas-Malcolm/slides/commit/15990c5772ede761bc397120ae1dd03d819533a7

Describe the bug Date is interpreted strangely.

To Reproduce Steps to reproduce the behavior:

1. Use date: 2022-05-22
2. See 282828-49-2828

Expected behavior Slides displays 2022-05-22.

Desktop (please complete the following information):

• OS: macOS
• Version 0.8.0

Describe the bug When a large markdown file is opened in slides, it just jumps to the last line.

To Reproduce Steps to reproduce the behavior:

1. Install latest slides
2. Open a markdown file larger than ROWS

Expected behavior slides should support scroll

Screenshots No need easily reproducible

Describe the bug Tests on the pre-release 0.4.0 tag fail.

~/Projects/aur/slides-git/src/slides main
❯ go test ./...
?   	github.com/maaslalani/slides	[no test files]
?   	github.com/maaslalani/slides/cmd	[no test files]
ok  	github.com/maaslalani/slides/internal/code	(cached)
ok  	github.com/maaslalani/slides/internal/file	(cached)
ok  	github.com/maaslalani/slides/internal/meta	(cached)
?   	github.com/maaslalani/slides/internal/model	[no test files]
--- FAIL: TestExecute (0.00s)
    --- FAIL: TestExecute/Replace (0.00s)
        execute_test.go:34: Invalid execution, want Replace, got 
FAIL
FAIL	github.com/maaslalani/slides/internal/process	0.001s
ok  	github.com/maaslalani/slides/styles	(cached)
FAIL

To Reproduce Steps to reproduce the behavior:

git clone https://github.com/maaslalani/slides.git
cd slides
git checkout main
git pull
go test ./...

Alternatively, on Arch Linux:

git clone https://aur.archlinux.org/slides-git.git
cd slides-git
makepkg

Yields:

~/Projects/aur/slides-git master*
❯ makepkg
==> Making package: slides-git 0.4.0.r0.g742251d-1 (Sun 27 Jun 2021 09:40:40 PM EDT)
==> Checking runtime dependencies...
==> Checking buildtime dependencies...
==> Retrieving sources...
  -> Updating slides git repo...
Fetching origin
From https://github.com/maaslalani/slides
 - [deleted]         (none)     -> node
 - [deleted]         (none)     -> preprocess
 - [deleted]         (none)     -> preprocessing
==> Validating source files with sha256sums...
    slides ... Skipped
==> Extracting sources...
  -> Creating working copy of slides git repo...
Switched to and reset branch 'makepkg'
==> Starting pkgver()...
==> Removing existing $pkgdir/ directory...
==> Starting build()...
==> Starting check()...
?   	github.com/maaslalani/slides	[no test files]
?   	github.com/maaslalani/slides/cmd	[no test files]
ok  	github.com/maaslalani/slides/internal/code	(cached)
ok  	github.com/maaslalani/slides/internal/file	0.002s
ok  	github.com/maaslalani/slides/internal/meta	(cached)
?   	github.com/maaslalani/slides/internal/model	[no test files]
--- FAIL: TestExecute (0.00s)
    --- FAIL: TestExecute/Replace (0.00s)
        execute_test.go:34: Invalid execution, want Replace, got 
FAIL
FAIL	github.com/maaslalani/slides/internal/process	0.001s
ok  	github.com/maaslalani/slides/styles	(cached)
FAIL
==> ERROR: A failure occurred in check().
    Aborting...

Expected behavior Tests pass.

Desktop (please complete the following information):

• OS: Arch Linux 5.12.12-arch1-1
• Golang: go version go1.16.5 linux/amd64

Changes Introduced

• c will copy code blocks to clipboard.

Currently, all blocks are copied individually in order. So the last code block will be on top of the "clipboard stack" if you use a clipboard manager. You could concatenate all blocks and copy them to the clipboard as a single entry.

Or, you could have slightly nicer behavior by having c copy a single block and then maintain a counter that tracks which block should be copied next and then have C concatenate all blocks into a single clipboard entry.

Bumps github.com/charmbracelet/wish from 0.7.0 to 1.0.0.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Is your feature request related to a problem? Please describe. On a presentation I would like to add a contents slide. In markdown, I usually use nested lists on a markdown file with tabs, for example:

1. Item 1
2. Item 2
3. Sub Item 1
4. Sub Item 2
5. Item 3

But if I do that on slides the result is:

1. Item1
2. Item 2
3. Sub Item 1
4. Sub Item 2
5. Item 3

Describe the solution you'd like I would like to have nested lists like:

1. Item 1
2. Item 2
3. Sub Item 1
4. Sub Item 2
5. Item 3

Describe alternatives you've considered Use lookatme instead (works there)

Describe the bug I'm using the jq library to format some JSON.

Here's what my markdown file looks like:

# Testing JSON formatting

```
~~~jq '.'
[{"q": "test"}]
~~~
```

Here's the command being run on the command line, to ensure it works as expected:

$ echo '[{"q": "test"}]' | jq '.'
[
  {
    "q": "test"
  }
]

Expected behavior I'm expecting the code block to show the output of what I see when I run the command above in the command line.

I've verified that the file has chmod +x permissions and other commands work.

Screenshots Just getting an empty code block. I've verified that the file has chmod +x permissions and other commands work.

Desktop (please complete the following information):

• OS: Apple MBP, M1 Max

Fixes #181

Changes Introduced

Allows users to run specific code blocks within a slide.

• ctrl+e puts the user in code block execution mode. It can be followed up with:
  • esc or ctrl+c: to exit code block execution mode
  • enter or n: to run the next code block on the slide (initially starting at the first one)
  • a: to run all code blocks on the slide, from first to last
  • [n], where [n] is some integer >= 0: to run code block with index [n] (0-based indexing)

After the last code block on the slide has been run, regardless of how it was run, the user automatically exits from code block execution mode.

Is your feature request related to a problem? Please describe. I want to ensure that some code blocks are not executable, not even by accident (for example when presenting potentially dangerous commands like rm).

Describe the solution you'd like A per-block option to disable code execution.

Describe alternatives you've considered Not specifying the language prevents execution (error message: Error: could not parse code block) but lacks syntax highlighting.

Is your feature request related to a problem? Please describe. I'd like to use slides sort of like a runnable playbook. Its actually not as crazy at it sounds :) (and I'd like to discuss this more).

Describe the solution you'd like I'd like for code blocks to do some work and if an error is returned by a code block (think bash returning an error) slide prints it and stops moving forward in the presentation.

Describe alternatives you've considered In terms of slide, I've only thought about printing a flashy warning POSSIBLY IN ALL CAPS that continuing is strongly not advised.

Additional context I don't think any are needed but can show some snippets of what I'd like to use this feature with if necessary.