beachio-hammer 0.1.0.pre6 → 0.1.0.pre8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3b4a0b499b230ddf29d32eec63d87dc4e6ceac09bbfdcbc11b076532dad79a6
-  data.tar.gz: 6eb175a810aae7ad23c4ffef79f770cb9201083f3ed4466b9c3ed5fefb975c4c
+  metadata.gz: 589ceae0ff8729f2cb3ecc0ee32d4838ace1138571c9c86d71ca78c17056e528
+  data.tar.gz: dca32a180fecf6664e35f2b6731190fc05c52fcf4833df8f0046dcb9030eb5f6
 SHA512:
-  metadata.gz: 1b6f05d60825d07e45d3c1055b76b4e9e1155c664ae7de008602c1072fbddec96d19818aad8496f7955eb1f3b4c7c9363cc6ab87ab8990e77dded5a4bd9e00c7
-  data.tar.gz: 036de2226fd8f9708baf2ff5a46c9fe58f23b7d54e61331ca55aa87f55fb2b0cf05c351869d6fc7a48091104068aebf18a0fa8b3e984115cfb175a5900d67d5b
+  metadata.gz: b150e39c1399ca2ae16ca81b6bc605cf5c98ce7a4574d802a575319de6b2bbd422f70a1c4c9b710da351d0d48003960ba31658cb0968f18388f665ff40630e3a
+  data.tar.gz: 846a0033ac0b6a5f3da13e50c543eada11d89902c809f8db1970e90c7a03ff90e308e8ba3f752fc2f3ea1b63673ad67e30f4be5203d9d431d20ae091151d9961

data/PUBLISH.md

