feat: solid test feature

Author: AstraBert

main.go

@@ -3,14 +3,21 @@ package main
 import (
 	"fmt"
 	"net/http"
+	"os"
 	"strconv"
 
 	"github.com/AstraBert/git-push-blog/models"
 	pagereader "github.com/AstraBert/git-push-blog/page_reader"
 	"github.com/AstraBert/git-push-blog/templates"
+	textsearch "github.com/AstraBert/git-push-blog/text_search"
 	"github.com/a-h/templ"
 )
 
+func pathExists(path string) bool {
+	_, err := os.Stat(path)
+	return !os.IsNotExist(err)
+}
+
 func main() {
 	mdFiles, errFls := pagereader.GetMarkdownFiles("./contents")
 	if errFls != nil {
@@ -31,6 +38,15 @@ func main() {
 		return
 	}
 	blogs = models.SortBlogPosts(blogs)
+	if pathExists("posts.bleve") {
+		os.RemoveAll("posts.bleve")
+	}
+	index, err := textsearch.CreateIndex(blogs, "posts.bleve")
+	if err != nil {
+		fmt.Println("An error occurred while creating the index: " + err.Error())
+		return
+	}
+
 	homeComponent := templates.Home()
 	blogComponent := templates.BlogPage(blogs)
 
@@ -52,7 +68,7 @@ func main() {
 		var blogPost *models.BlogPost
 
 		for _, post := range blogs {
-			if post.Id == postId {
+			if post.Id == id {
 				blogPost = post
 				break
 			}
@@ -61,6 +77,50 @@ func main() {
 		templates.Post(blogPost).Render(r.Context(), w)
 	})
 
+	http.HandleFunc("POST /search", func(w http.ResponseWriter, r *http.Request) {
+		err := r.ParseForm()
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		searchText := r.FormValue("search")
+		if searchText == "" {
+			http.Error(w, "Search text is required", http.StatusBadRequest)
+			return
+		}
+
+		results, err := textsearch.SearchText(searchText, index)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		searchResults, errS := textsearch.ParseSearchResults(results)
+
+		if errS != nil {
+			http.Error(w, "No matches where found for the search", http.StatusInternalServerError)
+			return
+		}
+
+		// Return HTML instead of JSON for HTMX
+		w.Header().Set("Content-Type", "text/html")
+
+		// Generate HTML for search results
+		html := ""
+		for _, post := range searchResults {
+			html += fmt.Sprintf(`<li class="text-gray-600 font-sans text-xl">• <a href="/blog/%s"><span class="text-pink-500 underline">%s</span></a> posted by <span class="font-semibold text-pink-400">%s</span> on %s</li>`,
+				post.Id, post.Title, post.Author, post.PublishingDate)
+		}
+
+		if html == "" {
+			html = `<li class="text-gray-600 font-sans text-xl">No results found</li>`
+		}
+
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(html))
+	})
+
 	fmt.Println("Server started on :8000")
 	http.ListenAndServe(":8000", nil)
 }

models/models.go

@@ -3,24 +3,27 @@ package models
 import (
 	"cmp"
 	"slices"
+	"strconv"
 )
 
 type BlogPost struct {
-	Id             int    `json:"id"`
+	Id             string `json:"id"`
 	Title          string `json:"title"`
 	PublishingDate string `json:"publishing_date"`
 	Author         string `json:"author"`
 	Content        string `json:"content"`
 }
 
-func NewBlogPost(id int, title, pubDate, author, content string) *BlogPost {
+func NewBlogPost(id string, title, pubDate, author, content string) *BlogPost {
 	return &BlogPost{Id: id, Title: title, PublishingDate: pubDate, Author: author, Content: content}
 }
 
 func SortBlogPosts(blogs []*BlogPost) []*BlogPost {
 	slices.SortFunc(blogs,
 		func(a, b *BlogPost) int {
-			return cmp.Compare(b.Id, a.Id)
+			bId, _ := strconv.Atoi(b.Id)
+			aId, _ := strconv.Atoi(a.Id)
+			return cmp.Compare(bId, aId)
 		})
 	return blogs
 }

models/models_test.go

@@ -7,36 +7,36 @@ import (
 
 func TestNewBlogPost(t *testing.T) {
 	testCases := []struct {
-		id          int
+		id          string
 		title       string
 		author      string
 		publishDate string
 		content     string
 	}{
-		{1, "hello", "world", "2025-09-20", "hello world"},
-		{2, "test", "test-author", "2025-09-20", "this is a test"},
-		{3, "test-1", "test-author-1", "2025-09-20", "this is a test and even more..."},
+		{"1", "hello", "world", "2025-09-20", "hello world"},
+		{"2", "test", "test-author", "2025-09-20", "this is a test"},
+		{"3", "test-1", "test-author-1", "2025-09-20", "this is a test and even more..."},
 	}
 	for _, tc := range testCases {
 		post := NewBlogPost(tc.id, tc.title, tc.publishDate, tc.author, tc.content)
 		if tc.author != post.Author || tc.id != post.Id || tc.content != post.Content || tc.publishDate != post.PublishingDate {
-			t.Errorf("Expecting BlogPost{Id: %d, Author: %s, Content: %s, PublishingDate: %s, Title: %s}, got BlogPost{Id: %d, Author: %s, Content: %s, PublishingDate: %s, Title: %s}", tc.id, tc.author, tc.content, tc.publishDate, tc.title, post.Id, post.Author, post.Content, post.PublishingDate, post.Title)
+			t.Errorf("Expecting BlogPost{Id: %s, Author: %s, Content: %s, PublishingDate: %s, Title: %s}, got BlogPost{Id: %s, Author: %s, Content: %s, PublishingDate: %s, Title: %s}", tc.id, tc.author, tc.content, tc.publishDate, tc.title, post.Id, post.Author, post.Content, post.PublishingDate, post.Title)
 		}
 	}
 }
 
 func TestSortBlogPosts(t *testing.T) {
 	testCases := []struct {
 		startingList []*BlogPost
-		expected     []int
+		expected     []string
 	}{
-		{[]*BlogPost{NewBlogPost(1, "", "", "", ""), NewBlogPost(4, "", "", "", ""), NewBlogPost(2, "", "", "", ""), NewBlogPost(3, "", "", "", "")}, []int{4, 3, 2, 1}},
-		{[]*BlogPost{NewBlogPost(5, "", "", "", ""), NewBlogPost(3, "", "", "", ""), NewBlogPost(2, "", "", "", ""), NewBlogPost(1, "", "", "", "")}, []int{5, 3, 2, 1}},
-		{[]*BlogPost{NewBlogPost(5, "", "", "", ""), NewBlogPost(3, "", "", "", ""), NewBlogPost(1, "", "", "", ""), NewBlogPost(1, "", "", "", "")}, []int{5, 3, 1, 1}},
+		{[]*BlogPost{NewBlogPost("1", "", "", "", ""), NewBlogPost("4", "", "", "", ""), NewBlogPost("2", "", "", "", ""), NewBlogPost("3", "", "", "", "")}, []string{"4", "3", "2", "1"}},
+		{[]*BlogPost{NewBlogPost("5", "", "", "", ""), NewBlogPost("3", "", "", "", ""), NewBlogPost("2", "", "", "", ""), NewBlogPost("1", "", "", "", "")}, []string{"5", "3", "2", "1"}},
+		{[]*BlogPost{NewBlogPost("5", "", "", "", ""), NewBlogPost("3", "", "", "", ""), NewBlogPost("1", "", "", "", ""), NewBlogPost("1", "", "", "", "")}, []string{"5", "3", "1", "1"}},
 	}
 	for _, tc := range testCases {
 		blogs := SortBlogPosts(tc.startingList)
-		blogIds := make([]int, len(blogs))
+		blogIds := make([]string, len(blogs))
 		for i, blog := range blogs {
 			blogIds[i] = blog.Id
 		}

page_reader/page_reader.go

@@ -31,10 +31,7 @@ func AddStyleToHTML(content string) string {
 }
 
 func MarkdownToPost(filePath string) (*models.BlogPost, error) {
-	postId, errConv := strconv.Atoi(strings.ReplaceAll(path.Base(filePath), ".md", ""))
-	if errConv != nil {
-		return nil, errConv
-	}
+	postId := strings.ReplaceAll(path.Base(filePath), ".md", "")
 	var postTitle string
 	var postAuthor string
 	var postDate string

page_reader/page_reader_test.go

@@ -4,7 +4,6 @@ import (
 	"os"
 	"path"
 	"slices"
-	"strconv"
 	"strings"
 	"testing"
 
@@ -100,9 +99,9 @@ func TestMarkdownToPost(t *testing.T) {
 			t.Errorf("Expecting no error while processing %s, got %s", fl, err.Error())
 		}
 
-		postId, _ := strconv.Atoi(strings.ReplaceAll(path.Base(fl), ".md", ""))
+		postId := strings.ReplaceAll(path.Base(fl), ".md", "")
 		if blog.Id != postId {
-			t.Errorf("Expected blog.Id to be %d, got %d", postId, blog.Id)
+			t.Errorf("Expected blog.Id to be %s, got %s", postId, blog.Id)
 		}
 		if blog.Author != "Clelia Astra Bertelli" {
 			t.Errorf("Expected blog.Author to be 'Clelia Astra Bertelli', got '%s'", blog.Author)

templates/blog.templ

@@ -28,9 +28,9 @@ templ BlogPage(blogPosts []*models.BlogPost) {
                     <a href="/blog" class="font-comic text-3xl text-pink-600">Explore the blog</a>
                 </div>
                 <div>
-                    <form>
+                    <form hx-post="/search" hx-target="#blogList" hx-trigger="submit">
                         <input name="search" placeholder="Search Something" class="text-sans rounded-lg border border-gray-100 shadow-lg text-lg">
-                        <button class="bg-pink-600 text-white font-semibold font-sans w-[100px] py-3 px-6 rounded-lg shadow-xl">
+                        <button class="bg-pink-600 text-white font-semibold font-sans w-[100px] py-3 px-6 rounded-lg shadow-xl" type="submit">
                             🔍
                         </button>
                     </form>
@@ -45,7 +45,7 @@ templ BlogPage(blogPosts []*models.BlogPost) {
         <div class="h-full w-full bg-white/15 rounded-2xl backdrop-filter backdrop-blur-xl border border-white/20 shadow-xl flex flex-col p-5">
         <ul id="blogList">
             for _, post := range blogPosts {
-                <li class="text-gray-600 font-sans text-xl">• <a href={fmt.Sprintf("/blog/%d", post.Id)}><span class="text-pink-500 underline">{post.Title}</span></a> posted by <span class="font-semibold text-pink-400">{post.Author}</span> on {post.PublishingDate}</li>
+                <li class="text-gray-600 font-sans text-xl">• <a href={fmt.Sprintf("/blog/%s", post.Id)}><span class="text-pink-500 underline">{post.Title}</span></a> posted by <span class="font-semibold text-pink-400">{post.Author}</span> on {post.PublishingDate}</li>
             }
         </ul>
         </div>

templates/blog_templ.go

@@ -61,19 +61,21 @@ package textsearch
 // }
 
 import (
+	"errors"
+
 	"github.com/AstraBert/git-push-blog/models"
 	"github.com/blevesearch/bleve"
 )
 
-func CreateIndex(posts []*models.BlogPost) (bleve.Index, error) {
+func CreateIndex(posts []*models.BlogPost, path string) (bleve.Index, error) {
 	mapping := bleve.NewIndexMapping()
-	index, err := bleve.New("posts.bleve", mapping)
+	index, err := bleve.New(path, mapping)
 	if err != nil {
 		return nil, err
 	}
 	batch := index.NewBatch()
 	for _, post := range posts {
-		err := batch.Index(post.Title, post)
+		err := batch.Index(post.Id, post)
 		if err != nil {
 			continue
 		}
@@ -91,10 +93,48 @@ func SearchText(text string, index bleve.Index) (*bleve.SearchResult, error) {
 	query := bleve.NewQueryStringQuery(text)
 	req := bleve.NewSearchRequest(query)
 	req.Explain = false
-	req.Fields = []string{"title", "author", "content"}
+	req.Fields = []string{"title", "author", "publishing_date"}
 	searchResult, err := index.Search(req)
 	if err != nil {
 		return nil, err
 	}
 	return searchResult, nil
 }
+
+func ParseSearchResults(searchResults *bleve.SearchResult) ([]*models.BlogPost, error) {
+	var posts []*models.BlogPost
+
+	for _, hit := range searchResults.Hits {
+		post := &models.BlogPost{}
+
+		// Access fields directly from the hit
+		if title, ok := hit.Fields["title"].(string); ok {
+			post.Title = title
+		} else {
+			continue
+		}
+
+		if author, ok := hit.Fields["author"].(string); ok {
+			post.Author = author
+		} else {
+			continue
+		}
+
+		if publishingDate, ok := hit.Fields["publishing_date"].(string); ok {
+			post.PublishingDate = publishingDate
+		} else {
+			continue
+		}
+
+		// You can also get the document ID if you stored it
+		post.Id = hit.ID
+
+		posts = append(posts, post)
+	}
+
+	if len(posts) == 0 {
+		return nil, errors.New("no posts matched the search")
+	}
+
+	return posts, nil
+}