changelog-parser 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a52b0f653d48af02c20cc4f1287dad6a76bcdc66efb802ba80470b21659a027e
-  data.tar.gz: f77abb93586e09bdf5b11e9e8022ab5d86656ec07ccbfad74fbd73c7f9cbed82
+  metadata.gz: 91646e7a7752f0f7c0766b6f488c9cf551f9ffd6b23f850ddf0b0598ff059c23
+  data.tar.gz: cd34eeb7f5033457acb042bf34e1130169de8384a2445a77672f99fa22780c66
 SHA512:
-  metadata.gz: 1fb1a622fe5b843d14f092acd112824221478ed0ec316b603d99f83e2dede43a31df04833fc226aa00a5574dd509731f3d88a62f19b91eed5cfa298740b6e9cc
-  data.tar.gz: 9d7c22d58a1520b85215c578778754d68d797fee125ee4cedd0e64cdb5caa6534d9935c9c3d19efb49a567b458ce6fa86393046f366cd7c8e0f2649593d80976
+  metadata.gz: ea798c67a91d6393a2c56a82373e7ac268952989e68185dcf51690b4a65212992b69266b326a2dd8bf9e669a9496fb2ed5528ec4a05e15e516ea6c9e89b9ea7d
+  data.tar.gz: 86e2a23610383116b309d8face4db4d8a6d99c201bfdaf162025b0297286c82a434f4f545b06a8844815d35a8b77311c54ba522c337bd29f6a6f96fe9bc8d37a

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## [Unreleased]
 