@@ -38,7 +38,11 @@ gem build beachio-hammer.gemspec
 gem push beachio-hammer-*.gem
 ```
 
-Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre6`**
+Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre7`**
+
+### 0.1.0.pre7 changes
+
+- Fix gem packaging: include `lib/hammer/check_command.rb` (pre6 omitted untracked file)
 
 ### 0.1.0.pre6 changes (`hammer check`)
 

data/lib/hammer/check_command.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Hammer
+  module CheckCommand
+    module_function
+
+    def run(argv)
+      options = parse_options(argv)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      project_dir, project_exit = resolve_project(options)
+      return project_exit if project_exit
+
+      errors = []
+      warnings = []
+      files_checked = 0
+
+      config_path = File.join(project_dir, "content.config.json")
+
+      unless File.file?(config_path)
+        warnings << issue(
+          rule_id: "CONFIG_MISSING",
+          message: "No content.config.json found",
+          file: project_dir,
+          suggestion: "Create a content.config.json to enable content validation"
+        )
+        duration_ms = elapsed_ms(start)
+        status = options[:strict] && !warnings.empty? ? "fail" : "pass"
+        output_result(status, errors, warnings, files_checked, duration_ms, options[:format])
+        return options[:strict] && !warnings.empty? ? 1 : 0
+      end
+
+      config = load_config(config_path, errors, warnings, files_checked, start, options[:format])
+      return 1 unless config
+
+      parser = Content::Parser.new(source_directory: project_dir)
+
+      config.collections.each do |collection_name, collection_config|
+        content_dir = File.join(project_dir, collection_config.path)
+
+        unless File.directory?(content_dir)
+          errors << issue(
+            rule_id: "COLLECTION_DIR_MISSING",
+            message: "Content directory not found for collection '#{collection_name}'",
+            file: collection_config.path,
+            suggestion: "Create the directory at #{collection_config.path}"
+          )
+          next
+        end
+
+        if collection_config.template
+          template_path = File.join(project_dir, collection_config.template)
+          unless File.file?(template_path)
+            errors << issue(
+              rule_id: "TEMPLATE_MISSING",
+              message: "Template not found for collection '#{collection_name}'",
+              file: collection_config.template,
+              suggestion: "Create the template file at #{collection_config.template}"
+            )
+          end
+        end
+
+        file_extension = collection_config.format || "md"
+        discover_content_files(content_dir, file_extension).each do |file_path|
+          files_checked += 1
+          relative_path = file_path.delete_prefix("#{project_dir}/")
+
+          document = parse_content_file(parser, file_path, file_extension, relative_path, errors)
+          next unless document
+
+          collection_config.validate_required_fields(document.metadata).each do |field|
+            errors << issue(
+              rule_id: "REQUIRED_FIELD_MISSING",
+              message: "Missing required field '#{field}' in collection '#{collection_name}'",
+              file: relative_path,
+              suggestion: "Add '#{field}' to the front matter"
+            )
+          end
+
+          next unless collection_config.slug
+
+          slug_config = collection_config.slug
+          slug_field = slug_config["field"] || slug_config[:field]
+          slug_fallback = slug_config["fallback"] || slug_config[:fallback]
+          slug_value = document.metadata[slug_field] || document.metadata[slug_fallback]
+          next unless slug_value.nil? || (slug_value.is_a?(String) && slug_value.empty?)
+
+          warnings << issue(
+            rule_id: "SLUG_MISSING",
+            message: "No slug or fallback value for collection '#{collection_name}'",
+            file: relative_path,
+            suggestion: "Add '#{slug_field}' or '#{slug_fallback}' to front matter"
+          )
+        end
+      end
+
+      duration_ms = elapsed_ms(start)
+      has_failed = !errors.empty? || (options[:strict] && !warnings.empty?)
+      status = has_failed ? "fail" : "pass"
+      output_result(status, errors, warnings, files_checked, duration_ms, options[:format])
+      has_failed ? 1 : 0
+    end
+
+    def parse_options(argv)
+      options = {
+        project: nil,
+        strict: false,
+        format: :human
+      }
+
+      i = 0
+      while i < argv.length
+        arg = argv[i]
+        case arg
+        when "--project"
+          options[:project] = argv[i += 1]
+        when "--strict"
+          options[:strict] = true
+        when "--format"
+          fmt = argv[i += 1].to_s.downcase
+          options[:format] = fmt == "json" ? :json : :human
+        else
+          warn "Unknown option: #{arg}"
+          raise ConfigError, "Unknown option: #{arg}"
+        end
+        i += 1
+      end
+
+      options
+    end
+
+    def resolve_project(options)
+      [ProjectResolver.resolve(explicit_path: options[:project]), nil]
+    rescue ConfigError => e
+      if options[:format] == :json
+        OutputFormatter.format_check_result(
+          status: "error",
+          errors: [issue(
+            rule_id: "PROJECT_NOT_FOUND",
+            message: e.message,
+            file: "",
+            suggestion: "Specify a project path with --project"
+          )],
+          warnings: [],
+          files_checked: 0,
+          duration_ms: 0,
+          format: :json
+        )
+      else
+        warn "Error: #{e.message}"
+      end
+      [nil, 2]
+    end
+
+    def load_config(config_path, errors, warnings, files_checked, start, format)
+      Content::Config.load(config_path)
+    rescue StandardError => e
+      errors << issue(
+        rule_id: "CONFIG_INVALID",
+        message: "content.config.json is invalid: #{e.message}",
+        file: "content.config.json",
+        suggestion: "Check the JSON syntax and structure"
+      )
+      duration_ms = elapsed_ms(start)
+      output_result("fail", errors, warnings, files_checked, duration_ms, format)
+      nil
+    end
+
+    def discover_content_files(content_dir, file_extension)
+      Dir.glob(File.join(content_dir, "**", "*")).select do |path|
+        File.file?(path) && File.extname(path).delete_prefix(".") == file_extension
+      end
+    end
+
+    def parse_content_file(parser, file_path, file_extension, relative_path, errors)
+      if file_extension == "md"
+        parser.parse_markdown_file(file_path)
+      else
+        parser.parse_yaml_file(file_path)
+      end
+    rescue StandardError => e
+      errors << issue(
+        rule_id: "PARSE_ERROR",
+        message: "Failed to parse content file: #{e.message}",
+        file: relative_path,
+        suggestion: "Check the file format and front matter syntax"
+      )
+      nil
+    end
+
+    def issue(rule_id:, message:, file:, suggestion:)
+      { rule_id: rule_id, message: message, file: file, suggestion: suggestion }
+    end
+
+    def output_result(status, errors, warnings, files_checked, duration_ms, format)
+      OutputFormatter.format_check_result(
+        status: status,
+        errors: errors,
+        warnings: warnings,
+        files_checked: files_checked,
+        duration_ms: duration_ms,
+        format: format
+      )
+    end
+
+    def elapsed_ms(start)
+      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).to_i
+    end
+  end
+end

data/lib/hammer/tag_parser.rb

@@ -439,8 +439,15 @@ module Hammer
     end
 
     def resolve_path_reference(ref)
+      fragment = ""
+      if ref.include?("#")
+        base, anchor = ref.split("#", 2)
+        ref = base
+        fragment = "##{anchor}" unless anchor.nil? || anchor.empty?
+      end
+
       if ref == "/"
-        return root_relative_path
+        return "#{root_relative_path}#{fragment}"
       end
 
       preserve_slash = ref.end_with?("/")
@@ -462,7 +469,8 @@ module Hammer
 
       @delegate&.warning(@current_file_path, "File not found: #{ref}") if paths.empty?
 
-      generate_context_aware_path(relative_path, preserve_trailing_slash: preserve_slash)
+      resolved = generate_context_aware_path(relative_path, preserve_trailing_slash: preserve_slash)
+      "#{resolved}#{fragment}"
     end
 
     def root_relative_path

data/lib/hammer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hammer
-  VERSION = "0.1.0.pre6"
+  VERSION = "0.1.0.pre8"
 end

data/spec/check_command_spec.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "fileutils"
+require "json"
+require "stringio"
+require "tmpdir"
+
+CONTENT_FIXTURE = File.expand_path("../../Test Projects/content-generation-test", __dir__)
+
+RSpec.describe Hammer::CheckCommand do
+
+  def capture_check(argv, project: CONTENT_FIXTURE)
+    out = StringIO.new
+    original = $stdout
+    $stdout = out
+    exit_code = Hammer::CheckCommand.run(["--project", project, *argv])
+    [out.string, exit_code]
+  ensure
+    $stdout = original
+  end
+
+  describe "content-generation-test fixture" do
+    it "passes validation" do
+      stdout, exit_code = capture_check(["--format", "json"])
+      result = JSON.parse(stdout)
+
+      expect(exit_code).to eq(0)
+      expect(result["status"]).to eq("pass")
+      expect(result["errors"]).to be_empty
+      expect(result["stats"]["filesChecked"]).to be > 0
+    end
+
+    it "passes with --strict when no warnings" do
+      _stdout, exit_code = capture_check(["--strict", "--format", "json"])
+      expect(exit_code).to eq(0)
+    end
+  end
+
+  describe "CONFIG_MISSING" do
+    it "passes with warning when not strict" do
+      Dir.mktmpdir do |dir|
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(0)
+        expect(result["status"]).to eq("pass")
+        expect(result["warnings"].map { |w| w["ruleId"] }).to include("CONFIG_MISSING")
+        expect(result["stats"]["filesChecked"]).to eq(0)
+      end
+    end
+
+    it "fails with --strict" do
+      Dir.mktmpdir do |dir|
+        stdout, exit_code = capture_check(["--strict", "--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["status"]).to eq("fail")
+        expect(result["warnings"].map { |w| w["ruleId"] }).to include("CONFIG_MISSING")
+      end
+    end
+  end
+
+  describe "CONFIG_INVALID" do
+    it "fails and does not scan files" do
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, "content.config.json"), "{ invalid json")
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["status"]).to eq("fail")
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("CONFIG_INVALID")
+        expect(result["stats"]["filesChecked"]).to eq(0)
+      end
+    end
+  end
+
+  describe "COLLECTION_DIR_MISSING" do
+    it "reports missing collection directory" do
+      Dir.mktmpdir do |dir|
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => { "path" => "content/missing" }
+            }
+          )
+        )
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("COLLECTION_DIR_MISSING")
+      end
+    end
+  end
+
+  describe "TEMPLATE_MISSING" do
+    it "reports missing template file" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => {
+                "path" => "content/posts",
+                "template" => "templates/missing.html"
+              }
+            }
+          )
+        )
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("TEMPLATE_MISSING")
+      end
+    end
+  end
+
+  describe "REQUIRED_FIELD_MISSING" do
+    it "reports missing required front matter fields" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => {
+                "path" => "content/posts",
+                "fields" => {
+                  "title" => { "type" => "string", "required" => true }
+                }
+              }
+            }
+          )
+        )
+        File.write(File.join(dir, "content", "posts", "no-title.md"), "---\ndate: 2024-01-01\n---\n\nBody")
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("REQUIRED_FIELD_MISSING")
+      end
+    end
+  end
+
+  describe "SLUG_MISSING" do
+    it "warns when slug and fallback are absent" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => {
+                "path" => "content/posts",
+                "slug" => { "field" => "slug", "fallback" => "title" }
+              }
+            }
+          )
+        )
+        File.write(File.join(dir, "content", "posts", "post.md"), "---\ndate: 2024-01-01\n---\n\nBody")
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(0)
+        expect(result["warnings"].map { |w| w["ruleId"] }).to include("SLUG_MISSING")
+      end
+    end
+
+    it "fails with --strict" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate(
+            "collections" => {
+              "posts" => {
+                "path" => "content/posts",
+                "slug" => { "field" => "slug", "fallback" => "title" }
+              }
+            }
+          )
+        )
+        File.write(File.join(dir, "content", "posts", "post.md"), "---\ndate: 2024-01-01\n---\n\nBody")
+        _stdout, exit_code = capture_check(["--strict", "--format", "json"], project: dir)
+        expect(exit_code).to eq(1)
+      end
+    end
+  end
+
+  describe "PARSE_ERROR" do
+    it "reports unparseable content files" do
+      Dir.mktmpdir do |dir|
+        FileUtils.mkdir_p(File.join(dir, "content", "posts"))
+        File.write(
+          File.join(dir, "content.config.json"),
+          JSON.generate("collections" => { "posts" => { "path" => "content/posts" } })
+        )
+        allow(Hammer::Content::Parser).to receive(:new).and_wrap_original do |method, **kwargs|
+          parser = method.call(**kwargs)
+          allow(parser).to receive(:parse_markdown_file).and_raise(StandardError, "bad front matter")
+          parser
+        end
+        File.write(File.join(dir, "content", "posts", "bad.md"), "---\ntitle: ok\n---\n\nBody")
+        stdout, exit_code = capture_check(["--format", "json"], project: dir)
+        result = JSON.parse(stdout)
+
+        expect(exit_code).to eq(1)
+        expect(result["errors"].map { |e| e["ruleId"] }).to include("PARSE_ERROR")
+      end
+    end
+  end
+
+  describe "PROJECT_NOT_FOUND" do
+    it "returns exit 2 with JSON error status" do
+      stdout, exit_code = capture_check(["--format", "json"], project: "/nonexistent/path")
+      result = JSON.parse(stdout)
+
+      expect(exit_code).to eq(2)
+      expect(result["status"]).to eq("error")
+      expect(result["errors"].first["ruleId"]).to eq("PROJECT_NOT_FOUND")
+    end
+  end
+
+  describe "CollectionConfig#validate_required_fields" do
+    it "flags missing keys and empty strings" do
+      config = Hammer::Content::CollectionConfig.new(
+        fields: {
+          "title" => Hammer::Content::FieldConfig.new(required: true),
+          "count" => Hammer::Content::FieldConfig.new(required: true)
+        }
+      )
+
+      missing = config.validate_required_fields("title" => "", "count" => 0)
+      expect(missing).to contain_exactly("title")
+    end
+  end
+end
+
+RSpec.describe Hammer::CLI do
+  def capture_cli(argv)
+    out = StringIO.new
+    original = $stdout
+    $stdout = out
+    exit_code = Hammer::CLI.run(argv)
+    [out.string, exit_code]
+  ensure
+    $stdout = original
+  end
+
+  it "dispatches hammer check" do
+    stdout, exit_code = capture_cli(["check", "--project", CONTENT_FIXTURE, "--format", "json"])
+    result = JSON.parse(stdout)
+
+    expect(exit_code).to eq(0)
+    expect(result["status"]).to eq("pass")
+  end
+
+  it "defaults to build for flag-only invocation" do
+    stdout, exit_code = capture_cli(["--project", CONTENT_FIXTURE, "--format", "json", "--quiet"])
+    result = JSON.parse(stdout)
+
+    expect(exit_code).to eq(0)
+    expect(result["status"]).to eq("success")
+  end
+
+  it "returns exit 2 for unknown commands" do
+    _stdout, exit_code = capture_cli(["unknown"])
+    expect(exit_code).to eq(2)
+  end
+end

data/spec/path_resolution_spec.rb

@@ -24,6 +24,15 @@ RSpec.describe Hammer::TagParser do
     expect(result).to include('href="../../"')
   end
 
+  it "preserves URL fragments when resolving @path to a page" do
+    parser.current_file_path = "index.html"
+    content = '<a href="<!-- @path work/mixfit/#team -->">'
+
+    result = parser.send(:parse, content)
+
+    expect(result).to match(/href="[^"]*mixfit\/#team"/)
+  end
+
   it "does not corrupt digits in image filenames when resolving @path" do
     parser.current_file_path = "products/forge/index.html"
     content = '<img src="<!-- @path assets/images/products/forge-2.jpg -->" />'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beachio-hammer
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre6
+  version: 0.1.0.pre8
 platform: ruby
 authors:
 - Beach.io
@@ -54,6 +54,7 @@ files:
 - lib/beachio-hammer.rb
 - lib/hammer/build_command.rb
 - lib/hammer/builder.rb
+- lib/hammer/check_command.rb
 - lib/hammer/cli.rb
 - lib/hammer/content/builder.rb
 - lib/hammer/content/config.rb
@@ -78,6 +79,7 @@ files:
 - scripts/test-content.rb
 - scripts/tree-diff.rb
 - spec/blog_listing_spec.rb
+- spec/check_command_spec.rb
 - spec/encoding_spec.rb
 - spec/parity/classic_spec.rb
 - spec/parity/content_spec.rb