+24 -4

cmd/publication_commands.go

··· 214 214 isDraft, _ := cmd.Flags().GetBool("draft") 215 215 preview, _ := cmd.Flags().GetBool("preview") 216 216 validate, _ := cmd.Flags().GetBool("validate") 217 217 + output, _ := cmd.Flags().GetString("output") 218 218 + plaintext, _ := cmd.Flags().GetBool("plaintext") 219 219 + txt, _ := cmd.Flags().GetBool("txt") 220 220 + 221 221 + if txt { 222 222 + plaintext = true 223 223 + } 217 224 218 225 defer c.handler.Close() 219 226 220 227 if preview { 221 221 - return c.handler.PostPreview(cmd.Context(), noteID, isDraft) 228 228 + return c.handler.PostPreview(cmd.Context(), noteID, isDraft, output, plaintext) 222 229 } 223 230 224 231 if validate { 225 225 - return c.handler.PostValidate(cmd.Context(), noteID, isDraft) 232 232 + return c.handler.PostValidate(cmd.Context(), noteID, isDraft, output, plaintext) 226 233 } 227 234 228 235 return c.handler.Post(cmd.Context(), noteID, isDraft) ··· 231 238 postCmd.Flags().Bool("draft", false, "Create as draft instead of publishing") 232 239 postCmd.Flags().Bool("preview", false, "Show what would be posted without actually posting") 233 240 postCmd.Flags().Bool("validate", false, "Validate markdown conversion without posting") 241 241 + postCmd.Flags().StringP("output", "o", "", "Write document to file (defaults to JSON format)") 242 242 + postCmd.Flags().Bool("plaintext", false, "Use plaintext format for output file") 243 243 + postCmd.Flags().Bool("txt", false, "Alias for --plaintext") 234 244 root.AddCommand(postCmd) 235 245 236 246 patchCmd := &cobra.Command{ ··· 257 267 258 268 preview, _ := cmd.Flags().GetBool("preview") 259 269 validate, _ := cmd.Flags().GetBool("validate") 270 270 + output, _ := cmd.Flags().GetString("output") 271 271 + plaintext, _ := cmd.Flags().GetBool("plaintext") 272 272 + txt, _ := cmd.Flags().GetBool("txt") 273 273 + 274 274 + if txt { 275 275 + plaintext = true 276 276 + } 260 277 261 278 defer c.handler.Close() 262 279 263 280 if preview { 264 264 - return c.handler.PatchPreview(cmd.Context(), noteID) 281 281 + return c.handler.PatchPreview(cmd.Context(), noteID, output, plaintext) 265 282 } 266 283 267 284 if validate { 268 268 - return c.handler.PatchValidate(cmd.Context(), noteID) 285 285 + return c.handler.PatchValidate(cmd.Context(), noteID, output, plaintext) 269 286 } 270 287 271 288 return c.handler.Patch(cmd.Context(), noteID) ··· 273 290 } 274 291 patchCmd.Flags().Bool("preview", false, "Show what would be updated without actually patching") 275 292 patchCmd.Flags().Bool("validate", false, "Validate markdown conversion without patching") 293 293 + patchCmd.Flags().StringP("output", "o", "", "Write document to file (defaults to JSON format)") 294 294 + patchCmd.Flags().Bool("plaintext", false, "Use plaintext format for output file") 295 295 + patchCmd.Flags().Bool("txt", false, "Alias for --plaintext") 276 296 root.AddCommand(patchCmd) 277 297 278 298 pushCmd := &cobra.Command{

+99 -4

internal/handlers/publication.go

··· 3 3 4 4 import ( 5 5 "context" 6 6 + "encoding/json" 6 7 "fmt" 8 8 + "os" 7 9 "path/filepath" 8 10 "time" 9 11 ··· 549 551 return note, doc, nil 550 552 } 551 553 554 554 + // writeDocumentOutput writes document to a file in JSON or plaintext format 555 555 + func writeDocumentOutput(doc *public.Document, note *models.Note, outputPath string, plaintext bool) error { 556 556 + var content []byte 557 557 + var err error 558 558 + 559 559 + if plaintext { 560 560 + status := "published" 561 561 + if note != nil && note.IsDraft { 562 562 + status = "draft" 563 563 + } 564 564 + 565 565 + output := "Document Preview\n" 566 566 + output += "================\n\n" 567 567 + output += fmt.Sprintf("Title: %s\n", doc.Title) 568 568 + output += fmt.Sprintf("Status: %s\n", status) 569 569 + if note != nil { 570 570 + output += fmt.Sprintf("Note ID: %d\n", note.ID) 571 571 + if note.LeafletRKey != nil { 572 572 + output += fmt.Sprintf("RKey: %s\n", *note.LeafletRKey) 573 573 + } 574 574 + } 575 575 + output += fmt.Sprintf("Pages: %d\n", len(doc.Pages)) 576 576 + if len(doc.Pages) > 0 { 577 577 + output += fmt.Sprintf("Blocks: %d\n", len(doc.Pages[0].Blocks)) 578 578 + } 579 579 + if doc.PublishedAt != "" { 580 580 + output += fmt.Sprintf("PublishedAt: %s\n", doc.PublishedAt) 581 581 + } 582 582 + if doc.Author != "" { 583 583 + output += fmt.Sprintf("Author: %s\n", doc.Author) 584 584 + } 585 585 + 586 586 + content = []byte(output) 587 587 + } else { 588 588 + content, err = json.MarshalIndent(doc, "", " ") 589 589 + if err != nil { 590 590 + return fmt.Errorf("failed to marshal document to JSON: %w", err) 591 591 + } 592 592 + } 593 593 + 594 594 + if err := os.WriteFile(outputPath, content, 0644); err != nil { 595 595 + return fmt.Errorf("failed to write output to %s: %w", outputPath, err) 596 596 + } 597 597 + 598 598 + return nil 599 599 + } 600 600 + 552 601 // PostPreview shows what would be posted without actually posting 553 553 - func (h *PublicationHandler) PostPreview(ctx context.Context, noteID int64, isDraft bool) error { 602 602 + func (h *PublicationHandler) PostPreview(ctx context.Context, noteID int64, isDraft bool, outputPath string, plaintext bool) error { 554 603 if !h.atproto.IsAuthenticated() { 555 604 return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first") 556 605 } ··· 574 623 ui.Infoln(" PublishedAt: %s", doc.PublishedAt) 575 624 } 576 625 ui.Infoln(" Note ID: %d", note.ID) 626 626 + 627 627 + if outputPath != "" { 628 628 + if err := writeDocumentOutput(doc, note, outputPath, plaintext); err != nil { 629 629 + return err 630 630 + } 631 631 + format := "JSON" 632 632 + if plaintext { 633 633 + format = "plaintext" 634 634 + } 635 635 + ui.Successln("Output written to %s (%s format)", outputPath, format) 636 636 + } 637 637 + 577 638 ui.Successln("Preview complete - no changes made") 578 639 579 640 return nil 580 641 } 581 642 582 643 // PostValidate validates markdown conversion without posting 583 583 - func (h *PublicationHandler) PostValidate(ctx context.Context, noteID int64, isDraft bool) error { 644 644 + func (h *PublicationHandler) PostValidate(ctx context.Context, noteID int64, isDraft bool, outputPath string, plaintext bool) error { 584 645 if !h.atproto.IsAuthenticated() { 585 646 return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first") 586 647 } ··· 595 656 ui.Infoln(" Title: %s", doc.Title) 596 657 ui.Infoln(" Blocks converted: %d", len(doc.Pages[0].Blocks)) 597 658 659 659 + if outputPath != "" { 660 660 + if err := writeDocumentOutput(doc, note, outputPath, plaintext); err != nil { 661 661 + return err 662 662 + } 663 663 + format := "JSON" 664 664 + if plaintext { 665 665 + format = "plaintext" 666 666 + } 667 667 + ui.Successln("Output written to %s (%s format)", outputPath, format) 668 668 + } 669 669 + 598 670 return nil 599 671 } 600 672 601 673 // PatchPreview shows what would be patched without actually patching 602 602 - func (h *PublicationHandler) PatchPreview(ctx context.Context, noteID int64) error { 674 674 + func (h *PublicationHandler) PatchPreview(ctx context.Context, noteID int64, outputPath string, plaintext bool) error { 603 675 if !h.atproto.IsAuthenticated() { 604 676 return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first") 605 677 } ··· 628 700 if doc.PublishedAt != "" { 629 701 ui.Infoln(" PublishedAt: %s", doc.PublishedAt) 630 702 } 703 703 + 704 704 + if outputPath != "" { 705 705 + if err := writeDocumentOutput(doc, note, outputPath, plaintext); err != nil { 706 706 + return err 707 707 + } 708 708 + format := "JSON" 709 709 + if plaintext { 710 710 + format = "plaintext" 711 711 + } 712 712 + ui.Successln("Output written to %s (%s format)", outputPath, format) 713 713 + } 714 714 + 631 715 ui.Successln("Preview complete - no changes made") 632 716 633 717 return nil 634 718 } 635 719 636 720 // PatchValidate validates markdown conversion without patching 637 637 - func (h *PublicationHandler) PatchValidate(ctx context.Context, noteID int64) error { 721 721 + func (h *PublicationHandler) PatchValidate(ctx context.Context, noteID int64, outputPath string, plaintext bool) error { 638 722 if !h.atproto.IsAuthenticated() { 639 723 return fmt.Errorf("not authenticated - run 'noteleaf pub auth' first") 640 724 } ··· 654 738 ui.Infoln(" Title: %s", doc.Title) 655 739 ui.Infoln(" RKey: %s", *note.LeafletRKey) 656 740 ui.Infoln(" Blocks converted: %d", len(doc.Pages[0].Blocks)) 741 741 + 742 742 + if outputPath != "" { 743 743 + if err := writeDocumentOutput(doc, note, outputPath, plaintext); err != nil { 744 744 + return err 745 745 + } 746 746 + format := "JSON" 747 747 + if plaintext { 748 748 + format = "plaintext" 749 749 + } 750 750 + ui.Successln("Output written to %s (%s format)", outputPath, format) 751 751 + } 657 752 658 753 return nil 659 754 }

+13 -13

internal/handlers/publication_test.go

··· 1019 1019 handler := CreateHandler(t, NewPublicationHandler) 1020 1020 ctx := context.Background() 1021 1021 1022 1022 - err := handler.PostPreview(ctx, 1, false) 1022 1022 + err := handler.PostPreview(ctx, 1, false, "", false) 1023 1023 if err == nil { 1024 1024 t.Error("Expected error when not authenticated") 1025 1025 } ··· 1051 1051 t.Fatalf("Failed to restore session: %v", err) 1052 1052 } 1053 1053 1054 1054 - err = handler.PostPreview(ctx, 999, false) 1054 1054 + err = handler.PostPreview(ctx, 999, false, "", false) 1055 1055 if err == nil { 1056 1056 t.Error("Expected error when note does not exist") 1057 1057 } ··· 1095 1095 t.Fatalf("Failed to restore session: %v", err) 1096 1096 } 1097 1097 1098 1098 - err = handler.PostPreview(ctx, id, false) 1098 1098 + err = handler.PostPreview(ctx, id, false, "", false) 1099 1099 if err == nil { 1100 1100 t.Error("Expected error when note already published") 1101 1101 } ··· 1135 1135 t.Fatalf("Failed to restore session: %v", err) 1136 1136 } 1137 1137 1138 1138 - err = handler.PostPreview(ctx, id, false) 1138 1138 + err = handler.PostPreview(ctx, id, false, "", false) 1139 1139 suite.AssertNoError(err, "preview should succeed") 1140 1140 }) 1141 1141 ··· 1169 1169 t.Fatalf("Failed to restore session: %v", err) 1170 1170 } 1171 1171 1172 1172 - err = handler.PostPreview(ctx, id, true) 1172 1172 + err = handler.PostPreview(ctx, id, true, "", false) 1173 1173 suite.AssertNoError(err, "preview draft should succeed") 1174 1174 }) 1175 1175 }) ··· 1182 1182 handler := CreateHandler(t, NewPublicationHandler) 1183 1183 ctx := context.Background() 1184 1184 1185 1185 - err := handler.PostValidate(ctx, 1, false) 1185 1185 + err := handler.PostValidate(ctx, 1, false, "", false) 1186 1186 if err == nil { 1187 1187 t.Error("Expected error when not authenticated") 1188 1188 } ··· 1222 1222 t.Fatalf("Failed to restore session: %v", err) 1223 1223 } 1224 1224 1225 1225 - err = handler.PostValidate(ctx, id, false) 1225 1225 + err = handler.PostValidate(ctx, id, false, "", false) 1226 1226 suite.AssertNoError(err, "validation should succeed") 1227 1227 }) 1228 1228 }) ··· 1235 1235 handler := CreateHandler(t, NewPublicationHandler) 1236 1236 ctx := context.Background() 1237 1237 1238 1238 - err := handler.PatchPreview(ctx, 1) 1238 1238 + err := handler.PatchPreview(ctx, 1, "", false) 1239 1239 if err == nil { 1240 1240 t.Error("Expected error when not authenticated") 1241 1241 } ··· 1267 1267 t.Fatalf("Failed to restore session: %v", err) 1268 1268 } 1269 1269 1270 1270 - err = handler.PatchPreview(ctx, 999) 1270 1270 + err = handler.PatchPreview(ctx, 999, "", false) 1271 1271 if err == nil { 1272 1272 t.Error("Expected error when note does not exist") 1273 1273 } ··· 1307 1307 t.Fatalf("Failed to restore session: %v", err) 1308 1308 } 1309 1309 1310 1310 - err = handler.PatchPreview(ctx, id) 1310 1310 + err = handler.PatchPreview(ctx, id, "", false) 1311 1311 if err == nil { 1312 1312 t.Error("Expected error when note not published") 1313 1313 } ··· 1354 1354 t.Fatalf("Failed to restore session: %v", err) 1355 1355 } 1356 1356 1357 1357 - err = handler.PatchPreview(ctx, id) 1357 1357 + err = handler.PatchPreview(ctx, id, "", false) 1358 1358 suite.AssertNoError(err, "preview should succeed") 1359 1359 }) 1360 1360 }) ··· 1367 1367 handler := CreateHandler(t, NewPublicationHandler) 1368 1368 ctx := context.Background() 1369 1369 1370 1370 - err := handler.PatchValidate(ctx, 1) 1370 1370 + err := handler.PatchValidate(ctx, 1, "", false) 1371 1371 if err == nil { 1372 1372 t.Error("Expected error when not authenticated") 1373 1373 } ··· 1412 1412 t.Fatalf("Failed to restore session: %v", err) 1413 1413 } 1414 1414 1415 1415 - err = handler.PatchValidate(ctx, id) 1415 1415 + err = handler.PatchValidate(ctx, id, "", false) 1416 1416 suite.AssertNoError(err, "validation should succeed") 1417 1417 }) 1418 1418 })