+## [0.2.0] - 2025-12-23
+
+### Added
+
+- `between(old_version, new_version)` method to extract content between versions
+- `line_for_version(version)` method with Dependabot-style pattern matching
+- `find_changelog(directory)` class method to locate changelog files
+- `find_and_parse(directory)` class method for one-step discovery and parsing
+- `to_html` method for markdown to HTML conversion (requires optional markdown gem)
+- Vandamme compatibility layer (`require "changelog/parser/vandamme"`)
+- CLI now accepts directories and auto-finds changelog files
+- CLI `between` command for extracting content between versions
+- CLI `validate` command for checking Keep a Changelog format compliance
+
+### Changed
+
+- CLI now uses subcommands (`parse`, `list`, `show`, `between`) instead of flags
+- Version matching now uses negative lookahead to avoid substring matches (e.g., won't match 1.0.1 when looking for 1.0.10)
+
 ## [0.1.0] - 2025-12-23
 
 ### Added

data/README.md

@@ -1,6 +1,8 @@
 # Changelog::Parser
 
-A Ruby gem for parsing changelog files into structured data. Supports the Keep a Changelog format, markdown headers, and custom patterns. Zero runtime dependencies.
+[![Gem Version](https://badge.fury.io/rb/changelog-parser.svg)](https://rubygems.org/gems/changelog-parser)
+
+A Ruby gem for parsing changelog files into structured data. Supports the Keep a Changelog format, markdown headers, and custom patterns.
 
 Inspired by [vandamme](https://github.com/tech-angels/vandamme).
 
@@ -94,6 +96,35 @@ Changelog::Parser.new(content, format: :markdown)
 Changelog::Parser.new(content, format: :underline)
 ```
 
+### Extracting content between versions
+
+Extract changelog content between two versions (like Dependabot does for PR descriptions):
+
+```ruby
+parser = Changelog::Parser.new(changelog)
+
+# Get content between old and new version
+parser.between("1.0.0", "2.0.0")
+
+# Get content from a version to the end
+parser.between(nil, "1.5.0")
+
+# Get content from start to a version
+parser.between("1.5.0", nil)
+```
+
+### Finding changelog files
+
+Automatically find and parse changelog files in a directory:
+
+```ruby
+# Find changelog file (searches for CHANGELOG.md, NEWS, HISTORY, etc.)
+path = Changelog::Parser.find_changelog("/path/to/project")
+
+# Find and parse in one step
+result = Changelog::Parser.find_and_parse("/path/to/project")
+```
+
 ### Custom patterns
 
 For changelogs with non-standard formats, provide a custom regex:
@@ -112,42 +143,52 @@ The gem includes a command-line interface:
 
 ```bash
 # Parse a changelog and output JSON
-changelog-parser CHANGELOG.md
+changelog-parser parse CHANGELOG.md
 
-# Pretty print JSON
-changelog-parser --pretty CHANGELOG.md
+# Parse from a directory (auto-finds CHANGELOG.md, NEWS, HISTORY, etc.)
+changelog-parser parse /path/to/project
 
 # List versions only
-changelog-parser --list CHANGELOG.md
+changelog-parser list CHANGELOG.md
 
-# Get a specific version
-changelog-parser --version 1.0.0 CHANGELOG.md
+# Show content for a specific version
+changelog-parser show 1.0.0 CHANGELOG.md
 
-# Get content only for a version
-changelog-parser --version 1.0.0 --content CHANGELOG.md
+# Show content between two versions (for PR descriptions)
+changelog-parser between 1.0.0 2.0.0 CHANGELOG.md
 
-# Specify format
-changelog-parser --format keep_a_changelog CHANGELOG.md
+# Validate against Keep a Changelog format
+changelog-parser validate CHANGELOG.md
+
+# Pretty print JSON
+changelog-parser parse --pretty CHANGELOG.md
 
 # Read from stdin
-cat CHANGELOG.md | changelog-parser -
+cat CHANGELOG.md | changelog-parser parse -
 
 # Custom regex pattern
-changelog-parser --pattern "^## v([\d.]+)" CHANGELOG.md
+changelog-parser parse --pattern "^## v([\d.]+)" CHANGELOG.md
+```
+
+### Commands
+
+```
+parse    Parse changelog and output JSON (default)
+list     List version numbers only
+show     Show content for a specific version
+between  Show content between two versions
+validate Validate changelog against Keep a Changelog format
 ```
 
-### CLI options
+### Options
 
 ```
 -f, --format FORMAT      Changelog format (keep_a_changelog, markdown, underline)
--v, --version VERSION    Show only a specific version
--l, --list               List versions only
--c, --content            Output content only (requires --version)
 -p, --pattern REGEX      Custom version header regex pattern
 -m, --match-group N      Regex capture group for version (default: 1)
     --pretty             Pretty print JSON output
 -h, --help               Show help message
-    --gem-version        Show gem version
+    --version            Show gem version
 ```
 
 ## Supported formats

data/exe/changelog-parser

@@ -5,16 +5,55 @@ require "optparse"
 require "json"
 require_relative "../lib/changelog/parser"
 
-options = {
-  format: nil,
-  output: :json,
-  version: nil
-}
-
-parser = OptionParser.new do |opts|
-  opts.banner = "Usage: changelog-parser [options] [file]"
+def load_changelog(path, options)
+  if path.nil? || path == "-"
+    $stdin.read
+  elsif File.directory?(path)
+    changelog_path = Changelog::Parser.find_changelog(path)
+    unless changelog_path
+      warn "Error: No changelog found in directory: #{path}"
+      exit 1
+    end
+    File.read(changelog_path)
+  elsif File.exist?(path)
+    File.read(path)
+  else
+    warn "Error: File or directory not found: #{path}"
+    exit 1
+  end
+end
+
+def build_parser(content, options)
+  Changelog::Parser.new(
+    content,
+    format: options[:format],
+    version_pattern: options[:pattern],
+    match_group: options[:match_group] || 1
+  )
+end
+
+def output_json(data, pretty: false)
+  json_data = data.transform_values do |entry|
+    entry.transform_values { |v| v.is_a?(Date) ? v.to_s : v }
+  end
+
+  if pretty
+    puts JSON.pretty_generate(json_data)
+  else
+    puts JSON.generate(json_data)
+  end
+end
+
+options = {}
+global_opts = OptionParser.new do |opts|
+  opts.banner = "Usage: changelog-parser <command> [options] [file_or_directory]"
   opts.separator ""
-  opts.separator "Parse changelog files and extract version information."
+  opts.separator "Commands:"
+  opts.separator "  parse    Parse changelog and output JSON (default)"
+  opts.separator "  list     List version numbers only"
+  opts.separator "  show     Show content for a specific version"
+  opts.separator "  between  Show content between two versions"
+  opts.separator "  validate Validate changelog against Keep a Changelog format"
   opts.separator ""
   opts.separator "Options:"
 
@@ -23,18 +62,6 @@ parser = OptionParser.new do |opts|
     options[:format] = f
   end
 
-  opts.on("-v", "--version VERSION", "Show only a specific version") do |v|
-    options[:version] = v
-  end
-
-  opts.on("-l", "--list", "List versions only") do
-    options[:output] = :list
-  end
-
-  opts.on("-c", "--content", "Output content only (requires --version)") do
-    options[:output] = :content
-  end
-
   opts.on("-p", "--pattern REGEX", "Custom version header regex pattern") do |p|
     options[:pattern] = Regexp.new(p)
   end
@@ -47,86 +74,161 @@ parser = OptionParser.new do |opts|
     options[:pretty] = true
   end
 
-  opts.on_tail("-h", "--help", "Show this help message") do
+  opts.on("-h", "--help", "Show this help message") do
     puts opts
+    puts ""
+    puts "Examples:"
+    puts "  changelog-parser parse CHANGELOG.md"
+    puts "  changelog-parser list ."
+    puts "  changelog-parser show 1.0.0 CHANGELOG.md"
+    puts "  changelog-parser between 1.0.0 2.0.0 CHANGELOG.md"
+    puts "  cat CHANGELOG.md | changelog-parser parse -"
     exit
   end
 
-  opts.on_tail("--gem-version", "Show gem version") do
+  opts.on("--version", "Show gem version") do
     puts Changelog::Parser::VERSION
     exit
   end
 end
 
 begin
-  parser.parse!
-rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
+  global_opts.parse!
+rescue OptionParser::InvalidOption => e
   warn "Error: #{e.message}"
-  warn parser
+  warn global_opts
   exit 1
 end
 
-input = if ARGV.empty? || ARGV.first == "-"
-  $stdin.read
-else
-  file = ARGV.first
-  unless File.exist?(file)
-    warn "Error: File not found: #{file}"
+command = ARGV.shift || "parse"
+
+case command
+when "parse"
+  path = ARGV.shift
+  content = load_changelog(path, options)
+  parser = build_parser(content, options)
+  output_json(parser.parse, pretty: options[:pretty])
+
+when "list"
+  path = ARGV.shift
+  content = load_changelog(path, options)
+  parser = build_parser(content, options)
+  puts parser.versions.join("\n")
+
+when "show"
+  version = ARGV.shift
+  path = ARGV.shift
+
+  # Check if version looks like a file path (missing version argument)
+  if version && File.exist?(version) && !path
+    warn "Error: show requires a version argument"
+    warn "Usage: changelog-parser show <version> [file_or_directory]"
     exit 1
   end
-  File.read(file)
-end
 
-if input.nil? || input.empty?
-  warn "Error: No input provided"
-  warn parser
-  exit 1
-end
+  unless version
+    warn "Error: show requires a version argument"
+    warn "Usage: changelog-parser show <version> [file_or_directory]"
+    exit 1
+  end
 
-parsed = Changelog::Parser.new(
-  input,
-  format: options[:format],
-  version_pattern: options[:pattern],
-  match_group: options[:match_group] || 1
-)
-
-result = parsed.parse
-
-case options[:output]
-when :list
-  puts result.keys.join("\n")
-when :content
-  unless options[:version]
-    warn "Error: --content requires --version"
+  content = load_changelog(path, options)
+  parser = build_parser(content, options)
+  entry = parser[version]
+
+  unless entry
+    warn "Error: Version not found: #{version}"
+    exit 1
+  end
+
+  puts entry[:content]
+
+when "between"
+  old_version = ARGV.shift
+  new_version = ARGV.shift
+  path = ARGV.shift
+
+  # Check if new_version looks like a file path (missing second version)
+  if new_version && File.exist?(new_version) && !path
+    warn "Error: between requires two version arguments"
+    warn "Usage: changelog-parser between <old_version> <new_version> [file_or_directory]"
+    exit 1
+  end
+
+  unless old_version && new_version
+    warn "Error: between requires two version arguments"
+    warn "Usage: changelog-parser between <old_version> <new_version> [file_or_directory]"
     exit 1
   end
-  entry = result[options[:version]]
-  if entry
-    puts entry[:content]
+
+  content = load_changelog(path, options)
+  parser = build_parser(content, options)
+  result = parser.between(old_version, new_version)
+
+  if result
+    puts result
   else
-    warn "Version not found: #{options[:version]}"
+    warn "Error: Could not find versions in changelog"
     exit 1
   end
-when :json
-  output = if options[:version]
-    entry = result[options[:version]]
-    unless entry
-      warn "Version not found: #{options[:version]}"
-      exit 1
+
+when "validate"
+  path = ARGV.shift
+  content = load_changelog(path, options)
+  parser = build_parser(content, options)
+  result = parser.parse
+  errors = []
+  warnings = []
+
+  # Check if any versions were found
+  if result.empty?
+    errors << "No versions found in changelog"
+  end
+
+  # Check for Unreleased section
+  unless result.key?("Unreleased")
+    warnings << "No [Unreleased] section found"
+  end
+
+  # Check for empty versions (Unreleased can be empty)
+  result.each do |version, entry|
+    next if version == "Unreleased"
+    if entry[:content].nil? || entry[:content].strip.empty?
+      warnings << "Version #{version} has no content"
     end
-    { options[:version] => entry }
-  else
-    result
   end
 
-  # Convert dates to strings for JSON
-  json_output = output.transform_values do |entry|
-    entry.transform_values { |v| v.is_a?(Date) ? v.to_s : v }
+  # Check date ordering (should be descending)
+  dated_versions = result.reject { |_, e| e[:date].nil? }
+  dates = dated_versions.values.map { |e| e[:date] }
+  unless dates == dates.sort.reverse
+    warnings << "Dates are not in descending order"
   end
 
-  if options[:pretty]
-    puts JSON.pretty_generate(json_output)
-  else
-    puts JSON.generate(json_output)
+  # Check for missing dates
+  result.each do |version, entry|
+    next if version == "Unreleased"
+    if entry[:date].nil?
+      warnings << "Version #{version} has no date"
+    end
   end
+
+  # Output results
+  if errors.empty? && warnings.empty?
+    puts "Valid changelog with #{result.size} version(s)"
+    exit 0
+  end
+
+  errors.each { |e| warn "Error: #{e}" }
+  warnings.each { |w| warn "Warning: #{w}" }
+
+  exit 1 if errors.any?
+  exit 0
+
+else
+  # Treat unknown command as a path (backwards compatibility)
+  path = command
+  content = load_changelog(path, options)
+  parser = build_parser(content, options)
+  output_json(parser.parse, pretty: options[:pretty])
 end

data/lib/changelog/parser/version.rb

@@ -2,6 +2,6 @@
 
 module Changelog
   class Parser
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/changelog/parser.rb

@@ -22,6 +22,17 @@ module Changelog
       underline: UNDERLINE_HEADER
     }.freeze
 
+    # Common changelog filenames in priority order (from Dependabot)
+    CHANGELOG_FILENAMES = %w[
+      changelog
+      news
+      changes
+      history
+      release
+      whatsnew
+      releases
+    ].freeze
+
     attr_reader :changelog, :version_pattern, :match_group
 
     def initialize(changelog, format: nil, version_pattern: nil, match_group: 1)
@@ -91,6 +102,46 @@ module Changelog
       end
     end
 
+    def between(old_version, new_version)
+      old_line = line_for_version(old_version)
+      new_line = line_for_version(new_version)
+      lines = changelog.split("\n")
+
+      range = if old_line && new_line
+        old_line < new_line ? (old_line..-1) : (new_line..old_line - 1)
+      elsif old_line
+        old_line.zero? ? nil : (0..old_line - 1)
+      elsif new_line
+        (new_line..-1)
+      end
+
+      return nil unless range
+
+      lines[range]&.join("\n")&.rstrip
+    end
+
+    def line_for_version(version)
+      return nil unless version
+
+      version = version.to_s.gsub(/^v/i, "")
+      escaped = Regexp.escape(version)
+      lines = changelog.split("\n")
+
+      lines.find_index.with_index do |line, index|
+        next false unless line.match?(/(?<!\.)#{escaped}(?![.\-\w])/)
+        next false if line.match?(/#{escaped}\.\./)
+
+        next true if line.start_with?("#", "!", "==")
+        next true if line.match?(/^v?#{escaped}:?\s/)
+        next true if line.match?(/^\[#{escaped}\]/)
+        next true if line.match?(/^[\+\*\-]\s+(version\s+)?#{escaped}/i)
+        next true if line.match?(/^\d{4}-\d{2}-\d{2}/)
+        next true if lines[index + 1]&.match?(/^[=\-\+]{3,}\s*$/)
+
+        false
+      end
+    end
+
     def self.parse(changelog, **options)
       new(changelog, **options).parse
     end
@@ -100,6 +151,35 @@ module Changelog
       new(content, **options).parse
     end
 
+    def self.find_changelog(directory = ".")
+      files = Dir.entries(directory).select { |f| File.file?(File.join(directory, f)) }
+
+      CHANGELOG_FILENAMES.each do |name|
+        pattern = /\A#{name}(\.(md|txt|rst|rdoc|markdown))?\z/i
+        candidates = files.select { |f| f.match?(pattern) }
+        candidates = candidates.reject { |f| f.end_with?(".sh") }
+
+        return File.join(directory, candidates.first) if candidates.one?
+
+        candidates.each do |candidate|
+          path = File.join(directory, candidate)
+          size = File.size(path)
+          next if size > 1_000_000 || size < 100
+
+          return path
+        end
+      end
+
+      nil
+    end
+
+    def self.find_and_parse(directory = ".", **options)
+      path = find_changelog(directory)
+      return nil unless path
+
+      parse_file(path, **options)
+    end
+
     def resolve_pattern(format, custom_pattern)
       return custom_pattern if custom_pattern
       return FORMATS.fetch(format) if format

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: changelog-parser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Nesbitt
@@ -10,7 +10,7 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby gem for parsing changelog files. Supports Keep a Changelog format,
-  markdown headers, and custom patterns. Zero runtime dependencies.
+  markdown headers, and custom patterns.
 email:
 - andrewnez@gmail.com
 executables: