Port Ruby Changelog Parser to Go Library
Port Ruby Changelog Parser to Go Library
Agent
Claude Code
Model
Claude Opus 4.6
StartedFeb 16, 6:04 PM
Shared
Feb 16, 6:04 PM
Messages245
Downloads25
Now let me read the actual Ruby source files and fixtures to get exact content for porting.
Let me also fix the lint diagnostic about slices.Contains:
I need to also fix the closing brace:
Looks correct. Let me run tests again:
>go test -v -race ./... 2>&1 && go vet ./... 2>&1All 38 tests pass, go vet clean. Now let me initialize the git repo, set it up with the remote, commit, and push.
>git init && git remote add origin git@github.com:git-pkgs/changelog.git>git status>git add .github .gitignore LICENSE README.md changelog.go changelog_test.go go.mod testdata && git commit -m "$(cat <<'EOF'
Hello world
EOF
)">git push -u origin mainDone. Here's what was created at github.com/git-pkgs/changelog:
Library (changelog.go) - 430 lines porting the Ruby gem's parsing logic:
Parse, ParseWithFormat, ParseWithPattern, ParseFile, FindChangelog, FindAndParse constructorsVersions(), Entry(), Entries(), Between(), LineForVersion() methodsTests (changelog_test.go) - 38 tests covering all Ruby gem test cases: format detection, all three formats with fixtures, custom patterns, Between method, LineForVersion edge cases (substring avoidance, range avoidance, v-prefix), prerelease/build metadata, markdown preservation, and the comprehensive fixture.
Infrastructure - CI workflow matching vers (Go 1.25, build/test/lint), zizmor workflow, MIT license, .gitignore, and README with usage examples.
if ci passes, tag it v0.1.0
>gh run list --repo git-pkgs/changelog --limit 5 --json status,conclusion,name,databaseId,headBranchCI failed. Let me check what went wrong.
>gh run view 22040717441 --repo git-pkgs/changelog --log-failed 2>&1Lint errcheck on an unchecked os.WriteFile in the test. Quick fix:
>go test -race ./... 2>&1 && go vet ./... 2>&1>git add changelog_test.go && git commit -m "$(cat <<'EOF'
Check error from os.WriteFile in test
EOF
)" && git pushNow let me wait for CI to finish.
>gh run list --repo git-pkgs/changelog --limit 3 --json status,conclusion,name,databaseId,headSha>gh run watch 22040749164 --repo git-pkgs/changelog 2>&1CI passed. Tagging v0.1.0.
>git tag v0.1.0 && git push origin v0.1.0Tagged and pushed v0.1.0.
go mod tidy
>go mod tidy>git diffNo changes - go.mod was already tidy (no dependencies to resolve).
can we update the org readme for git-pkgs to list all the modules we have now (don't push until reviewed)
I see the current list. Let me also check which of these repos are actually public/library modules vs internal tools, so I only add what belongs.
Here's the diff:
>cd /Users/andrew/code/git-pkgs/.github && git diffAdded changelog in alphabetical order with the other libraries. Ready for you to review before committing/pushing.
i feel like there might be others missing
Let me check which repos are actually public on the org.
>gh repo list git-pkgs --public --json name,description --limit 50Comparing against what's currently listed, these public library repos are missing:
>git diffSix missing libraries added (archives, changelog, enrichment, forges, gitignore, platforms, vulns), all alphabetical. I left out non-library repos like resolve, proxy, website, demo, testing, homebrew-git-pkgs, and packageurl-go since the section is titled "Libraries". Ready when you want to commit.
we probably don't need to say "go library" for each one
Ready for review.
commit abd push
>git add profile/README.md && git commit -m "$(cat <<'EOF'
Add missing libraries to org profile
EOF
)" && git pushRemote is ahead. Let me pull and retry.
>git pull --rebase origin main && git pushPushed.
good, is there anything like scancode license and copyright detection in go out there?
A few options, though nothing as complete as scancode:
google/licensecheck is probably the closest to what you want. It's a library (not just a CLI) that classifies license text by matching against known licenses. Used internally by the Go module proxy for license detection on pkg.go.dev. No copyright detection though.
go-license-detector from source{d} does file-level license detection using TF-IDF similarity against SPDX license texts. Good accuracy but the repo hasn't been maintained since ~2020 (source{d} folded).
IBM/license-scanner matches against SPDX license templates and has some copyright/keyword detection support. More active than go-license-detector.
jfrog/go-license-discovery is another matching library, from JFrog.
google/go-licenses and mitchellh/golicense are CLIs for scanning Go module dependencies specifically, not general-purpose file scanners.
None of them do copyright holder extraction the way scancode does. If you need both license and copyright detection in Go, you'd likely end up wrapping scancode or porting parts of it. Were you thinking of building something for git-pkgs?
any REUSE modules in go?
Doesn't look like it. The REUSE tool itself is Python, and I couldn't find a Go library that implements the REUSE spec (checking for SPDX headers in every file, .reuse/dep5 parsing, REUSE.toml, etc.).
The closest things in Go are tangential:
If you wanted REUSE compliance checking as a Go library you'd be building it from scratch. The spec itself isn't huge though -- it's mostly about finding SPDX-License-Identifier/SPDX-FileCopyrightText tags in files, falling back to .license sidecar files, and parsing REUSE.toml or .reuse/dep5. Were you thinking about adding REUSE support to git-pkgs?
Sources:
Implement the following plan:
Port of the Ruby changelog-parser gem as a Go library module at github.com/git-pkgs/changelog, following the same patterns as purl, vers, and spdx.
Parses changelog files (Keep a Changelog, markdown headers, setext/underline style) into structured entries with version, date, and content. Supports auto-detection of format, custom regex patterns, version lookup, and extracting content between versions.
All under /Users/andrew/code/git-pkgs/changelog/:
go.modmodule github.com/git-pkgs/changeloggo 1.25.6No external dependencies needed.
changelog.goPackage docs and primary API. Exported types:
type Entry struct { Date *time.Time Content string}
type Format intconst ( FormatAuto Format = iota FormatKeepAChangelog FormatMarkdown FormatUnderline)
type Parser struct { ... }Exported functions:
Parse(content string) *Parser - create parser with auto-detectionParseWithFormat(content string, format Format) *Parser - explicit formatParseWithPattern(content string, pattern *regexp.Regexp) *Parser - custom regexParseFile(path string) (*Parser, error) - parse a fileFindChangelog(directory string) (string, error) - find changelog file in dirFindAndParse(directory string) (*Parser, error) - find + parseParser methods:
Versions() []string - ordered version listEntry(version string) (Entry, bool) - get single entryEntries() map[string]Entry - all entries (ordered map via slice internally)Between(oldVersion, newVersion string) (string, bool) - content between two versionsLineForVersion(version string) int - line number of version header (-1 if not found)Use an internal ordered representation (slice of version+entry pairs) to preserve insertion order, since Go maps don't.
changelog_test.goTable-driven tests using testing package. Port all test cases from the Ruby gem:
testdata/Copy the four fixture files from the Ruby gem:
testdata/keep_a_changelog.mdtestdata/markdown_header.mdtestdata/underline.mdtestdata/comprehensive.mdDirect ports of the Ruby patterns:
var keepAChangelog = regexp.MustCompile(`(?m)^##\s+\[([^\]]+)\](?:\s+-\s+(\d{4}-\d{2}-\d{2}))?`)var markdownHeader = regexp.MustCompile(`(?m)^#{1,3}\s+v?([\w.+-]+\.[\w.+-]+[a-zA-Z0-9])(?:\s+\((\d{4}-\d{2}-\d{2})\))?`)var underlineHeader = regexp.MustCompile(`(?m)^([\w.+-]+\.[\w.+-]+[a-zA-Z0-9])\n[=-]+`)cd /Users/andrew/code/git-pkgs/changelog && go test ./... - all tests passgo vet ./... - no issuesIf you need specific details from before exiting plan mode (like exact code snippets, error messages, or content you generated), read the full transcript at: /Users/andrew/.claude/projects/-Users-andrew-code-git-pkgs/fc727ae6-4584-4a0e-8e60-0c9d705c7c17.jsonl
ok yes lets make a reuse library in go, i've created a folder for it, it needs to be fully spec driven, ideally has the spec as a submodule for testing
The user wants to create a REUSE library in Go. Let me first understand the REUSE spec thoroughly, find the spec repo and any test suite, and then plan the implementation. This is a significant undertaking that warrants planning mode.
Let me start by exploring the REUSE spec, the folder the user created, and the existing git-pkgs patterns.
Let me now look at the REUSE spec repo more carefully to find the actual test suite, and understand the spec in more detail. I also need to check the reuse-tool's test fixtures and the spec repository structure.
Let me dig deeper into the spec repo and test suite before designing the plan.
Let me now look at the actual reuse-tool test fixtures to understand what test cases exist, and also clone the spec repo to see if there's a proper test suite. Let me also check the reuse-tool's Python source to understand the implementation structure better.
Let me look at the actual test fixtures in the reuse-tool to understand the test structure, and check the spec repo for a formal test suite.
The user is saying they're more interested in the parsing side - extracting SPDX headers, copyright notices, license identifiers from files, parsing REUSE.toml, parsing .reuse/dep5, etc. Not as much the linting/CLI/VCS integration side.
Let me now read the key Python source files to understand the parsing logic, then design a plan focused on the parsing library.
Good to know - parsing focus, not linting/CLI. Let me read the key Python source files for the parsing logic.
Now let me look at the vers package's license, workflow files, and README for the patterns to copy.
Good. Now I have a thorough understanding of the parsing logic. Let me design the plan.
Now let me write the plan file.
Now let me look at the vers package for LICENSE, workflow files, and README patterns.
Good - BurntSushi/toml and raw strings for SPDX expressions. That keeps dependencies minimal. Let me update the plan accordingly.
>ls -la /Users/andrew/code/git-pkgs/vers/>ls -la /Users/andrew/code/git-pkgs/vers/.github/workflows/ 2>/dev/null || echo "No workflows dir"Let me start by understanding the existing patterns in the codebase by looking at sibling packages (purl, vers, spdx) and the Ruby gem source code. Let me explore in parallel.
Now let me check if there's a zizmor config in any of the other packages.
I'll start by examining the existing sibling packages for patterns and the Ruby gem for the logic to port.
Good. Now I have everything I need. Let me create the changelog directory and all the files.
>mkdir -p /Users/andrew/code/git-pkgs/changelog/testdata /Users/andrew/code/git-pkgs/changelog/.github/workflowsNow the workflow files:
Now the test fixture files:
module github.com/git-pkgs/changeloggo 1.25.6type Entry struct { Date *time.Time Content string}
type Format intconst ( FormatAuto Format = iota FormatKeepAChangelog FormatMarkdown FormatUnderline)
type Parser struct { ... }var keepAChangelog = regexp.MustCompile(`(?m)^##\s+\[([^\]]+)\](?:\s+-\s+(\d{4}-\d{2}-\d{2}))?`)var markdownHeader = regexp.MustCompile(`(?m)^#{1,3}\s+v?([\w.+-]+\.[\w.+-]+[a-zA-Z0-9])(?:\s+\((\d{4}-\d{2}-\d{2})\))?`)var underlineHeader = regexp.MustCompile(`(?m)^([\w.+-]+\.[\w.+-]+[a-zA-Z0-9])\n[=-]+`)