+18 -11

internal/ui/publication_list_adapter.go

··· 170 170 return NewPublicationDataList(repo, opts, filter) 171 171 } 172 172 173 173 - // formatPublicationForView formats a publication for display with glamour 174 174 - func formatPublicationForView(note *models.Note) string { 173 173 + // buildPublicationMarkdown builds markdown content for a publication without rendering 174 174 + func buildPublicationMarkdown(note *models.Note) string { 175 175 var content strings.Builder 176 176 177 177 content.WriteString("# " + note.Title + "\n\n") ··· 180 180 if note.IsDraft { 181 181 status = "draft" 182 182 } 183 183 - content.WriteString("**Status:** " + status + "\n") 183 183 + content.WriteString("- **Status:** " + status + "\n") 184 184 185 185 if note.PublishedAt != nil { 186 186 - content.WriteString("**Published:** " + note.PublishedAt.Format("2006-01-02 15:04") + "\n") 186 186 + content.WriteString("- **Published:** " + note.PublishedAt.Format("2006-01-02 15:04") + "\n") 187 187 } 188 188 189 189 - content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n") 189 189 + content.WriteString("- **Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n") 190 190 191 191 if note.LeafletRKey != nil { 192 192 - content.WriteString("**RKey:** `" + *note.LeafletRKey + "`\n") 192 192 + content.WriteString("- **RKey:** `" + ObfuscateMiddle(*note.LeafletRKey, 3, 3) + "`\n") 193 193 } 194 194 195 195 if note.LeafletCID != nil { 196 196 - content.WriteString("**CID:** `" + *note.LeafletCID + "`\n") 196 196 + content.WriteString("- **CID:** `" + ObfuscateMiddle(*note.LeafletCID, 3, 3) + "`\n") 197 197 } 198 198 199 199 content.WriteString("\n---\n\n") ··· 208 208 } 209 209 } 210 210 211 211 + return content.String() 212 212 + } 213 213 + 214 214 + // formatPublicationForView formats a publication for display with glamour 215 215 + func formatPublicationForView(note *models.Note) string { 216 216 + markdown := buildPublicationMarkdown(note) 217 217 + 211 218 renderer, err := glamour.NewTermRenderer( 212 212 - glamour.WithAutoStyle(), 219 219 + glamour.WithStandardStyle("tokyo-night"), 213 220 glamour.WithWordWrap(80), 214 221 ) 215 222 if err != nil { 216 216 - return content.String() 223 223 + return markdown 217 224 } 218 225 219 219 - rendered, err := renderer.Render(content.String()) 226 226 + rendered, err := renderer.Render(markdown) 220 227 if err != nil { 221 221 - return content.String() 228 228 + return markdown 222 229 } 223 230 224 231 return rendered

