Added TUI, etc (#148)

Author: djthorpe

pkg/cmd/server.go

@@ -125,6 +125,10 @@ func (s *RunServer) Run(ctx server.Cmd) error {
 		return fmt.Errorf("catchall: %w", err)
 	}
 
+	// Serve requests through the wrapped router so CORS, CSRF protection and
+	// router middleware are applied to the registered routes.
+	srv.SetHandler(router)
+
 	// Bind to the server's address to ensure it's available
 	if err := srv.Listen(); err != nil {
 		return err

pkg/httprequest/read.go

@@ -41,6 +41,8 @@ func Read(r *http.Request, v interface{}) error {
 		return readString(r, v)
 	case types.ContentTypeFormData:
 		return readFormData(r, v)
+	case types.ContentTypeForm:
+		return readFormURLEncoded(r, v)
 	}
 
 	// Cannot handle this content type
@@ -162,6 +164,19 @@ func readFormData(r *http.Request, v any) error {
 	return nil
 }
 
+func readFormURLEncoded(r *http.Request, v any) error {
+	if err := r.ParseForm(); err != nil {
+		return errBadRequest.With(err.Error())
+	}
+	if r.PostForm == nil {
+		return httpresponse.ErrBadRequest.With("Missing form data")
+	}
+	if err := Query(r.PostForm, v); err != nil {
+		return err
+	}
+	return nil
+}
+
 // fileHeaderPath returns the sanitised logical path for a multipart file part.
 // It prefers the X-Path header (set by go-client when the path contains
 // directory components, since the stdlib strips directories from the

pkg/httprequest/read_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"mime/multipart"
 	"net/http"
+	"net/url"
 	"strings"
 	"testing"
 
@@ -136,6 +137,33 @@ func Test_Read_FormData(t *testing.T) {
 	})
 }
 
