[Feature] add bash execution

.mockery.yaml

@@ -10,4 +10,12 @@ packages:
       CellParser:
         config:
           dir: ./internal/
-          pkgname: internal_test
+          pkgname: internal_test
+      OutputParser:
+        config:
+          dir: ./internal/bash/
+          pkgname: bash_test
+      Runner:
+        config:
+          dir: ./internal/bash/
+          pkgname: bash_test

cmd/file.go

@@ -21,8 +21,8 @@ var fileCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		path := args[0]
 		parsers := map[string]internal.CellParser{
-			"static": internal.CellParserFunc(static.ParseCell),
-			"bash":   internal.CellParserFunc(bash.ParseCell),
+			"static": static.NewParser(),
+			"bash":   bash.MakeParser(),
 		}
 		data, err := internal.ProcessFile(path, parsers)
 		if err != nil {

internal/bash/cell.go

@@ -2,53 +2,72 @@ package bash
 
 import (
 	"fmt"
+	"strings"
 
 	"litdoc/internal"
 )
 
 type Cell struct {
 	block  internal.Block
 	output internal.Output
+	runner internal.Runner
 }
 
-func MakeCellFromRaw(content, indent string, output internal.Output) Cell {
+func makeCellFromRaw(
+	content, indent string,
+	output internal.Output,
+	runner internal.Runner,
+) Cell {
 	return Cell{
 		block:  internal.MakeBlockFromRaw(internal.BlockKindFencedCode, content, indent, false),
 		output: output,
+		runner: runner,
 	}
 }
 
-func ParseCell(
-	block internal.Block,
-	following []internal.Block,
-) (
-	internal.Cell,
-	int,
-	error,
-) {
-	return parseCellWith(block, following, internal.OutputFromBlocks)
+type Parser struct {
+	runner       internal.Runner
+	outputParser internal.OutputParser
 }
 
-func parseCellWith(
+func MakeParser() Parser {
+	return makeParserFromRaw(Runner{}, internal.OutputParserFunc(internal.OutputFromBlocks))
+}
+
+func makeParserFromRaw(
+	runner internal.Runner,
+	outputParser internal.OutputParser,
+) Parser {
+	return Parser{runner: runner, outputParser: outputParser}
+}
+
+func (p Parser) Parse(
 	block internal.Block,
 	following []internal.Block,
-	parseOutput func(internal.Block, []internal.Block) (internal.Output, int, error),
 ) (
 	internal.Cell,
 	int,
 	error,
 ) {
-	output, consumed, err := parseOutput(block, following)
+	output, consumed, err := p.outputParser.Parse(block, following)
 	if err != nil {
 		return nil, 0, fmt.Errorf("parsing output: %w", err)
 	}
-	return Cell{block: block, output: output}, consumed, nil
+	return Cell{block: block, output: output, runner: p.runner}, consumed, nil
 }
 
 func (c Cell) Execute() (internal.Cell, error) {
+	stdout, stderr, exitCode, err := c.runner.Run(internal.CodeBody(c.block.Content()))
+	if err != nil {
+		return nil, fmt.Errorf("running cell: %w", err)
+	}
+	if exitCode != 0 {
+		return nil, fmt.Errorf("exit status %d: %s", exitCode, strings.TrimSpace(stderr))
+	}
 	return Cell{
 		block:  c.block,
-		output: internal.MakeOutput("output", c.block.Indent()),
+		runner: c.runner,
+		output: internal.MakeOutput(stdout, c.block.Indent()),
 	}, nil
 }
 

internal/bash/cell_private_test.go

@@ -0,0 +1,38 @@
+package bash
+
+import (
+	"testing"
+
+	"litdoc/internal"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMakeCellFromRaw(t *testing.T) {
+	// given
+	content := "```bash\necho hello\n```\n"
+	indent := "  "
+	output := internal.MakeOutput("hello", "")
+	runner := Runner{}
+	block := internal.MakeBlockFromRaw(internal.BlockKindFencedCode, content, indent, false)
+
+	// when
+	c := makeCellFromRaw(content, indent, output, runner)
+
+	// then
+	assert.Equal(t, block, c.block)
+	assert.Equal(t, output, c.output)
+	assert.Equal(t, runner, c.runner)
+}
+
+func TestMakeParserFromRaw(t *testing.T) {
+	// given
+	runner := Runner{}
+
+	// when
+	p := makeParserFromRaw(runner, internal.OutputParserFunc(internal.OutputFromBlocks))
+
+	// then
+	assert.Equal(t, runner, p.runner)
+	assert.NotNil(t, p.outputParser)
+}