+18 -24

internal/ui/publication_list_adapter_test.go

··· 493 493 } 494 494 }) 495 495 496 496 - t.Run("formatPublicationForView", func(t *testing.T) { 496 496 + t.Run("buildPublicationMarkdown", func(t *testing.T) { 497 497 t.Run("formats published note with all metadata", func(t *testing.T) { 498 498 rkey := "test-rkey" 499 499 cid := "test-cid" ··· 510 510 LeafletCID: &cid, 511 511 } 512 512 513 513 - result := formatPublicationForView(note) 513 513 + result := buildPublicationMarkdown(note) 514 514 515 515 if !strings.Contains(result, "Test Article") { 516 516 - t.Errorf("Formatted view should contain title\nGot: %s", result) 516 516 + t.Error("Markdown should contain title") 517 517 } 518 518 if !strings.Contains(result, "published") { 519 519 - t.Errorf("Formatted view should contain status 'published'\nGot: %s", result) 519 519 + t.Error("Markdown should contain status 'published'") 520 520 } 521 521 if !strings.Contains(result, "2024-01-15") { 522 522 - t.Errorf("Formatted view should contain published date\nGot: %s", result) 522 522 + t.Error("Markdown should contain published date") 523 523 } 524 524 - if !strings.Contains(result, "Modified") && !strings.Contains(result, "2024-01-16") { 525 525 - t.Errorf("Formatted view should contain modified date\nGot: %s", result) 526 526 - } 527 527 - if !strings.Contains(result, "test-rkey") { 528 528 - t.Error("Formatted view should contain rkey") 529 529 - } 530 530 - if !strings.Contains(result, "test-cid") { 531 531 - t.Error("Formatted view should contain cid") 524 524 + if !strings.Contains(result, "2024-01-16") { 525 525 + t.Error("Markdown should contain modified date") 532 526 } 533 527 }) 534 528 ··· 541 535 Modified: time.Date(2024, 1, 20, 14, 0, 0, 0, time.UTC), 542 536 } 543 537 544 544 - result := formatPublicationForView(note) 538 538 + result := buildPublicationMarkdown(note) 545 539 546 540 if !strings.Contains(result, "Draft Article") { 547 547 - t.Error("Formatted view should contain title") 541 541 + t.Error("Markdown should contain title") 548 542 } 549 543 if !strings.Contains(result, "draft") { 550 550 - t.Error("Formatted view should contain status 'draft'") 544 544 + t.Error("Markdown should contain status 'draft'") 551 545 } 552 546 if strings.Contains(result, "Published:") { 553 553 - t.Error("Formatted draft view should not contain published date") 547 547 + t.Error("Draft markdown should not contain published date") 554 548 } 555 549 if !strings.Contains(result, "2024-01-20 14:00") { 556 556 - t.Error("Formatted view should contain modified date") 550 550 + t.Error("Markdown should contain modified date") 557 551 } 558 552 }) 559 553 ··· 566 560 Modified: time.Now(), 567 561 } 568 562 569 569 - result := formatPublicationForView(note) 563 563 + result := buildPublicationMarkdown(note) 570 564 571 565 if !strings.Contains(result, "Plain Content") { 572 572 - t.Error("Formatted view should contain title") 566 566 + t.Error("Markdown should contain title") 573 567 } 574 568 if !strings.Contains(result, "This content has no markdown header") { 575 575 - t.Error("Formatted view should contain full content") 569 569 + t.Error("Markdown should contain full content") 576 570 } 577 571 }) 578 572 ··· 585 579 Modified: time.Now(), 586 580 } 587 581 588 588 - result := formatPublicationForView(note) 582 582 + result := buildPublicationMarkdown(note) 589 583 590 584 titleCount := strings.Count(result, "Article Title") 591 585 if titleCount < 1 { 592 592 - t.Error("Formatted view should contain title at least once") 586 586 + t.Error("Markdown should contain title at least once") 593 587 } 594 588 if !strings.Contains(result, "Content after title") { 595 595 - t.Error("Formatted view should contain content after title") 589 589 + t.Error("Markdown should contain content after title") 596 590 } 597 591 }) 598 592 })