+func Test_Read_FormURLEncoded(t *testing.T) {
+	assert := assert.New(t)
+
+	t.Run("WithFields", func(t *testing.T) {
+		type payload struct {
+			Name   string   `json:"name"`
+			Age    string   `json:"age"`
+			Scopes []string `json:"scope"`
+		}
+
+		values := url.Values{
+			"name":  {"alice"},
+			"age":   {"30"},
+			"scope": {"openid", "profile"},
+		}
+		r, _ := http.NewRequest(http.MethodPost, "/", strings.NewReader(values.Encode()))
+		r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+		var p payload
+		err := httprequest.Read(r, &p)
+		assert.NoError(err)
+		assert.Equal("alice", p.Name)
+		assert.Equal("30", p.Age)
+		assert.Equal([]string{"openid", "profile"}, p.Scopes)
+	})
+}
+
 func Test_Read_FormData_JSON(t *testing.T) {
 	assert := assert.New(t)
 

pkg/httprouter/security.go

@@ -29,7 +29,6 @@ func (r *Router) RegisterSecurityScheme(name string, scheme SecurityScheme) erro
 	if _, exists := r.security[name]; exists {
 		return httpresponse.ErrConflict.Withf("security scheme %q already registered", name)
 	}
-
 	r.spec.AddSecurityScheme(name, scheme.Spec())
 	r.security[name] = scheme
 	return nil

pkg/httpserver/httpserver.go

@@ -22,6 +22,7 @@ import (
 type server struct {
 	http       http.Server
 	listener   net.Listener
+	mux        *http.ServeMux
 	serverName string
 }
 
@@ -71,7 +72,8 @@ func New(listen string, tls *tls.Config, opts ...Opt) (*server, error) {
 	listen = ListenAddr(listen, tls != nil && len(tls.Certificates) > 0)
 
 	// Set other options
-	server.http.Handler = http.DefaultServeMux
+	server.mux = http.NewServeMux()
+	server.http.Handler = server.mux
 	server.http.Addr = listen
 	if tls != nil && len(tls.Certificates) > 0 {
 		server.http.TLSConfig = tls
@@ -94,7 +96,18 @@ func New(listen string, tls *tls.Config, opts ...Opt) (*server, error) {
 
 // Router returns the server's http.ServeMux for registering handlers.
 func (server *server) Router() *http.ServeMux {
-	return server.http.Handler.(*http.ServeMux)
+	return server.mux
+}
+
+// SetHandler replaces the HTTP handler used to serve requests.
+// Route registration should continue to use Router, which always returns the
+// dedicated internal ServeMux.
+func (server *server) SetHandler(handler http.Handler) {
+	if handler == nil {
+		server.http.Handler = server.mux
+		return
+	}
+	server.http.Handler = handler
 }
 
 // Addr returns the listen address. After [Listen] has been called this

pkg/openapi/markdown.go

@@ -0,0 +1,165 @@
+package openapi
+
+import (
+	"bytes"
+	_ "embed"
+	"errors"
+	"strings"
+
+	// Packages
+	tokenizer "github.com/mutablelogic/go-tokenizer"
+	ast "github.com/mutablelogic/go-tokenizer/pkg/ast"
+	markdown "github.com/mutablelogic/go-tokenizer/pkg/markdown"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type MarkdownDoc struct {
+	root     ast.Node
+	sections []Section
+}
+
+type Section struct {
+	Level int
+	Title string
+	Body  string
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func ParseMarkdown(data []byte) (doc *MarkdownDoc) {
+	return &MarkdownDoc{
+		root:     markdown.Parse(bytes.NewReader(data), tokenizer.Pos{}),
+		sections: parseSections(string(data)),
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (doc *MarkdownDoc) Sections() []Section {
+	if doc == nil {
+		return nil
+	}
+	return doc.sections
+}
+
+func (doc *MarkdownDoc) Section(level int, title string) Section {
+	if doc == nil {
+		return Section{}
+	}
+	title = normalizeTitle(title)
+	for _, section := range doc.sections {
+		if section.Level == level && strings.EqualFold(section.Title, title) {
+			return section
+		}
+	}
+	return Section{}
+}
+
+// FindSection returns the first heading whose text matches title.
+func (doc *MarkdownDoc) FindSection(title string) *markdown.Heading {
+	if doc == nil || doc.root == nil {
+		return nil
+	}
+	title = strings.TrimSpace(title)
+	if title == "" {
+		return nil
+	}
+
+	var section *markdown.Heading
+	_ = ast.Walk(doc.root, func(node ast.Node, depth int) error {
+		heading, ok := node.(*markdown.Heading)
+		if !ok {
+			return nil
+		}
+		if strings.EqualFold(markdownNodeText(heading), title) {
+			section = heading
+			return errors.New("found markdown section")
+		}
+		return nil
+	})
+	return section
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+func markdownNodeText(node ast.Node) string {
+	if node == nil {
+		return ""
+	}
+
+	var text strings.Builder
+	_ = ast.Walk(node, func(node ast.Node, depth int) error {
+		switch node := node.(type) {
+		case *markdown.Text:
+			text.WriteString(node.Value())
+		case *markdown.Code:
+			text.WriteString(node.String())
+		}
+		return nil
+	})
+
+	return strings.TrimSpace(text.String())
+}
+
+func parseSections(content string) []Section {
+	lines := strings.Split(content, "\n")
+	sections := make([]Section, 0, len(lines))
+
+	var current *Section
+	for _, line := range lines {
+		if level, title, ok := parseHeading(line); ok {
+			if current != nil {
+				current.Body = strings.Trim(current.Body, "\n")
+				sections = append(sections, *current)
+			}
+			current = &Section{Level: level, Title: title}
+			continue
+		}
+		if current == nil {
+			current = &Section{}
+		}
+		current.Body += line + "\n"
+	}
+	if current != nil {
+		current.Body = strings.Trim(current.Body, "\n")
+		sections = append(sections, *current)
+	}
+
+	return sections
+}
+
+func parseHeading(line string) (level int, title string, ok bool) {
+	trimmed := strings.TrimLeft(line, " ")
+	if len(trimmed) == 0 || trimmed[0] != '#' {
+		return 0, "", false
+	}
+	i := 0
+	for i < len(trimmed) && trimmed[i] == '#' {
+		i++
+	}
+	if i > 6 {
+		return 0, "", false
+	}
+	if i < len(trimmed) && trimmed[i] != ' ' && trimmed[i] != '\t' {
+		return 0, "", false
+	}
+	title = strings.TrimSpace(trimmed[i:])
+	title = strings.TrimRight(title, "# ")
+	title = normalizeTitle(title)
+	return i, title, true
+}
+
+func normalizeTitle(title string) string {
+	title = strings.TrimSpace(title)
+	for _, marker := range []string{"`", "**", "__", "*", "_"} {
+		if strings.HasPrefix(title, marker) && strings.HasSuffix(title, marker) && len(title) >= 2*len(marker) {
+			title = strings.TrimSpace(title[len(marker) : len(title)-len(marker)])
+		}
+	}
+	return title
+}

pkg/openapi/markdown_test.go

@@ -0,0 +1,98 @@
+package openapi
+
+import (
+	"testing"
+
+	assert "github.com/stretchr/testify/assert"
+)
+
+func TestParseMarkdownSections(t *testing.T) {
+	const input = `# Top
+
+Preamble text.
+
+## Section A
+
+Body of A.
+
+### Subsection A1
+
+Body of A1.
+
+## Section B
+
+Body of B.
+`
+
+	doc := ParseMarkdown([]byte(input))
+
+	t.Run("Sections", func(t *testing.T) {
+		assert := assert.New(t)
+		sections := doc.Sections()
+		assert.Len(sections, 4)
+
+		assert.Equal(1, sections[0].Level)
+		assert.Equal("Top", sections[0].Title)
+		assert.Contains(sections[0].Body, "Preamble text.")
+
+		assert.Equal(2, sections[1].Level)
+		assert.Equal("Section A", sections[1].Title)
+
+		assert.Equal(3, sections[2].Level)
+		assert.Equal("Subsection A1", sections[2].Title)
+
+		assert.Equal(2, sections[3].Level)
+		assert.Equal("Section B", sections[3].Title)
+	})
+
+	t.Run("SectionLookup", func(t *testing.T) {
+		assert := assert.New(t)
+		s := doc.Section(2, "Section A")
+		assert.Contains(s.Body, "Body of A.")
+
+		s = doc.Section(2, "section a")
+		assert.Equal("Section A", s.Title)
+
+		s = doc.Section(2, "Nonexistent")
+		assert.Empty(s.Title)
+	})
+}
+
+func TestParseMarkdownPreamble(t *testing.T) {
+	const input = `Some text before any heading.
+
+# First
+Content.
+`
+	doc := ParseMarkdown([]byte(input))
+	assert := assert.New(t)
+
+	sections := doc.Sections()
+	assert.Len(sections, 2)
+
+	assert.Equal(0, sections[0].Level)
+	assert.Equal("", sections[0].Title)
+	assert.Contains(sections[0].Body, "Some text before any heading.")
+
+	assert.Equal(1, sections[1].Level)
+	assert.Equal("First", sections[1].Title)
+}
+
+func TestParseMarkdownClosingHashes(t *testing.T) {
+	doc := ParseMarkdown([]byte("## Foo ##\n\nbar"))
+	s := doc.Section(2, "Foo")
+	assert.Contains(t, s.Body, "bar")
+}
+
+func TestParseMarkdownInlineCodeHeading(t *testing.T) {
+	doc := ParseMarkdown([]byte("## `GET /auth/config`\n\nbody"))
+	s := doc.Section(2, "GET /auth/config")
+	assert.Equal(t, "GET /auth/config", s.Title)
+	assert.Equal(t, "body", s.Body)
+}
+
+func TestParseMarkdownEmpty(t *testing.T) {
+	doc := ParseMarkdown(nil)
+	assert.Len(t, doc.Sections(), 1)
+	assert.Equal(t, 0, doc.Sections()[0].Level)
+}