├── .codespellignore ├── .github ├── ISSUE_TEMPLATE │ ├── bug_report.md │ ├── feature_request.md │ └── user-story.md └── workflows │ ├── dependabot.yml │ ├── go-coverage.yml │ ├── go.yml │ └── release.yml ├── .gitignore ├── .markdownlint.yaml ├── .pre-commit-config.yaml ├── .secrets.baseline ├── CHANGELOG.md ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE ├── Makefile ├── README.md ├── RELEASE_NOTES.md ├── assets └── gocard-logo.webp ├── cmd └── gocard │ └── main.go ├── docs └── PRD.md ├── examples ├── README.md ├── algorithms │ └── quicksort.md ├── concepts │ └── cap-theorem.md ├── gocard-features │ └── markdown-features.md ├── language-learning │ └── vocabulary │ │ └── spanish-greetings.md ├── math │ └── calculus-limits.md └── programming │ ├── go │ └── concurrency-patterns.md │ └── python │ └── decorators.md ├── go.mod ├── go.sum ├── internal ├── data │ ├── dummy_store.go │ ├── markdown_parser.go │ ├── markdown_parser_test.go │ ├── markdown_writer.go │ ├── markdown_writer_test.go │ └── store.go ├── model │ ├── card.go │ └── deck.go ├── srs │ └── algorithm.go └── ui │ ├── browse_decks.go │ ├── browse_decks_test.go │ ├── deck_review_tab.go │ ├── deck_review_tab_test.go │ ├── forecast_tab.go │ ├── forecast_tab_test.go │ ├── main_menu.go │ ├── main_menu_test.go │ ├── markdown_renderer.go │ ├── markdown_renderer_test.go │ ├── stats_screen.go │ ├── stats_screen_test.go │ ├── study_screen.go │ ├── study_screen_test.go │ ├── styles.go │ ├── summary_tab.go │ └── summary_tab_test.go ├── scripts ├── create_release.sh ├── generate_coverage_report.sh ├── package_coverage.sh └── visual_coverage_report.sh └── wireframes └── high-fidelity ├── .gitignore ├── 00-main-menu.svg ├── 01-deck-selection.svg ├── 02-01-study-session-answer-hidden.svg ├── 02-01-study-session-answer-revealed.svg ├── 03-01-stats-summary.svg ├── 03-02-stats-deck.svg ├── 03-03-stats-forcast.svg └── Makefile /.codespellignore: -------------------------------------------------------------------------------- 1 | Miserak 2 | ser 3 | Ser 4 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | ### Describe the bug 11 | 12 | A clear and concise description of what the bug is. 13 | 14 | ### To Reproduce 15 | 16 | Steps to reproduce the behavior: 17 | 18 | 1. Go to '...' 19 | 2. Click on '....' 20 | 3. Scroll down to '....' 21 | 4. See error 22 | 23 | ### Expected behavior 24 | 25 | A clear and concise description of what you expected to happen. 26 | 27 | ### Screenshots 28 | 29 | If applicable, add screenshots to help explain your problem. 30 | 31 | ### Desktop (please complete the following information) 32 | 33 | - OS: [e.g. iOS] 34 | - Browser [e.g. chrome, safari] 35 | - Version [e.g. 22] 36 | 37 | ### Smartphone (please complete the following information) 38 | 39 | - Device: [e.g. iPhone6] 40 | - OS: [e.g. iOS8.1] 41 | - Browser [e.g. stock browser, safari] 42 | - Version [e.g. 22] 43 | 44 | ### Additional context 45 | 46 | Add any other context about the problem here. 47 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Is your feature request related to a problem? Please describe.** 11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 12 | 13 | **Describe the solution you'd like** 14 | A clear and concise description of what you want to happen. 15 | 16 | **Describe alternatives you've considered** 17 | A clear and concise description of any alternative solutions or features you've considered. 18 | 19 | **Additional context** 20 | Add any other context or screenshots about the feature request here. 21 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/user-story.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: User Story 3 | about: This template is for creating user stories 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | ### User Story 11 | 12 | **As a** [role] 13 | **I need** [function] 14 | **So that** [benefit] 15 | 16 | ### Details and Assumptions 17 | 18 | + [document what you know] 19 | 20 | ### Acceptance Criteria 21 | 22 | ```gherkin 23 | Given [some context] 24 | When [certain action is taken] 25 | Then [the outcome of action is observed] 26 | ``` 27 | 28 | ### Implementation Notes 29 | 30 | + [Add any relevant items] 31 | 32 | ### Relates Issues 33 | 34 | + Issue [Issue No.]: Issue Title (how does this relate to this issue)? 35 | 36 | ### Priority 37 | 38 | [Low, Medium, High] - The reason for this priority level. 39 | -------------------------------------------------------------------------------- /.github/workflows/dependabot.yml: -------------------------------------------------------------------------------- 1 | name: Dependabot Auto-Merge 2 | on: 3 | pull_request: 4 | branches: 5 | - main 6 | - master 7 | 8 | jobs: 9 | dependabot: 10 | runs-on: ubuntu-latest 11 | if: ${{ github.actor == 'dependabot[bot]' }} 12 | steps: 13 | - name: Enable auto-merge for Dependabot PRs 14 | run: gh pr merge --auto --merge "$PR_URL" 15 | env: 16 | PR_URL: ${{github.event.pull_request.html_url}} 17 | GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}} 18 | -------------------------------------------------------------------------------- /.github/workflows/go-coverage.yml: -------------------------------------------------------------------------------- 1 | name: Go Coverage 2 | 3 | on: 4 | push: 5 | branches: [ main, master ] 6 | pull_request: 7 | branches: [ main, master ] 8 | 9 | jobs: 10 | coverage: 11 | name: Test Coverage 12 | runs-on: ubuntu-latest 13 | steps: 14 | - name: Set up Go 15 | uses: actions/setup-go@v4 16 | with: 17 | go-version: '1.24' 18 | check-latest: true 19 | 20 | - name: Check out code 21 | uses: actions/checkout@v4 22 | 23 | - name: Go Cache 24 | uses: actions/cache@v3 25 | with: 26 | path: | 27 | ~/.cache/go-build 28 | ~/go/pkg/mod 29 | key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} 30 | restore-keys: | 31 | ${{ runner.os }}-go- 32 | 33 | - name: Get dependencies 34 | run: go mod download 35 | 36 | - name: Run tests with coverage 37 | run: go test -coverprofile=coverage.out -covermode=atomic ./... 38 | 39 | - name: Convert coverage to lcov format 40 | run: | 41 | go install github.com/jandelgado/gcov2lcov@latest 42 | gcov2lcov -infile=coverage.out -outfile=coverage.lcov 43 | 44 | - name: Upload coverage to Codecov 45 | uses: codecov/codecov-action@v3 46 | with: 47 | files: ./coverage.lcov 48 | flags: unittests 49 | fail_ci_if_error: false 50 | 51 | - name: Generate Coverage Report 52 | run: go tool cover -func=coverage.out > coverage.txt 53 | 54 | - name: Check Coverage Threshold 55 | run: | 56 | COVERAGE=$(go tool cover -func=coverage.out | grep total | awk '{print $3}' | tr -d '%') 57 | echo "Total coverage: $COVERAGE%" 58 | if (( $(echo "$COVERAGE < 70" | bc -l) )); then 59 | echo "Coverage is below threshold of 70%" 60 | exit 0 # Don't fail the build yet, just report 61 | else 62 | echo "Coverage meets threshold of 70%" 63 | fi 64 | 65 | - name: Upload coverage report artifact 66 | uses: actions/upload-artifact@v4 67 | with: 68 | name: coverage-report 69 | path: | 70 | coverage.out 71 | coverage.txt 72 | coverage.lcov 73 | -------------------------------------------------------------------------------- /.github/workflows/go.yml: -------------------------------------------------------------------------------- 1 | name: Go 2 | 3 | on: 4 | push: 5 | branches: [ main, master ] 6 | pull_request: 7 | branches: [ main, master ] 8 | 9 | jobs: 10 | test: 11 | name: Test 12 | runs-on: ubuntu-latest 13 | steps: 14 | - name: Set up Go 15 | uses: actions/setup-go@v4 16 | with: 17 | go-version: '1.23' 18 | check-latest: true 19 | 20 | - name: Check out code 21 | uses: actions/checkout@v4 22 | 23 | - name: Go Cache 24 | uses: actions/cache@v3 25 | with: 26 | path: | 27 | ~/.cache/go-build 28 | ~/go/pkg/mod 29 | key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} 30 | restore-keys: | 31 | ${{ runner.os }}-go- 32 | 33 | - name: Get dependencies 34 | run: go mod download 35 | 36 | # Add to .github/workflows/go.yml 37 | - name: Run tests with coverage 38 | run: | 39 | go test -short -v -coverprofile=coverage.out ./... 40 | go tool cover -func=coverage.out 41 | 42 | # Optional: Add coverage threshold check 43 | COVERAGE=$(go tool cover -func=coverage.out | grep total | awk '{print $3}' | tr -d '%') 44 | if (( $(echo "$COVERAGE < 20" | bc -l) )); then 45 | echo "Test coverage is below 20%: $COVERAGE%" 46 | exit 1 47 | fi 48 | 49 | lint: 50 | name: Lint 51 | runs-on: ubuntu-latest 52 | steps: 53 | - name: Set up Go 54 | uses: actions/setup-go@v4 55 | with: 56 | go-version: '1.23' 57 | check-latest: true 58 | 59 | - name: Check out code 60 | uses: actions/checkout@v4 61 | 62 | - name: golangci-lint 63 | uses: golangci/golangci-lint-action@v3 64 | with: 65 | version: latest 66 | 67 | build: 68 | name: Build 69 | runs-on: ubuntu-latest 70 | needs: [test, lint] 71 | steps: 72 | - name: Set up Go 73 | uses: actions/setup-go@v4 74 | with: 75 | go-version: '1.23' 76 | check-latest: true 77 | 78 | - name: Check out code 79 | uses: actions/checkout@v4 80 | 81 | - name: Go Cache 82 | uses: actions/cache@v3 83 | with: 84 | path: | 85 | ~/.cache/go-build 86 | ~/go/pkg/mod 87 | key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} 88 | restore-keys: | 89 | ${{ runner.os }}-go- 90 | 91 | - name: Get dependencies 92 | run: go mod download 93 | 94 | - name: Build 95 | run: go build -v ./cmd/gocard 96 | 97 | # Cross-platform build job 98 | cross-build: 99 | name: Build ${{ matrix.os }} 100 | runs-on: ${{ matrix.os }} 101 | needs: [test] 102 | strategy: 103 | matrix: 104 | os: [ubuntu-latest, macos-latest, windows-latest] 105 | include: 106 | - os: ubuntu-latest 107 | artifact_name: GoCard 108 | asset_name: gocard-linux-amd64 109 | - os: macos-latest 110 | artifact_name: GoCard 111 | asset_name: gocard-macos-amd64 112 | - os: windows-latest 113 | artifact_name: GoCard.exe 114 | asset_name: gocard-windows-amd64.exe 115 | 116 | steps: 117 | - name: Set up Go 118 | uses: actions/setup-go@v4 119 | with: 120 | go-version: '1.23' 121 | check-latest: true 122 | 123 | - name: Check out code 124 | uses: actions/checkout@v4 125 | 126 | - name: Go Cache 127 | uses: actions/cache@v3 128 | with: 129 | path: | 130 | ~/.cache/go-build 131 | ~/go/pkg/mod 132 | key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} 133 | restore-keys: | 134 | ${{ runner.os }}-go- 135 | 136 | - name: Get dependencies 137 | run: go mod download 138 | 139 | - name: Build 140 | run: go build -v -o ${{ matrix.artifact_name }} ./cmd/gocard 141 | 142 | - name: Upload build artifact 143 | uses: actions/upload-artifact@v4 144 | with: 145 | name: ${{ matrix.asset_name }} 146 | path: ${{ matrix.artifact_name }} 147 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | name: Release 2 | 3 | on: 4 | push: 5 | tags: 6 | - 'v*' 7 | 8 | jobs: 9 | release: 10 | name: Create Release 11 | runs-on: ubuntu-latest 12 | permissions: 13 | contents: write 14 | outputs: 15 | upload_url: ${{ steps.create_release.outputs.upload_url }} 16 | steps: 17 | - name: Create Release 18 | id: create_release 19 | uses: actions/create-release@v1 20 | env: 21 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 22 | with: 23 | tag_name: ${{ github.ref }} 24 | release_name: Release ${{ github.ref }} 25 | draft: false 26 | prerelease: false 27 | 28 | build: 29 | name: Build Release Assets 30 | needs: release 31 | runs-on: ${{ matrix.os }} 32 | permissions: 33 | contents: write 34 | strategy: 35 | matrix: 36 | os: [ubuntu-latest, macos-latest, windows-latest] 37 | include: 38 | - os: ubuntu-latest 39 | artifact_name: GoCard 40 | asset_name: gocard-linux-amd64 41 | - os: macos-latest 42 | artifact_name: GoCard 43 | asset_name: gocard-macos-amd64 44 | - os: windows-latest 45 | artifact_name: GoCard.exe 46 | asset_name: gocard-windows-amd64.exe 47 | 48 | steps: 49 | - name: Set up Go 50 | uses: actions/setup-go@v4 51 | with: 52 | go-version: '1.24' 53 | check-latest: true 54 | 55 | - name: Check out code 56 | uses: actions/checkout@v4 57 | 58 | - name: Go Cache 59 | uses: actions/cache@v3 60 | with: 61 | path: | 62 | ~/.cache/go-build 63 | ~/go/pkg/mod 64 | key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} 65 | restore-keys: | 66 | ${{ runner.os }}-go- 67 | 68 | - name: Get dependencies 69 | run: go mod download 70 | 71 | - name: Build 72 | run: go build -v -ldflags="-X 'main.Version=$(echo ${{ github.ref_name }} | sed 's/^v//')'" -o ${{ matrix.artifact_name }} ./cmd/gocard 73 | 74 | - name: Upload Release Asset 75 | uses: actions/upload-release-asset@v1 76 | env: 77 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 78 | with: 79 | upload_url: ${{ needs.release.outputs.upload_url }} 80 | asset_path: ./${{ matrix.artifact_name }} 81 | asset_name: ${{ matrix.asset_name }} 82 | asset_content_type: application/octet-stream 83 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Go specific 2 | /GoCard 3 | *.exe 4 | *.exe~ 5 | *.dll 6 | *.so 7 | *.dylib 8 | *.test 9 | *.out 10 | go.work 11 | 12 | # Build/debug directories 13 | /bin/ 14 | /dist/ 15 | /debug/ 16 | /vendor/ 17 | /tmp/ 18 | 19 | # IDE and editor files (expanded) 20 | .vscode/* 21 | !.vscode/settings.json 22 | !.vscode/tasks.json 23 | !.vscode/launch.json 24 | !.vscode/extensions.json 25 | .idea/ 26 | *.swp 27 | *.swo 28 | *~ 29 | 30 | # OS specific files 31 | .DS_Store 32 | Thumbs.db 33 | 34 | # Log files 35 | *.log 36 | 37 | # Binary files 38 | gocard-*-amd64 39 | -------------------------------------------------------------------------------- /.markdownlint.yaml: -------------------------------------------------------------------------------- 1 | default: true 2 | MD013: false # Line length 3 | MD024: false # Multiple headers with the same content 4 | MD029: false # Ordered list item prefix 5 | MD033: false # Allow inline HTML for README.md 6 | MD034: false # Bare URL used 7 | MD041: false # First line in file should be a top level heading 8 | -------------------------------------------------------------------------------- /.pre-commit-config.yaml: -------------------------------------------------------------------------------- 1 | repos: 2 | # Check for conventional commit messages 3 | - repo: https://github.com/compilerla/conventional-pre-commit 4 | rev: v4.0.0 5 | hooks: 6 | - id: conventional-pre-commit 7 | stages: [commit-msg] 8 | args: [] 9 | 10 | # General file checks 11 | - repo: https://github.com/pre-commit/pre-commit-hooks 12 | rev: v5.0.0 13 | hooks: 14 | - id: trailing-whitespace 15 | - id: end-of-file-fixer 16 | - id: check-yaml 17 | - id: check-added-large-files 18 | args: ['--maxkb=500'] 19 | - id: mixed-line-ending 20 | args: ['--fix=lf'] 21 | - id: check-merge-conflict 22 | 23 | # Go specific checks 24 | - repo: https://github.com/dnephin/pre-commit-golang 25 | rev: v0.5.1 26 | hooks: 27 | - id: go-fmt 28 | files: ".*\\.go$" 29 | 30 | # Search for problematic terms in the text 31 | - repo: https://github.com/codespell-project/codespell 32 | rev: v2.4.1 33 | hooks: 34 | - id: codespell 35 | args: ['--ignore-words=.codespellignore'] 36 | files: '\.(md|go)$' # Added go files for checking 37 | exclude: examples/ 38 | 39 | # Optional: Lint Markdown files if you have any 40 | - repo: https://github.com/igorshubovych/markdownlint-cli 41 | rev: v0.44.0 42 | hooks: 43 | - id: markdownlint 44 | args: ["--config", ".markdownlint.yaml"] 45 | files: '\.(md)$' 46 | 47 | # Detect secrets 48 | - repo: https://github.com/Yelp/detect-secrets 49 | rev: v1.5.0 50 | hooks: 51 | - id: detect-secrets 52 | args: ['--baseline', '.secrets.baseline'] 53 | exclude: go\.(mod|sum)$ 54 | -------------------------------------------------------------------------------- /.secrets.baseline: -------------------------------------------------------------------------------- 1 | { 2 | "version": "1.5.0", 3 | "plugins_used": [ 4 | { 5 | "name": "ArtifactoryDetector" 6 | }, 7 | { 8 | "name": "AWSKeyDetector" 9 | }, 10 | { 11 | "name": "AzureStorageKeyDetector" 12 | }, 13 | { 14 | "name": "Base64HighEntropyString", 15 | "limit": 4.5 16 | }, 17 | { 18 | "name": "BasicAuthDetector" 19 | }, 20 | { 21 | "name": "CloudantDetector" 22 | }, 23 | { 24 | "name": "DiscordBotTokenDetector" 25 | }, 26 | { 27 | "name": "GitHubTokenDetector" 28 | }, 29 | { 30 | "name": "GitLabTokenDetector" 31 | }, 32 | { 33 | "name": "HexHighEntropyString", 34 | "limit": 3.0 35 | }, 36 | { 37 | "name": "IbmCloudIamDetector" 38 | }, 39 | { 40 | "name": "IbmCosHmacDetector" 41 | }, 42 | { 43 | "name": "IPPublicDetector" 44 | }, 45 | { 46 | "name": "JwtTokenDetector" 47 | }, 48 | { 49 | "name": "KeywordDetector", 50 | "keyword_exclude": "" 51 | }, 52 | { 53 | "name": "MailchimpDetector" 54 | }, 55 | { 56 | "name": "NpmDetector" 57 | }, 58 | { 59 | "name": "OpenAIDetector" 60 | }, 61 | { 62 | "name": "PrivateKeyDetector" 63 | }, 64 | { 65 | "name": "PypiTokenDetector" 66 | }, 67 | { 68 | "name": "SendGridDetector" 69 | }, 70 | { 71 | "name": "SlackDetector" 72 | }, 73 | { 74 | "name": "SoftlayerDetector" 75 | }, 76 | { 77 | "name": "SquareOAuthDetector" 78 | }, 79 | { 80 | "name": "StripeDetector" 81 | }, 82 | { 83 | "name": "TelegramBotTokenDetector" 84 | }, 85 | { 86 | "name": "TwilioKeyDetector" 87 | } 88 | ], 89 | "filters_used": [ 90 | { 91 | "path": "detect_secrets.filters.allowlist.is_line_allowlisted" 92 | }, 93 | { 94 | "path": "detect_secrets.filters.common.is_ignored_due_to_verification_policies", 95 | "min_level": 2 96 | }, 97 | { 98 | "path": "detect_secrets.filters.heuristic.is_indirect_reference" 99 | }, 100 | { 101 | "path": "detect_secrets.filters.heuristic.is_likely_id_string" 102 | }, 103 | { 104 | "path": "detect_secrets.filters.heuristic.is_lock_file" 105 | }, 106 | { 107 | "path": "detect_secrets.filters.heuristic.is_not_alphanumeric_string" 108 | }, 109 | { 110 | "path": "detect_secrets.filters.heuristic.is_potential_uuid" 111 | }, 112 | { 113 | "path": "detect_secrets.filters.heuristic.is_prefixed_with_dollar_sign" 114 | }, 115 | { 116 | "path": "detect_secrets.filters.heuristic.is_sequential_string" 117 | }, 118 | { 119 | "path": "detect_secrets.filters.heuristic.is_swagger_file" 120 | }, 121 | { 122 | "path": "detect_secrets.filters.heuristic.is_templated_secret" 123 | } 124 | ], 125 | "results": {}, 126 | "generated_at": "2025-03-21T13:40:24Z" 127 | } 128 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | 3 | All notable changes to GoCard will be documented in this file. 4 | 5 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 6 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). 7 | 8 | ## [0.3.0] - 2025-04-02 9 | 10 | ### Added 11 | 12 | - Terminal-based user interface with Bubble Tea 13 | - Support for multiple flashcard decks 14 | - Spaced repetition system based on SM-2 algorithm 15 | - Markdown rendering for questions and answers 16 | - Support for code syntax highlighting in cards 17 | - Statistics tracking and visualization 18 | - Import/export functionality using Markdown files 19 | - Cross-platform support (Linux, macOS, Windows) 20 | 21 | ### Technical 22 | 23 | - Implemented testing suite with coverage reporting 24 | - Set up GitHub Actions for CI/CD 25 | - Added pre-commit hooks for code quality 26 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | 2 | # Contributor Covenant Code of Conduct 3 | 4 | ## Our Pledge 5 | 6 | We as members, contributors, and leaders pledge to make participation in our 7 | community a harassment-free experience for everyone, regardless of age, body 8 | size, visible or invisible disability, ethnicity, sex characteristics, gender 9 | identity and expression, level of experience, education, socio-economic status, 10 | nationality, personal appearance, race, caste, color, religion, or sexual 11 | identity and orientation. 12 | 13 | We pledge to act and interact in ways that contribute to an open, welcoming, 14 | diverse, inclusive, and healthy community. 15 | 16 | ## Our Standards 17 | 18 | Examples of behavior that contributes to a positive environment for our 19 | community include: 20 | 21 | * Demonstrating empathy and kindness toward other people 22 | * Being respectful of differing opinions, viewpoints, and experiences 23 | * Giving and gracefully accepting constructive feedback 24 | * Accepting responsibility and apologizing to those affected by our mistakes, 25 | and learning from the experience 26 | * Focusing on what is best not just for us as individuals, but for the overall 27 | community 28 | 29 | Examples of unacceptable behavior include: 30 | 31 | * The use of sexualized language or imagery, and sexual attention or advances of 32 | any kind 33 | * Trolling, insulting or derogatory comments, and personal or political attacks 34 | * Public or private harassment 35 | * Publishing others' private information, such as a physical or email address, 36 | without their explicit permission 37 | * Other conduct which could reasonably be considered inappropriate in a 38 | professional setting 39 | 40 | ## Enforcement Responsibilities 41 | 42 | Community leaders are responsible for clarifying and enforcing our standards of 43 | acceptable behavior and will take appropriate and fair corrective action in 44 | response to any behavior that they deem inappropriate, threatening, offensive, 45 | or harmful. 46 | 47 | Community leaders have the right and responsibility to remove, edit, or reject 48 | comments, commits, code, wiki edits, issues, and other contributions that are 49 | not aligned to this Code of Conduct, and will communicate reasons for moderation 50 | decisions when appropriate. 51 | 52 | ## Scope 53 | 54 | This Code of Conduct applies within all community spaces, and also applies when 55 | an individual is officially representing the community in public spaces. 56 | Examples of representing our community include using an official email address, 57 | posting via an official social media account, or acting as an appointed 58 | representative at an online or offline event. 59 | 60 | ## Enforcement 61 | 62 | Instances of abusive, harassing, or otherwise unacceptable behavior may be 63 | reported to the community leaders responsible for enforcement at 64 | [david.miserak@gmail.com](mailto: david.miserak@gmail.com). 65 | All complaints will be reviewed and investigated promptly and fairly. 66 | 67 | All community leaders are obligated to respect the privacy and security of the 68 | reporter of any incident. 69 | 70 | ## Enforcement Guidelines 71 | 72 | Community leaders will follow these Community Impact Guidelines in determining 73 | the consequences for any action they deem in violation of this Code of Conduct: 74 | 75 | ### 1. Correction 76 | 77 | **Community Impact**: Use of inappropriate language or other behavior deemed 78 | unprofessional or unwelcome in the community. 79 | 80 | **Consequence**: A private, written warning from community leaders, providing 81 | clarity around the nature of the violation and an explanation of why the 82 | behavior was inappropriate. A public apology may be requested. 83 | 84 | ### 2. Warning 85 | 86 | **Community Impact**: A violation through a single incident or series of 87 | actions. 88 | 89 | **Consequence**: A warning with consequences for continued behavior. No 90 | interaction with the people involved, including unsolicited interaction with 91 | those enforcing the Code of Conduct, for a specified period of time. This 92 | includes avoiding interactions in community spaces as well as external channels 93 | like social media. Violating these terms may lead to a temporary or permanent 94 | ban. 95 | 96 | ### 3. Temporary Ban 97 | 98 | **Community Impact**: A serious violation of community standards, including 99 | sustained inappropriate behavior. 100 | 101 | **Consequence**: A temporary ban from any sort of interaction or public 102 | communication with the community for a specified period of time. No public or 103 | private interaction with the people involved, including unsolicited interaction 104 | with those enforcing the Code of Conduct, is allowed during this period. 105 | Violating these terms may lead to a permanent ban. 106 | 107 | ### 4. Permanent Ban 108 | 109 | **Community Impact**: Demonstrating a pattern of violation of community 110 | standards, including sustained inappropriate behavior, harassment of an 111 | individual, or aggression toward or disparagement of classes of individuals. 112 | 113 | **Consequence**: A permanent ban from any sort of public interaction within the 114 | community. 115 | 116 | ## Attribution 117 | 118 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], 119 | version 2.1, available at 120 | [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. 121 | 122 | Community Impact Guidelines were inspired by 123 | [Mozilla's code of conduct enforcement ladder][Mozilla CoC]. 124 | 125 | For answers to common questions about this code of conduct, see the FAQ at 126 | [https://www.contributor-covenant.org/faq][FAQ]. Translations are available at 127 | [https://www.contributor-covenant.org/translations][translations]. 128 | 129 | [homepage]: https://www.contributor-covenant.org 130 | [v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html 131 | [Mozilla CoC]: https://github.com/mozilla/diversity 132 | [FAQ]: https://www.contributor-covenant.org/faq 133 | [translations]: https://www.contributor-covenant.org/translations 134 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing to GoCard 2 | 3 | First off, thank you for considering contributing to GoCard! It's people like you that make GoCard such a great tool for learning and knowledge management. 4 | 5 | ## Code of Conduct 6 | 7 | This project and everyone participating in it are governed by our [Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. 8 | 9 | ## How Can I Contribute? 10 | 11 | ### Reporting Bugs 12 | 13 | 1. **Ensure the bug is not already reported** by searching existing GitHub issues. 14 | 2. If you can't find an existing issue, [open a new one](https://github.com/DavidMiserak/GoCard/issues/new?template=bug_report.md). 15 | 3. Include a clear title and description, as much relevant information as possible, and a code sample or an executable test case demonstrating the expected behavior that is not occurring. 16 | 17 | ### Suggesting Enhancements 18 | 19 | 1. Check the [issues list](https://github.com/DavidMiserak/GoCard/issues) to see if your suggestion is already there. 20 | 2. If not, [open a new feature request](https://github.com/DavidMiserak/GoCard/issues/new?template=feature_request.md). 21 | 3. Provide a clear and detailed explanation of the feature you want to see. 22 | 23 | ### Your First Code Contribution 24 | 25 | Unsure where to begin contributing? You can start by looking through these `good-first-issue` and `help-wanted` issues: 26 | 27 | - [Good First Issues](https://github.com/DavidMiserak/GoCard/labels/good%20first%20issue) - issues that should only require a few lines of code 28 | - [Help Wanted](https://github.com/DavidMiserak/GoCard/labels/help%20wanted) - issues that are more involved but not necessarily difficult 29 | 30 | ### Pull Requests 31 | 32 | 1. Fork the repository and create your branch from `main`. 33 | 2. If you've added code that should be tested, add tests. 34 | 3. If you've changed APIs, update the documentation. 35 | 4. Ensure the test suite passes. 36 | 5. Make sure your code lints. 37 | 6. Issue the pull request! 38 | 39 | #### Pull Request Process 40 | 41 | 1. Update the README.md or documentation with details of changes if applicable. 42 | 2. Increase version numbers in any examples files and the README.md to the new version that this Pull Request would represent. 43 | 3. You may merge the Pull Request once it has been reviewed and approved by a maintainer. 44 | 45 | ## Development Setup 46 | 47 | ### Prerequisites 48 | 49 | - Go 1.23 or later 50 | - Git 51 | - Pre-commit (optional but recommended) 52 | 53 | ### Setup Steps 54 | 55 | 1. Clone the repository 56 | 57 | ```bash 58 | git clone https://github.com/DavidMiserak/GoCard.git 59 | cd GoCard 60 | ``` 61 | 62 | 2. Install dependencies 63 | 64 | ```bash 65 | go mod download 66 | ``` 67 | 68 | 3. Install pre-commit hooks (recommended) 69 | 70 | ```bash 71 | make pre-commit-setup 72 | ``` 73 | 74 | ### Running Tests 75 | 76 | ```bash 77 | # Run all tests 78 | go test ./... 79 | 80 | # Run tests with coverage 81 | make test-cover 82 | 83 | # Run linters 84 | make lint 85 | ``` 86 | 87 | ## Coding Conventions 88 | 89 | ### Go Formatting 90 | 91 | - Use `gofmt` for formatting 92 | - Follow Go best practices and idioms 93 | - Keep functions small and focused 94 | - Add comments to explain complex logic 95 | 96 | ### Commit Messages 97 | 98 | We use [Conventional Commits](https://www.conventionalcommits.org/) format: 99 | 100 | - `feat:` A new feature 101 | - `fix:` A bug fix 102 | - `docs:` Documentation changes 103 | - `style:` Formatting, missing semicolons, etc. 104 | - `refactor:` Code refactoring 105 | - `test:` Adding or modifying tests 106 | - `chore:` Maintenance tasks 107 | 108 | Example: 109 | 110 | ```markdown 111 | feat: add import/export functionality for cards 112 | 113 | - Implement Anki package (.apkg) import 114 | - Add export to markdown feature 115 | - Update documentation with new features 116 | ``` 117 | 118 | ### Git Workflow 119 | 120 | 1. Create a feature branch: `git checkout -b feat/new-feature` 121 | 2. Make your changes 122 | 3. Run tests and linters 123 | 4. Commit with a conventional commit message 124 | 5. Push your branch 125 | 6. Open a pull request 126 | 127 | ## Reporting Security Issues 128 | 129 | Please do not create public GitHub issues for security vulnerabilities. 130 | Instead, send a detailed description to [david.miserak@gmail.com](mailto: david.miserak@gmail.com). 131 | 132 | ## Questions? 133 | 134 | If you have any questions, feel free to open an issue or reach out to the maintainers. 135 | 136 | **Happy Contributing!** 🚀📚 137 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2025 David Miserak 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # Filename: Makefile 2 | 3 | .PHONY: clean 4 | clean: 5 | rm -f GoCard gocard-linux-amd64 gocard-macos-amd64 gocard-windows-amd64.exe 6 | go clean 7 | 8 | .PHONY: pre-commit-setup 9 | pre-commit-setup: 10 | @echo "Setting up pre-commit hooks..." 11 | @echo "consider running to get the latest versions" 12 | pre-commit install 13 | pre-commit install --install-hooks 14 | pre-commit run --all-files 15 | 16 | GoCard: 17 | go fmt ./... 18 | CGO_ENABLED=0 go build -o GoCard ./cmd/gocard 19 | 20 | .PHONY: format 21 | format: 22 | go fmt ./... 23 | 24 | .PHONY: lint 25 | lint: 26 | golangci-lint run 27 | 28 | .PHONY: test 29 | test: 30 | go fmt ./... 31 | go test -timeout 3m -race ./... | tee test.log 32 | 33 | .PHONY: test-cover 34 | test-cover: 35 | go test -coverprofile=coverage.out ./... 36 | go tool cover -func=coverage.out | tee coverage.log 37 | 38 | .PHONY: test-cover-html 39 | test-cover-html: test-cover 40 | go tool cover -html=coverage.out -o coverage.html 41 | @echo "Coverage report generated: coverage.html" 42 | @echo "Open with: xdg-open coverage.html" 43 | 44 | .PHONY: test-cover-verbose 45 | test-cover-verbose: 46 | go test -v -covermode=count -coverprofile=coverage.out ./... 47 | go tool cover -func=coverage.out 48 | 49 | .PHONY: test-cover-report 50 | test-cover-report: 51 | @./scripts/generate_coverage_report.sh 52 | 53 | # Target for checking if coverage meets threshold (e.g., 70%) 54 | .PHONY: test-cover-check 55 | test-cover-check: 56 | @go test -coverprofile=coverage.out ./... 57 | @coverage=$$(go tool cover -func=coverage.out | grep total | awk '{print $$3}' | tr -d '%'); \ 58 | echo "Total coverage: $$coverage%"; \ 59 | if [ $$(echo "$$coverage < 70" | bc -l) -eq 1 ]; then \ 60 | echo "Coverage is below threshold of 70%"; \ 61 | exit 1; \ 62 | else \ 63 | echo "Coverage meets threshold of 70%"; \ 64 | fi 65 | 66 | .PHONY: build-all 67 | build-all: gocard-linux-amd64 gocard-macos-amd64 gocard-windows-amd64.exe 68 | 69 | gocard-linux-amd64: 70 | @echo "Building for Linux..." 71 | GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -v -o $@ ./cmd/gocard 72 | 73 | gocard-macos-amd64: 74 | @echo "Building for macOS..." 75 | GOOS=darwin GOARCH=amd64 CGO_ENABLED=0 go build -v -o $@ ./cmd/gocard 76 | 77 | gocard-windows-amd64.exe: 78 | @echo "Building for Windows..." 79 | GOOS=windows GOARCH=amd64 CGO_ENABLED=0 go build -v -o $@ ./cmd/gocard 80 | -------------------------------------------------------------------------------- /RELEASE_NOTES.md: -------------------------------------------------------------------------------- 1 | # GoCard v0.3.0 Release Notes 2 | 3 | We're excited to announce this release of GoCard, a terminal-based flashcard application designed for developers and learners who prefer to stay in the command line. 4 | 5 | ## Key Features 6 | 7 | ### Terminal-Based Flashcard System 8 | 9 | - Study flashcards directly in your terminal with a clean, intuitive interface 10 | - Navigate using keyboard shortcuts (with vim-like navigation options) 11 | - View beautiful markdown rendering with syntax highlighting for code examples 12 | 13 | ### Spaced Repetition Learning 14 | 15 | - Built on the SM-2 algorithm to optimize your learning and retention 16 | - Rate cards from 1-5 based on difficulty to customize your review schedule 17 | - Track progress with comprehensive statistics 18 | 19 | ### Developer-Friendly 20 | 21 | - Store flashcards as plain markdown files for easy version control 22 | - Import and export decks as markdown for sharing and backup 23 | - Support for code snippets with syntax highlighting 24 | 25 | ### Statistics and Tracking 26 | 27 | - View your learning progress with visual statistics 28 | - Track retention rates and study patterns 29 | - Forecast upcoming reviews 30 | 31 | ## Installation 32 | 33 | Download the appropriate binary for your platform from the releases page: 34 | 35 | - Linux: `gocard-linux-amd64` 36 | - macOS: `gocard-macos-amd64` 37 | - Windows: `gocard-windows-amd64.exe` 38 | 39 | Make the file executable 40 | 41 | - for Linux: 42 | 43 | ```bash 44 | chmod +x gocard-linux-amd64 45 | ``` 46 | 47 | - for macOS: 48 | 49 | ```bash 50 | chmod +x gocard-macos-amd64 51 | ``` 52 | 53 | - for Windows: 54 | 55 | ```powershell 56 | # No need to change permissions, just run the .exe file 57 | ``` 58 | -------------------------------------------------------------------------------- /assets/gocard-logo.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DavidMiserak/GoCard/2810cf5ad19eac0d0a15e0740915505595aab602/assets/gocard-logo.webp -------------------------------------------------------------------------------- /cmd/gocard/main.go: -------------------------------------------------------------------------------- 1 | // File: internal/main.go 2 | 3 | package main 4 | 5 | import ( 6 | "flag" 7 | "fmt" 8 | "os" 9 | "path/filepath" 10 | 11 | "github.com/DavidMiserak/GoCard/internal/data" 12 | "github.com/DavidMiserak/GoCard/internal/ui" 13 | tea "github.com/charmbracelet/bubbletea" 14 | ) 15 | 16 | func main() { 17 | // Parse command-line flags 18 | var deckDir string 19 | defaultDir := filepath.Join(os.Getenv("HOME"), "GoCard") 20 | flag.StringVar(&deckDir, "dir", defaultDir, "Directory containing flashcard decks") 21 | flag.Parse() 22 | 23 | // Resolve tilde in path if present 24 | if deckDir == "~/GoCard" || deckDir == "~/GoCard/" { 25 | deckDir = defaultDir 26 | } 27 | 28 | // Initialize the store 29 | var store *data.Store 30 | 31 | // Check if directory exists and load decks from it 32 | if _, err := os.Stat(deckDir); os.IsNotExist(err) { 33 | fmt.Printf("Warning: Directory '%s' does not exist. Using default decks.\n", deckDir) 34 | store = data.NewStore() // Use default store with dummy data 35 | } else { 36 | // Load decks from the specified directory 37 | var err error 38 | store, err = data.NewStoreFromDir(deckDir) 39 | if err != nil { 40 | fmt.Printf("Error loading decks: %v\nUsing default decks instead.\n", err) 41 | store = data.NewStore() // Fallback to default store with dummy data 42 | } 43 | } 44 | 45 | // Initialize the main menu with the store 46 | p := tea.NewProgram(ui.NewMainMenu(store), tea.WithAltScreen()) 47 | 48 | // Start the program 49 | if _, err := p.Run(); err != nil { 50 | fmt.Printf("Error running program: %v\n", err) 51 | os.Exit(1) 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /docs/PRD.md: -------------------------------------------------------------------------------- 1 | # GoCard: Product Requirements Document 2 | 3 | ## 1. Executive Summary 4 | 5 | GoCard is a lightweight, file-based spaced repetition system (SRS) 6 | built in Go. It addresses the needs of developers and technical users 7 | who prefer working with plain text files and version control systems 8 | for managing their knowledge. GoCard provides a distraction-free 9 | terminal interface that combines powerful learning algorithms with the 10 | simplicity of Markdown files. 11 | 12 | ## 2. Problem Statement 13 | 14 | Existing spaced repetition and flashcard applications typically store 15 | data in proprietary formats or databases, making it difficult to: 16 | 17 | - Version control flashcard content 18 | - Collaborate with others on knowledge bases 19 | - Back up content using standard tools 20 | - Edit content with preferred text editors 21 | - Maintain ownership of learning data 22 | 23 | Additionally, many applications include distracting elements that 24 | detract from the learning experience. 25 | 26 | ## 3. Goals and Objectives 27 | 28 | - Create a spaced repetition system that uses plain Markdown files as its primary data source 29 | - Implement an enhanced version of the SuperMemo-2 (SM-2) algorithm for optimal learning efficiency 30 | - Provide a clean, keyboard-driven terminal interface for distraction-free studying 31 | - Deliver comprehensive statistics to help users track their learning progress 32 | - Ensure cross-platform compatibility across Linux, MacOS, and Windows 33 | - Support rich Markdown rendering with syntax highlighting for code examples 34 | 35 | ## 4. Target Audience 36 | 37 | GoCard targets: 38 | 39 | - Software developers and technical professionals 40 | - Users who prefer terminal-based applications 41 | - People who want to maintain version control of their learning materials 42 | - Learners who value data portability and ownership 43 | - Users who appreciate minimalist, distraction-free interfaces 44 | 45 | ## 5. User Stories 46 | 47 | 1. As a developer, I want to store my flashcards as Markdown files so I can version control them with Git. 48 | 2. As a learner, I want the system to schedule my reviews optimally so I can maximize retention with minimal time investment. 49 | 3. As a user, I want a distraction-free interface so I can focus solely on learning. 50 | 4. As a programmer, I want proper syntax highlighting for code snippets so I can study programming concepts effectively. 51 | 5. As a power user, I want keyboard shortcuts for all actions so I can navigate efficiently. 52 | 6. As a student, I want comprehensive statistics so I can track my learning progress. 53 | 7. As a knowledge worker, I want to organize cards into decks so I can separate different subject areas. 54 | 55 | ## 6. Feature Requirements 56 | 57 | ### 6.1 Core Functionality 58 | 59 | #### File-Based Storage 60 | 61 | - **Must have:** Store all flashcards as Markdown files in standard directories 62 | - **Must have:** Support standard Markdown formatting in questions and answers 63 | - **Must have:** Include YAML front-matter for card metadata (tags, review dates, intervals) 64 | 65 | #### Spaced Repetition Algorithm 66 | 67 | - **Must have:** Implement an enhanced SM-2 algorithm 68 | - **Must have:** Support a five-point rating scale (1-Blackout to 5-Easy) 69 | - **Must have:** Dynamically adjust intervals based on performance 70 | - **Must have:** Track review history and success rates 71 | 72 | #### Card Organization 73 | 74 | - **Must have:** Support organization via directories (as decks) 75 | - **Must have:** Allow tagging of cards via front-matter 76 | - **Should have:** Support for filtering cards by tags 77 | 78 | ### 6.2 User Interface 79 | 80 | #### Terminal Interface 81 | 82 | - **Must have:** Clean, distraction-free TUI for focused learning 83 | - **Must have:** Full keyboard navigation 84 | - **Must have:** Rich Markdown rendering with syntax highlighting 85 | - **Must have:** Progress indicators for study sessions 86 | - **Must have:** Visual distinction between question and answer views 87 | 88 | #### Study Screen 89 | 90 | - **Must have:** Clear separation between question and answer 91 | - **Must have:** Rating buttons (1-5) for card difficulty 92 | - **Must have:** Card count and progress indicators 93 | - **Should have:** Scrolling support for long answers 94 | 95 | #### Statistics Views 96 | 97 | - **Must have:** Summary statistics (total cards, retention rate) 98 | - **Must have:** Deck-specific metrics 99 | - **Must have:** Review forecast visualization 100 | - **Must have:** Study history visualization 101 | 102 | ## 7. Technical Requirements 103 | 104 | ### 7.1 Performance 105 | 106 | - Application startup time under 1 second 107 | - Smooth performance with collections of 10,000+ cards 108 | - Responsive UI with no perceptible lag during interactions 109 | 110 | ### 7.2 Dependencies 111 | 112 | - Go programming language 113 | - Bubble Tea framework for terminal UI 114 | - Goldmark and Glamour for Markdown rendering 115 | - Lip Gloss for terminal styling 116 | - Chroma for code syntax highlighting 117 | 118 | ### 7.3 Cross-Platform Compatibility 119 | 120 | - Must work consistently on Linux, MacOS, and Windows 121 | - Must handle path differences between operating systems 122 | - Must work with various terminal emulators 123 | 124 | ## 8. User Interface Design 125 | 126 | ### 8.1 Navigation Structure 127 | 128 | 1. Main Menu 129 | 130 | - Study 131 | - Browse Decks 132 | - Statistics 133 | - Quit 134 | 135 | 2. Browse Decks Screen 136 | 137 | - List of decks with metadata (card count, due cards, last studied) 138 | - Pagination for large collections 139 | - Options to study selected deck 140 | 141 | 3. Study Screen 142 | 143 | - Question display 144 | - Answer reveal on key-press 145 | - Rating interface (1-5) 146 | - Progress indicator 147 | 148 | 4. Statistics Screen 149 | 150 | - Tab navigation between views: 151 | - Summary (overall statistics) 152 | - Deck Review (deck-specific metrics) 153 | - Review Forecast (upcoming reviews) 154 | 155 | ### 8.2 Keyboard Shortcuts 156 | 157 | - Space: Show answer 158 | - 1-5: Rate card difficulty 159 | - ↑/k: Move up/scroll up 160 | - ↓/j: Move down/scroll down 161 | - Enter: Select/confirm 162 | - Tab: Switch tab (in statistics) 163 | - b: Back to previous screen 164 | - q: Quit 165 | 166 | ## 9. Implementation Constraints 167 | 168 | - Terminal-based interface only (no GUI) 169 | - File system for data storage 170 | - Must work with standard terminal dimensions 171 | - Must handle Unicode characters correctly 172 | - Must preserve card formatting during reading/writing 173 | 174 | ## 10. Success Metrics 175 | 176 | - User retention and daily usage patterns 177 | - Average retention rate improvement over time 178 | - Speed of card review (cards per minute) 179 | - Growth in user flashcard collections 180 | - User feedback on terminal interface usability 181 | 182 | ## 11. Future Considerations 183 | 184 | - Synchronization between devices 185 | - Web interface for mobile access 186 | - Improved data visualization for statistics 187 | - Integration with external learning resources 188 | - Enhanced collaboration features 189 | - Audio support for language learning 190 | - Image support in cards 191 | -------------------------------------------------------------------------------- /examples/README.md: -------------------------------------------------------------------------------- 1 | # GoCard Examples 2 | 3 | This directory contains example flashcards demonstrating various features of GoCard. 4 | 5 | ## Directory Structure 6 | 7 | - **programming/** - Programming language specific cards 8 | - **go/** - Go programming language 9 | - **python/** - Python programming language 10 | - **algorithms/** - Algorithm concepts and implementations 11 | - **concepts/** - Computer science concepts 12 | - **math/** - Mathematical concepts 13 | - **language-learning/** - Natural language learning examples 14 | - **vocabulary/** - Vocabulary examples 15 | - **gocard-features/** - Cards showcasing GoCard features 16 | 17 | ## Using These Examples 18 | 19 | Copy these examples to your GoCard directory to try them out: 20 | 21 | ```bash 22 | cp -r examples/* ~/GoCard/ 23 | ``` 24 | 25 | Or point GoCard directly to this directory: 26 | 27 | ```bash 28 | gocard ./examples 29 | ``` 30 | 31 | ## Creating Your Own Cards 32 | 33 | Use these examples as templates for creating your own cards. Each card is a Markdown file with YAML frontmatter for metadata. 34 | 35 | Basic structure: 36 | 37 | ```markdown 38 | --- 39 | tags: tag1, tag2 40 | created: YYYY-MM-DD 41 | last_reviewed: YYYY-MM-DD 42 | review_interval: 0 43 | difficulty: 0 44 | --- 45 | 46 | # Card Title 47 | 48 | ## Question 49 | 50 | Your question goes here? 51 | 52 | ## Answer 53 | 54 | Your answer goes here. 55 | ``` 56 | -------------------------------------------------------------------------------- /examples/algorithms/quicksort.md: -------------------------------------------------------------------------------- 1 | --- 2 | tags: [algorithms,sorting,divide-and-conquer,complexity] 3 | created: 2025-03-22 4 | last_reviewed: 2025-03-22 5 | review_interval: 0 6 | difficulty: 0 7 | --- 8 | 9 | # Quicksort Algorithm 10 | 11 | ## Question 12 | 13 | Explain the quicksort algorithm, including its time complexity, space complexity, and when it performs well or poorly. 14 | 15 | ## Answer 16 | 17 | Quicksort is a divide-and-conquer sorting algorithm that works by selecting a 'pivot' element and partitioning the array around it. 18 | 19 | ### Algorithm Steps 20 | 21 | 1. Choose a pivot element from the array 22 | 2. Partition the array around the pivot (elements < pivot go left, elements > pivot go right) 23 | 3. Recursively apply the above steps to the sub-arrays 24 | 25 | ### Implementation 26 | 27 | ```python 28 | def quicksort(arr, low=0, high=None): 29 | if high is None: 30 | high = len(arr) - 1 31 | 32 | if low < high: 33 | # Partition the array and get pivot position 34 | pivot_index = partition(arr, low, high) 35 | 36 | # Recursively sort the sub-arrays 37 | quicksort(arr, low, pivot_index - 1) 38 | quicksort(arr, pivot_index + 1, high) 39 | 40 | return arr 41 | 42 | def partition(arr, low, high): 43 | # Choose rightmost element as pivot 44 | pivot = arr[high] 45 | 46 | # Index of smaller element 47 | i = low - 1 48 | 49 | for j in range(low, high): 50 | # If current element is smaller than the pivot 51 | if arr[j] <= pivot: 52 | # Increment index of smaller element 53 | i += 1 54 | arr[i], arr[j] = arr[j], arr[i] 55 | 56 | # Place pivot in its correct position 57 | arr[i + 1], arr[high] = arr[high], arr[i + 1] 58 | return i + 1 59 | ``` 60 | 61 | ### Time Complexity 62 | 63 | - **Best case**: O(n log n) - When the pivot divides the array into roughly equal halves 64 | - **Average case**: O(n log n) 65 | - **Worst case**: O(n²) - When the smallest or largest element is always chosen as pivot (e.g., already sorted array) 66 | 67 | ### Space Complexity 68 | 69 | - O(log n) for the recursion stack in average case 70 | - O(n) in worst case 71 | 72 | ### Performance Characteristics 73 | 74 | #### When Quicksort Performs Well 75 | 76 | - Random or evenly distributed data 77 | - Cache efficiency (good locality of reference) 78 | - When implemented with optimizations like: 79 | 80 | - Random pivot selection 81 | - Median-of-three pivot selection 82 | - Switching to insertion sort for small subarrays 83 | 84 | #### When Quicksort Performs Poorly 85 | 86 | - Already sorted or nearly sorted arrays 87 | - Arrays with many duplicate elements 88 | - When the pivot selection consistently produces unbalanced partitions 89 | 90 | ### Key Advantages 91 | 92 | - In-place sorting (requires small additional space) 93 | - Cache-friendly 94 | - Typically faster than other O(n log n) algorithms like mergesort in practice 95 | - Easy to implement and optimize 96 | 97 | ### Key Disadvantages 98 | 99 | - Not stable (equal elements may change relative order) 100 | - Worst-case performance is O(n²) 101 | - Recursive, so can cause stack overflow for very large arrays 102 | -------------------------------------------------------------------------------- /examples/concepts/cap-theorem.md: -------------------------------------------------------------------------------- 1 | --- 2 | tags: [distributed-systems,cap-theorem,consistency,availability,partition-tolerance] 3 | created: 2025-03-22 4 | last_reviewed: 2025-03-22 5 | review_interval: 0 6 | difficulty: 0 7 | --- 8 | 9 | # CAP Theorem 10 | 11 | ## Question 12 | 13 | What is the CAP theorem, and how does it influence distributed system design? Give examples of systems making different CAP tradeoffs. 14 | 15 | ## Answer 16 | 17 | The CAP theorem (also known as Brewer's theorem) states that a distributed data store cannot simultaneously provide more than two out of the following three guarantees: 18 | 19 | ### The Three Guarantees 20 | 21 | 1. **Consistency (C)**: Every read receives the most recent write or an error 22 | 2. **Availability (A)**: Every request receives a non-error response, without guarantee that it contains the most recent write 23 | 3. **Partition Tolerance (P)**: The system continues to operate despite network partitions (nodes cannot communicate) 24 | 25 | ### Key Insight 26 | 27 | In a distributed system, network partitions are inevitable, so you must choose between consistency and availability when a partition occurs: 28 | 29 | - **CP systems**: Prioritize consistency over availability during partitions 30 | - **AP systems**: Prioritize availability over consistency during partitions 31 | - **CA systems**: Cannot exist in real-world distributed systems (as partitions are unavoidable) 32 | 33 | ### Real-World System Examples 34 | 35 | | Type | Examples | Characteristics | 36 | |------|----------|-----------------| 37 | | **CP** | - Google's Spanner
- HBase
- Apache ZooKeeper
- etcd | - Strong consistency
- May become unavailable during partitions
- Often use consensus protocols like Paxos/Raft | 38 | | **AP** | - Amazon Dynamo
- Cassandra
- CouchDB
- Riak | - High availability
- Eventually consistent
- Often use techniques like vector clocks, gossip protocols | 39 | | **CA** | - Single-node relational databases
- (Not truly distributed) | - Cannot tolerate partitions
- Useful comparison benchmark | 40 | 41 | ### Design Implications 42 | 43 | 1. **When to Choose CP**: 44 | - Financial systems requiring strong consistency 45 | - Systems where incorrect data is worse than no data 46 | - Configuration management, leader election, service discovery 47 | 48 | 2. **When to Choose AP**: 49 | - High-traffic web applications 50 | - Real-time analytics 51 | - Systems where stale data is acceptable 52 | - Content delivery networks 53 | 54 | 3. **Strategies to Mitigate Tradeoffs**: 55 | - PACELC theorem extension: When there's no partition, choose between latency and consistency 56 | - Tunable consistency levels (e.g., Cassandra's quorum reads) 57 | - CRDT (Conflict-free Replicated Data Types) 58 | - Event sourcing and Command Query Responsibility Segregation (CQRS) 59 | -------------------------------------------------------------------------------- /examples/gocard-features/markdown-features.md: -------------------------------------------------------------------------------- 1 | --- 2 | tags: [gocard,features,markdown,syntax-highlighting,tables] 3 | created: 2025-03-22 4 | last_reviewed: 2025-03-22 5 | review_interval: 0 6 | difficulty: 0 7 | --- 8 | 9 | # GoCard Markdown Features Demo 10 | 11 | ## Question 12 | 13 | What Markdown features does GoCard support and how can they be used effectively in flashcards? 14 | 15 | ## Answer 16 | 17 | GoCard supports a wide range of Markdown features, making it powerful for creating rich flashcards. Here's a comprehensive demonstration: 18 | 19 | ### Text Formatting 20 | 21 | **Bold text** is created with `**double asterisks**` 22 | 23 | *Italic text* is created with `*single asterisks*` 24 | 25 | ***Bold and italic*** text is created with `***triple asterisks***` 26 | 27 | ~~Strikethrough~~ is created with `~~double tildes~~` 28 | 29 | ### Lists 30 | 31 | Unordered lists: 32 | 33 | - Item 1 34 | - Item 2 35 | - Nested item 36 | - Another nested item 37 | - Item 3 38 | 39 | Ordered lists: 40 | 41 | 1. First item 42 | 2. Second item 43 | 3. Third item 44 | 1. Nested ordered item 45 | 2. Another nested item 46 | 47 | ### Code Blocks with Syntax Highlighting 48 | 49 | JavaScript example: 50 | 51 | ```javascript 52 | function calculateFactorial(n) { 53 | if (n === 0 || n === 1) { 54 | return 1; 55 | } 56 | return n * calculateFactorial(n - 1); 57 | } 58 | 59 | // Calculate and display factorial of 5 60 | console.log(calculateFactorial(5)); // Output: 120 61 | ``` 62 | 63 | SQL example: 64 | 65 | ```sql 66 | SELECT 67 | users.name, 68 | COUNT(orders.id) AS order_count, 69 | SUM(orders.amount) AS total_spent 70 | FROM users 71 | JOIN orders ON users.id = orders.user_id 72 | WHERE orders.created_at > DATE_SUB(NOW(), INTERVAL 1 YEAR) 73 | GROUP BY users.id 74 | HAVING total_spent > 1000 75 | ORDER BY total_spent DESC 76 | LIMIT 10; 77 | ``` 78 | 79 | Inline code: `const x = 42;` 80 | 81 | ### Tables 82 | 83 | | Feature | Markdown Syntax | Notes | 84 | |---------|-----------------|-------| 85 | | Headers | `# H1`, `## H2` | Up to 6 levels | 86 | | Bold | `**text**` | For emphasis | 87 | | Tables | `\| col1 \| col2 \|` | Requires header row | 88 | | Code | \`\`\`language | Specify language for highlighting | 89 | 90 | ### Blockquotes 91 | 92 | > This is a blockquote. 93 | > 94 | > It can span multiple lines. 95 | > 96 | > > And it can be nested. 97 | 98 | ### Links and Images 99 | 100 | [Link to GoCard Repository](https://github.com/DavidMiserak/GoCard) 101 | 102 | ![GoCard Logo](assets/gocard-logo.webp) 103 | 104 | ### Task Lists 105 | 106 | - [x] Implemented core features 107 | - [x] Added markdown support 108 | - [ ] Complete all example cards 109 | - [ ] Release v1.0 110 | 111 | ### Horizontal Rules 112 | 113 | --- 114 | 115 | ### Mathematical Notation 116 | 117 | Inline math: $E = mc^2$ 118 | 119 | Block math: 120 | $$ 121 | \frac{d}{dx}(e^x) = e^x 122 | $$ 123 | 124 | $$ 125 | \int_{a}^{b} f(x) \, dx = F(b) - F(a) 126 | $$ 127 | 128 | ### Tips for Effective Flashcards 129 | 130 | 1. **Keep questions focused** on one concept 131 | 2. **Use formatting** to emphasize key points 132 | 3. **Include code examples** where relevant 133 | 4. **Use tables** to organize related information 134 | 5. **Add visual elements** when they help understanding 135 | 6. **Structure answers** with clear headings and sections 136 | -------------------------------------------------------------------------------- /examples/language-learning/vocabulary/spanish-greetings.md: -------------------------------------------------------------------------------- 1 | --- 2 | tags: [spanish,vocabulary,language-learning,greetings] 3 | created: 2025-03-22 4 | last_reviewed: 2025-03-22 5 | review_interval: 0 6 | difficulty: 0 7 | --- 8 | 9 | # Spanish Greetings and Introductions 10 | 11 | ## Question 12 | 13 | What are the common Spanish greetings and introductions, and when should you use each one? 14 | 15 | ## Answer 16 | 17 | ### Formal Greetings 18 | 19 | | Spanish | English | Usage | 20 | |---------|---------|-------| 21 | | Buenos días | Good morning | Used until noon | 22 | | Buenas tardes | Good afternoon | Used from noon until sunset | 23 | | Buenas noches | Good evening/night | Used after sunset | 24 | | Hola, mucho gusto | Hello, nice to meet you | Formal introduction | 25 | | ¿Cómo está usted? | How are you? | Formal "you" form | 26 | | Encantado/a de conocerle | Pleased to meet you | Formal introduction (masculine/feminine forms) | 27 | 28 | ### Informal Greetings 29 | 30 | | Spanish | English | Usage | 31 | |---------|---------|-------| 32 | | ¡Hola! | Hello! | Universal informal greeting | 33 | | ¿Qué tal? | How's it going? | Casual greeting | 34 | | ¿Cómo estás? | How are you? | Informal "you" form | 35 | | ¿Qué pasa? | What's happening? | Very casual, among friends | 36 | | ¿Qué onda? | What's up? | Slang, used in Latin America | 37 | | ¡Buenas! | Hi there! | Shortened form of formal greetings, slightly informal | 38 | 39 | ### Regional Variations 40 | 41 | - **Spain**: "Hola, ¿qué tal?" is very common 42 | - **Mexico**: "¿Qué onda?" or "¿Qué hubo?" (What's up?) 43 | - **Argentina**: "¡Che, boludo!" (among close male friends) or "¿Cómo andás?" (How are you doing?) 44 | - **Colombia**: "¿Quiubo?" (Contraction of "¿Qué hubo?") or "¿Cómo vas?" 45 | - **Caribbean**: "¿Dimelo?" (Tell me) in Dominican Republic 46 | 47 | ### Introductions 48 | 49 | **Introducing yourself:** 50 | 51 | - "Me llamo..." (My name is...) 52 | - "Soy..." (I am...) 53 | 54 | **Asking someone's name:** 55 | 56 | - "¿Cómo te llamas?" (informal) 57 | - "¿Cómo se llama usted?" (formal) 58 | 59 | **Saying where you're from:** 60 | 61 | - "Soy de..." (I'm from...) 62 | - "Vengo de..." (I come from...) 63 | 64 | ### Time-based Considerations 65 | 66 | In Spanish-speaking countries, greetings often follow the time of day more strictly than in English: 67 | 68 | - Use "Buenos días" typically until 12:00 PM 69 | - Switch to "Buenas tardes" from around 12:00 PM until sunset (6-8 PM) 70 | - Use "Buenas noches" after sunset both as a greeting and when saying goodbye 71 | 72 | ### Cultural Note 73 | 74 | Physical greetings vary by country: 75 | 76 | - One kiss on the cheek is common in many countries (between women or a man and woman) 77 | - Two kisses (one on each cheek) in Spain 78 | - Handshakes in more formal settings 79 | - Hugs (abrazos) between close friends 80 | -------------------------------------------------------------------------------- /examples/math/calculus-limits.md: -------------------------------------------------------------------------------- 1 | --- 2 | tags: [math,calculus,limits,basic-concepts] 3 | created: 2025-03-22 4 | last_reviewed: 2025-03-22 5 | review_interval: 0 6 | difficulty: 0 7 | --- 8 | 9 | # Limits in Calculus 10 | 11 | ## Question 12 | 13 | What is a limit in calculus? Explain the formal (ε-δ) definition and provide examples of evaluating limits, including cases where direct substitution doesn't work. 14 | 15 | ## Answer 16 | 17 | A limit describes the value a function approaches as the input approaches a particular value. 18 | 19 | ### Informal Definition 20 | 21 | For a function f(x), the limit of f(x) as x approaches a value c is written as: 22 | 23 | $$\lim_{x \to c} f(x) = L$$ 24 | 25 | This means that as x gets arbitrarily close to c (but not necessarily equal to c), the function value f(x) gets arbitrarily close to L. 26 | 27 | ### Formal (ε-δ) Definition 28 | 29 | $$\lim_{x \to c} f(x) = L \text{ if and only if for every } \varepsilon > 0 \text{ there exists a } \delta > 0 \text{ such that if } 0 < |x - c| < \delta \text{ then } |f(x) - L| < \varepsilon$$ 30 | 31 | In plain language: We can make f(x) as close as we want to L by making x sufficiently close to c. 32 | 33 | ### Evaluating Limits 34 | 35 | #### Method 1: Direct Substitution 36 | 37 | If f(x) is continuous at x = c, then: 38 | 39 | $$\lim_{x \to c} f(x) = f(c)$$ 40 | 41 | **Example**: 42 | 43 | $$\lim_{x \to 2} (x^2 + 3x) = 2^2 + 3(2) = 4 + 6 = 10$$ 44 | 45 | #### Method 2: Algebraic Manipulation 46 | 47 | When direct substitution gives an indeterminate form (like 0/0), algebraic manipulation can help. 48 | 49 | **Example**: 50 | 51 | $$\lim_{x \to 3} \frac{x^2 - 9}{x - 3}$$ 52 | 53 | Direct substitution gives $\frac{0}{0}$ (indeterminate), so we factor: 54 | $$\lim_{x \to 3} \frac{(x - 3)(x + 3)}{x - 3} = \lim_{x \to 3} (x + 3) = 6$$ 55 | 56 | #### Method 3: L'Hôpital's Rule 57 | 58 | For indeterminate forms like $\frac{0}{0}$ or $\frac{\infty}{\infty}$: 59 | $$\lim_{x \to c} \frac{f(x)}{g(x)} = \lim_{x \to c} \frac{f'(x)}{g'(x)}$$ 60 | 61 | **Example**: 62 | 63 | $$\lim_{x \to 0} \frac{\sin(x)}{x} = \lim_{x \to 0} \frac{\cos(x)}{1} = 1$$ 64 | 65 | #### Method 4: Special Limit Results 66 | 67 | **Example**: Squeeze Theorem 68 | 69 | If g(x) ≤ f(x) ≤ h(x) near x = c, and $\lim_{x \to c} g(x) = \lim_{x \to c} h(x) = L$, then $\lim_{x \to c} f(x) = L$ 70 | 71 | ### Common Indeterminate Forms 72 | 73 | - $\frac{0}{0}$ - Use factoring or L'Hôpital's rule 74 | - $\frac{\infty}{\infty}$ - Use algebraic manipulation or L'Hôpital's rule 75 | - $0 \cdot \infty$ - Rewrite as $\frac{0}{1/\infty}$ or $\frac{\infty}{1/0}$ 76 | - $\infty - \infty$ - Find a common denominator or use algebraic manipulation 77 | - $0^0$, $1^{\infty}$, $\infty^0$ - Use logarithms or exponential properties 78 | 79 | ### One-sided Limits 80 | 81 | - Left-hand limit: $\lim_{x \to c^-} f(x)$ (x approaches c from values less than c) 82 | - Right-hand limit: $\lim_{x \to c^+} f(x)$ (x approaches c from values greater than c) 83 | - A limit exists if and only if both one-sided limits exist and are equal 84 | -------------------------------------------------------------------------------- /examples/programming/go/concurrency-patterns.md: -------------------------------------------------------------------------------- 1 | --- 2 | tags: [go,concurrency,channels,programming] 3 | created: 2025-03-22 4 | last_reviewed: 2025-03-22 5 | review_interval: 0 6 | difficulty: 0 7 | --- 8 | 9 | # Go Concurrency Patterns 10 | 11 | ## Question 12 | 13 | What is the fan-out fan-in concurrency pattern in Go and when should you use it? 14 | 15 | ## Answer 16 | 17 | The fan-out fan-in pattern is a concurrency pattern in Go where: 18 | 19 | 1. **Fan-out**: Start multiple goroutines to handle input from a single source (distributing work) 20 | 2. **Fan-in**: Combine multiple results from those goroutines into a single channel 21 | 22 | ### Implementation 23 | 24 | ```go 25 | func fanOut(input <-chan int, n int) []<-chan int { 26 | // Create n output channels 27 | outputs := make([]<-chan int, n) 28 | 29 | for i := 0; i < n; i++ { 30 | outputs[i] = worker(input) 31 | } 32 | 33 | return outputs 34 | } 35 | 36 | func worker(input <-chan int) <-chan int { 37 | output := make(chan int) 38 | 39 | go func() { 40 | defer close(output) 41 | for n := range input { 42 | // Do some work with n 43 | result := process(n) 44 | output <- result 45 | } 46 | }() 47 | 48 | return output 49 | } 50 | 51 | func fanIn(inputs []<-chan int) <-chan int { 52 | output := make(chan int) 53 | var wg sync.WaitGroup 54 | 55 | // Start a goroutine for each input channel 56 | for _, ch := range inputs { 57 | wg.Add(1) 58 | go func(ch <-chan int) { 59 | defer wg.Done() 60 | for n := range ch { 61 | output <- n 62 | } 63 | }(ch) 64 | } 65 | 66 | // Close output once all input channels are drained 67 | go func() { 68 | wg.Wait() 69 | close(output) 70 | }() 71 | 72 | return output 73 | } 74 | ``` 75 | 76 | ### When to use it 77 | 78 | - CPU-intensive operations that can be parallelized 79 | - Operations that have independent work units 80 | - When you need to process many items but control the level of concurrency 81 | - Example use cases: image processing, data transformation pipelines, web scraping 82 | -------------------------------------------------------------------------------- /examples/programming/python/decorators.md: -------------------------------------------------------------------------------- 1 | --- 2 | tags: [python,decorators,programming,functions] 3 | created: 2025-03-22 4 | last_reviewed: 2025-03-22 5 | review_interval: 0 6 | difficulty: 0 7 | --- 8 | 9 | # Python Decorators 10 | 11 | ## Question 12 | 13 | What are decorators in Python and how do you implement a decorator with arguments? 14 | 15 | ## Answer 16 | 17 | Decorators are a design pattern in Python that allows you to modify the behavior of a function or class without directly changing its source code. 18 | 19 | ### Basic Decorator Structure 20 | 21 | ```python 22 | def my_decorator(func): 23 | def wrapper(*args, **kwargs): 24 | # Do something before the function call 25 | result = func(*args, **kwargs) 26 | # Do something after the function call 27 | return result 28 | return wrapper 29 | 30 | @my_decorator 31 | def my_function(): 32 | pass 33 | ``` 34 | 35 | ### Decorator with Arguments 36 | 37 | To create a decorator that accepts arguments, you need an additional level of nesting: 38 | 39 | ```python 40 | def repeat(n=1): 41 | def decorator(func): 42 | def wrapper(*args, **kwargs): 43 | result = None 44 | for _ in range(n): 45 | result = func(*args, **kwargs) 46 | return result 47 | return wrapper 48 | return decorator 49 | 50 | @repeat(3) 51 | def say_hello(name): 52 | print(f"Hello, {name}!") 53 | 54 | # This will print "Hello, World!" three times 55 | say_hello("World") 56 | ``` 57 | 58 | ### Common Use Cases 59 | 60 | 1. **Timing functions**: 61 | 62 | ```python 63 | def timing_decorator(func): 64 | def wrapper(*args, **kwargs): 65 | import time 66 | start_time = time.time() 67 | result = func(*args, **kwargs) 68 | end_time = time.time() 69 | print(f"{func.__name__} took {end_time - start_time:.2f} seconds") 70 | return result 71 | return wrapper 72 | ``` 73 | 74 | 2. **Caching/memoization**: 75 | 76 | ```python 77 | def memoize(func): 78 | cache = {} 79 | def wrapper(*args): 80 | if args not in cache: 81 | cache[args] = func(*args) 82 | return cache[args] 83 | return wrapper 84 | ``` 85 | 86 | 3. **Authentication and authorization**: 87 | 88 | ```python 89 | def requires_auth(func): 90 | def wrapper(*args, **kwargs): 91 | if not is_authenticated(): 92 | raise Exception("Authentication required") 93 | return func(*args, **kwargs) 94 | return wrapper 95 | ``` 96 | 97 | 4. **Logging**: 98 | 99 | ```python 100 | def log_function_call(func): 101 | def wrapper(*args, **kwargs): 102 | print(f"Calling {func.__name__} with {args}, {kwargs}") 103 | result = func(*args, **kwargs) 104 | print(f"{func.__name__} returned {result}") 105 | return result 106 | return wrapper 107 | ``` 108 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | // File: go.mod 2 | module github.com/DavidMiserak/GoCard 3 | 4 | go 1.23.0 5 | 6 | require ( 7 | github.com/alecthomas/chroma/v2 v2.15.0 8 | github.com/charmbracelet/bubbles v0.20.0 9 | github.com/charmbracelet/bubbletea v1.3.4 10 | github.com/charmbracelet/glamour v0.9.1 11 | github.com/charmbracelet/lipgloss v1.1.0 12 | gopkg.in/yaml.v3 v3.0.1 13 | ) 14 | 15 | require ( 16 | github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect 17 | github.com/aymerick/douceur v0.2.0 // indirect 18 | github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect 19 | github.com/charmbracelet/x/ansi v0.8.0 // indirect 20 | github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect 21 | github.com/charmbracelet/x/term v0.2.1 // indirect 22 | github.com/dlclark/regexp2 v1.11.4 // indirect 23 | github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect 24 | github.com/gorilla/css v1.0.1 // indirect 25 | github.com/lucasb-eyer/go-colorful v1.2.0 // indirect 26 | github.com/mattn/go-isatty v0.0.20 // indirect 27 | github.com/mattn/go-localereader v0.0.1 // indirect 28 | github.com/mattn/go-runewidth v0.0.16 // indirect 29 | github.com/microcosm-cc/bluemonday v1.0.27 // indirect 30 | github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect 31 | github.com/muesli/cancelreader v0.2.2 // indirect 32 | github.com/muesli/reflow v0.3.0 // indirect 33 | github.com/muesli/termenv v0.16.0 // indirect 34 | github.com/rivo/uniseg v0.4.7 // indirect 35 | github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect 36 | github.com/yuin/goldmark v1.7.8 // indirect 37 | github.com/yuin/goldmark-emoji v1.0.5 // indirect 38 | golang.org/x/net v0.33.0 // indirect 39 | golang.org/x/sync v0.12.0 // indirect 40 | golang.org/x/sys v0.31.0 // indirect 41 | golang.org/x/term v0.30.0 // indirect 42 | golang.org/x/text v0.23.0 // indirect 43 | ) 44 | -------------------------------------------------------------------------------- /go.sum: -------------------------------------------------------------------------------- 1 | github.com/alecthomas/assert/v2 v2.11.0 h1:2Q9r3ki8+JYXvGsDyBXwH3LcJ+WK5D0gc5E8vS6K3D0= 2 | github.com/alecthomas/assert/v2 v2.11.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k= 3 | github.com/alecthomas/chroma/v2 v2.15.0 h1:LxXTQHFoYrstG2nnV9y2X5O94sOBzf0CIUpSTbpxvMc= 4 | github.com/alecthomas/chroma/v2 v2.15.0/go.mod h1:gUhVLrPDXPtp/f+L1jo9xepo9gL4eLwRuGAunSZMkio= 5 | github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc= 6 | github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4= 7 | github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= 8 | github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= 9 | github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8= 10 | github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA= 11 | github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk= 12 | github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4= 13 | github.com/charmbracelet/bubbles v0.20.0 h1:jSZu6qD8cRQ6k9OMfR1WlM+ruM8fkPWkHvQWD9LIutE= 14 | github.com/charmbracelet/bubbles v0.20.0/go.mod h1:39slydyswPy+uVOHZ5x/GjwVAFkCsV8IIVy+4MhzwwU= 15 | github.com/charmbracelet/bubbletea v1.3.4 h1:kCg7B+jSCFPLYRA52SDZjr51kG/fMUEoPoZrkaDHyoI= 16 | github.com/charmbracelet/bubbletea v1.3.4/go.mod h1:dtcUCyCGEX3g9tosuYiut3MXgY/Jsv9nKVdibKKRRXo= 17 | github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs= 18 | github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk= 19 | github.com/charmbracelet/glamour v0.9.1 h1:11dEfiGP8q1BEqvGoIjivuc2rBk+5qEXdPtaQ2WoiCM= 20 | github.com/charmbracelet/glamour v0.9.1/go.mod h1:+SHvIS8qnwhgTpVMiXwn7OfGomSqff1cHBCI8jLOetk= 21 | github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY= 22 | github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30= 23 | github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE= 24 | github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q= 25 | github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8= 26 | github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs= 27 | github.com/charmbracelet/x/exp/golden v0.0.0-20240815200342-61de596daa2b h1:MnAMdlwSltxJyULnrYbkZpp4k58Co7Tah3ciKhSNo0Q= 28 | github.com/charmbracelet/x/exp/golden v0.0.0-20240815200342-61de596daa2b/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U= 29 | github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ= 30 | github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg= 31 | github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo= 32 | github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= 33 | github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4= 34 | github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM= 35 | github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8= 36 | github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0= 37 | github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= 38 | github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= 39 | github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= 40 | github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= 41 | github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= 42 | github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= 43 | github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= 44 | github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= 45 | github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= 46 | github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= 47 | github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= 48 | github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk= 49 | github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA= 50 | github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= 51 | github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= 52 | github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= 53 | github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= 54 | github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= 55 | github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= 56 | github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc= 57 | github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk= 58 | github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= 59 | github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= 60 | github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= 61 | github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= 62 | github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= 63 | github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM= 64 | github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E= 65 | github.com/yuin/goldmark v1.7.8 h1:iERMLn0/QJeHFhxSt3p6PeN9mGnvIKSpG9YYorDMnic= 66 | github.com/yuin/goldmark v1.7.8/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E= 67 | github.com/yuin/goldmark-emoji v1.0.5 h1:EMVWyCGPlXJfUXBXpuMu+ii3TIaxbVBnEX9uaDC4cIk= 68 | github.com/yuin/goldmark-emoji v1.0.5/go.mod h1:tTkZEbwu5wkPmgTcitqddVxY9osFZiavD+r4AzQrh1U= 69 | golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E= 70 | golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= 71 | golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I= 72 | golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= 73 | golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= 74 | golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= 75 | golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 76 | golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 77 | golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= 78 | golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= 79 | golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y= 80 | golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g= 81 | golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= 82 | golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= 83 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= 84 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= 85 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 86 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= 87 | -------------------------------------------------------------------------------- /internal/data/markdown_parser.go: -------------------------------------------------------------------------------- 1 | // File: internal/data/markdown_parser.go 2 | 3 | package data 4 | 5 | import ( 6 | "bufio" 7 | "fmt" 8 | "io/fs" 9 | "os" 10 | "path/filepath" 11 | "strings" 12 | "time" 13 | 14 | "github.com/DavidMiserak/GoCard/internal/model" 15 | "gopkg.in/yaml.v3" 16 | ) 17 | 18 | // FrontMatter represents the YAML frontmatter in a markdown file 19 | type FrontMatter struct { 20 | Tags []string `yaml:"tags"` 21 | Created time.Time `yaml:"created"` 22 | LastReviewed time.Time `yaml:"last_reviewed"` 23 | ReviewInterval int `yaml:"review_interval"` 24 | Difficulty float64 `yaml:"difficulty"` 25 | } 26 | 27 | // MarkdownCard represents a card in markdown format 28 | type MarkdownCard struct { 29 | Path string 30 | FrontMatter FrontMatter 31 | Question string 32 | Answer string 33 | } 34 | 35 | // ParseMarkdownFile parses a markdown file into a MarkdownCard 36 | func ParseMarkdownFile(path string) (*MarkdownCard, error) { 37 | file, err := os.Open(path) 38 | if err != nil { 39 | return nil, fmt.Errorf("error opening file: %w", err) 40 | } 41 | defer file.Close() //nolint:errcheck 42 | 43 | card := &MarkdownCard{ 44 | Path: path, 45 | } 46 | 47 | scanner := bufio.NewScanner(file) 48 | 49 | // Parse frontmatter 50 | if !scanner.Scan() || scanner.Text() != "---" { 51 | return nil, fmt.Errorf("missing frontmatter start") 52 | } 53 | 54 | var frontmatterLines []string 55 | for scanner.Scan() { 56 | line := scanner.Text() 57 | if line == "---" { 58 | break 59 | } 60 | frontmatterLines = append(frontmatterLines, line) 61 | } 62 | 63 | frontmatter := strings.Join(frontmatterLines, "\n") 64 | if err := yaml.Unmarshal([]byte(frontmatter), &card.FrontMatter); err != nil { 65 | return nil, fmt.Errorf("error parsing frontmatter: %w", err) 66 | } 67 | 68 | // Parse question and answer 69 | section := "" 70 | var questionLines, answerLines []string 71 | 72 | for scanner.Scan() { 73 | line := scanner.Text() 74 | 75 | if strings.HasPrefix(line, "# Question") || strings.HasPrefix(line, "## Question") { 76 | section = "question" 77 | continue 78 | } else if strings.HasPrefix(line, "# Answer") || strings.HasPrefix(line, "## Answer") { 79 | section = "answer" 80 | continue 81 | } 82 | 83 | switch section { 84 | case "question": 85 | questionLines = append(questionLines, line) 86 | case "answer": 87 | answerLines = append(answerLines, line) 88 | } 89 | } 90 | 91 | if err := scanner.Err(); err != nil { 92 | return nil, fmt.Errorf("error scanning file: %w", err) 93 | } 94 | 95 | card.Question = strings.TrimSpace(strings.Join(questionLines, "\n")) 96 | card.Answer = strings.TrimSpace(strings.Join(answerLines, "\n")) 97 | 98 | return card, nil 99 | } 100 | 101 | // ToModelCard converts a MarkdownCard to a model.Card 102 | func (mc *MarkdownCard) ToModelCard(deckID string) model.Card { 103 | // Set sensible defaults 104 | now := time.Now() 105 | lastReviewed := mc.FrontMatter.LastReviewed 106 | if lastReviewed.IsZero() { 107 | lastReviewed = now 108 | } 109 | 110 | // Calculate next review based on interval 111 | interval := mc.FrontMatter.ReviewInterval 112 | nextReview := lastReviewed.AddDate(0, 0, interval) 113 | 114 | // Default ease value if not specified 115 | ease := mc.FrontMatter.Difficulty 116 | if ease == 0 { 117 | ease = 2.5 // Default difficulty value 118 | } 119 | 120 | return model.Card{ 121 | ID: mc.Path, 122 | Question: mc.Question, 123 | Answer: mc.Answer, 124 | DeckID: deckID, 125 | LastReviewed: lastReviewed, 126 | NextReview: nextReview, 127 | Ease: ease, 128 | Interval: interval, 129 | Rating: 0, // Default to 0 for new cards 130 | } 131 | } 132 | 133 | // ScanDirForMarkdown scans a directory for markdown files 134 | func ScanDirForMarkdown(dirPath string) ([]string, error) { 135 | var mdFiles []string 136 | 137 | err := filepath.WalkDir(dirPath, func(path string, d fs.DirEntry, err error) error { 138 | if err != nil { 139 | return err 140 | } 141 | 142 | if d.IsDir() && path != dirPath { 143 | return filepath.SkipDir // Skip subdirectories 144 | } 145 | 146 | if !d.IsDir() && strings.HasSuffix(strings.ToLower(path), ".md") { 147 | mdFiles = append(mdFiles, path) 148 | } 149 | 150 | return nil 151 | }) 152 | 153 | if err != nil { 154 | return nil, fmt.Errorf("error scanning directory: %w", err) 155 | } 156 | 157 | return mdFiles, nil 158 | } 159 | 160 | // ImportMarkdownToDeck imports markdown files into an existing deck 161 | func ImportMarkdownToDeck(dirPath string, deck *model.Deck) error { 162 | mdFiles, err := ScanDirForMarkdown(dirPath) 163 | if err != nil { 164 | return err 165 | } 166 | 167 | for _, path := range mdFiles { 168 | card, err := ParseMarkdownFile(path) 169 | if err != nil { 170 | return fmt.Errorf("error parsing %s: %w", path, err) 171 | } 172 | 173 | modelCard := card.ToModelCard(deck.ID) 174 | deck.Cards = append(deck.Cards, modelCard) 175 | } 176 | 177 | return nil 178 | } 179 | 180 | // CreateDeckFromDir creates a new deck from a directory of markdown files 181 | func CreateDeckFromDir(dirPath string) (*model.Deck, error) { 182 | // Create a new deck 183 | deckInfo, err := os.Stat(dirPath) 184 | if err != nil { 185 | return nil, fmt.Errorf("error accessing deck directory: %w", err) 186 | } 187 | 188 | if !deckInfo.IsDir() { 189 | return nil, fmt.Errorf("path is not a directory: %s", dirPath) 190 | } 191 | 192 | deck := &model.Deck{ 193 | ID: dirPath, 194 | Name: filepath.Base(dirPath), 195 | CreatedAt: time.Now(), 196 | LastStudied: time.Now(), 197 | Cards: []model.Card{}, 198 | } 199 | 200 | // Import markdown files 201 | if err := ImportMarkdownToDeck(dirPath, deck); err != nil { 202 | return nil, err 203 | } 204 | 205 | return deck, nil 206 | } 207 | -------------------------------------------------------------------------------- /internal/data/markdown_parser_test.go: -------------------------------------------------------------------------------- 1 | // File: internal/data/markdown_parser_test.go 2 | 3 | package data 4 | 5 | import ( 6 | "os" 7 | "path/filepath" 8 | "testing" 9 | "time" 10 | 11 | "github.com/DavidMiserak/GoCard/internal/model" 12 | ) 13 | 14 | func TestParseMarkdownFile(t *testing.T) { 15 | // Create a temporary directory 16 | tempDir, err := os.MkdirTemp("", "markdown-test") 17 | if err != nil { 18 | t.Fatalf("Failed to create temp dir: %v", err) 19 | } 20 | defer os.RemoveAll(tempDir) //nolint:errcheck 21 | 22 | // Create a test markdown file 23 | testFile := filepath.Join(tempDir, "test-card.md") 24 | content := `--- 25 | tags: [go,test] 26 | created: 2025-03-22 27 | last_reviewed: 2025-03-22 28 | review_interval: 3 29 | difficulty: 2.0 30 | --- 31 | 32 | # Question 33 | 34 | What is Go testing? 35 | 36 | ## Answer 37 | 38 | Go testing is a framework for writing automated tests in Go. 39 | ` 40 | if err := os.WriteFile(testFile, []byte(content), 0644); err != nil { 41 | t.Fatalf("Failed to write test file: %v", err) 42 | } 43 | 44 | // Test parsing 45 | card, err := ParseMarkdownFile(testFile) 46 | if err != nil { 47 | t.Fatalf("ParseMarkdownFile error: %v", err) 48 | } 49 | 50 | // Validate parsed data 51 | if card.Path != testFile { 52 | t.Errorf("Expected path %s, got %s", testFile, card.Path) 53 | } 54 | 55 | if len(card.FrontMatter.Tags) != 2 || card.FrontMatter.Tags[0] != "go" || card.FrontMatter.Tags[1] != "test" { 56 | t.Errorf("Expected tags [go test], got %v", card.FrontMatter.Tags) 57 | } 58 | 59 | expectedDate := time.Date(2025, 3, 22, 0, 0, 0, 0, time.UTC) 60 | if !card.FrontMatter.Created.Equal(expectedDate) { 61 | t.Errorf("Expected created %v, got %v", expectedDate, card.FrontMatter.Created) 62 | } 63 | 64 | if card.FrontMatter.ReviewInterval != 3 { 65 | t.Errorf("Expected interval 3, got %d", card.FrontMatter.ReviewInterval) 66 | } 67 | 68 | if card.FrontMatter.Difficulty != 2.0 { 69 | t.Errorf("Expected difficulty 2.0, got %f", card.FrontMatter.Difficulty) 70 | } 71 | 72 | expectedQuestion := "What is Go testing?" 73 | if card.Question != expectedQuestion { 74 | t.Errorf("Expected question %q, got %q", expectedQuestion, card.Question) 75 | } 76 | 77 | expectedAnswer := "Go testing is a framework for writing automated tests in Go." 78 | if card.Answer != expectedAnswer { 79 | t.Errorf("Expected answer %q, got %q", expectedAnswer, card.Answer) 80 | } 81 | } 82 | 83 | func TestToModelCard(t *testing.T) { 84 | // Create a test markdown card 85 | created := time.Date(2025, 3, 22, 0, 0, 0, 0, time.UTC) 86 | lastReviewed := time.Date(2025, 3, 23, 0, 0, 0, 0, time.UTC) 87 | 88 | mc := &MarkdownCard{ 89 | Path: "/path/to/card.md", 90 | FrontMatter: FrontMatter{ 91 | Tags: []string{"go", "test"}, 92 | Created: created, 93 | LastReviewed: lastReviewed, 94 | ReviewInterval: 3, 95 | Difficulty: 2.1, 96 | }, 97 | Question: "Test Question", 98 | Answer: "Test Answer", 99 | } 100 | 101 | // Convert to model card 102 | deckID := "/path/to/deck" 103 | card := mc.ToModelCard(deckID) 104 | 105 | // Validate conversion 106 | if card.ID != mc.Path { 107 | t.Errorf("Expected ID %s, got %s", mc.Path, card.ID) 108 | } 109 | 110 | if card.Question != mc.Question { 111 | t.Errorf("Expected question %s, got %s", mc.Question, card.Question) 112 | } 113 | 114 | if card.Answer != mc.Answer { 115 | t.Errorf("Expected answer %s, got %s", mc.Answer, card.Answer) 116 | } 117 | 118 | if card.DeckID != deckID { 119 | t.Errorf("Expected deckID %s, got %s", deckID, card.DeckID) 120 | } 121 | 122 | if !card.LastReviewed.Equal(lastReviewed) { 123 | t.Errorf("Expected lastReviewed %v, got %v", lastReviewed, card.LastReviewed) 124 | } 125 | 126 | expectedNextReview := lastReviewed.AddDate(0, 0, 3) 127 | if !card.NextReview.Equal(expectedNextReview) { 128 | t.Errorf("Expected nextReview %v, got %v", expectedNextReview, card.NextReview) 129 | } 130 | 131 | if card.Ease != mc.FrontMatter.Difficulty { 132 | t.Errorf("Expected ease %f, got %f", mc.FrontMatter.Difficulty, card.Ease) 133 | } 134 | 135 | if card.Interval != mc.FrontMatter.ReviewInterval { 136 | t.Errorf("Expected interval %d, got %d", mc.FrontMatter.ReviewInterval, card.Interval) 137 | } 138 | 139 | if card.Rating != 0 { 140 | t.Errorf("Expected rating 0, got %d", card.Rating) 141 | } 142 | } 143 | 144 | func TestScanDirForMarkdown(t *testing.T) { 145 | // Create a temporary directory 146 | tempDir, err := os.MkdirTemp("", "markdown-scan") 147 | if err != nil { 148 | t.Fatalf("Failed to create temp dir: %v", err) 149 | } 150 | defer os.RemoveAll(tempDir) //nolint:errcheck 151 | 152 | // Create test files 153 | files := []string{ 154 | "test1.md", 155 | "test2.md", 156 | "not-markdown.txt", 157 | } 158 | 159 | for _, file := range files { 160 | path := filepath.Join(tempDir, file) 161 | if err := os.WriteFile(path, []byte("test content"), 0644); err != nil { 162 | t.Fatalf("Failed to write file %s: %v", file, err) 163 | } 164 | } 165 | 166 | // Create a subdirectory with a markdown file (should be skipped) 167 | subDir := filepath.Join(tempDir, "subdir") 168 | if err := os.Mkdir(subDir, 0755); err != nil { 169 | t.Fatalf("Failed to create subdirectory: %v", err) 170 | } 171 | 172 | subFile := filepath.Join(subDir, "sub.md") 173 | if err := os.WriteFile(subFile, []byte("subdir content"), 0644); err != nil { 174 | t.Fatalf("Failed to write file in subdirectory: %v", err) 175 | } 176 | 177 | // Test scanning 178 | mdFiles, err := ScanDirForMarkdown(tempDir) 179 | if err != nil { 180 | t.Fatalf("ScanDirForMarkdown error: %v", err) 181 | } 182 | 183 | // Validate results 184 | if len(mdFiles) != 2 { 185 | t.Errorf("Expected 2 markdown files, got %d", len(mdFiles)) 186 | } 187 | 188 | // Check that only markdown files are included 189 | for _, file := range mdFiles { 190 | if filepath.Ext(file) != ".md" { 191 | t.Errorf("Non-markdown file included: %s", file) 192 | } 193 | 194 | // Check that subdirectory files are not included 195 | if filepath.Dir(file) != tempDir { 196 | t.Errorf("File from subdirectory included: %s", file) 197 | } 198 | } 199 | } 200 | 201 | func TestImportMarkdownToDeck(t *testing.T) { 202 | // Create a temporary directory 203 | tempDir, err := os.MkdirTemp("", "markdown-import") 204 | if err != nil { 205 | t.Fatalf("Failed to create temp dir: %v", err) 206 | } 207 | defer os.RemoveAll(tempDir) //nolint:errcheck 208 | 209 | // Create test markdown files 210 | for i := 1; i <= 2; i++ { 211 | filename := filepath.Join(tempDir, "test"+string(rune('0'+i))+".md") 212 | content := `--- 213 | tags: [go,test` + string(rune('0'+i)) + `] 214 | created: 2025-03-22 215 | last_reviewed: 2025-03-22 216 | review_interval: ` + string(rune('0'+i)) + ` 217 | difficulty: 2.` + string(rune('0'+i)) + ` 218 | --- 219 | 220 | # Question 221 | 222 | Test question ` + string(rune('0'+i)) + `? 223 | 224 | ## Answer 225 | 226 | Test answer ` + string(rune('0'+i)) + `. 227 | ` 228 | if err := os.WriteFile(filename, []byte(content), 0644); err != nil { 229 | t.Fatalf("Failed to write test file: %v", err) 230 | } 231 | } 232 | 233 | // Create a deck 234 | deck := &model.Deck{ 235 | ID: tempDir, 236 | Name: "Test Deck", 237 | } 238 | 239 | // Test importing 240 | if err := ImportMarkdownToDeck(tempDir, deck); err != nil { 241 | t.Fatalf("ImportMarkdownToDeck error: %v", err) 242 | } 243 | 244 | // Validate deck 245 | if len(deck.Cards) != 2 { 246 | t.Errorf("Expected 2 cards in deck, got %d", len(deck.Cards)) 247 | } 248 | 249 | // Check card content 250 | for _, card := range deck.Cards { 251 | if card.DeckID != tempDir { 252 | t.Errorf("Expected deckID %s, got %s", tempDir, card.DeckID) 253 | } 254 | 255 | // Check that files were properly parsed 256 | if card.Question == "" || card.Answer == "" { 257 | t.Errorf("Card missing question or answer: %+v", card) 258 | } 259 | } 260 | } 261 | 262 | func TestCreateDeckFromDir(t *testing.T) { 263 | // Create a temporary directory 264 | tempDir, err := os.MkdirTemp("", "deck-create") 265 | if err != nil { 266 | t.Fatalf("Failed to create temp dir: %v", err) 267 | } 268 | defer os.RemoveAll(tempDir) //nolint:errcheck 269 | 270 | // Create test markdown files 271 | for i := 1; i <= 3; i++ { 272 | filename := filepath.Join(tempDir, "test"+string(rune('0'+i))+".md") 273 | content := `--- 274 | tags: [go,test` + string(rune('0'+i)) + `] 275 | created: 2025-03-22 276 | last_reviewed: 2025-03-22 277 | review_interval: ` + string(rune('0'+i)) + ` 278 | difficulty: 2.` + string(rune('0'+i)) + ` 279 | --- 280 | 281 | # Question 282 | 283 | Test question ` + string(rune('0'+i)) + `? 284 | 285 | ## Answer 286 | 287 | Test answer ` + string(rune('0'+i)) + `. 288 | ` 289 | if err := os.WriteFile(filename, []byte(content), 0644); err != nil { 290 | t.Fatalf("Failed to write test file: %v", err) 291 | } 292 | } 293 | 294 | // Test creating deck 295 | deck, err := CreateDeckFromDir(tempDir) 296 | if err != nil { 297 | t.Fatalf("CreateDeckFromDir error: %v", err) 298 | } 299 | 300 | // Validate deck 301 | if deck.ID != tempDir { 302 | t.Errorf("Expected ID %s, got %s", tempDir, deck.ID) 303 | } 304 | 305 | expectedName := filepath.Base(tempDir) 306 | if deck.Name != expectedName { 307 | t.Errorf("Expected name %s, got %s", expectedName, deck.Name) 308 | } 309 | 310 | if len(deck.Cards) != 3 { 311 | t.Errorf("Expected 3 cards in deck, got %d", len(deck.Cards)) 312 | } 313 | 314 | // Check non-directory 315 | nonDir := filepath.Join(tempDir, "test1.md") 316 | _, err = CreateDeckFromDir(nonDir) 317 | if err == nil { 318 | t.Error("Expected error when creating deck from non-directory, got nil") 319 | } 320 | } 321 | -------------------------------------------------------------------------------- /internal/data/markdown_writer.go: -------------------------------------------------------------------------------- 1 | // File: internal/data/markdown_writer.go 2 | 3 | package data 4 | 5 | import ( 6 | "fmt" 7 | "os" 8 | "path/filepath" 9 | "regexp" 10 | "strings" 11 | "time" 12 | 13 | "github.com/DavidMiserak/GoCard/internal/model" 14 | "gopkg.in/yaml.v3" 15 | ) 16 | 17 | // CardToMarkdown converts a model.Card to a MarkdownCard 18 | func CardToMarkdown(card model.Card) *MarkdownCard { 19 | // Extract tags (if stored in the card) 20 | tags := []string{} 21 | 22 | // Create MarkdownCard 23 | mc := &MarkdownCard{ 24 | Path: card.ID, 25 | FrontMatter: FrontMatter{ 26 | Tags: tags, 27 | Created: time.Now(), // Default to now if not available 28 | LastReviewed: card.LastReviewed, 29 | ReviewInterval: card.Interval, 30 | Difficulty: card.Ease, 31 | }, 32 | Question: card.Question, 33 | Answer: card.Answer, 34 | } 35 | 36 | return mc 37 | } 38 | 39 | // SanitizeFilename converts a string to a Unix-friendly filename 40 | func SanitizeFilename(name string) string { 41 | // First trim spaces from start and end 42 | name = strings.TrimSpace(name) 43 | 44 | // If string is empty or just dots, return default 45 | if name == "" || strings.Trim(name, ".") == "" { 46 | return "card" 47 | } 48 | 49 | // Replace all whitespace with underscores 50 | re := regexp.MustCompile(`\s+`) 51 | name = re.ReplaceAllString(name, "_") 52 | 53 | // Replace other problematic characters 54 | name = strings.ReplaceAll(name, "/", "-") 55 | name = strings.ReplaceAll(name, "\\", "-") 56 | name = strings.ReplaceAll(name, ":", "-") 57 | name = strings.ReplaceAll(name, "*", "-") 58 | name = strings.ReplaceAll(name, "?", "-") 59 | name = strings.ReplaceAll(name, "\"", "-") 60 | name = strings.ReplaceAll(name, "<", "-") 61 | name = strings.ReplaceAll(name, ">", "-") 62 | name = strings.ReplaceAll(name, "|", "-") 63 | 64 | // Trim leading/trailing dots 65 | name = strings.Trim(name, ".") 66 | 67 | // Final check for empty string 68 | if name == "" { 69 | return "card" 70 | } 71 | 72 | return name 73 | } 74 | 75 | // WriteMarkdownCard writes a MarkdownCard to a file 76 | func WriteMarkdownCard(mc *MarkdownCard, path string) error { 77 | // Ensure directory exists 78 | dir := filepath.Dir(path) 79 | if err := os.MkdirAll(dir, 0755); err != nil { 80 | return fmt.Errorf("error creating directory: %w", err) 81 | } 82 | 83 | // Marshall frontmatter to YAML 84 | frontmatterBytes, err := yaml.Marshal(mc.FrontMatter) 85 | if err != nil { 86 | return fmt.Errorf("error marshalling frontmatter: %w", err) 87 | } 88 | 89 | // Construct file content 90 | content := fmt.Sprintf("---\n%s---\n\n# Question\n\n%s\n\n## Answer\n\n%s\n", 91 | string(frontmatterBytes), 92 | mc.Question, 93 | mc.Answer) 94 | 95 | // Write to file 96 | if err := os.WriteFile(path, []byte(content), 0644); err != nil { 97 | return fmt.Errorf("error writing file: %w", err) 98 | } 99 | 100 | return nil 101 | } 102 | 103 | // WriteCard writes a model.Card to a markdown file 104 | func WriteCard(card model.Card, path string) error { 105 | mc := CardToMarkdown(card) 106 | return WriteMarkdownCard(mc, path) 107 | } 108 | 109 | // WriteDeckToMarkdown writes all cards in a deck to markdown files 110 | func WriteDeckToMarkdown(deck *model.Deck, dirPath string) error { 111 | // Ensure directory exists 112 | if err := os.MkdirAll(dirPath, 0755); err != nil { 113 | return fmt.Errorf("error creating directory: %w", err) 114 | } 115 | 116 | // Write each card 117 | for i, card := range deck.Cards { 118 | // Generate filename if not available 119 | var filename string 120 | if card.ID == "" { 121 | // Simple numeric filename 122 | filename = filepath.Join(dirPath, fmt.Sprintf("card_%d.md", i+1)) 123 | } else { 124 | // Use card ID but sanitize it first 125 | baseName := filepath.Base(card.ID) 126 | sanitizedName := SanitizeFilename(baseName) 127 | 128 | // Ensure it ends with .md 129 | if !strings.HasSuffix(strings.ToLower(sanitizedName), ".md") { 130 | sanitizedName += ".md" 131 | } 132 | 133 | filename = filepath.Join(dirPath, sanitizedName) 134 | } 135 | 136 | // Update card ID to match filename 137 | card.ID = filename 138 | 139 | // Write card 140 | if err := WriteCard(card, filename); err != nil { 141 | return fmt.Errorf("error writing card %d: %w", i, err) 142 | } 143 | } 144 | 145 | return nil 146 | } 147 | 148 | // WriteNewDeck creates a new deck directory and writes all cards as markdown files 149 | func WriteNewDeck(deck *model.Deck) error { 150 | // Use deck ID as directory path 151 | dirPath := deck.ID 152 | if dirPath == "" { 153 | return fmt.Errorf("deck ID (directory path) is required") 154 | } 155 | 156 | return WriteDeckToMarkdown(deck, dirPath) 157 | } 158 | 159 | // UpdateCardFile updates an existing markdown file with modified card data 160 | func UpdateCardFile(card model.Card) error { 161 | // Check if file exists 162 | _, err := os.Stat(card.ID) 163 | if err != nil { 164 | if os.IsNotExist(err) { 165 | // Create new file if it doesn't exist 166 | return WriteCard(card, card.ID) 167 | } 168 | return fmt.Errorf("error checking file: %w", err) 169 | } 170 | 171 | // Read existing card to preserve metadata 172 | existingCard, err := ParseMarkdownFile(card.ID) 173 | if err != nil { 174 | return fmt.Errorf("error reading existing card: %w", err) 175 | } 176 | 177 | // Update with new data while preserving tags and created date 178 | mc := CardToMarkdown(card) 179 | mc.FrontMatter.Tags = existingCard.FrontMatter.Tags 180 | 181 | // Keep original creation date if it exists 182 | if !existingCard.FrontMatter.Created.IsZero() { 183 | mc.FrontMatter.Created = existingCard.FrontMatter.Created 184 | } 185 | 186 | // Write updated card 187 | return WriteMarkdownCard(mc, card.ID) 188 | } 189 | -------------------------------------------------------------------------------- /internal/data/store.go: -------------------------------------------------------------------------------- 1 | // File: internal/data/store.go 2 | 3 | package data 4 | 5 | import ( 6 | "fmt" 7 | "os" 8 | "path/filepath" 9 | "regexp" 10 | "strings" 11 | "time" 12 | 13 | "github.com/DavidMiserak/GoCard/internal/model" 14 | "github.com/DavidMiserak/GoCard/internal/srs" 15 | ) 16 | 17 | // Store manages all data for the application 18 | type Store struct { 19 | Decks []model.Deck 20 | } 21 | 22 | // NewStore creates a new data store with dummy data 23 | func NewStore() *Store { 24 | store := &Store{ 25 | Decks: []model.Deck{}, 26 | } 27 | 28 | // Add dummy data 29 | store.Decks = GetDummyDecks() 30 | 31 | return store 32 | } 33 | 34 | // NewStoreFromDir creates a new data store with decks from the specified directory 35 | func NewStoreFromDir(dirPath string) (*Store, error) { 36 | store := &Store{ 37 | Decks: []model.Deck{}, 38 | } 39 | 40 | // List all subdirectories (each will be a deck) 41 | subdirs, err := listSubdirectories(dirPath) 42 | if err != nil { 43 | return nil, fmt.Errorf("error listing subdirectories: %w", err) 44 | } 45 | 46 | // If no subdirectories found, treat the main directory as a single deck 47 | if len(subdirs) == 0 { 48 | deck, err := CreateDeckFromDir(dirPath) 49 | if err != nil { 50 | return nil, fmt.Errorf("error creating deck from directory: %w", err) 51 | } 52 | store.Decks = append(store.Decks, *deck) 53 | return store, nil 54 | } 55 | 56 | // Create decks from each subdirectory 57 | for _, subdir := range subdirs { 58 | deck, err := CreateDeckFromDir(subdir) 59 | if err != nil { 60 | // Log the error but continue with other subdirectories 61 | fmt.Printf("Warning: Error loading deck from %s: %v\n", subdir, err) 62 | continue 63 | } 64 | store.Decks = append(store.Decks, *deck) 65 | } 66 | 67 | // If no decks were loaded, use dummy data 68 | if len(store.Decks) == 0 { 69 | fmt.Println("No decks found in the specified directory. Using dummy data instead.") 70 | store.Decks = GetDummyDecks() 71 | } 72 | 73 | return store, nil 74 | } 75 | 76 | // listSubdirectories lists all immediate subdirectories in the given path 77 | func listSubdirectories(dirPath string) ([]string, error) { 78 | var subdirs []string 79 | 80 | entries, err := os.ReadDir(dirPath) 81 | if err != nil { 82 | return nil, err 83 | } 84 | 85 | for _, entry := range entries { 86 | if entry.IsDir() { 87 | subdirPath := filepath.Join(dirPath, entry.Name()) 88 | subdirs = append(subdirs, subdirPath) 89 | } 90 | } 91 | 92 | return subdirs, nil 93 | } 94 | 95 | // GetDecks returns all decks 96 | func (s *Store) GetDecks() []model.Deck { 97 | return s.Decks 98 | } 99 | 100 | // GetDeck returns a deck by ID 101 | func (s *Store) GetDeck(id string) (model.Deck, bool) { 102 | for _, deck := range s.Decks { 103 | if deck.ID == id { 104 | return deck, true 105 | } 106 | } 107 | return model.Deck{}, false 108 | } 109 | 110 | // GetDueCards returns cards due for review 111 | func (s *Store) GetDueCards() []model.Card { 112 | var dueCards []model.Card 113 | now := time.Now() 114 | 115 | for _, deck := range s.Decks { 116 | for _, card := range deck.Cards { 117 | if card.NextReview.Before(now) { 118 | dueCards = append(dueCards, card) 119 | } 120 | } 121 | } 122 | 123 | return dueCards 124 | } 125 | 126 | // GetDueCardsForDeck returns cards due for review in a specific deck 127 | func (s *Store) GetDueCardsForDeck(deckID string) []model.Card { 128 | var dueCards []model.Card 129 | now := time.Now() 130 | 131 | for _, deck := range s.Decks { 132 | if deck.ID == deckID { 133 | for _, card := range deck.Cards { 134 | if card.NextReview.Before(now) { 135 | dueCards = append(dueCards, card) 136 | } 137 | } 138 | break 139 | } 140 | } 141 | 142 | return dueCards 143 | } 144 | 145 | // UpdateCard updates a card in the store and returns whether it was found 146 | func (s *Store) UpdateCard(updatedCard model.Card) bool { 147 | // Find and update the card in its deck 148 | for i, deck := range s.Decks { 149 | if deck.ID == updatedCard.DeckID { 150 | for j, card := range deck.Cards { 151 | if card.ID == updatedCard.ID { 152 | // Update the card 153 | s.Decks[i].Cards[j] = updatedCard 154 | return true 155 | } 156 | } 157 | } 158 | } 159 | return false 160 | } 161 | 162 | // UpdateDeckLastStudied updates the LastStudied timestamp for a deck 163 | func (s *Store) UpdateDeckLastStudied(deckID string) bool { 164 | for i, deck := range s.Decks { 165 | if deck.ID == deckID { 166 | s.Decks[i].LastStudied = time.Now() 167 | return true 168 | } 169 | } 170 | return false 171 | } 172 | 173 | // SaveCardReview updates a card with its new review data and updates 174 | // the parent deck's LastStudied timestamp 175 | func (s *Store) SaveCardReview(card model.Card, rating int) bool { 176 | // Use the SRS algorithm to schedule the card 177 | updatedCard := srs.ScheduleCard(card, rating) 178 | 179 | // Update the card in the store 180 | cardUpdated := s.UpdateCard(updatedCard) 181 | 182 | // Update the deck's last studied timestamp 183 | deckUpdated := s.UpdateDeckLastStudied(card.DeckID) 184 | 185 | return cardUpdated && deckUpdated 186 | } 187 | 188 | // SaveDeckToMarkdown saves SRS metadata for all cards in a deck back to their markdown files 189 | func (s *Store) SaveDeckToMarkdown(deckID string) error { 190 | // Get the deck from the store 191 | deck, found := s.GetDeck(deckID) 192 | if !found { 193 | return fmt.Errorf("deck with ID %s not found", deckID) 194 | } 195 | 196 | // Only proceed if the deck ID looks like a valid directory path 197 | if !filepath.IsAbs(deck.ID) && !strings.Contains(deck.ID, "/") && !strings.Contains(deck.ID, "\\") { 198 | // This appears to be a dummy deck without proper file paths 199 | return nil 200 | } 201 | 202 | // For each card in the deck, update its SRS metadata 203 | for _, card := range deck.Cards { 204 | // Skip cards without a proper file path 205 | if card.ID == "" || (!filepath.IsAbs(card.ID) && 206 | !strings.Contains(card.ID, "/") && !strings.Contains(card.ID, "\\")) { 207 | continue 208 | } 209 | 210 | // Verify the file exists before updating 211 | if _, err := os.Stat(card.ID); os.IsNotExist(err) { 212 | // Skip non-existent files 213 | continue 214 | } 215 | 216 | // Read the existing file content 217 | content, err := os.ReadFile(card.ID) 218 | if err != nil { 219 | return fmt.Errorf("error reading card file %s: %w", card.ID, err) 220 | } 221 | 222 | // Parse the content to extract front matter 223 | contentStr := string(content) 224 | fmStart := strings.Index(contentStr, "---") 225 | if fmStart < 0 { 226 | continue // No front matter found 227 | } 228 | 229 | fmEnd := strings.Index(contentStr[fmStart+3:], "---") 230 | if fmEnd < 0 { 231 | continue // Incomplete front matter 232 | } 233 | fmEnd = fmStart + 3 + fmEnd 234 | 235 | frontMatter := contentStr[fmStart : fmEnd+3] 236 | bodyContent := contentStr[fmEnd+3:] 237 | 238 | // Update only the SRS-specific fields in front matter 239 | updatedFrontMatter := updateFrontMatterFields(frontMatter, card) 240 | 241 | // Combine updated front matter with original body content 242 | updatedContent := updatedFrontMatter + bodyContent 243 | 244 | // Write back to file 245 | if err := os.WriteFile(card.ID, []byte(updatedContent), 0644); err != nil { 246 | return fmt.Errorf("error writing updated card file %s: %w", card.ID, err) 247 | } 248 | } 249 | 250 | return nil 251 | } 252 | 253 | // Helper function to update only SRS-related fields in front matter 254 | func updateFrontMatterFields(frontMatter string, card model.Card) string { 255 | // Regular expressions to update specific fields 256 | reviewIntervalRe := regexp.MustCompile(`(review_interval:\s*)[0-9.]+`) 257 | difficultyRe := regexp.MustCompile(`(difficulty:\s*)[0-9.]+`) 258 | lastReviewedRe := regexp.MustCompile(`(last_reviewed:\s*)[^\n]+`) 259 | 260 | // Format date in the YYYY-MM-DD format 261 | lastReviewedFormatted := card.LastReviewed.Format("2006-01-02") 262 | 263 | // Update each field if it exists 264 | if reviewIntervalRe.MatchString(frontMatter) { 265 | frontMatter = reviewIntervalRe.ReplaceAllString(frontMatter, 266 | fmt.Sprintf("${1}%d", card.Interval)) 267 | } 268 | 269 | if difficultyRe.MatchString(frontMatter) { 270 | frontMatter = difficultyRe.ReplaceAllString(frontMatter, 271 | fmt.Sprintf("${1}%.1f", card.Ease)) 272 | } 273 | 274 | if lastReviewedRe.MatchString(frontMatter) { 275 | frontMatter = lastReviewedRe.ReplaceAllString(frontMatter, 276 | fmt.Sprintf("${1}%s", lastReviewedFormatted)) 277 | } 278 | 279 | return frontMatter 280 | } 281 | -------------------------------------------------------------------------------- /internal/model/card.go: -------------------------------------------------------------------------------- 1 | // File: internal/model/card.go 2 | 3 | package model 4 | 5 | import "time" 6 | 7 | // TODO: Make a tool to import Markdown files in directory to cards 8 | 9 | // Card represents a flashcard 10 | type Card struct { 11 | ID string // Will be the filepath of the card 12 | Question string 13 | Answer string 14 | DeckID string // Will the filepath of the deck (directory) 15 | LastReviewed time.Time 16 | NextReview time.Time 17 | Ease float64 18 | Interval int // in days 19 | Rating int // 1-5 rating per SmartMemo2 Algorithm 20 | } 21 | -------------------------------------------------------------------------------- /internal/model/deck.go: -------------------------------------------------------------------------------- 1 | // File: internal/model/deck.go 2 | 3 | package model 4 | 5 | import "time" 6 | 7 | // Deck represents a collection of flashcards 8 | type Deck struct { 9 | ID string // Will be filepath of the deck (directory) 10 | Name string // Will be base name of the directory 11 | Description string 12 | Cards []Card // TODO: Make a tool to import Markdown files in directory to cards 13 | CreatedAt time.Time 14 | LastStudied time.Time 15 | } 16 | -------------------------------------------------------------------------------- /internal/srs/algorithm.go: -------------------------------------------------------------------------------- 1 | // File: internal/srs/algorithm.go 2 | 3 | package srs 4 | 5 | import ( 6 | "time" 7 | 8 | "github.com/DavidMiserak/GoCard/internal/model" 9 | ) 10 | 11 | // Default values for SM-2 algorithm 12 | const ( 13 | defaultEase = 2.5 // Initial ease factor 14 | minEase = 1.3 // Minimum ease factor 15 | easeModifier = 0.15 // How much ease changes based on rating 16 | maxInterval = 365 // Maximum interval in days 17 | easyBonus = 1.3 // Multiplier for "easy" cards 18 | defaultInterval = 1 // Default interval for new cards 19 | ) 20 | 21 | // ScheduleCard updates a card based on the user's rating (1-5) 22 | // and returns the updated card 23 | // 24 | // Rating scale: 25 | // 1 - Blackout (complete failure) 26 | // 2 - Wrong (significant difficulty) 27 | // 3 - Hard (correct with difficulty) 28 | // 4 - Good (correct with some effort) 29 | // 5 - Easy (correct with no effort) 30 | func ScheduleCard(card model.Card, rating int) model.Card { 31 | // Update the last reviewed time 32 | card.LastReviewed = time.Now() 33 | 34 | // Store the user's rating 35 | card.Rating = rating 36 | 37 | // Calculate new interval and ease based on rating 38 | switch rating { 39 | case 1: // Blackout 40 | // Reset the interval, reduce ease 41 | card.Interval = 1 42 | card.Ease = maxFloat(card.Ease-0.3, minEase) 43 | 44 | case 2: // Wrong 45 | // Reset the interval, reduce ease 46 | card.Interval = 1 47 | card.Ease = maxFloat(card.Ease-0.2, minEase) 48 | 49 | case 3: // Hard 50 | // Slight increase in interval, reduce ease 51 | if card.Interval == 0 { 52 | card.Interval = 1 53 | } else { 54 | card.Interval = int(float64(card.Interval) * 1.2) 55 | } 56 | card.Ease = maxFloat(card.Ease-easeModifier, minEase) 57 | 58 | case 4: // Good 59 | // Standard increase in interval 60 | switch card.Interval { 61 | case 0: 62 | card.Interval = defaultInterval 63 | case 1: 64 | card.Interval = 3 65 | default: 66 | card.Interval = int(float64(card.Interval) * card.Ease) 67 | } 68 | // Ease remains the same 69 | 70 | case 5: // Easy 71 | // Larger increase in interval, increase ease 72 | switch card.Interval { 73 | case 0: 74 | card.Interval = defaultInterval * 2 75 | case 1: 76 | card.Interval = 4 77 | default: 78 | card.Interval = int(float64(card.Interval) * card.Ease * easyBonus) 79 | } 80 | card.Ease = minFloat(card.Ease+easeModifier, 4.0) 81 | } 82 | 83 | // Cap the interval at the maximum 84 | card.Interval = minInt(card.Interval, maxInterval) 85 | 86 | // Set the next review date 87 | card.NextReview = time.Now().AddDate(0, 0, card.Interval) 88 | 89 | return card 90 | } 91 | 92 | // InitializeNewCard initializes a new card with default SRS values 93 | func InitializeNewCard(card model.Card) model.Card { 94 | // Set default values for a new card 95 | if card.Ease == 0 { 96 | card.Ease = defaultEase 97 | } 98 | card.Interval = 0 99 | card.NextReview = time.Now() // Due immediately 100 | 101 | return card 102 | } 103 | 104 | // Helper functions 105 | func minInt(a, b int) int { 106 | if a < b { 107 | return a 108 | } 109 | return b 110 | } 111 | 112 | func maxFloat(a, b float64) float64 { 113 | if a > b { 114 | return a 115 | } 116 | return b 117 | } 118 | 119 | func minFloat(a, b float64) float64 { 120 | if a < b { 121 | return a 122 | } 123 | return b 124 | } 125 | -------------------------------------------------------------------------------- /internal/ui/browse_decks.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/browse_decks.go 2 | 3 | package ui 4 | 5 | import ( 6 | "fmt" 7 | "time" 8 | 9 | "github.com/charmbracelet/bubbles/key" 10 | tea "github.com/charmbracelet/bubbletea" 11 | 12 | "github.com/DavidMiserak/GoCard/internal/data" 13 | "github.com/DavidMiserak/GoCard/internal/model" 14 | ) 15 | 16 | const ( 17 | // Number of decks to display per page 18 | decksPerPage = 5 19 | ) 20 | 21 | // Key mapping for browse screen 22 | type browseKeyMap struct { 23 | Up key.Binding 24 | Down key.Binding 25 | Enter key.Binding 26 | Back key.Binding 27 | Next key.Binding 28 | Prev key.Binding 29 | Quit key.Binding 30 | } 31 | 32 | var browseKeys = browseKeyMap{ 33 | Up: key.NewBinding( 34 | key.WithKeys("up", "k"), // "k" for Vim users 35 | key.WithHelp("↑/k", "navigate"), 36 | ), 37 | Down: key.NewBinding( 38 | key.WithKeys("down", "j"), // "j" for Vim users 39 | key.WithHelp("↓/j", "navigate"), 40 | ), 41 | Enter: key.NewBinding( 42 | key.WithKeys("enter"), 43 | key.WithHelp("enter", "study"), 44 | ), 45 | Back: key.NewBinding( 46 | key.WithKeys("b"), 47 | key.WithHelp("b", "back"), 48 | ), 49 | Next: key.NewBinding( 50 | key.WithKeys("n", "right", "l"), // "l" for Vim users 51 | key.WithHelp("n/p", "next/prev page"), 52 | ), 53 | Prev: key.NewBinding( 54 | key.WithKeys("p", "left", "h"), // "h" for Vim users 55 | key.WithHelp("n/p", "next/prev page"), 56 | ), 57 | Quit: key.NewBinding( 58 | key.WithKeys("q", "ctrl+c"), 59 | key.WithHelp("q", "quit"), 60 | ), 61 | } 62 | 63 | // BrowseScreen represents the browse decks screen 64 | type BrowseScreen struct { 65 | store *data.Store 66 | decks []model.Deck 67 | cursor int 68 | page int 69 | totalPages int 70 | width int 71 | height int 72 | selectedDeck string 73 | } 74 | 75 | // NewBrowseScreen creates a new browse screen 76 | func NewBrowseScreen(store *data.Store) *BrowseScreen { 77 | decks := store.GetDecks() 78 | totalPages := (len(decks) + decksPerPage - 1) / decksPerPage // Ceiling division 79 | 80 | return &BrowseScreen{ 81 | store: store, 82 | decks: decks, 83 | cursor: 0, 84 | page: 0, 85 | totalPages: totalPages, 86 | } 87 | } 88 | 89 | // Init initializes the browse screen 90 | func (b BrowseScreen) Init() tea.Cmd { 91 | return nil 92 | } 93 | 94 | // Update handles user input and updates the model 95 | func (b BrowseScreen) Update(msg tea.Msg) (tea.Model, tea.Cmd) { 96 | switch msg := msg.(type) { 97 | case tea.KeyMsg: 98 | switch { 99 | case key.Matches(msg, browseKeys.Quit): 100 | return b, tea.Quit 101 | 102 | case key.Matches(msg, browseKeys.Up): 103 | if b.cursor > 0 { 104 | b.cursor-- 105 | } 106 | 107 | case key.Matches(msg, browseKeys.Down): 108 | // Calculate the maximum cursor position for the current page 109 | maxCursor := min(decksPerPage, len(b.decks)-b.page*decksPerPage) - 1 110 | if b.cursor < maxCursor { 111 | b.cursor++ 112 | } 113 | 114 | case key.Matches(msg, browseKeys.Next): 115 | if b.page < b.totalPages-1 { 116 | b.page++ 117 | b.cursor = 0 118 | } 119 | 120 | case key.Matches(msg, browseKeys.Prev): 121 | if b.page > 0 { 122 | b.page-- 123 | b.cursor = 0 124 | } 125 | 126 | case key.Matches(msg, browseKeys.Back): 127 | // Return to main menu 128 | return NewMainMenu(b.store), nil 129 | 130 | case key.Matches(msg, browseKeys.Enter): 131 | // Get the selected deck 132 | deckIndex := (b.page * decksPerPage) + b.cursor 133 | if deckIndex < len(b.decks) { 134 | b.selectedDeck = b.decks[deckIndex].ID 135 | // Navigate to study screen with the selected deck 136 | return NewStudyScreen(b.store, b.selectedDeck), nil 137 | } 138 | } 139 | 140 | case tea.WindowSizeMsg: 141 | b.width = 120 // Default width 142 | b.height = msg.Height 143 | } 144 | 145 | return b, nil 146 | } 147 | 148 | // View renders the browse screen 149 | func (b BrowseScreen) View() string { 150 | // Title 151 | s := headerStyle.Render("Browse Decks") 152 | s += "\n\n" 153 | 154 | // Header row 155 | headerRow := fmt.Sprintf("%-20s %-10s %-10s %-15s", "DECK NAME", "CARDS", "DUE", "LAST STUDIED") 156 | s += headerStyle.Render(headerRow) 157 | s += "\n" 158 | 159 | // Calculate the range of decks to display on the current page 160 | startIdx := b.page * decksPerPage 161 | endIdx := min(startIdx+decksPerPage, len(b.decks)) 162 | displayDecks := b.decks[startIdx:endIdx] 163 | 164 | // Display each deck 165 | for i, deck := range displayDecks { 166 | // Count due cards 167 | dueCards := 0 168 | for _, card := range deck.Cards { 169 | if card.NextReview.Before(time.Now()) { 170 | dueCards++ 171 | } 172 | } 173 | 174 | // Format the last studied date 175 | lastStudied := "Never" 176 | if !deck.LastStudied.IsZero() { 177 | if isToday(deck.LastStudied) { 178 | lastStudied = "Today" 179 | } else if isYesterday(deck.LastStudied) { 180 | lastStudied = "Yesterday" 181 | } else if isWithinDays(deck.LastStudied, 7) { 182 | days := daysBetween(deck.LastStudied, time.Now()) 183 | lastStudied = fmt.Sprintf("%d days ago", days) 184 | } else { 185 | lastStudied = deck.LastStudied.Format("Jan 2") 186 | } 187 | } 188 | 189 | // Format the row 190 | row := fmt.Sprintf("%-20s %-10d %-10d %-15s", 191 | truncate(deck.Name, 20), 192 | len(deck.Cards), 193 | dueCards, 194 | lastStudied) 195 | 196 | // Highlight the selected row 197 | if i == b.cursor { 198 | s += selectedRowStyle.Render("> " + row) 199 | } else { 200 | s += normalRowStyle.Render(" " + row) 201 | } 202 | s += "\n" 203 | } 204 | 205 | // Pagination 206 | s += "\n" 207 | pagination := fmt.Sprintf("Page %d of %d", b.page+1, b.totalPages) 208 | s += paginationStyle.Render(pagination) 209 | s += "\n\n" 210 | 211 | // Help text 212 | help := "\t↑/↓: Navigate" + "\tEnter: Study\t" + "b: Back" + "\tn/p: Next/Prev Page" + "\tq: Quit" 213 | s += browseHelpStyle.Render(help) 214 | 215 | return s 216 | } 217 | 218 | // Helper functions 219 | 220 | func min(a, b int) int { 221 | if a < b { 222 | return a 223 | } 224 | return b 225 | } 226 | 227 | func truncate(s string, max int) string { 228 | if len(s) <= max { 229 | return s 230 | } 231 | return s[:max-3] + "..." 232 | } 233 | 234 | func isToday(t time.Time) bool { 235 | now := time.Now() 236 | return t.Year() == now.Year() && t.Month() == now.Month() && t.Day() == now.Day() 237 | } 238 | 239 | func isYesterday(t time.Time) bool { 240 | yesterday := time.Now().AddDate(0, 0, -1) 241 | return t.Year() == yesterday.Year() && t.Month() == yesterday.Month() && t.Day() == yesterday.Day() 242 | } 243 | 244 | func isWithinDays(t time.Time, days int) bool { 245 | return time.Since(t).Hours() < float64(days)*24 246 | } 247 | 248 | func daysBetween(a, b time.Time) int { 249 | return int(b.Sub(a).Hours() / 24) 250 | } 251 | -------------------------------------------------------------------------------- /internal/ui/browse_decks_test.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/browse_decks_test.go 2 | 3 | package ui 4 | 5 | import ( 6 | "strings" 7 | "testing" 8 | 9 | tea "github.com/charmbracelet/bubbletea" 10 | 11 | "github.com/DavidMiserak/GoCard/internal/data" 12 | ) 13 | 14 | func TestBrowseScreenView(t *testing.T) { 15 | // Create a store with dummy data 16 | store := data.NewStore() 17 | 18 | // Create the browse screen 19 | browse := NewBrowseScreen(store) 20 | 21 | // Test the view rendering 22 | view := browse.View() 23 | 24 | // Check that the view contains expected elements 25 | expectedElements := []string{ 26 | "Browse Decks", 27 | "DECK NAME", 28 | "CARDS", 29 | "DUE", 30 | "LAST STUDIED", 31 | "Page 1 of", 32 | } 33 | 34 | for _, element := range expectedElements { 35 | if !strings.Contains(view, element) { 36 | t.Errorf("Expected view to contain '%s', but it didn't", element) 37 | } 38 | } 39 | 40 | // Check that the first deck is selected (has cursor) 41 | lines := strings.Split(view, "\n") 42 | foundSelected := false 43 | 44 | // Look for a line that contains both ">" and the first deck's name 45 | for _, line := range lines { 46 | if strings.Contains(line, ">") && strings.Contains(line, store.GetDecks()[0].Name) { 47 | foundSelected = true 48 | break 49 | } 50 | } 51 | 52 | if !foundSelected { 53 | t.Errorf("Expected first deck to be selected, but it wasn't") 54 | } 55 | } 56 | 57 | func TestBrowseScreenNavigation(t *testing.T) { 58 | // Create a store with dummy data 59 | store := data.NewStore() 60 | 61 | // Create the browse screen 62 | browse := NewBrowseScreen(store) 63 | 64 | // Test navigation 65 | downMsg := tea.KeyMsg{Type: tea.KeyDown} 66 | upMsg := tea.KeyMsg{Type: tea.KeyUp} 67 | 68 | // Move cursor down 69 | updatedModel, _ := browse.Update(downMsg) 70 | updatedBrowse, ok := updatedModel.(BrowseScreen) 71 | if !ok { 72 | t.Fatalf("Expected BrowseScreen, got %T", updatedModel) 73 | } 74 | 75 | if updatedBrowse.cursor != 1 { 76 | t.Errorf("Expected cursor position to be 1 after down key, got %d", updatedBrowse.cursor) 77 | } 78 | 79 | // Move cursor back up 80 | updatedModel, _ = updatedBrowse.Update(upMsg) 81 | updatedBrowse, ok = updatedModel.(BrowseScreen) 82 | if !ok { 83 | t.Fatalf("Expected BrowseScreen, got %T", updatedModel) 84 | } 85 | 86 | if updatedBrowse.cursor != 0 { 87 | t.Errorf("Expected cursor position to be 0 after up key, got %d", updatedBrowse.cursor) 88 | } 89 | } 90 | 91 | func TestBrowseScreenPagination(t *testing.T) { 92 | // Create a store with dummy data 93 | store := data.NewStore() 94 | 95 | // Ensure we have enough decks for pagination 96 | if len(store.GetDecks()) <= decksPerPage { 97 | t.Skip("Not enough decks to test pagination") 98 | } 99 | 100 | // Create the browse screen 101 | browse := NewBrowseScreen(store) 102 | 103 | // Test pagination 104 | nextPageMsg := tea.KeyMsg{Type: tea.KeyRight} 105 | prevPageMsg := tea.KeyMsg{Type: tea.KeyLeft} 106 | 107 | // Move to next page 108 | updatedModel, _ := browse.Update(nextPageMsg) 109 | updatedBrowse, ok := updatedModel.(BrowseScreen) 110 | if !ok { 111 | t.Fatalf("Expected BrowseScreen, got %T", updatedModel) 112 | } 113 | 114 | if updatedBrowse.page != 1 { 115 | t.Errorf("Expected page to be 1 after next page key, got %d", updatedBrowse.page) 116 | } 117 | 118 | // Move back to previous page 119 | updatedModel, _ = updatedBrowse.Update(prevPageMsg) 120 | updatedBrowse, ok = updatedModel.(BrowseScreen) 121 | if !ok { 122 | t.Fatalf("Expected BrowseScreen, got %T", updatedModel) 123 | } 124 | 125 | if updatedBrowse.page != 0 { 126 | t.Errorf("Expected page to be 0 after prev page key, got %d", updatedBrowse.page) 127 | } 128 | } 129 | 130 | func TestBrowseScreenBackButton(t *testing.T) { 131 | // Create a store with dummy data 132 | store := data.NewStore() 133 | 134 | // Create the browse screen 135 | browse := NewBrowseScreen(store) 136 | 137 | // Test back button 138 | backMsg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'b'}} 139 | 140 | // Press back button 141 | updatedModel, _ := browse.Update(backMsg) 142 | 143 | // Verify we got a MainMenu model back 144 | _, ok := updatedModel.(*MainMenu) 145 | if !ok { 146 | t.Fatalf("Expected *MainMenu after back key, got %T", updatedModel) 147 | } 148 | } 149 | -------------------------------------------------------------------------------- /internal/ui/deck_review_tab.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/deck_review_tab.go 2 | 3 | package ui 4 | 5 | import ( 6 | "fmt" 7 | "strings" 8 | "time" 9 | 10 | "github.com/DavidMiserak/GoCard/internal/data" 11 | "github.com/DavidMiserak/GoCard/internal/model" 12 | "github.com/charmbracelet/lipgloss" 13 | ) 14 | 15 | // renderDeckReviewStats renders the Deck Review tab statistics for a specific deck 16 | func renderDeckReviewStats(store *data.Store, focusDeckID string) string { 17 | var sb strings.Builder 18 | var deckID string 19 | 20 | // First priority: use the focusDeckID if provided 21 | if focusDeckID != "" { 22 | deckID = focusDeckID 23 | } else { 24 | // Second priority: fall back to most recently studied deck 25 | deckID = getLastStudiedDeckID(store) 26 | } 27 | 28 | // If no deck is found, display message 29 | if deckID == "" { 30 | return "No deck available to show statistics." 31 | } 32 | 33 | // Find the deck 34 | deck, found := store.GetDeck(deckID) 35 | if !found { 36 | return "Selected deck not found." 37 | } 38 | 39 | // Display deck name 40 | deckTitle := fmt.Sprintf("Deck: %s", deck.Name) 41 | sb.WriteString(statLabelStyle.Bold(true).Render(deckTitle)) 42 | sb.WriteString("\n\n") 43 | 44 | // Get deck-specific stats data 45 | totalCards := len(deck.Cards) 46 | matureCards := getDeckMatureCards(deck) 47 | newCards := totalCards - matureCards 48 | successRate := calculateDeckSuccessRate(deck) 49 | avgInterval := calculateDeckAverageInterval(deck) 50 | lastStudied := deck.LastStudied 51 | ratingDistribution := calculateDeckRatingDistribution(deck) 52 | 53 | // Layout the stats in two columns 54 | leftWidth := 20 55 | rightWidth := 20 56 | 57 | // Left column stats 58 | leftColumn := lipgloss.JoinVertical(lipgloss.Left, 59 | statLabelStyle.Render("Total Cards:")+strings.Repeat(" ", leftWidth-12)+fmt.Sprintf("%4d", totalCards), 60 | statLabelStyle.Render("Mature Cards:")+strings.Repeat(" ", leftWidth-13)+fmt.Sprintf("%4d", matureCards), 61 | statLabelStyle.Render("New Cards:")+strings.Repeat(" ", leftWidth-10)+fmt.Sprintf("%4d", newCards), 62 | ) 63 | 64 | // Format the average interval with one decimal place 65 | intervalStr := fmt.Sprintf("%.1f days", avgInterval) 66 | // Format the last studied date 67 | lastStudiedStr := formatLastStudied(lastStudied) 68 | 69 | // Right column stats 70 | rightColumn := lipgloss.JoinVertical(lipgloss.Left, 71 | statLabelStyle.Render("\tSuccess Rate:")+strings.Repeat(" ", rightWidth-14)+fmt.Sprintf("%3d%%", successRate), 72 | statLabelStyle.Render("\tAvg. Interval:")+strings.Repeat(" ", rightWidth-14)+intervalStr, 73 | statLabelStyle.Render("\tLast Studied:")+strings.Repeat(" ", rightWidth-14)+lastStudiedStr, 74 | ) 75 | 76 | // Join columns horizontally 77 | columns := lipgloss.JoinHorizontal(lipgloss.Top, leftColumn, rightColumn) 78 | sb.WriteString(columns) 79 | 80 | // Add ratings distribution title with some padding 81 | sb.WriteString("\n\n") 82 | sb.WriteString(statLabelStyle.Render("Ratings Distribution")) 83 | sb.WriteString("\n\n") 84 | 85 | // Render ratings distribution chart 86 | chart := renderRatingsDistribution(ratingDistribution) 87 | sb.WriteString(chart) 88 | 89 | return sb.String() 90 | } 91 | 92 | // formatLastStudied formats the last studied date 93 | func formatLastStudied(lastDate time.Time) string { 94 | if lastDate.IsZero() { 95 | return "Never" 96 | } 97 | 98 | now := time.Now() 99 | today := now.Truncate(24 * time.Hour) 100 | lastDateDay := lastDate.Truncate(24 * time.Hour) 101 | 102 | if lastDateDay.Equal(today) { 103 | return "Today" 104 | } else if lastDateDay.Equal(today.AddDate(0, 0, -1)) { 105 | return "Yesterday" 106 | } else { 107 | return lastDate.Format("Jan 2") 108 | } 109 | } 110 | 111 | // getLastStudiedDeckID returns the ID of the most recently studied deck 112 | func getLastStudiedDeckID(store *data.Store) string { 113 | var lastDate time.Time 114 | var lastDeckID string 115 | 116 | for _, deck := range store.GetDecks() { 117 | if deck.LastStudied.After(lastDate) { 118 | lastDate = deck.LastStudied 119 | lastDeckID = deck.ID 120 | } 121 | } 122 | 123 | return lastDeckID 124 | } 125 | 126 | // getDeckMatureCards returns the number of cards with interval >= 21 days for a specific deck 127 | func getDeckMatureCards(deck model.Deck) int { 128 | count := 0 129 | for _, card := range deck.Cards { 130 | if card.Interval >= 21 { 131 | count++ 132 | } 133 | } 134 | return count 135 | } 136 | 137 | // calculateDeckSuccessRate calculates the percentage of reviews rated 3, 4, or 5 for a specific deck 138 | func calculateDeckSuccessRate(deck model.Deck) int { 139 | var totalReviewed, successful int 140 | 141 | // Get reviews from the last 30 days 142 | thirtyDaysAgo := time.Now().AddDate(0, 0, -30) 143 | 144 | for _, card := range deck.Cards { 145 | if !card.LastReviewed.IsZero() && card.LastReviewed.After(thirtyDaysAgo) { 146 | totalReviewed++ 147 | if card.Rating >= 3 { 148 | successful++ 149 | } 150 | } 151 | } 152 | 153 | if totalReviewed == 0 { 154 | return 0 155 | } 156 | 157 | return int((float64(successful) / float64(totalReviewed)) * 100) 158 | } 159 | 160 | // calculateDeckAverageInterval calculates the average interval for all reviewed cards in a specific deck 161 | func calculateDeckAverageInterval(deck model.Deck) float64 { 162 | var totalCards, totalInterval int 163 | 164 | for _, card := range deck.Cards { 165 | if !card.LastReviewed.IsZero() && card.Interval > 0 { 166 | totalCards++ 167 | totalInterval += card.Interval 168 | } 169 | } 170 | 171 | if totalCards == 0 { 172 | return 0 173 | } 174 | 175 | return float64(totalInterval) / float64(totalCards) 176 | } 177 | 178 | // calculateDeckRatingDistribution calculates the distribution of ratings (1-5) for a specific deck 179 | func calculateDeckRatingDistribution(deck model.Deck) map[int]int { 180 | // Initialize the ratings map 181 | distribution := make(map[int]int) 182 | for i := 1; i <= 5; i++ { 183 | distribution[i] = 0 184 | } 185 | 186 | // Get ratings from the last 30 days 187 | thirtyDaysAgo := time.Now().AddDate(0, 0, -30) 188 | 189 | for _, card := range deck.Cards { 190 | if !card.LastReviewed.IsZero() && card.LastReviewed.After(thirtyDaysAgo) && card.Rating >= 1 && card.Rating <= 5 { 191 | distribution[card.Rating]++ 192 | } 193 | } 194 | 195 | return distribution 196 | } 197 | 198 | // renderRatingsDistribution creates a horizontal bar chart for ratings distribution 199 | func renderRatingsDistribution(distribution map[int]int) string { 200 | var sb strings.Builder 201 | 202 | // Calculate total reviews to get percentages 203 | totalReviews := 0 204 | for _, count := range distribution { 205 | totalReviews += count 206 | } 207 | 208 | if totalReviews == 0 { 209 | return "No ratings data available" 210 | } 211 | 212 | // Define rating labels and corresponding styles 213 | ratingLabels := map[int]string{ 214 | 1: "Blackout", 215 | 2: "Wrong", 216 | 3: "Hard", 217 | 4: "Good", 218 | 5: "Easy", 219 | } 220 | 221 | ratingStyles := map[int]lipgloss.Style{ 222 | 1: lipgloss.NewStyle().Foreground(ratingBlackoutColor), 223 | 2: lipgloss.NewStyle().Foreground(ratingWrongColor), 224 | 3: lipgloss.NewStyle().Foreground(ratingHardColor), 225 | 4: lipgloss.NewStyle().Foreground(ratingGoodColor), 226 | 5: lipgloss.NewStyle().Foreground(ratingEasyColor), 227 | } 228 | 229 | // Max width for the bars 230 | maxBarWidth := 30 231 | 232 | // Render each rating bar 233 | for i := 1; i <= 5; i++ { 234 | count := distribution[i] 235 | percentage := 0 236 | if totalReviews > 0 { 237 | percentage = int((float64(count) / float64(totalReviews)) * 100) 238 | } 239 | 240 | // Format the label with rating number and name 241 | label := fmt.Sprintf("%-8s (%d)", ratingLabels[i], i) 242 | labelWidth := 15 243 | formattedLabel := fmt.Sprintf("%-*s", labelWidth, label) 244 | 245 | // Calculate bar width based on percentage 246 | barWidth := int((float64(percentage) / 100.0) * float64(maxBarWidth)) 247 | if percentage > 0 && barWidth == 0 { 248 | barWidth = 1 // Ensure visible bar for non-zero values 249 | } 250 | 251 | // Draw the bar using the appropriate style 252 | bar := "" 253 | if barWidth > 0 { 254 | bar = ratingStyles[i].Render(strings.Repeat("█", barWidth)) 255 | } 256 | 257 | // Combine label and bar 258 | sb.WriteString(formattedLabel + " " + bar) 259 | 260 | // Add percentage at the end of the bar 261 | if percentage > 0 { 262 | sb.WriteString(fmt.Sprintf(" %d%%", percentage)) 263 | } 264 | 265 | // Add spacing between bars except for the last one 266 | if i < 5 { 267 | sb.WriteString("\n\n") 268 | } 269 | } 270 | 271 | return sb.String() 272 | } 273 | -------------------------------------------------------------------------------- /internal/ui/deck_review_tab_test.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/deck_review_tab_test.go 2 | 3 | package ui 4 | 5 | import ( 6 | "strings" 7 | "testing" 8 | "time" 9 | 10 | "github.com/DavidMiserak/GoCard/internal/data" 11 | "github.com/DavidMiserak/GoCard/internal/model" 12 | ) 13 | 14 | // Deck Review Tab Tests 15 | func TestGetDeckMatureCards(t *testing.T) { 16 | // Create a deck with known card intervals 17 | testDeck := model.Deck{ 18 | ID: "test-deck", 19 | Name: "Test Deck", 20 | Cards: []model.Card{ 21 | { 22 | ID: "card-1", 23 | Interval: 10, // Not mature (< 21) 24 | }, 25 | { 26 | ID: "card-2", 27 | Interval: 21, // Mature (>= 21) 28 | }, 29 | { 30 | ID: "card-3", 31 | Interval: 30, // Mature 32 | }, 33 | }, 34 | } 35 | 36 | // Expected: 2 mature cards 37 | expectedCount := 2 38 | actualCount := getDeckMatureCards(testDeck) 39 | 40 | if actualCount != expectedCount { 41 | t.Errorf("Expected mature cards to be %d, got %d", expectedCount, actualCount) 42 | } 43 | } 44 | 45 | func TestCalculateDeckSuccessRate(t *testing.T) { 46 | // Create a deck with known ratings 47 | testDeck := model.Deck{ 48 | ID: "test-deck", 49 | Name: "Test Deck", 50 | Cards: []model.Card{ 51 | { 52 | ID: "card-1", 53 | LastReviewed: time.Now(), 54 | Rating: 5, // Success (rating >= 3) 55 | }, 56 | { 57 | ID: "card-2", 58 | LastReviewed: time.Now(), 59 | Rating: 3, // Success 60 | }, 61 | { 62 | ID: "card-3", 63 | LastReviewed: time.Now(), 64 | Rating: 2, // Failure 65 | }, 66 | { 67 | ID: "card-4", 68 | LastReviewed: time.Now(), 69 | Rating: 1, // Failure 70 | }, 71 | }, 72 | } 73 | 74 | // Expected success rate: 2 successful out of 4 = 50% 75 | expectedRate := 50 76 | actualRate := calculateDeckSuccessRate(testDeck) 77 | 78 | if actualRate != expectedRate { 79 | t.Errorf("Expected success rate to be %d%%, got %d%%", expectedRate, actualRate) 80 | } 81 | } 82 | 83 | func TestCalculateDeckAverageInterval(t *testing.T) { 84 | // Create a deck with known intervals 85 | testDeck := model.Deck{ 86 | ID: "test-deck", 87 | Name: "Test Deck", 88 | Cards: []model.Card{ 89 | { 90 | ID: "card-1", 91 | LastReviewed: time.Now(), 92 | Interval: 10, 93 | }, 94 | { 95 | ID: "card-2", 96 | LastReviewed: time.Now(), 97 | Interval: 20, 98 | }, 99 | }, 100 | } 101 | 102 | // Expected average: (10 + 20) / 2 = 15 103 | expectedAvg := 15.0 104 | actualAvg := calculateDeckAverageInterval(testDeck) 105 | 106 | if actualAvg != expectedAvg { 107 | t.Errorf("Expected average interval to be %.1f, got %.1f", expectedAvg, actualAvg) 108 | } 109 | } 110 | 111 | func TestFormatLastStudied(t *testing.T) { 112 | now := time.Now() 113 | today := now.Truncate(24 * time.Hour) 114 | yesterday := today.AddDate(0, 0, -1) 115 | twoDaysAgo := today.AddDate(0, 0, -2) 116 | 117 | tests := []struct { 118 | name string 119 | date time.Time 120 | expected string 121 | }{ 122 | { 123 | name: "Zero time", 124 | date: time.Time{}, 125 | expected: "Never", 126 | }, 127 | { 128 | name: "Today", 129 | date: today.Add(2 * time.Hour), // Some time today 130 | expected: "Today", 131 | }, 132 | { 133 | name: "Yesterday", 134 | date: yesterday.Add(2 * time.Hour), // Some time yesterday 135 | expected: "Yesterday", 136 | }, 137 | { 138 | name: "Earlier date", 139 | date: twoDaysAgo, 140 | expected: twoDaysAgo.Format("Jan 2"), 141 | }, 142 | } 143 | 144 | for _, test := range tests { 145 | t.Run(test.name, func(t *testing.T) { 146 | result := formatLastStudied(test.date) 147 | if result != test.expected { 148 | t.Errorf("Expected formatLastStudied(%v) to be '%s', got '%s'", test.date, test.expected, result) 149 | } 150 | }) 151 | } 152 | } 153 | 154 | func TestCalculateDeckRatingDistribution(t *testing.T) { 155 | // Create a deck with known ratings 156 | testDeck := model.Deck{ 157 | ID: "test-deck", 158 | Name: "Test Deck", 159 | Cards: []model.Card{ 160 | { 161 | ID: "card-1", 162 | LastReviewed: time.Now(), 163 | Rating: 1, 164 | }, 165 | { 166 | ID: "card-2", 167 | LastReviewed: time.Now(), 168 | Rating: 2, 169 | }, 170 | { 171 | ID: "card-3", 172 | LastReviewed: time.Now(), 173 | Rating: 2, // Another 2 174 | }, 175 | { 176 | ID: "card-4", 177 | LastReviewed: time.Now(), 178 | Rating: 3, 179 | }, 180 | { 181 | ID: "card-5", 182 | LastReviewed: time.Now(), 183 | Rating: 4, 184 | }, 185 | }, 186 | } 187 | 188 | distribution := calculateDeckRatingDistribution(testDeck) 189 | 190 | // Check each rating count 191 | expectedDistribution := map[int]int{ 192 | 1: 1, // One card with rating 1 193 | 2: 2, // Two cards with rating 2 194 | 3: 1, // One card with rating 3 195 | 4: 1, // One card with rating 4 196 | 5: 0, // No cards with rating 5 197 | } 198 | 199 | for rating, expectedCount := range expectedDistribution { 200 | if distribution[rating] != expectedCount { 201 | t.Errorf("Expected rating %d to have count %d, got %d", rating, expectedCount, distribution[rating]) 202 | } 203 | } 204 | } 205 | 206 | func TestGetLastStudiedDeckID(t *testing.T) { 207 | // Create a store with decks that have different LastStudied times 208 | now := time.Now() 209 | oldTime := now.Add(-24 * time.Hour) 210 | olderTime := now.Add(-48 * time.Hour) 211 | 212 | testStore := &data.Store{ 213 | Decks: []model.Deck{ 214 | { 215 | ID: "deck-1", 216 | Name: "Deck 1", 217 | LastStudied: oldTime, 218 | }, 219 | { 220 | ID: "deck-2", 221 | Name: "Deck 2", 222 | LastStudied: now, // Most recent 223 | }, 224 | { 225 | ID: "deck-3", 226 | Name: "Deck 3", 227 | LastStudied: olderTime, 228 | }, 229 | }, 230 | } 231 | 232 | // We expect deck-2 to be returned as the most recently studied 233 | expectedID := "deck-2" 234 | actualID := getLastStudiedDeckID(testStore) 235 | 236 | if actualID != expectedID { 237 | t.Errorf("Expected last studied deck ID to be %s, got %s", expectedID, actualID) 238 | } 239 | } 240 | 241 | func TestRenderDeckReviewStats(t *testing.T) { 242 | store := createTestStoreForDeckReview() 243 | 244 | // Just test that rendering doesn't panic and returns a non-empty string 245 | result := renderDeckReviewStats(store, "") 246 | 247 | if result == "" { 248 | t.Error("Expected renderDeckReviewStats to return a non-empty string") 249 | } 250 | 251 | // Check if the result contains expected headers 252 | expectedHeaders := []string{ 253 | "Total Cards:", 254 | "Mature Cards:", 255 | "New Cards:", 256 | "Success Rate:", 257 | "Avg. Interval:", 258 | "Last Studied:", 259 | "Ratings Distribution", 260 | } 261 | 262 | for _, header := range expectedHeaders { 263 | if !strings.Contains(result, header) { 264 | t.Errorf("Expected output to contain '%s'", header) 265 | } 266 | } 267 | } 268 | 269 | // Helper function to create a test store 270 | func createTestStoreForDeckReview() *data.Store { 271 | return data.NewStore() // Using the existing NewStore function that creates dummy data 272 | } 273 | -------------------------------------------------------------------------------- /internal/ui/forecast_tab.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/forecast_tab.go 2 | 3 | package ui 4 | 5 | import ( 6 | "fmt" 7 | "strings" 8 | "time" 9 | 10 | "github.com/DavidMiserak/GoCard/internal/data" 11 | "github.com/charmbracelet/lipgloss" 12 | ) 13 | 14 | // renderReviewForecastStats renders the Review Forecast tab statistics 15 | func renderReviewForecastStats(store *data.Store) string { 16 | var sb strings.Builder 17 | 18 | // Get forecast data 19 | cardsDueToday := len(store.GetDueCards()) 20 | cardsDueTomorrow := getCardsDueOnDate(store, time.Now().AddDate(0, 0, 1)) 21 | cardsDueThisWeek := getCardsDueInNextDays(store, 7) 22 | newCardsPerDay := calculateNewCardsPerDay(store) 23 | reviewsPerDay := calculateReviewsPerDay(store) 24 | forecastData := generateForecastData(store, 7) 25 | 26 | // Layout the top stats in a row 27 | topRowWidth := 20 28 | 29 | // Top row stats 30 | topRow := lipgloss.JoinHorizontal(lipgloss.Top, 31 | statLabelStyle.Render("\tDue Today:")+strings.Repeat(" ", topRowWidth-11)+fmt.Sprintf("%4d", cardsDueToday), 32 | statLabelStyle.Render("\tDue Tomorrow:")+strings.Repeat(" ", topRowWidth-14)+fmt.Sprintf("%4d", cardsDueTomorrow), 33 | statLabelStyle.Render("\tDue This Week:")+strings.Repeat(" ", topRowWidth-15)+fmt.Sprintf("%4d", cardsDueThisWeek), 34 | ) 35 | sb.WriteString(topRow) 36 | sb.WriteString("\n") 37 | 38 | // Second row stats 39 | secondRow := lipgloss.JoinHorizontal(lipgloss.Top, 40 | statLabelStyle.Render("\tNew Cards/Day:")+strings.Repeat(" ", topRowWidth-15)+fmt.Sprintf("%4d", newCardsPerDay), 41 | statLabelStyle.Render("\tReviews/Day (Avg):")+strings.Repeat(" ", topRowWidth-19)+fmt.Sprintf("%4d", reviewsPerDay), 42 | ) 43 | sb.WriteString(secondRow) 44 | 45 | // Add chart title with some padding 46 | sb.WriteString("\n\n") 47 | sb.WriteString(statLabelStyle.Render("Cards Due by Day")) 48 | sb.WriteString("\n\n") 49 | 50 | // Render legend for the chart 51 | sb.WriteString(renderForecastLegend()) 52 | sb.WriteString("\n\n") 53 | 54 | // Render horizontal bar chart for cards due by day 55 | chart := renderHorizontalForecastChart(forecastData) 56 | sb.WriteString(chart) 57 | 58 | return sb.String() 59 | } 60 | 61 | // getCardsDueOnDate returns the number of cards due on a specific date 62 | func getCardsDueOnDate(store *data.Store, date time.Time) int { 63 | count := 0 64 | startOfDay := date.Truncate(24 * time.Hour) 65 | endOfDay := startOfDay.Add(24 * time.Hour) 66 | 67 | for _, deck := range store.GetDecks() { 68 | for _, card := range deck.Cards { 69 | if card.NextReview.After(startOfDay) && card.NextReview.Before(endOfDay) { 70 | count++ 71 | } 72 | } 73 | } 74 | return count 75 | } 76 | 77 | // getCardsDueInNextDays returns the number of cards due in the next n days 78 | func getCardsDueInNextDays(store *data.Store, days int) int { 79 | count := 0 80 | now := time.Now() 81 | endDate := now.AddDate(0, 0, days) 82 | 83 | for _, deck := range store.GetDecks() { 84 | for _, card := range deck.Cards { 85 | if card.NextReview.After(now) && card.NextReview.Before(endDate) { 86 | count++ 87 | } 88 | } 89 | } 90 | return count 91 | } 92 | 93 | // calculateNewCardsPerDay returns the average number of new cards studied per day 94 | func calculateNewCardsPerDay(store *data.Store) int { 95 | // In a real implementation, you would analyze the study history 96 | // For now, we'll return a fixed number as in the screenshot 97 | return 10 98 | } 99 | 100 | // calculateReviewsPerDay returns the average number of reviews per day 101 | func calculateReviewsPerDay(store *data.Store) int { 102 | // In a real implementation, you would analyze the study history 103 | // For now, we'll return a fixed number as in the screenshot 104 | return 32 105 | } 106 | 107 | // ForecastDay represents forecast data for a single day 108 | type ForecastDay struct { 109 | Date time.Time 110 | ReviewDue int 111 | NewDue int 112 | } 113 | 114 | // generateForecastData generates forecast data for the next n days 115 | func generateForecastData(store *data.Store, days int) []ForecastDay { 116 | now := time.Now() 117 | return generateForecastDataFromDate(store, days, now) 118 | } 119 | 120 | // New helper function with explicit date control for testing 121 | func generateForecastDataFromDate(store *data.Store, days int, baseDate time.Time) []ForecastDay { 122 | forecast := make([]ForecastDay, days) 123 | 124 | // Initialize the forecast days 125 | for i := 0; i < days; i++ { 126 | date := baseDate.AddDate(0, 0, i) 127 | forecast[i] = ForecastDay{ 128 | Date: date, 129 | ReviewDue: 0, 130 | NewDue: 0, 131 | } 132 | } 133 | 134 | // Fill in the forecast data 135 | for _, deck := range store.GetDecks() { 136 | for _, card := range deck.Cards { 137 | if card.NextReview.IsZero() { 138 | continue 139 | } 140 | 141 | // Find which forecast day this card belongs to 142 | for i, forecastDay := range forecast { 143 | if isSameDay(card.NextReview, forecastDay.Date) { 144 | if card.Interval > 0 { 145 | // Card has been reviewed before (review card) 146 | forecast[i].ReviewDue++ 147 | } else { 148 | // New card 149 | forecast[i].NewDue++ 150 | } 151 | break // Card can only be due on one day 152 | } 153 | } 154 | } 155 | } 156 | 157 | return forecast 158 | } 159 | 160 | // Helper function to check if two dates are the same day 161 | func isSameDay(date1, date2 time.Time) bool { 162 | y1, m1, d1 := date1.Date() 163 | y2, m2, d2 := date2.Date() 164 | return y1 == y2 && m1 == m2 && d1 == d2 165 | } 166 | 167 | // renderForecastLegend renders the legend for the forecast chart 168 | func renderForecastLegend() string { 169 | 170 | // Create styled blocks for legend 171 | reviewStyle := lipgloss.NewStyle().Foreground(colorBlue) 172 | newStyle := lipgloss.NewStyle().Foreground(colorGreen) 173 | 174 | reviewBlock := reviewStyle.Render("█") 175 | newBlock := newStyle.Render("█") 176 | 177 | return fmt.Sprintf("%s Review %s New", reviewBlock, newBlock) 178 | } 179 | 180 | // renderHorizontalForecastChart creates a horizontal bar chart for cards due by day 181 | func renderHorizontalForecastChart(data []ForecastDay) string { 182 | var sb strings.Builder 183 | 184 | // Find the maximum value for scaling 185 | maxValue := 0 186 | for _, day := range data { 187 | total := day.ReviewDue + day.NewDue 188 | if total > maxValue { 189 | maxValue = total 190 | } 191 | } 192 | 193 | // Set a minimum scale if data is empty 194 | if maxValue == 0 { 195 | maxValue = 50 // Match the scale in the screenshot 196 | } 197 | 198 | // Create styles with the explicit colors 199 | reviewStyle := lipgloss.NewStyle().Foreground(colorBlue) 200 | newStyle := lipgloss.NewStyle().Foreground(colorGreen) 201 | 202 | // Maximum width for the bars 203 | maxBarWidth := 30 204 | 205 | // Draw each day's bar 206 | for i, day := range data { 207 | // Format the date for the y-axis label 208 | var dateLabel string 209 | if i == 0 { 210 | dateLabel = "Today" 211 | } else { 212 | dateLabel = day.Date.Format("Jan 2") 213 | } 214 | 215 | // Format the label with fixed width for alignment 216 | labelWidth := 10 217 | formattedLabel := fmt.Sprintf("%-*s", labelWidth, dateLabel) 218 | 219 | // Calculate bar widths based on values and scale to max width 220 | reviewWidth := 0 221 | if day.ReviewDue > 0 { 222 | reviewWidth = int((float64(day.ReviewDue) / float64(maxValue)) * float64(maxBarWidth)) 223 | if reviewWidth == 0 { 224 | reviewWidth = 1 // Ensure visible bar for non-zero values 225 | } 226 | } 227 | 228 | newWidth := 0 229 | if day.NewDue > 0 { 230 | newWidth = int((float64(day.NewDue) / float64(maxValue)) * float64(maxBarWidth)) 231 | if newWidth == 0 { 232 | newWidth = 1 // Ensure visible bar for non-zero values 233 | } 234 | } 235 | 236 | // Create colored bars with explicit styling 237 | newBar := "" 238 | if newWidth > 0 { 239 | newBar = newStyle.Render(strings.Repeat("█", newWidth)) 240 | } 241 | 242 | reviewBar := "" 243 | if reviewWidth > 0 { 244 | reviewBar = reviewStyle.Render(strings.Repeat("█", reviewWidth)) 245 | } 246 | 247 | // Combine label and bars 248 | sb.WriteString(formattedLabel + " " + newBar + reviewBar) 249 | 250 | // Add total count at the end of the bar 251 | total := day.ReviewDue + day.NewDue 252 | if total > 0 { 253 | sb.WriteString(fmt.Sprintf(" %d", total)) 254 | } 255 | 256 | // Add spacing between bars except for the last one 257 | if i < len(data)-1 { 258 | sb.WriteString("\n\n") 259 | } 260 | } 261 | 262 | return sb.String() 263 | } 264 | -------------------------------------------------------------------------------- /internal/ui/forecast_tab_test.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/forecast_tab_test.go 2 | 3 | package ui 4 | 5 | import ( 6 | "strings" 7 | "testing" 8 | "time" 9 | 10 | "github.com/DavidMiserak/GoCard/internal/data" 11 | "github.com/DavidMiserak/GoCard/internal/model" 12 | ) 13 | 14 | // Forecast Tab Tests 15 | func TestGetCardsDueOnDate(t *testing.T) { 16 | // Create a store with cards due on specific dates 17 | tomorrow := time.Now().AddDate(0, 0, 1) 18 | dayAfterTomorrow := time.Now().AddDate(0, 0, 2) 19 | 20 | testStore := &data.Store{ 21 | Decks: []model.Deck{ 22 | { 23 | ID: "test-deck", 24 | Cards: []model.Card{ 25 | { 26 | ID: "card-1", 27 | NextReview: tomorrow.Add(1 * time.Hour), // Due tomorrow 28 | }, 29 | { 30 | ID: "card-2", 31 | NextReview: tomorrow.Add(2 * time.Hour), // Also due tomorrow 32 | }, 33 | { 34 | ID: "card-3", 35 | NextReview: dayAfterTomorrow, // Not due tomorrow 36 | }, 37 | }, 38 | }, 39 | }, 40 | } 41 | 42 | // Expected: 2 cards due tomorrow 43 | expectedCount := 2 44 | actualCount := getCardsDueOnDate(testStore, tomorrow) 45 | 46 | if actualCount != expectedCount { 47 | t.Errorf("Expected cards due tomorrow to be %d, got %d", expectedCount, actualCount) 48 | } 49 | } 50 | 51 | func TestGetCardsDueInNextDays(t *testing.T) { 52 | now := time.Now() 53 | tomorrow := now.AddDate(0, 0, 1) 54 | threeDaysFromNow := now.AddDate(0, 0, 3) 55 | sevenDaysFromNow := now.AddDate(0, 0, 7) 56 | 57 | testStore := &data.Store{ 58 | Decks: []model.Deck{ 59 | { 60 | ID: "test-deck", 61 | Cards: []model.Card{ 62 | { 63 | ID: "card-1", 64 | NextReview: tomorrow, 65 | }, 66 | { 67 | ID: "card-2", 68 | NextReview: threeDaysFromNow, 69 | }, 70 | { 71 | ID: "card-3", 72 | NextReview: sevenDaysFromNow, 73 | }, 74 | { 75 | ID: "card-4", 76 | NextReview: now.AddDate(0, 0, 10), // Outside the 7-day window 77 | }, 78 | }, 79 | }, 80 | }, 81 | } 82 | 83 | // Expected: 3 cards due in the next 7 days 84 | expectedCount := 3 85 | actualCount := getCardsDueInNextDays(testStore, 7) 86 | 87 | if actualCount != expectedCount { 88 | t.Errorf("Expected cards due in 7 days to be %d, got %d", expectedCount, actualCount) 89 | } 90 | } 91 | 92 | func TestCalculateNewCardsPerDay(t *testing.T) { 93 | store := createTestStoreForForcast() 94 | 95 | // This is a fixed function in the code, so we just check it returns a reasonable value 96 | result := calculateNewCardsPerDay(store) 97 | 98 | if result <= 0 { 99 | t.Errorf("Expected new cards per day to be positive, got %d", result) 100 | } 101 | } 102 | 103 | func TestCalculateReviewsPerDay(t *testing.T) { 104 | store := createTestStoreForForcast() 105 | 106 | // This is a fixed function in the code, so we just check it returns a reasonable value 107 | result := calculateReviewsPerDay(store) 108 | 109 | if result <= 0 { 110 | t.Errorf("Expected reviews per day to be positive, got %d", result) 111 | } 112 | } 113 | 114 | func TestGenerateForecastData(t *testing.T) { 115 | // Create a fixed reference date in UTC 116 | baseDate := time.Date(2025, 4, 2, 0, 0, 0, 0, time.UTC) 117 | tomorrow := baseDate.AddDate(0, 0, 1) 118 | 119 | // Create test cards with controlled dates and intervals 120 | testStore := &data.Store{ 121 | Decks: []model.Deck{ 122 | { 123 | ID: "test-deck", 124 | Cards: []model.Card{ 125 | { 126 | ID: "card-1", 127 | NextReview: tomorrow.Add(5 * time.Hour), // Due tomorrow, time doesn't matter 128 | Interval: 0, // New card 129 | }, 130 | { 131 | ID: "card-2", 132 | NextReview: tomorrow.Add(10 * time.Hour), // Due tomorrow, time doesn't matter 133 | Interval: 5, // Review card (Interval > 0) 134 | }, 135 | }, 136 | }, 137 | }, 138 | } 139 | 140 | // Generate forecast using our fixed UTC base date 141 | forecast := generateForecastDataFromDate(testStore, 3, baseDate) 142 | 143 | // The index for tomorrow should always be 1 (today is 0, tomorrow is 1) 144 | tomorrowIndex := 1 145 | 146 | // Check counts for tomorrow 147 | if forecast[tomorrowIndex].NewDue != 1 { 148 | t.Errorf("Expected 1 new card due tomorrow, got %d", forecast[tomorrowIndex].NewDue) 149 | } 150 | 151 | if forecast[tomorrowIndex].ReviewDue != 1 { 152 | t.Errorf("Expected 1 review card due tomorrow, got %d", forecast[tomorrowIndex].ReviewDue) 153 | } 154 | } 155 | 156 | func TestRenderForecastLegend(t *testing.T) { 157 | result := renderForecastLegend() 158 | 159 | if result == "" { 160 | t.Error("Expected renderForecastLegend to return a non-empty string") 161 | } 162 | 163 | // Check if the result contains expected text 164 | if !strings.Contains(result, "Review") { 165 | t.Error("Expected legend to contain 'Review'") 166 | } 167 | 168 | if !strings.Contains(result, "New") { 169 | t.Error("Expected legend to contain 'New'") 170 | } 171 | } 172 | 173 | func TestRenderHorizontalForecastChart(t *testing.T) { 174 | // Create test forecast data 175 | today := time.Now() 176 | forecast := []ForecastDay{ 177 | { 178 | Date: today, 179 | ReviewDue: 10, 180 | NewDue: 5, 181 | }, 182 | { 183 | Date: today.AddDate(0, 0, 1), 184 | ReviewDue: 8, 185 | NewDue: 3, 186 | }, 187 | } 188 | 189 | // Render the chart 190 | result := renderHorizontalForecastChart(forecast) 191 | 192 | // Check for basic content 193 | if result == "" { 194 | t.Error("Expected renderHorizontalForecastChart to return a non-empty string") 195 | } 196 | 197 | // Check for "Today" label 198 | if !strings.Contains(result, "Today") { 199 | t.Error("Expected chart to contain 'Today' label") 200 | } 201 | } 202 | 203 | func TestRenderReviewForecastStats(t *testing.T) { 204 | store := createTestStore() 205 | 206 | // Just test that rendering doesn't panic and returns a non-empty string 207 | result := renderReviewForecastStats(store) 208 | 209 | if result == "" { 210 | t.Error("Expected renderReviewForecastStats to return a non-empty string") 211 | } 212 | 213 | // Check if the result contains expected headers 214 | expectedHeaders := []string{ 215 | "Due Today:", 216 | "Due Tomorrow:", 217 | "Due This Week:", 218 | "New Cards/Day:", 219 | "Reviews/Day", 220 | "Cards Due by Day", 221 | } 222 | 223 | for _, header := range expectedHeaders { 224 | if !strings.Contains(result, header) { 225 | t.Errorf("Expected output to contain '%s'", header) 226 | } 227 | } 228 | } 229 | 230 | // Helper function to create a test store 231 | func createTestStoreForForcast() *data.Store { 232 | return data.NewStore() 233 | } 234 | -------------------------------------------------------------------------------- /internal/ui/main_menu.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/menu.go 2 | 3 | package ui 4 | 5 | import ( 6 | "github.com/charmbracelet/bubbles/key" 7 | tea "github.com/charmbracelet/bubbletea" 8 | 9 | "github.com/DavidMiserak/GoCard/internal/data" 10 | ) 11 | 12 | // Define key mappings 13 | type keyMap struct { 14 | Up key.Binding 15 | Down key.Binding 16 | Enter key.Binding 17 | Quit key.Binding 18 | } 19 | 20 | var keys = keyMap{ 21 | Up: key.NewBinding( 22 | key.WithKeys("up", "k"), // "k" for Vim users 23 | key.WithHelp("↑/k", "up"), 24 | ), 25 | Down: key.NewBinding( 26 | key.WithKeys("down", "j"), // "j" for Vim users 27 | key.WithHelp("↓/j", "down"), 28 | ), 29 | Enter: key.NewBinding( 30 | key.WithKeys("enter"), 31 | key.WithHelp("enter", "select"), 32 | ), 33 | Quit: key.NewBinding( 34 | key.WithKeys("q", "ctrl+c"), 35 | key.WithHelp("q", "quit"), 36 | ), 37 | } 38 | 39 | // MainMenu represents the main menu model 40 | type MainMenu struct { 41 | items []string 42 | cursor int 43 | selected int 44 | width int 45 | height int 46 | store *data.Store // Added store field 47 | } 48 | 49 | // NewMainMenu creates a new main menu 50 | func NewMainMenu(store *data.Store) *MainMenu { 51 | // If no store provided, create a new one with dummy data 52 | if store == nil { 53 | store = data.NewStore() 54 | } 55 | 56 | return &MainMenu{ 57 | items: []string{"Study", "Browse Decks", "Statistics", "Quit"}, 58 | cursor: 0, 59 | selected: -1, 60 | store: store, 61 | } 62 | } 63 | 64 | // Init initializes the main menu 65 | func (m MainMenu) Init() tea.Cmd { 66 | return nil 67 | } 68 | 69 | // Update handles user input and updates the model 70 | func (m MainMenu) Update(msg tea.Msg) (tea.Model, tea.Cmd) { 71 | switch msg := msg.(type) { 72 | case tea.KeyMsg: 73 | switch { 74 | case key.Matches(msg, keys.Quit): 75 | return m, tea.Quit 76 | 77 | case key.Matches(msg, keys.Up): 78 | if m.cursor > 0 { 79 | m.cursor-- 80 | } 81 | 82 | case key.Matches(msg, keys.Down): 83 | if m.cursor < len(m.items)-1 { 84 | m.cursor++ 85 | } 86 | 87 | case key.Matches(msg, keys.Enter): 88 | m.selected = m.cursor 89 | 90 | // Handle menu selection 91 | switch m.cursor { 92 | case 0: // Study 93 | // Navigate to study screen 94 | return NewBrowseScreen(m.store), nil 95 | 96 | case 1: // Browse Decks 97 | // Navigate to browse decks screen 98 | return NewBrowseScreen(m.store), nil 99 | 100 | case 2: // Statistics 101 | // Navigate to statistics screen 102 | return NewStatisticsScreen(m.store), nil 103 | 104 | case 3: // Quit 105 | return m, tea.Quit 106 | } 107 | } 108 | 109 | case tea.WindowSizeMsg: 110 | m.width = 120 // Default width 111 | m.height = msg.Height 112 | } 113 | 114 | return m, nil 115 | } 116 | 117 | // View renders the main menu 118 | func (m MainMenu) View() string { 119 | // Title and subtitle 120 | s := titleStyle.Render("GoCard") 121 | s += "\n" + subtitleStyle.Render("Terminal Flashcards") 122 | s += "\n\n" 123 | 124 | // Menu items 125 | for i, item := range m.items { 126 | if i == m.cursor { 127 | s += selectedItemStyle.Render("> " + item) 128 | } else { 129 | s += normalItemStyle.Render(" " + item) 130 | } 131 | s += "\n" 132 | } 133 | 134 | // Help 135 | s += "\n" + helpStyle.Render("\t↑/↓: Navigate"+"\tEnter: Select"+"\tq: Quit") 136 | 137 | return s 138 | } 139 | -------------------------------------------------------------------------------- /internal/ui/main_menu_test.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/menu_test.go 2 | 3 | package ui 4 | 5 | import ( 6 | "strings" 7 | "testing" 8 | 9 | "github.com/DavidMiserak/GoCard/internal/data" 10 | tea "github.com/charmbracelet/bubbletea" 11 | ) 12 | 13 | // TestMainMenuView tests that the menu renders correctly 14 | func TestMainMenuView(t *testing.T) { 15 | // Create a test store 16 | store := data.NewStore() 17 | 18 | // Create a new instance of our menu 19 | menu := NewMainMenu(store) 20 | 21 | // Test the initial view rendering 22 | view := menu.View() 23 | 24 | // Check that the view contains all expected menu items 25 | expectedItems := []string{"Study", "Browse Decks", "Statistics", "Quit"} 26 | for _, item := range expectedItems { 27 | if !strings.Contains(view, item) { 28 | t.Errorf("Expected view to contain menu item '%s', but it didn't", item) 29 | } 30 | } 31 | 32 | // Check that the view contains the title 33 | if !strings.Contains(view, "GoCard") { 34 | t.Errorf("Expected view to contain the title 'GoCard', but it didn't") 35 | } 36 | 37 | // Check that the view contains the subtitle 38 | if !strings.Contains(view, "Terminal Flashcards") { 39 | t.Errorf("Expected view to contain the subtitle 'Terminal Flashcards', but it didn't") 40 | } 41 | } 42 | 43 | // TestMainMenuUpdate tests cursor movement and selection 44 | func TestMainMenuUpdate(t *testing.T) { 45 | // Create a test store 46 | store := data.NewStore() 47 | 48 | // Create a new instance of our menu 49 | menu := NewMainMenu(store) 50 | 51 | // Test cursor movement with up/down keys 52 | downMsg := tea.KeyMsg{Type: tea.KeyDown} 53 | upMsg := tea.KeyMsg{Type: tea.KeyUp} 54 | 55 | // Initial cursor position should be 0 56 | if menu.cursor != 0 { 57 | t.Errorf("Expected initial cursor position to be 0, got %d", menu.cursor) 58 | } 59 | 60 | // Move cursor down once 61 | updatedModel, _ := menu.Update(downMsg) 62 | updatedMenu, ok := updatedModel.(MainMenu) 63 | if !ok { 64 | t.Fatalf("Expected MainMenu, got %T", updatedModel) 65 | } 66 | 67 | if updatedMenu.cursor != 1 { 68 | t.Errorf("Expected cursor position to be 1 after down key, got %d", updatedMenu.cursor) 69 | } 70 | 71 | // Move cursor up 72 | updatedModel, _ = updatedMenu.Update(upMsg) 73 | updatedMenu, ok = updatedModel.(MainMenu) 74 | if !ok { 75 | t.Fatalf("Expected MainMenu, got %T", updatedModel) 76 | } 77 | 78 | if updatedMenu.cursor != 0 { 79 | t.Errorf("Expected cursor position to be 0 after up key, got %d", updatedMenu.cursor) 80 | } 81 | } 82 | -------------------------------------------------------------------------------- /internal/ui/markdown_renderer.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/markdown_renderer.go 2 | 3 | package ui 4 | 5 | import ( 6 | "bytes" 7 | "fmt" 8 | "strings" 9 | 10 | "github.com/alecthomas/chroma/v2/formatters" 11 | "github.com/alecthomas/chroma/v2/lexers" 12 | "github.com/alecthomas/chroma/v2/styles" 13 | "github.com/charmbracelet/glamour" 14 | ) 15 | 16 | // MarkdownRenderer handles rendering Markdown text to styled terminal output 17 | type MarkdownRenderer struct { 18 | renderer *glamour.TermRenderer 19 | renderedCache map[string]string 20 | defaultWidth int 21 | syntaxTheme string 22 | } 23 | 24 | // NewMarkdownRenderer creates a new markdown renderer with specified width and theme 25 | func NewMarkdownRenderer(width int, themeName string) *MarkdownRenderer { 26 | // Use default width if not specified 27 | if width <= 0 { 28 | width = 80 29 | } 30 | 31 | // Validate and set theme, fallback to "monokai" if invalid 32 | if themeName == "" { 33 | themeName = "monokai" 34 | } 35 | 36 | // Initialize glamour renderer with explicit style 37 | renderer, _ := glamour.NewTermRenderer( 38 | glamour.WithStandardStyle("dark"), 39 | glamour.WithWordWrap(width), 40 | glamour.WithEmoji(), 41 | ) 42 | 43 | return &MarkdownRenderer{ 44 | renderer: renderer, 45 | renderedCache: make(map[string]string), 46 | defaultWidth: width, 47 | syntaxTheme: themeName, 48 | } 49 | } 50 | 51 | // renderCodeBlock uses Chroma to syntax highlight code blocks 52 | func renderCodeBlock(code, language, themeName string) string { 53 | // Determine the lexer based on the language 54 | lexer := lexers.Get(language) 55 | if lexer == nil { 56 | lexer = lexers.Fallback 57 | } 58 | 59 | // Use specified theme 60 | style := styles.Get(themeName) 61 | if style == nil { 62 | style = styles.Fallback 63 | } 64 | 65 | // Create a terminal formatter 66 | formatter := formatters.Get("terminal") 67 | if formatter == nil { 68 | formatter = formatters.Fallback 69 | } 70 | 71 | // Tokenize the code 72 | iterator, err := lexer.Tokenise(nil, code) 73 | if err != nil { 74 | return code // Fallback to original code if tokenization fails 75 | } 76 | 77 | // Render the highlighted code 78 | var buf bytes.Buffer 79 | err = formatter.Format(&buf, style, iterator) 80 | if err != nil { 81 | return code // Fallback to original code if formatting fails 82 | } 83 | 84 | return buf.String() 85 | } 86 | 87 | // UpdateWidth updates the renderer's width and clears the cache 88 | func (r *MarkdownRenderer) UpdateWidth(width int) { 89 | if width <= 0 { 90 | return 91 | } 92 | 93 | // Create a new renderer with the updated width 94 | renderer, _ := glamour.NewTermRenderer( 95 | glamour.WithStandardStyle("dark"), 96 | glamour.WithWordWrap(width), 97 | glamour.WithEmoji(), 98 | ) 99 | 100 | r.renderer = renderer 101 | r.defaultWidth = width 102 | 103 | // Clear the cache because we need to re-render with new width 104 | r.renderedCache = make(map[string]string) 105 | } 106 | 107 | // SetSyntaxTheme allows changing the syntax highlighting theme 108 | func (r *MarkdownRenderer) SetSyntaxTheme(themeName string) { 109 | // Validate theme 110 | if themeName == "" { 111 | themeName = "monokai" 112 | } 113 | 114 | // Update renderer with new theme 115 | renderer, _ := glamour.NewTermRenderer( 116 | glamour.WithStandardStyle("dark"), 117 | glamour.WithWordWrap(r.defaultWidth), 118 | glamour.WithEmoji(), 119 | ) 120 | 121 | r.renderer = renderer 122 | r.syntaxTheme = themeName 123 | 124 | // Clear cache to force re-rendering with new theme 125 | r.renderedCache = make(map[string]string) 126 | } 127 | 128 | // Render renders markdown text to terminal output 129 | func (r *MarkdownRenderer) Render(markdown string) string { 130 | // Create cache key using content, width, and theme to ensure proper rendering 131 | cacheKey := fmt.Sprintf("%s-%d-%s", markdown, r.defaultWidth, r.syntaxTheme) 132 | 133 | // Check if we already have this content rendered in the cache 134 | if rendered, exists := r.renderedCache[cacheKey]; exists { 135 | return rendered 136 | } 137 | 138 | // Not in cache, render it now 139 | if r.renderer == nil { 140 | // Fallback if renderer isn't initialized 141 | return markdown 142 | } 143 | 144 | rendered, err := r.renderer.Render(markdown) 145 | if err != nil { 146 | // Return the original text if rendering fails 147 | return markdown 148 | } 149 | 150 | // Trim extra whitespace that glamour might add 151 | rendered = strings.TrimSpace(rendered) 152 | 153 | // Store in cache for future use 154 | r.renderedCache[cacheKey] = rendered 155 | 156 | return rendered 157 | } 158 | 159 | // ClearCache clears the rendering cache 160 | func (r *MarkdownRenderer) ClearCache() { 161 | r.renderedCache = make(map[string]string) 162 | } 163 | -------------------------------------------------------------------------------- /internal/ui/stats_screen.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/stats_screen.go 2 | 3 | package ui 4 | 5 | import ( 6 | "strings" 7 | 8 | tea "github.com/charmbracelet/bubbletea" 9 | 10 | "github.com/DavidMiserak/GoCard/internal/data" 11 | ) 12 | 13 | // StatisticsScreen represents the statistics view 14 | type StatisticsScreen struct { 15 | store *data.Store 16 | width int 17 | height int 18 | activeTab int 19 | cardStats []int // Cards studied per day for the last 5 days 20 | lastDeckID string // ID of the last deck studied/viewed 21 | } 22 | 23 | // NewStatisticsScreen creates a new statistics screen 24 | func NewStatisticsScreen(store *data.Store) *StatisticsScreen { 25 | return &StatisticsScreen{ 26 | store: store, 27 | activeTab: 1, // Default to the Deck Review tab 28 | cardStats: calculateCardStudiedPerDay(store), 29 | lastDeckID: "", // Will be set when coming from a study session 30 | } 31 | } 32 | 33 | // NewStatisticsScreenWithDeck creates a new statistics screen with a focus on a specific deck 34 | func NewStatisticsScreenWithDeck(store *data.Store, deckID string) *StatisticsScreen { 35 | return &StatisticsScreen{ 36 | store: store, 37 | activeTab: 1, // Start with the Deck Review tab 38 | cardStats: calculateCardStudiedPerDay(store), 39 | lastDeckID: deckID, 40 | } 41 | } 42 | 43 | // calculateCardStudiedPerDay calculates cards studied per day for the last 5 days 44 | func calculateCardStudiedPerDay(store *data.Store) []int { 45 | // This is a placeholder implementation 46 | // In a real app, you'd track actual study history 47 | return []int{35, 15, 25, 40, 20} 48 | } 49 | 50 | // Init initializes the statistics screen 51 | func (s *StatisticsScreen) Init() tea.Cmd { 52 | return nil 53 | } 54 | 55 | // Update handles user input for the statistics screen 56 | func (s *StatisticsScreen) Update(msg tea.Msg) (tea.Model, tea.Cmd) { 57 | switch msg := msg.(type) { 58 | case tea.KeyMsg: 59 | switch msg.String() { 60 | case "q", "ctrl+c": 61 | return s, tea.Quit 62 | case "b": 63 | // Return to main menu 64 | return NewMainMenu(s.store), nil 65 | case "tab": 66 | // Cycle through tabs 67 | s.activeTab = (s.activeTab + 1) % 3 68 | } 69 | 70 | case tea.WindowSizeMsg: 71 | s.width = 120 // Default width 72 | s.height = msg.Height 73 | } 74 | 75 | return s, nil 76 | } 77 | 78 | // View renders the statistics screen 79 | func (s *StatisticsScreen) View() string { 80 | var sb strings.Builder 81 | 82 | // Title 83 | sb.WriteString(statTitleStyle.Render("Statistics")) 84 | sb.WriteString("\n\n") 85 | 86 | // Tabs 87 | tabs := []string{"Summary", "Deck Review", "Review Forecast"} 88 | tabRow := "" 89 | for i, tab := range tabs { 90 | if i == s.activeTab { 91 | tabRow += activeTabStyle.Render(tab) + " " 92 | } else { 93 | tabRow += tabStyle.Render(tab) + " " 94 | } 95 | } 96 | sb.WriteString(tabRow) 97 | sb.WriteString("\n\n") 98 | 99 | // Render the active tab 100 | switch s.activeTab { 101 | case 0: 102 | sb.WriteString(renderSummaryStats(s.store)) 103 | case 1: 104 | // Pass the lastDeckID to the Deck Review tab 105 | // This ensures the specific deck is shown if available 106 | sb.WriteString(renderDeckReviewStats(s.store, s.lastDeckID)) 107 | case 2: 108 | sb.WriteString(renderReviewForecastStats(s.store)) 109 | } 110 | 111 | sb.WriteString("\n\n") 112 | 113 | // Help text 114 | helpText := statLabelStyle.Render("Tab: Switch View" + "\tb: Back to Main Menu" + "\tq: Quit") 115 | sb.WriteString(helpText) 116 | 117 | return sb.String() 118 | } 119 | -------------------------------------------------------------------------------- /internal/ui/stats_screen_test.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/stats_screen_test.go 2 | 3 | package ui 4 | 5 | import ( 6 | "strings" 7 | "testing" 8 | 9 | "github.com/DavidMiserak/GoCard/internal/data" 10 | tea "github.com/charmbracelet/bubbletea" 11 | ) 12 | 13 | func TestNewStatisticsScreen(t *testing.T) { 14 | store := data.NewStore() 15 | statsScreen := NewStatisticsScreen(store) 16 | 17 | if statsScreen == nil { 18 | t.Fatal("Expected NewStatisticsScreen to return a non-nil StatisticsScreen") 19 | } 20 | 21 | if statsScreen.store != store { 22 | t.Errorf("Expected store to be %v, got %v", store, statsScreen.store) 23 | } 24 | 25 | // Now we expect activeTab to be initialized to 1 (Deck Review tab) 26 | if statsScreen.activeTab != 1 { 27 | t.Errorf("Expected activeTab to be 1, got %d", statsScreen.activeTab) 28 | } 29 | 30 | if len(statsScreen.cardStats) == 0 { 31 | t.Error("Expected cardStats to be initialized with data") 32 | } 33 | 34 | // Check that lastDeckID is initialized to empty string 35 | if statsScreen.lastDeckID != "" { 36 | t.Errorf("Expected lastDeckID to be empty, got %s", statsScreen.lastDeckID) 37 | } 38 | } 39 | 40 | func TestNewStatisticsScreenWithDeck(t *testing.T) { 41 | store := data.NewStore() 42 | deckID := "test-deck-id" 43 | statsScreen := NewStatisticsScreenWithDeck(store, deckID) 44 | 45 | if statsScreen == nil { 46 | t.Fatal("Expected NewStatisticsScreenWithDeck to return a non-nil StatisticsScreen") 47 | } 48 | 49 | if statsScreen.store != store { 50 | t.Errorf("Expected store to be %v, got %v", store, statsScreen.store) 51 | } 52 | 53 | if statsScreen.activeTab != 1 { 54 | t.Errorf("Expected activeTab to be 1 (Deck Review tab), got %d", statsScreen.activeTab) 55 | } 56 | 57 | if len(statsScreen.cardStats) == 0 { 58 | t.Error("Expected cardStats to be initialized with data") 59 | } 60 | 61 | // Check that lastDeckID is set to the provided deckID 62 | if statsScreen.lastDeckID != deckID { 63 | t.Errorf("Expected lastDeckID to be %s, got %s", deckID, statsScreen.lastDeckID) 64 | } 65 | } 66 | 67 | func TestStatisticsScreenInit(t *testing.T) { 68 | store := data.NewStore() 69 | statsScreen := NewStatisticsScreen(store) 70 | 71 | cmd := statsScreen.Init() 72 | 73 | if cmd != nil { 74 | t.Error("Expected Init to return nil cmd") 75 | } 76 | } 77 | 78 | func TestStatisticsScreenUpdate(t *testing.T) { 79 | store := data.NewStore() 80 | statsScreen := NewStatisticsScreen(store) 81 | 82 | // Since activeTab is now initialized to 1, we expect it to cycle to 2 83 | model, cmd := statsScreen.Update(tea.KeyMsg{Type: tea.KeyTab}) 84 | updatedScreen := model.(*StatisticsScreen) 85 | 86 | if updatedScreen.activeTab != 2 { 87 | t.Errorf("Expected activeTab to be 2 after Tab key, got %d", updatedScreen.activeTab) 88 | } 89 | 90 | if cmd != nil { 91 | t.Error("Expected cmd to be nil") 92 | } 93 | 94 | // Test cycling back to 0 95 | model, _ = updatedScreen.Update(tea.KeyMsg{Type: tea.KeyTab}) 96 | updatedScreen = model.(*StatisticsScreen) 97 | 98 | if updatedScreen.activeTab != 0 { 99 | t.Errorf("Expected activeTab to be 0 after second Tab key, got %d", updatedScreen.activeTab) 100 | } 101 | 102 | // Test back to main menu 103 | model, _ = updatedScreen.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'b'}}) 104 | _, ok := model.(*MainMenu) 105 | if !ok { 106 | t.Errorf("Expected model to be *MainMenu after 'b' key, got %T", model) 107 | } 108 | 109 | // Test window size update 110 | width, height := 120, 24 111 | statsScreen = NewStatisticsScreen(store) // Reset stats screen 112 | model, _ = statsScreen.Update(tea.WindowSizeMsg{Width: width, Height: height}) 113 | updatedScreen = model.(*StatisticsScreen) 114 | 115 | if updatedScreen.width != width { 116 | t.Errorf("Expected width to be %d, got %d", width, updatedScreen.width) 117 | } 118 | 119 | if updatedScreen.height != height { 120 | t.Errorf("Expected height to be %d, got %d", height, updatedScreen.height) 121 | } 122 | } 123 | 124 | func TestStatisticsScreenView(t *testing.T) { 125 | store := data.NewStore() 126 | statsScreen := NewStatisticsScreen(store) 127 | 128 | // Set screen dimensions 129 | statsScreen.width = 80 130 | statsScreen.height = 24 131 | 132 | // Test view for each tab 133 | for tab := 0; tab < 3; tab++ { 134 | statsScreen.activeTab = tab 135 | view := statsScreen.View() 136 | 137 | if view == "" { 138 | t.Errorf("Expected View to return non-empty string for tab %d", tab) 139 | } 140 | 141 | // Basic check that the view contains help text 142 | if !containsAnyOf(view, []string{"Tab", "Back", "Menu", "Quit"}) { 143 | t.Error("Expected view to contain help text") 144 | } 145 | 146 | // Check that the tab headings are present 147 | if !containsAnyOf(view, []string{"Summary", "Deck Review", "Review Forecast"}) { 148 | t.Error("Expected view to contain tab headings") 149 | } 150 | } 151 | } 152 | 153 | func TestStatisticsScreenWithDeckView(t *testing.T) { 154 | // Create a store with some test data 155 | store := data.NewStore() 156 | 157 | // Assuming GetDecks returns at least one deck with an ID and Name 158 | decks := store.GetDecks() 159 | if len(decks) == 0 { 160 | t.Skip("No decks available for testing") 161 | return 162 | } 163 | 164 | deckID := decks[0].ID 165 | 166 | // Create stats screen with a specific deck 167 | statsScreen := NewStatisticsScreenWithDeck(store, deckID) 168 | 169 | // Set screen dimensions 170 | statsScreen.width = 80 171 | statsScreen.height = 24 172 | 173 | // Make sure we're on the Deck Review tab 174 | statsScreen.activeTab = 1 175 | 176 | // Get the view 177 | view := statsScreen.View() 178 | 179 | // Check that the view is not empty 180 | if view == "" { 181 | t.Error("Expected view to return non-empty string") 182 | } 183 | 184 | // We should see the Deck Review tab content 185 | if !containsAnyOf(view, []string{"Deck Review", "Ratings Distribution"}) { 186 | t.Error("Expected view to contain Deck Review content") 187 | } 188 | } 189 | 190 | // Helper function to check if a string contains any of the provided substrings 191 | func containsAnyOf(s string, substrings []string) bool { 192 | for _, sub := range substrings { 193 | if contains(s, sub) { 194 | return true 195 | } 196 | } 197 | return false 198 | } 199 | 200 | // Helper function to check if a string contains a substring 201 | func contains(s, substring string) bool { 202 | // This current implementation looks a bit unusual and might not work as expected 203 | // Let's use a more straightforward approach 204 | return s != "" && substring != "" && s != substring && strings.Contains(s, substring) 205 | } 206 | 207 | // Helper function to create a test store 208 | func createTestStore() *data.Store { 209 | return data.NewStore() 210 | } 211 | -------------------------------------------------------------------------------- /internal/ui/styles.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/styles.go 2 | 3 | package ui 4 | 5 | import ( 6 | "github.com/charmbracelet/lipgloss" 7 | ) 8 | 9 | // Common color palette 10 | var ( 11 | colorWhite = lipgloss.Color("#FFFFFF") 12 | colorLightGray = lipgloss.Color("#888888") 13 | colorDarkGray = lipgloss.Color("#444444") 14 | colorGreen = lipgloss.Color("#00FF00") 15 | colorBlue = lipgloss.Color("#2196F3") 16 | ) 17 | 18 | // Title and Header Styles 19 | var ( 20 | titleStyle = lipgloss.NewStyle(). 21 | Foreground(colorWhite). 22 | Bold(true). 23 | Align(lipgloss.Center). 24 | Padding(1, 0, 0, 0) 25 | 26 | headerStyle = lipgloss.NewStyle(). 27 | Foreground(colorWhite). 28 | Bold(true) 29 | 30 | subtitleStyle = lipgloss.NewStyle(). 31 | Foreground(colorLightGray). 32 | Align(lipgloss.Center). 33 | Padding(0, 0, 1, 0) 34 | ) 35 | 36 | // Menu and Navigation Styles 37 | var ( 38 | selectedItemStyle = lipgloss.NewStyle(). 39 | Foreground(colorGreen) 40 | 41 | normalItemStyle = lipgloss.NewStyle(). 42 | Foreground(colorWhite) 43 | 44 | helpStyle = lipgloss.NewStyle(). 45 | Foreground(colorLightGray) 46 | ) 47 | 48 | // Statistics Screen Styles 49 | var ( 50 | statTitleStyle = lipgloss.NewStyle(). 51 | Foreground(colorWhite). 52 | Bold(true) 53 | 54 | statLabelStyle = lipgloss.NewStyle(). 55 | Foreground(colorLightGray) 56 | 57 | tabStyle = lipgloss.NewStyle(). 58 | Padding(0, 2). 59 | Foreground(colorLightGray) 60 | 61 | activeTabStyle = tabStyle. 62 | Foreground(colorWhite). 63 | Underline(true) 64 | ) 65 | 66 | // Browse Decks Styles 67 | var ( 68 | selectedRowStyle = lipgloss.NewStyle(). 69 | Foreground(colorGreen) 70 | 71 | normalRowStyle = lipgloss.NewStyle(). 72 | Foreground(colorWhite) 73 | 74 | paginationStyle = lipgloss.NewStyle(). 75 | Foreground(lipgloss.Color("#999999")) 76 | 77 | browseHelpStyle = lipgloss.NewStyle(). 78 | Foreground(colorLightGray) 79 | ) 80 | 81 | // Study Screen Styles 82 | var ( 83 | studyTitleStyle = lipgloss.NewStyle(). 84 | Foreground(colorWhite). 85 | Bold(true) 86 | 87 | cardCountStyle = lipgloss.NewStyle(). 88 | Foreground(colorLightGray) 89 | 90 | questionStyle = lipgloss.NewStyle(). 91 | Foreground(colorWhite). 92 | PaddingLeft(4). 93 | PaddingRight(4). 94 | PaddingTop(2). 95 | PaddingBottom(2). 96 | Width(50). 97 | Align(lipgloss.Left) 98 | 99 | answerStyle = lipgloss.NewStyle(). 100 | Foreground(lipgloss.Color("#CCCCCC")). 101 | PaddingLeft(4). 102 | PaddingRight(4). 103 | PaddingTop(2). 104 | PaddingBottom(2). 105 | Width(50). 106 | Align(lipgloss.Left) 107 | 108 | revealPromptStyle = lipgloss.NewStyle(). 109 | Foreground(colorLightGray). 110 | Border(lipgloss.NormalBorder()). 111 | BorderForeground(colorDarkGray). 112 | PaddingLeft(2). 113 | PaddingRight(2). 114 | PaddingTop(1). 115 | PaddingBottom(1). 116 | Align(lipgloss.Center) 117 | 118 | studyHelpStyle = lipgloss.NewStyle(). 119 | Foreground(colorLightGray) 120 | 121 | // Rating Colors 122 | ratingBlackoutColor = lipgloss.Color("#9C27B0") 123 | ratingWrongColor = lipgloss.Color("#F44336") 124 | ratingHardColor = lipgloss.Color("#FF9800") 125 | ratingGoodColor = lipgloss.Color("#FFC107") 126 | ratingEasyColor = lipgloss.Color("#4CAF50") 127 | 128 | // Rating Styles 129 | ratingBlackoutStyle = lipgloss.NewStyle(). 130 | Foreground(colorWhite). 131 | Background(ratingBlackoutColor). 132 | PaddingLeft(1). 133 | PaddingRight(1) 134 | 135 | ratingWrongStyle = lipgloss.NewStyle(). 136 | Foreground(colorWhite). 137 | Background(ratingWrongColor). 138 | PaddingLeft(1). 139 | PaddingRight(1) 140 | 141 | ratingHardStyle = lipgloss.NewStyle(). 142 | Foreground(colorWhite). 143 | Background(ratingHardColor). 144 | PaddingLeft(1). 145 | PaddingRight(1) 146 | 147 | ratingGoodStyle = lipgloss.NewStyle(). 148 | Foreground(colorWhite). 149 | Background(ratingGoodColor). 150 | PaddingLeft(1). 151 | PaddingRight(1) 152 | 153 | ratingEasyStyle = lipgloss.NewStyle(). 154 | Foreground(colorWhite). 155 | Background(ratingEasyColor). 156 | PaddingLeft(1). 157 | PaddingRight(1) 158 | 159 | // Progress Bar Styles 160 | progressBarEmptyStyle = lipgloss.NewStyle(). 161 | Background(colorDarkGray) 162 | 163 | progressBarFilledStyle = lipgloss.NewStyle(). 164 | Background(colorBlue) 165 | ) 166 | 167 | // ViewPort Styles 168 | var ( 169 | viewportStyle = lipgloss.NewStyle().Padding(1, 2) 170 | ) 171 | -------------------------------------------------------------------------------- /internal/ui/summary_tab.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/summary_tab.go 2 | 3 | package ui 4 | 5 | import ( 6 | "fmt" 7 | "strings" 8 | "time" 9 | 10 | "github.com/DavidMiserak/GoCard/internal/data" 11 | "github.com/charmbracelet/lipgloss" 12 | ) 13 | 14 | // renderSummaryStats renders the Summary tab statistics 15 | func renderSummaryStats(store *data.Store) string { 16 | var sb strings.Builder 17 | 18 | // Get stats data 19 | totalCards := getTotalCards(store) 20 | cardsDueToday := len(store.GetDueCards()) 21 | studiedToday := getCardsStudiedToday(store) 22 | retentionRate := calculateRetentionRate(store) 23 | cardsStudiedPerDay := getCardsStudiedPerDay(store) 24 | 25 | // Layout the stats in two columns 26 | leftWidth := 20 27 | rightWidth := 20 28 | 29 | // Left column stats 30 | leftColumn := lipgloss.JoinVertical(lipgloss.Left, 31 | statLabelStyle.Render("Total Cards:")+strings.Repeat(" ", leftWidth-12)+fmt.Sprintf("%4d", totalCards), 32 | statLabelStyle.Render("Cards Due Today:")+strings.Repeat(" ", leftWidth-16)+fmt.Sprintf("%4d", cardsDueToday), 33 | ) 34 | 35 | // Right column stats 36 | rightColumn := lipgloss.JoinVertical(lipgloss.Left, 37 | statLabelStyle.Render("\tStudied Today:")+strings.Repeat(" ", leftWidth-15)+fmt.Sprintf("%4d", studiedToday), 38 | statLabelStyle.Render("\tRetention Rate:")+strings.Repeat(" ", rightWidth-16)+fmt.Sprintf("%3d%%", retentionRate), 39 | ) 40 | 41 | // Join columns horizontally 42 | columns := lipgloss.JoinHorizontal(lipgloss.Top, leftColumn, rightColumn) 43 | sb.WriteString(columns) 44 | 45 | // Add chart title with some padding 46 | sb.WriteString("\n\n") 47 | sb.WriteString(statLabelStyle.Render("Cards Studied per Day")) 48 | sb.WriteString("\n\n") 49 | 50 | // Render bar chart for cards studied per day 51 | chart := renderHorizontalBarChart(cardsStudiedPerDay, 30) 52 | sb.WriteString(chart) 53 | 54 | return sb.String() 55 | } 56 | 57 | // getTotalCards returns the total number of cards across all decks 58 | func getTotalCards(store *data.Store) int { 59 | count := 0 60 | for _, deck := range store.GetDecks() { 61 | count += len(deck.Cards) 62 | } 63 | return count 64 | } 65 | 66 | // getCardsStudiedToday returns the number of cards studied today 67 | func getCardsStudiedToday(store *data.Store) int { 68 | count := 0 69 | today := time.Now().Truncate(24 * time.Hour) // Start of today 70 | 71 | for _, deck := range store.GetDecks() { 72 | for _, card := range deck.Cards { 73 | if card.LastReviewed.After(today) || card.LastReviewed.Equal(today) { 74 | count++ 75 | } 76 | } 77 | } 78 | return count 79 | } 80 | 81 | // calculateRetentionRate calculates retention rate based on card ratings 82 | // Ratings 4-5 are considered "retained" 83 | func calculateRetentionRate(store *data.Store) int { 84 | var totalReviewed, retained int 85 | 86 | // Get reviews from the last 30 days 87 | thirtyDaysAgo := time.Now().AddDate(0, 0, -30) 88 | 89 | for _, deck := range store.GetDecks() { 90 | for _, card := range deck.Cards { 91 | if card.LastReviewed.After(thirtyDaysAgo) { 92 | totalReviewed++ 93 | if card.Rating >= 4 { 94 | retained++ 95 | } 96 | } 97 | } 98 | } 99 | 100 | if totalReviewed == 0 { 101 | return 0 102 | } 103 | 104 | return int((float64(retained) / float64(totalReviewed)) * 100) 105 | } 106 | 107 | // getCardsStudiedPerDay returns the number of cards studied per day for the last 6 days 108 | func getCardsStudiedPerDay(store *data.Store) map[string]int { 109 | // Initialize the last 6 days (including today) 110 | result := make(map[string]int) 111 | for i := 5; i >= 0; i-- { 112 | date := time.Now().AddDate(0, 0, -i) 113 | dateStr := date.Format("Jan 2") 114 | result[dateStr] = 0 115 | } 116 | 117 | // Count cards studied on each day 118 | for _, deck := range store.GetDecks() { 119 | for _, card := range deck.Cards { 120 | // Skip cards that haven't been reviewed 121 | if card.LastReviewed.IsZero() { 122 | continue 123 | } 124 | 125 | // Check if the review was within the last 6 days 126 | dayDiff := int(time.Since(card.LastReviewed).Hours() / 24) 127 | if dayDiff <= 5 { 128 | dateStr := card.LastReviewed.Format("Jan 2") 129 | result[dateStr]++ 130 | } 131 | } 132 | } 133 | 134 | return result 135 | } 136 | 137 | // renderHorizontalBarChart creates a text-based horizontal bar chart for cards studied per day 138 | func renderHorizontalBarChart(data map[string]int, maxBarWidth int) string { 139 | var sb strings.Builder 140 | 141 | // Find the maximum value for scaling 142 | maxValue := 0 143 | for _, count := range data { 144 | if count > maxValue { 145 | maxValue = count 146 | } 147 | } 148 | 149 | // Set a minimum scale if data is empty 150 | if maxValue == 0 { 151 | maxValue = 1 152 | } 153 | 154 | // Sort dates from oldest to newest (last 6 days) 155 | dates := make([]string, 0, 6) 156 | for i := 5; i >= 0; i-- { 157 | date := time.Now().AddDate(0, 0, -i) 158 | dates = append(dates, date.Format("Jan 2")) 159 | } 160 | 161 | // Draw the bars 162 | for _, date := range dates { 163 | count := data[date] 164 | 165 | // Calculate bar width - scale to max width 166 | barWidth := int((float64(count) / float64(maxValue)) * float64(maxBarWidth)) 167 | if count > 0 && barWidth == 0 { 168 | barWidth = 1 // Ensure visible bar for non-zero values 169 | } 170 | 171 | // Format the y-axis label (date) 172 | labelWidth := 10 173 | label := fmt.Sprintf("%-*s", labelWidth, date) 174 | 175 | // Draw the bar using block characters 176 | bar := "" 177 | if barWidth > 0 { 178 | bar = lipgloss.NewStyle().Foreground(colorBlue).Render(strings.Repeat("█", barWidth)) 179 | } 180 | 181 | // Combine label and bar 182 | sb.WriteString(label + " " + bar) 183 | 184 | // Add count at the end of the bar 185 | if count > 0 { 186 | sb.WriteString(fmt.Sprintf(" %d", count)) 187 | } 188 | 189 | sb.WriteString("\n\n") 190 | } 191 | 192 | return sb.String() 193 | } 194 | -------------------------------------------------------------------------------- /internal/ui/summary_tab_test.go: -------------------------------------------------------------------------------- 1 | // File: internal/ui/summary_tab_test.go 2 | 3 | package ui 4 | 5 | import ( 6 | "strings" 7 | "testing" 8 | "time" 9 | 10 | "github.com/DavidMiserak/GoCard/internal/data" 11 | "github.com/DavidMiserak/GoCard/internal/model" 12 | ) 13 | 14 | // Summary Tab Tests 15 | func TestGetTotalCards(t *testing.T) { 16 | store := createTestStoreForSummary() 17 | 18 | expectedCount := 20 // Total count of cards across all decks in our test store 19 | actualCount := getTotalCards(store) 20 | 21 | if actualCount != expectedCount { 22 | t.Errorf("Expected total cards to be %d, got %d", expectedCount, actualCount) 23 | } 24 | } 25 | 26 | func TestGetCardsStudiedToday(t *testing.T) { 27 | store := createTestStoreForSummary() 28 | 29 | // We need to modify our test store to have some cards studied today 30 | today := time.Now() 31 | 32 | // Set a fixed number of cards to have been studied today 33 | studiedToday := 0 34 | for i, deck := range store.GetDecks() { 35 | for j, card := range deck.Cards { 36 | if i == 0 && j < 2 { // Make two cards in the first deck studied today 37 | card.LastReviewed = today 38 | deck.Cards[j] = card 39 | studiedToday++ 40 | } 41 | } 42 | store.Decks[i] = deck 43 | } 44 | 45 | actualCount := getCardsStudiedToday(store) 46 | 47 | if actualCount != studiedToday { 48 | t.Errorf("Expected cards studied today to be %d, got %d", studiedToday, actualCount) 49 | } 50 | } 51 | 52 | func TestCalculateRetentionRate(t *testing.T) { 53 | // We'll create a store with known ratings to test the calculation 54 | testStore := &data.Store{ 55 | Decks: []model.Deck{ 56 | { 57 | ID: "test-deck", 58 | Cards: []model.Card{ 59 | { 60 | ID: "card-1", 61 | LastReviewed: time.Now(), 62 | Rating: 5, // Retained (rating >= 4) 63 | }, 64 | { 65 | ID: "card-2", 66 | LastReviewed: time.Now(), 67 | Rating: 4, // Retained 68 | }, 69 | { 70 | ID: "card-3", 71 | LastReviewed: time.Now(), 72 | Rating: 3, // Not retained 73 | }, 74 | { 75 | ID: "card-4", 76 | LastReviewed: time.Now(), 77 | Rating: 2, // Not retained 78 | }, 79 | }, 80 | }, 81 | }, 82 | } 83 | 84 | // Expected retention rate: 2 retained out of 4 = 50% 85 | expectedRate := 50 86 | actualRate := calculateRetentionRate(testStore) 87 | 88 | if actualRate != expectedRate { 89 | t.Errorf("Expected retention rate to be %d%%, got %d%%", expectedRate, actualRate) 90 | } 91 | } 92 | 93 | func TestGetCardsStudiedPerDay(t *testing.T) { 94 | // Create a store with cards studied on specific dates 95 | now := time.Now() 96 | yesterday := now.AddDate(0, 0, -1) 97 | dayBeforeYesterday := now.AddDate(0, 0, -2) 98 | 99 | // Format dates to the expected format 100 | nowStr := now.Format("Jan 2") 101 | yesterdayStr := yesterday.Format("Jan 2") 102 | dayBeforeYesterdayStr := dayBeforeYesterday.Format("Jan 2") 103 | 104 | testStore := &data.Store{ 105 | Decks: []model.Deck{ 106 | { 107 | ID: "test-deck", 108 | Cards: []model.Card{ 109 | { 110 | ID: "card-1", 111 | LastReviewed: now, 112 | }, 113 | { 114 | ID: "card-2", 115 | LastReviewed: now, 116 | }, 117 | { 118 | ID: "card-3", 119 | LastReviewed: yesterday, 120 | }, 121 | { 122 | ID: "card-4", 123 | LastReviewed: dayBeforeYesterday, 124 | }, 125 | { 126 | ID: "card-5", 127 | LastReviewed: dayBeforeYesterday, 128 | }, 129 | }, 130 | }, 131 | }, 132 | } 133 | 134 | result := getCardsStudiedPerDay(testStore) 135 | 136 | // Check counts for specific days 137 | if result[nowStr] != 2 { 138 | t.Errorf("Expected %s to have 2 cards, got %d", nowStr, result[nowStr]) 139 | } 140 | 141 | if result[yesterdayStr] != 1 { 142 | t.Errorf("Expected %s to have 1 card, got %d", yesterdayStr, result[yesterdayStr]) 143 | } 144 | 145 | if result[dayBeforeYesterdayStr] != 2 { 146 | t.Errorf("Expected %s to have 2 cards, got %d", dayBeforeYesterdayStr, result[dayBeforeYesterdayStr]) 147 | } 148 | } 149 | 150 | func TestRenderHorizontalBarChart(t *testing.T) { 151 | // Create test data with specific days that match our format 152 | data := map[string]int{ 153 | "Mar 29": 10, 154 | "Mar 30": 20, 155 | "Mar 31": 5, 156 | } 157 | 158 | // Render the chart 159 | result := renderHorizontalBarChart(data, 10) 160 | 161 | // Check for presence of key elements rather than exact matches 162 | if !strings.Contains(result, "Mar") { 163 | t.Error("Expected chart to contain month abbreviation 'Mar'") 164 | } 165 | 166 | if !strings.Contains(result, "29") { 167 | t.Error("Expected chart to contain day '29'") 168 | } 169 | 170 | if !strings.Contains(result, "30") { 171 | t.Error("Expected chart to contain day '30'") 172 | } 173 | 174 | if !strings.Contains(result, "31") { 175 | t.Error("Expected chart to contain day '31'") 176 | } 177 | 178 | // Check that the output contains the values (may be formatted differently) 179 | if !strings.Contains(result, "10") { 180 | t.Error("Expected chart to contain value '10'") 181 | } 182 | 183 | if !strings.Contains(result, "20") { 184 | t.Error("Expected chart to contain value '20'") 185 | } 186 | 187 | if !strings.Contains(result, "5") { 188 | t.Error("Expected chart to contain value '5'") 189 | } 190 | } 191 | 192 | func TestRenderSummaryStats(t *testing.T) { 193 | store := createTestStoreForSummary() 194 | 195 | // Just test that rendering doesn't panic and returns a non-empty string 196 | result := renderSummaryStats(store) 197 | 198 | if result == "" { 199 | t.Error("Expected renderSummaryStats to return a non-empty string") 200 | } 201 | 202 | // Check if the result contains expected headers 203 | expectedHeaders := []string{ 204 | "Total Cards:", 205 | "Cards Due Today:", 206 | "Studied Today:", 207 | "Retention Rate:", 208 | "Cards Studied per Day", 209 | } 210 | 211 | for _, header := range expectedHeaders { 212 | if !strings.Contains(result, header) { 213 | t.Errorf("Expected output to contain '%s'", header) 214 | } 215 | } 216 | } 217 | 218 | // Helper function to create a test store 219 | func createTestStoreForSummary() *data.Store { 220 | return data.NewStore() 221 | } 222 | -------------------------------------------------------------------------------- /scripts/create_release.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # scripts/create_release.sh - Helper script for creating a new GoCard release 3 | 4 | # Configuration 5 | VERSION="0.3.0" 6 | TAG_NAME="v$VERSION" 7 | BRANCH_NAME="release/$VERSION" 8 | 9 | # Colors for output 10 | GREEN='\033[0;32m' 11 | YELLOW='\033[1;33m' 12 | RED='\033[0;31m' 13 | NC='\033[0m' # No Color 14 | 15 | # Check if we're on a clean branch 16 | if [ -n "$(git status --porcelain)" ]; then 17 | echo -e "${RED}Error: Working directory is not clean.${NC}" 18 | echo "Please commit or stash all changes before creating a release." 19 | exit 1 20 | fi 21 | 22 | # Create a release branch 23 | echo -e "${GREEN}Creating release branch $BRANCH_NAME...${NC}" 24 | git checkout -b "$BRANCH_NAME" 25 | 26 | # Update version in files 27 | echo -e "${GREEN}Updating version to $VERSION in files...${NC}" 28 | sed -i 's/Version = "0.1.0"/Version = "'"$VERSION"'"/' cmd/gocard/flags.go 29 | 30 | # Confirm CHANGELOG.md exists 31 | if [ ! -f CHANGELOG.md ]; then 32 | echo -e "${YELLOW}Warning: CHANGELOG.md not found.${NC}" 33 | echo "Consider creating a CHANGELOG.md file to document changes." 34 | read -p "Continue without CHANGELOG? (y/n) " -n 1 -r 35 | echo 36 | if [[ ! $REPLY =~ ^[Yy]$ ]]; then 37 | git checkout - 38 | exit 1 39 | fi 40 | fi 41 | 42 | # Check for RELEASE_NOTES.md 43 | if [ ! -f RELEASE_NOTES.md ]; then 44 | echo -e "${YELLOW}Warning: RELEASE_NOTES.md not found.${NC}" 45 | echo "Consider creating release notes to document this version." 46 | read -p "Continue without RELEASE_NOTES? (y/n) " -n 1 -r 47 | echo 48 | if [[ ! $REPLY =~ ^[Yy]$ ]]; then 49 | git checkout - 50 | exit 1 51 | fi 52 | fi 53 | 54 | # Commit the version changes 55 | echo -e "${GREEN}Committing version changes...${NC}" 56 | git add cmd/gocard/flags.go CHANGELOG.md RELEASE_NOTES.md 57 | git commit -m "chore: bump version to $VERSION for release" 58 | 59 | # Create and push the tag 60 | echo -e "${GREEN}Creating and pushing tag $TAG_NAME...${NC}" 61 | git tag -a "$TAG_NAME" -m "Release $VERSION" 62 | git push origin "$TAG_NAME" 63 | 64 | # Push the release branch 65 | echo -e "${GREEN}Pushing release branch $BRANCH_NAME...${NC}" 66 | git push -u origin "$BRANCH_NAME" 67 | 68 | echo -e "${GREEN}Release process initiated!${NC}" 69 | echo "The release workflow should now be running on GitHub." 70 | echo "You can check the progress at: https://github.com/DavidMiserak/GoCard/actions" 71 | echo -e "${YELLOW}Note: You may want to create a PR to merge these changes back to main.${NC}" 72 | -------------------------------------------------------------------------------- /scripts/generate_coverage_report.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # scripts/generate_coverage_report.sh 3 | 4 | # Create directory for reports 5 | mkdir -p coverage/reports 6 | 7 | # Run tests with coverage 8 | go test -coverprofile=coverage/coverage.out ./... 9 | 10 | # Generate summary 11 | go tool cover -func=coverage/coverage.out > coverage/summary.txt 12 | total=$(grep "total:" coverage/summary.txt | awk '{print $3}') 13 | echo "Total coverage: $total" 14 | 15 | # Generate HTML report 16 | go tool cover -html=coverage/coverage.out -o coverage/report.html 17 | 18 | # Generate per-package coverage information 19 | echo "Package coverage:" > coverage/packages.txt 20 | go tool cover -func=coverage/coverage.out | grep -v "total:" >> coverage/packages.txt 21 | 22 | # Identify packages with low coverage (below 50%) 23 | echo "Low coverage packages:" > coverage/low_coverage.txt 24 | go tool cover -func=coverage/coverage.out | awk '$3 < "50.0%" && $1 !~ /total/ {print $1 ": " $3}' >> coverage/low_coverage.txt 25 | 26 | # Identify files with no tests 27 | echo "Files without tests:" > coverage/no_tests.txt 28 | go list -f '{{.Dir}}' ./... | while read -r pkg; do 29 | go list -f '{{range .GoFiles}}{{$.Dir}}/{{.}}{{"\n"}}{{end}}' "$pkg" | while read -r file; do 30 | if ! grep -q "$(basename "$file" .go)" coverage/coverage.out; then 31 | echo "$file" >> coverage/no_tests.txt 32 | fi 33 | done 34 | done 35 | 36 | echo "Coverage reports generated in the coverage directory" 37 | -------------------------------------------------------------------------------- /scripts/package_coverage.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # scripts/package_coverage.sh 3 | 4 | # Create output directory 5 | mkdir -p coverage_analysis 6 | 7 | # Get list of all packages 8 | packages=$(go list ./...) 9 | 10 | # Run tests for each package individually and generate report 11 | echo "Package Coverage:" 12 | echo "=================" 13 | echo "Package | Coverage | Files | Lines of Code | Covered Lines" 14 | echo "--------|----------|-------|--------------|-------------" 15 | 16 | for pkg in $packages; do 17 | # Skip test packages 18 | if [[ $pkg == *"_test" ]]; then 19 | continue 20 | fi 21 | 22 | echo "Testing $pkg..." 23 | 24 | # Run tests for this package only 25 | go test -coverprofile=coverage_analysis/temp.out $pkg >/dev/null 2>&1 26 | 27 | if [ $? -eq 0 ]; then 28 | # Get coverage percentage 29 | coverage=$(go tool cover -func=coverage_analysis/temp.out | grep total | awk '{print $3}') 30 | 31 | # Count files 32 | files=$(go list -f '{{len .GoFiles}}' $pkg) 33 | 34 | # Get lines of code (approximate) 35 | lines=$(find $(go list -f '{{.Dir}}' $pkg) -name "*.go" -not -path "*_test.go" | xargs wc -l 2>/dev/null | tail -n 1 | awk '{print $1}') 36 | 37 | # Calculate covered lines (approximate) 38 | if [[ $coverage == *"%" ]]; then 39 | coverage_num=${coverage//%/} 40 | covered_lines=$(echo "$lines * $coverage_num / 100" | bc) 41 | else 42 | covered_lines="N/A" 43 | fi 44 | 45 | echo "$pkg | $coverage | $files | $lines | $covered_lines" | tee -a coverage_analysis/package_report.txt 46 | else 47 | echo "$pkg | 0.0% | N/A | N/A | 0" | tee -a coverage_analysis/package_report.txt 48 | fi 49 | done 50 | 51 | # Sort packages by coverage (lowest first) 52 | echo -e "\nRanked by Coverage (lowest first):" 53 | echo "=============================" 54 | tail -n +3 coverage_analysis/package_report.txt | sort -t'|' -k2 -n | head -10 55 | 56 | # Clean up temporary files 57 | rm coverage_analysis/temp.out 58 | 59 | echo -e "\nFull report saved to coverage_analysis/package_report.txt" 60 | -------------------------------------------------------------------------------- /scripts/visual_coverage_report.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # scripts/visual_coverage_report.sh 3 | 4 | # Ensure go-cover-treemap is installed 5 | if ! command -v go-cover-treemap &> /dev/null; then 6 | echo "Installing go-cover-treemap..." 7 | go install github.com/nikolaydubina/go-cover-treemap@latest 8 | fi 9 | 10 | # Ensure gocovsh is installed 11 | if ! command -v gocovsh &> /dev/null; then 12 | echo "Installing gocovsh..." 13 | go install github.com/orlangure/gocovsh@latest 14 | fi 15 | 16 | # Run tests with coverage 17 | echo "Running tests with coverage..." 18 | go test -coverprofile=coverage.out ./... 19 | 20 | # Generate HTML report 21 | echo "Generating standard HTML report..." 22 | go tool cover -html=coverage.out -o coverage.html 23 | 24 | # Generate treemap visualization 25 | echo "Generating treemap visualization..." 26 | go-cover-treemap -coverprofile coverage.out > coverage_treemap.svg 27 | 28 | # Generate coverage heat map directory 29 | mkdir -p coverage_report 30 | echo "Generating coverage heat map..." 31 | gocovsh covdata --profile coverage.out --html ./coverage_report 32 | 33 | echo "Coverage reports generated:" 34 | echo "1. Standard HTML: coverage.html" 35 | echo "2. Treemap visualization: coverage_treemap.svg" 36 | echo "3. Interactive heatmap: ./coverage_report/index.html" 37 | -------------------------------------------------------------------------------- /wireframes/high-fidelity/.gitignore: -------------------------------------------------------------------------------- 1 | *.png 2 | -------------------------------------------------------------------------------- /wireframes/high-fidelity/00-main-menu.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | GoCard 10 | 11 | 12 | Terminal Flashcards 13 | 14 | 15 | 16 | 17 | 18 | 19 | › 20 | Study 21 | 22 | Browse Decks 23 | Statistics 24 | Quit 25 | 26 | 27 | 28 | ↑/↓: Navigate 29 | Enter: Select 30 | q: Quit 31 | 32 | -------------------------------------------------------------------------------- /wireframes/high-fidelity/01-deck-selection.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Browse Decks 10 | 11 | 12 | 13 | DECK NAME 14 | CARDS 15 | DUE 16 | LAST STUDIED 17 | 18 | 19 | 20 | 21 | 22 | › 23 | Go Programming 24 | 42 25 | 12 26 | Today 27 | 28 | 29 | Computer Science 30 | 78 31 | 25 32 | Yesterday 33 | 34 | Data Structures 35 | 64 36 | 15 37 | 3 days ago 38 | 39 | Algorithms 40 | 53 41 | 18 42 | 2 days ago 43 | 44 | Bubble Tea UI 45 | 29 46 | 10 47 | 1 week ago 48 | 49 | 50 | Page 1 of 2 51 | 52 | 53 | ↑/↓: Navigate 54 | Enter: Study 55 | b: Back 56 | n/p: Next/Prev Page 57 | q: Quit 58 | 59 | -------------------------------------------------------------------------------- /wireframes/high-fidelity/02-01-study-session-answer-hidden.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Studying: Go Programming 10 | Card 7/42 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | What is the purpose of the "defer" keyword in Go? 19 | 20 | 21 | 22 | Press SPACE to reveal answer 23 | 24 | 25 | SPACE: Show Answer 26 | →: Skip 27 | b: Back to Decks 28 | q: Quit 29 | 30 | -------------------------------------------------------------------------------- /wireframes/high-fidelity/02-01-study-session-answer-revealed.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Studying: Go Programming 10 | Card 7/42 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | What is the purpose of the "defer" keyword in Go? 19 | 20 | 21 | 22 | The "defer" keyword in Go schedules a function call to be 23 | executed just before the function returns. This is often 24 | used for cleanup actions, ensuring they will be executed 25 | even if the function panics. 26 | 27 | 28 | 29 | 30 | 31 | Blackout (1) 32 | 33 | 34 | 35 | Wrong (2) 36 | 37 | 38 | 39 | Hard (3) 40 | 41 | 42 | 43 | Good (4) 44 | 45 | 46 | 47 | Easy (5) 48 | 49 | 50 | 51 | 1-5: Rate Card 52 | b: Back to Decks 53 | q: Quit 54 | 55 | -------------------------------------------------------------------------------- /wireframes/high-fidelity/03-01-stats-summary.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Statistics 10 | 11 | 12 | 13 | Summary 14 | 15 | 16 | Deck Review 17 | 18 | 19 | Review Forecast 20 | 21 | 22 | 23 | Total Cards: 24 | 266 25 | 26 | Cards Due Today: 27 | 42 28 | 29 | Studied Today: 30 | 27 31 | 32 | 33 | Retention Rate: 34 | 87% 35 | 36 | Time Studied: 37 | 1h 24m 38 | 39 | Average Per Card: 40 | 12.4s 41 | 42 | 43 | 44 | Cards Studied per Day 45 | 46 | 47 | 48 | 49 | 50 | 51 | Mar 25 52 | Mar 26 53 | Mar 27 54 | Mar 28 55 | Mar 29 56 | Mar 30 57 | 58 | 59 | 0 60 | 25 61 | 50 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | Tab: Switch View 73 | b: Back to Main Menu 74 | q: Quit 75 | 76 | -------------------------------------------------------------------------------- /wireframes/high-fidelity/03-02-stats-deck.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Statistics 10 | 11 | 12 | 13 | Summary 14 | 15 | 16 | Deck Review 17 | 18 | 19 | Review Forecast 20 | 21 | 22 | 23 | Total Cards: 24 | 42 25 | 26 | Mature Cards: 27 | 28 28 | 29 | New Cards: 30 | 14 31 | 32 | 33 | Success Rate: 34 | 92% 35 | 36 | Avg. Interval: 37 | 12.6 days 38 | 39 | Last Studied: 40 | Today 41 | 42 | 43 | 44 | Ratings Distribution 45 | 46 | 47 | 48 | 49 | 50 | Blackout (1) 51 | 52 | 5% 53 | 54 | Wrong (2) 55 | 56 | 8% 57 | 58 | Hard (3) 59 | 60 | 15% 61 | 62 | 63 | Good (4) 64 | 65 | 32% 66 | 67 | Easy (5) 68 | 69 | 40% 70 | 71 | 72 | Tab: Switch View 73 | b: Back to Main Menu 74 | q: Quit 75 | 76 | -------------------------------------------------------------------------------- /wireframes/high-fidelity/Makefile: -------------------------------------------------------------------------------- 1 | # Filename: Makefile 2 | 3 | .PHONY: all 4 | all: 00-main-menu.png 01-deck-selection.png 02-01-study-session-answer-hidden.png 02-01-study-session-answer-revealed.png 03-01-stats-summary.png 03-02-stats-deck.png 03-03-stats-forcast.png 5 | 6 | 00-main-menu.png: 7 | 01-deck-selection.png: 8 | 02-01-study-session-answer-hidden.png: 9 | 02-01-study-session-answer-revealed.png: 10 | 03-01-stats-summary.png: 11 | 03-02-stats-deck.png: 12 | 03-03-stats-forcast.png: 13 | 14 | %.png: %.svg 15 | inkscape --export-type=png --export-filename=$@ $< 16 | 17 | .PHONY: clean 18 | clean: 19 | rm -f *.png 20 | --------------------------------------------------------------------------------