+48 -43

internal/ui/publication_view.go

··· 5 5 "fmt" 6 6 "io" 7 7 "os" 8 8 - "strings" 8 8 + "unicode/utf8" 9 9 10 10 "github.com/charmbracelet/bubbles/help" 11 11 "github.com/charmbracelet/bubbles/key" ··· 173 173 return lipgloss.JoinVertical(lipgloss.Left, title, "", content, "", help) 174 174 } 175 175 176 176 - // buildPublicationMarkdown creates the markdown content for rendering 177 177 - func buildPublicationMarkdown(note *models.Note) string { 178 178 - var content strings.Builder 179 179 - 180 180 - content.WriteString("# " + note.Title + "\n\n") 181 181 - 182 182 - status := "published" 183 183 - if note.IsDraft { 184 184 - status = "draft" 185 185 - } 186 186 - content.WriteString("**Status:** " + status + "\n") 187 187 - 188 188 - if note.PublishedAt != nil { 189 189 - content.WriteString("**Published:** " + note.PublishedAt.Format("2006-01-02 15:04") + "\n") 190 190 - } 191 191 - 192 192 - content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n") 193 193 - 194 194 - if note.LeafletRKey != nil { 195 195 - content.WriteString("**RKey:** `" + *note.LeafletRKey + "`\n") 196 196 - } 197 197 - 198 198 - if note.LeafletCID != nil { 199 199 - content.WriteString("**CID:** `" + *note.LeafletCID + "`\n") 200 200 - } 201 201 - 202 202 - content.WriteString("\n---\n\n") 203 203 - 204 204 - noteContent := strings.TrimSpace(note.Content) 205 205 - if !strings.HasPrefix(noteContent, "# ") { 206 206 - content.WriteString(noteContent) 207 207 - } else { 208 208 - lines := strings.Split(noteContent, "\n") 209 209 - if len(lines) > 1 { 210 210 - content.WriteString(strings.Join(lines[1:], "\n")) 211 211 - } 212 212 - } 213 213 - 214 214 - return content.String() 215 215 - } 216 216 - 217 176 // formatPublicationContent renders markdown with glamour for viewport display 218 177 func formatPublicationContent(note *models.Note) (string, error) { 219 178 markdown := buildPublicationMarkdown(note) 220 179 221 180 renderer, err := glamour.NewTermRenderer( 222 181 glamour.WithAutoStyle(), 223 223 - glamour.WithWordWrap(80), 182 182 + glamour.WithStandardStyle("tokyo-night"), 183 183 + glamour.WithPreservedNewLines(), 184 184 + glamour.WithWordWrap(79), 224 185 ) 225 186 if err != nil { 226 187 return markdown, fmt.Errorf("failed to create renderer: %w", err) ··· 277 238 fmt.Fprint(pv.opts.Output, content) 278 239 return nil 279 240 } 241 241 + 242 242 + // ObfuscateMiddle returns a string where the middle portion is replaced by "..." 243 243 + // TODO: move to package utils or shared 244 244 + func ObfuscateMiddle(s string, left, right int) string { 245 245 + if s == "" { 246 246 + return s 247 247 + } 248 248 + if left < 0 { 249 249 + left = 0 250 250 + } 251 251 + if right < 0 { 252 252 + right = 0 253 253 + } 254 254 + 255 255 + n := utf8.RuneCountInString(s) 256 256 + if left+right >= n { 257 257 + return s 258 258 + } 259 259 + 260 260 + var ( 261 261 + prefixRunes = make([]rune, 0, left) 262 262 + suffixRunes = make([]rune, 0, right) 263 263 + ) 264 264 + i := 0 265 265 + for _, r := range s { 266 266 + if i >= left { 267 267 + break 268 268 + } 269 269 + prefixRunes = append(prefixRunes, r) 270 270 + i++ 271 271 + } 272 272 + 273 273 + if right > 0 { 274 274 + allRunes := []rune(s) 275 275 + start := max(n-right, 0) 276 276 + suffixRunes = append(suffixRunes, allRunes[start:]...) 277 277 + } 278 278 + 279 279 + const repl = "..." 280 280 + if right == 0 { 281 281 + return string(prefixRunes) + repl 282 282 + } 283 283 + return string(prefixRunes) + repl + string(suffixRunes) 284 284 + }

