beachio-hammer 0.1.0.pre6 → 0.1.0.pre7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3b4a0b499b230ddf29d32eec63d87dc4e6ceac09bbfdcbc11b076532dad79a6
-  data.tar.gz: 6eb175a810aae7ad23c4ffef79f770cb9201083f3ed4466b9c3ed5fefb975c4c
+  metadata.gz: 7f49550d59c10cbcb9b8ed9dae068082d5962abd833fcf2b6b039d07ce409b5e
+  data.tar.gz: 4e04f20a894021945d2366a00a4b4239404541d139d60ed99c93c49afff767e5
 SHA512:
-  metadata.gz: 1b6f05d60825d07e45d3c1055b76b4e9e1155c664ae7de008602c1072fbddec96d19818aad8496f7955eb1f3b4c7c9363cc6ab87ab8990e77dded5a4bd9e00c7
-  data.tar.gz: 036de2226fd8f9708baf2ff5a46c9fe58f23b7d54e61331ca55aa87f55fb2b0cf05c351869d6fc7a48091104068aebf18a0fa8b3e984115cfb175a5900d67d5b
+  metadata.gz: 69c67662fc6d413a3af72e8873ad96345e8e363a87fac6657c1c10385239ab195201805c2e9d1784beae717316f15e9835ba81f1483e39f43b8028c971d03ab4
+  data.tar.gz: 0efecd32fde11e6c6b6be017f427554cd7d57c11ad633d766c8b61be499b660cf7f61928e25dbcfd53db52cfe1ed765016c0ab0a5aa0d71a13503b921ed4f029

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hammer
-  VERSION = "0.1.0.pre6"
+  VERSION = "0.1.0.pre7"
 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

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.pre7
 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