+11 -11

internal/ui/publication_view_test.go

··· 138 138 139 139 output := buf.String() 140 140 141 141 - if !strings.Contains(output, "Test Publication") { 141 141 + if !strings.Contains(output, "Test") || !strings.Contains(output, "Publication") { 142 142 t.Error("Note title not displayed") 143 143 } 144 144 if !strings.Contains(output, "published") { ··· 153 153 if !strings.Contains(output, "RKey:") { 154 154 t.Error("RKey not displayed") 155 155 } 156 156 - if !strings.Contains(output, "test-rkey-123") { 156 156 + if !strings.Contains(output, "tes") || !strings.Contains(output, "123") { 157 157 t.Error("RKey value not displayed") 158 158 } 159 159 if !strings.Contains(output, "CID:") { 160 160 t.Error("CID not displayed") 161 161 } 162 162 - if !strings.Contains(output, "test-cid-456") { 162 162 + if !strings.Contains(output, "tes") || !strings.Contains(output, "456") { 163 163 t.Error("CID value not displayed") 164 164 } 165 165 - if !strings.Contains(output, "This is the content") { 165 165 + if !strings.Contains(output, "This") || !strings.Contains(output, "content") { 166 166 t.Error("Note content not displayed") 167 167 } 168 168 }) ··· 213 213 214 214 output := buf.String() 215 215 216 216 - if !strings.Contains(output, "Minimal Note") { 216 216 + if !strings.Contains(output, "Minimal") || !strings.Contains(output, "Note") { 217 217 t.Error("Note title not displayed") 218 218 } 219 219 - if !strings.Contains(output, "Simple content") { 219 219 + if !strings.Contains(output, "Simple") || !strings.Contains(output, "content") { 220 220 t.Error("Note content not displayed") 221 221 } 222 222 if !strings.Contains(output, "Modified:") { ··· 235 235 "**Status:** published", 236 236 "**Published:**", 237 237 "**Modified:**", 238 238 - "**RKey:** `test-rkey-123`", 239 239 - "**CID:** `test-cid-456`", 238 238 + "**RKey:**", 239 239 + "**CID:**", 240 240 "---", 241 241 "This is the content", 242 242 } ··· 308 308 t.Fatalf("formatPublicationContent failed: %v", err) 309 309 } 310 310 311 311 - if !strings.Contains(content, "Test Publication") { 311 311 + if !strings.Contains(content, "Test") || !strings.Contains(content, "Publication") { 312 312 t.Error("Formatted content should include note title") 313 313 } 314 314 }) ··· 634 634 t.Error("No output generated") 635 635 } 636 636 637 637 - if !strings.Contains(output, note.Title) { 637 637 + if !strings.Contains(output, "Test") || !strings.Contains(output, "Publication") { 638 638 t.Error("Note title not displayed") 639 639 } 640 640 - if !strings.Contains(output, "This is the content") { 640 640 + if !strings.Contains(output, "This") || !strings.Contains(output, "content") { 641 641 t.Error("Note content not displayed") 642 642 } 643 643 })