beachio-hammer 0.1.0.pre4 → 0.1.0.pre6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3470eba02cbe963f2f12e5b4d9cc94c2cb7d2b770ada0e7ca90de6c3a57e74a8
-  data.tar.gz: 336084edab3f5528a9dc6171b8b5fb363e1e6d05ab456d10fb15905583752b2e
+  metadata.gz: f3b4a0b499b230ddf29d32eec63d87dc4e6ceac09bbfdcbc11b076532dad79a6
+  data.tar.gz: 6eb175a810aae7ad23c4ffef79f770cb9201083f3ed4466b9c3ed5fefb975c4c
 SHA512:
-  metadata.gz: 2dd5e1d16f62a38b7bde783e30313ef54d10c17dd001abbcd1a9ddf374f1255dac772f7f312a0312c28d44da1c8d781dd312d1b915ebe4af95f7a7a22bebd41d
-  data.tar.gz: 49089ebfa731d5c58a7f5d91634cf726eb44c320c7dc84782fcf374b4ef9a4eec97745533cb962c8c3ef2f6fbbf7be575b170f8b63c32fa9a548dc55b1bf4970
+  metadata.gz: 1b6f05d60825d07e45d3c1055b76b4e9e1155c664ae7de008602c1072fbddec96d19818aad8496f7955eb1f3b4c7c9363cc6ab87ab8990e77dded5a4bd9e00c7
+  data.tar.gz: 036de2226fd8f9708baf2ff5a46c9fe58f23b7d54e61331ca55aa87f55fb2b0cf05c351869d6fc7a48091104068aebf18a0fa8b3e984115cfb175a5900d67d5b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    beachio-hammer (0.1.0.pre4)
+    beachio-hammer (0.1.0.pre6)
       json (~> 2.7)
 
 GEM

data/PUBLISH.md

@@ -38,7 +38,20 @@ gem build beachio-hammer.gemspec
 gem push beachio-hammer-*.gem
 ```
 
-Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre4`**
+Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre6`**
+
+### 0.1.0.pre6 changes (`hammer check`)
+
+- Add `hammer check` for content validation (Swift CLI parity)
+- Flags: `--project`, `--strict`, `--format json|human`
+- Rule IDs: `CONFIG_MISSING`, `CONFIG_INVALID`, `COLLECTION_DIR_MISSING`, `TEMPLATE_MISSING`, `PARSE_ERROR`, `REQUIRED_FIELD_MISSING`, `SLUG_MISSING`, `PROJECT_NOT_FOUND`
+- Agent QC: `hammer check --strict --format json`
+
+### 0.1.0.pre5 changes (collection loops on static pages)
+
+- Parse loop attributes (`sort="date:desc"`) when pre-processing `collections.*` loops
+- Evaluate `$helpers.formatDate(...)` inside `@loop` bodies
+- Fix loop condition checks for `post.category` syntax
 
 ### 0.1.0.pre4 changes (filename digit corruption)
 
@@ -62,16 +75,17 @@ Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre4`**
 Pin the published gem version in the executor Dockerfile:
 
 ```dockerfile
-RUN gem install beachio-hammer -v 0.1.0.pre4
+RUN gem install beachio-hammer -v 0.1.0.pre6
 ```
 
-Build step in the agent:
+Validate and build in the agent:
 
 ```bash
+hammer check --project "$WORKSPACE" --strict --format json
 hammer build --project "$WORKSPACE" --mode export --format json --clean
 ```
 
-### CLI contract
+### CLI contract — `hammer build`
 
 | Flag | Default | Notes |
 |------|---------|-------|
@@ -94,6 +108,29 @@ hammer build --project "$WORKSPACE" --mode export --format json --clean
 }
 ```
 
+### CLI contract — `hammer check`
+
+| Flag | Default | Notes |
+|------|---------|-------|
+| `--project` | cwd (walk-up for markers) | Project root |
+| `--strict` | off | Treat warnings as errors |
+| `--format` | `human` | `json` for agent parsing |
+
+**Exit codes:** `0` pass (or warnings without `--strict`), `1` check failures, `2` project/config error, `3` internal.
+
+**JSON stdout** (`--format json`):
+
+```json
+{
+  "status": "pass",
+  "errors": [{ "ruleId", "message", "file", "suggestion" }],
+  "warnings": [{ "ruleId", "message", "file", "suggestion" }],
+  "stats": { "filesChecked", "durationMs" }
+}
+```
+
+**Rule IDs:** `CONFIG_MISSING` (warn), `CONFIG_INVALID`, `COLLECTION_DIR_MISSING`, `TEMPLATE_MISSING`, `PARSE_ERROR`, `REQUIRED_FIELD_MISSING`, `SLUG_MISSING` (warn), `PROJECT_NOT_FOUND` (JSON `status: "error"`, exit 2).
+
 ### Parity fixtures
 
 | Fixture | Path | Files |

data/lib/beachio-hammer.rb

@@ -23,6 +23,7 @@ require_relative "hammer/content/page_generator"
 require_relative "hammer/content/builder"
 require_relative "hammer/builder"
 require_relative "hammer/build_command"
+require_relative "hammer/check_command"
 require_relative "hammer/cli"
 
 module Hammer

data/lib/hammer/cli.rb

@@ -2,13 +2,17 @@
 
 module Hammer
   module CLI
+    KNOWN_COMMANDS = %w[build check].freeze
+
     module_function
 
     def run(argv)
-      command = argv.first == "build" ? argv.shift : "build"
+      command = resolve_command(argv)
       case command
       when "build"
         BuildCommand.run(argv)
+      when "check"
+        CheckCommand.run(argv)
       else
         warn "Unknown command: #{command}"
         2
@@ -23,5 +27,13 @@ module Hammer
       warn "Build failed: #{e.message}"
       1
     end
+
+    def resolve_command(argv)
+      return "build" if argv.empty?
+      return argv.shift if KNOWN_COMMANDS.include?(argv.first)
+      return "build" if argv.first.start_with?("-")
+
+      argv.first
+    end
   end
 end

data/lib/hammer/content/config.rb

@@ -22,6 +22,24 @@ module Hammer
         output&.dig("filename") || output_path
       end
 
+      def validate_required_fields(metadata)
+        return [] unless fields
+
+        missing = []
+        fields.each do |field_name, field_config|
+          next unless field_config.required == true
+
+          unless metadata.key?(field_name)
+            missing << field_name
+            next
+          end
+
+          value = metadata[field_name]
+          missing << field_name if value.is_a?(String) && value.empty?
+        end
+        missing
+      end
+
       def self.from_hash(hash)
         fields = (hash["fields"] || {}).transform_values { |f| FieldConfig.from_hash(f) }
         new(

data/lib/hammer/content/helpers.rb

@@ -45,10 +45,21 @@ module Hammer
         when "long" then time.strftime("%B %d, %Y")
         when "full" then time.strftime("%A, %B %d, %Y")
         when "iso", "iso8601" then time.utc.iso8601
-        else time.strftime(format)
+        else time.strftime(swift_date_format_to_strftime(format))
         end
       end
 
+      def swift_date_format_to_strftime(format)
+        format
+          .gsub("yyyy", "%Y")
+          .gsub("MMM", "%b")
+          .gsub("MM", "%m")
+          .gsub("dd", "%d")
+          .gsub("HH", "%H")
+          .gsub("mm", "%M")
+          .gsub("ss", "%S")
+      end
+
       def relative_path(args)
         from = args[0].to_s
         to = args[1].to_s

data/lib/hammer/content/page_generator.rb

@@ -237,7 +237,11 @@ module Hammer
           collection_expr = m[2].strip
           next if collection_expr.start_with?("_loop_")
 
-          collection_value = evaluator.evaluate(collection_expr)
+          base_expression, attributes = parse_loop_attributes(collection_expr)
+          collection_value = evaluator.evaluate(base_expression)
+          next if collection_value.nil?
+
+          collection_value = apply_loop_attributes(collection_value, attributes) unless attributes.empty?
           items = collection_to_json_items(collection_value)
           json_array = JSON.generate(items)
           escaped = json_array.gsub("\\", "\\\\").gsub('"', '\\"').gsub("\n", "\\n")
@@ -266,11 +270,94 @@ module Hammer
           end
         when Document
           [value.to_h]
+        when NilClass
+          []
         else
           [{ "value" => value.to_s }]
         end
       end
 
+      def parse_loop_attributes(expression)
+        attributes = {}
+        base_expression = expression.strip
+        pattern = /(\w+)\s*=\s*(["'])(.*?)\2/
+
+        expression.scan(pattern) do |name, quote, value|
+          attributes[name] = value
+        end
+
+        if attributes.any?
+          base_expression = expression.gsub(/\s*\w+\s*=\s*(["']).*?\1/, "").strip
+        end
+
+        [base_expression, attributes]
+      end
+
+      def parse_sort_attribute(sort_value)
+        sort_value.split(",").filter_map do |field_spec|
+          field, direction = field_spec.strip.split(":", 2)
+          next if field.nil? || field.empty?
+
+          order = direction&.downcase
+          order = :desc if order == "desc" || order == "descending"
+          order = :asc unless order == :desc
+          { field: field.strip, order: order }
+        end
+      end
+
+      def apply_loop_attributes(value, attributes)
+        return value unless attributes["sort"]
+
+        sorts = parse_sort_attribute(attributes["sort"])
+        return value if sorts.empty?
+
+        documents = case value
+                    when Collection then value.documents.dup
+                    when Array then value.dup
+                    else return value
+                    end
+
+        sorts.reverse_each do |sort|
+          documents.sort! do |left, right|
+            left_value = extract_sort_value(left, sort[:field])
+            right_value = extract_sort_value(right, sort[:field])
+            comparison = compare_sort_values(left_value, right_value)
+            sort[:order] == :desc ? -comparison : comparison
+          end
+        end
+
+        case value
+        when Collection then Collection.new(value.name, documents)
+        else documents
+        end
+      end
+
+      def extract_sort_value(item, field)
+        case item
+        when Document
+          item.metadata[field] || (field == "date" ? item.date : nil)
+        when Hash
+          item[field] || item[field.to_sym]
+        end
+      end
+
+      def compare_sort_values(left, right)
+        left_time = sortable_time(left)
+        right_time = sortable_time(right)
+        return left_time <=> right_time if left_time && right_time
+
+        left.to_s <=> right.to_s
+      end
+
+      def sortable_time(value)
+        case value
+        when Time then value
+        when ::Date then value.to_time
+        when String
+          Document.parse_date(value)&.to_time
+        end
+      end
+
       def parse_json_collection(value)
         trimmed = value.strip
         return value unless trimmed.start_with?("[") || trimmed.start_with?("{")

data/lib/hammer/output_formatter.rb

@@ -29,5 +29,56 @@ module Hammer
         puts "Build finished in #{duration.round(2)}s — #{file_count} files (#{build_size})"
       end
     end
+
+    def format_check_result(status:, errors:, warnings:, files_checked:, duration_ms:, format:)
+      if format == :json
+        payload = {
+          "status" => status,
+          "errors" => errors.map { |e| check_issue_hash(e) },
+          "warnings" => warnings.map { |w| check_issue_hash(w) },
+          "stats" => {
+            "filesChecked" => files_checked,
+            "durationMs" => duration_ms
+          }
+        }
+        puts JSON.pretty_generate(payload)
+        return
+      end
+
+      puts ""
+      if status == "pass"
+        puts "\u2714 #{files_checked} files validated"
+      else
+        puts "\u2716 #{errors.length} error#{errors.length == 1 ? '' : 's'}"
+      end
+
+      errors.each do |error|
+        puts ""
+        puts "[#{error[:rule_id]}]"
+        puts error[:message]
+        puts "  #{error[:file]}"
+        puts "  Suggestion: #{error[:suggestion]}" if error[:suggestion]
+      end
+
+      unless warnings.empty?
+        puts ""
+        puts "\u26A0 #{warnings.length} warning#{warnings.length == 1 ? '' : 's'}"
+        warnings.each do |warning|
+          puts "  [#{warning[:rule_id]}] #{warning[:message]}"
+          puts "    #{warning[:file]}"
+        end
+      end
+      puts ""
+    end
+
+    def check_issue_hash(issue)
+      hash = {
+        "ruleId" => issue[:rule_id],
+        "message" => issue[:message],
+        "file" => issue[:file]
+      }
+      hash["suggestion"] = issue[:suggestion] if issue[:suggestion]
+      hash
+    end
   end
 end

data/lib/hammer/tag_parser.rb

@@ -240,7 +240,7 @@ module Hammer
           end
           item_content = process_nested_properties(item_content, item_hash, item_name)
           item_content = process_conditionals_in_loop(item_content, item_hash, item_name)
-          item_content
+          process_helper_expressions_in_loop(item_content, item_hash, item_name)
         end.join
 
         result.sub!(match[0], processed)
@@ -270,6 +270,89 @@ module Hammer
       end
     end
 
+    def process_helper_expressions_in_loop(content, item, item_name)
+      content.gsub(/<!--\s*\$([^>]+?)\s*-->/) do
+        expr = Regexp.last_match(1).strip
+        next Regexp.last_match(0) unless expr.include?("helpers.") || expr.start_with?("#{item_name}.")
+
+        evaluate_loop_helper_expression(expr, item, item_name) || Regexp.last_match(0)
+      end
+    end
+
+    def evaluate_loop_helper_expression(expr, item, item_name)
+      if expr.include?("helpers.") && expr.include?("(")
+        helper_name, args = parse_helper_call(expr)
+        return nil unless helper_name&.start_with?("helpers.")
+
+        evaluated_args = args.map { |arg| evaluate_loop_helper_argument(arg, item, item_name) }
+        Content::Helpers.call(helper_name.delete_prefix("helpers."), evaluated_args)
+      elsif expr.start_with?("#{item_name}.")
+        value = expr.split(".").drop(1).reduce(item) do |obj, key|
+          obj.is_a?(Hash) ? (obj[key] || obj[key.to_sym]) : nil
+        end
+        value_to_string(value)
+      end
+    rescue StandardError
+      nil
+    end
+
+    def parse_helper_call(expr)
+      open = expr.index("(")
+      name = expr[0...open].strip
+      args_str = expr[open + 1..]
+      close = find_matching_paren(args_str)
+      args = split_helper_args(args_str[0...close])
+      [name, args]
+    end
+
+    def find_matching_paren(str)
+      depth = 1
+      str.chars.each_with_index do |ch, idx|
+        depth += 1 if ch == "("
+        if ch == ")"
+          depth -= 1
+          return idx if depth.zero?
+        end
+      end
+      str.length - 1
+    end
+
+    def split_helper_args(args_str)
+      args = []
+      current = +""
+      in_quotes = false
+      quote = nil
+
+      args_str.each_char do |ch|
+        if !in_quotes && (ch == '"' || ch == "'")
+          in_quotes = true
+          quote = ch
+          current << ch
+        elsif in_quotes && ch == quote
+          in_quotes = false
+          quote = nil
+          current << ch
+        elsif !in_quotes && ch == ","
+          args << current.strip
+          current = +""
+        else
+          current << ch
+        end
+      end
+      args << current.strip unless current.strip.empty?
+      args
+    end
+
+    def evaluate_loop_helper_argument(arg, item, item_name)
+      trimmed = arg.strip
+      if (trimmed.start_with?('"') && trimmed.end_with?('"')) ||
+         (trimmed.start_with?("'") && trimmed.end_with?("'"))
+        return trimmed[1..-2]
+      end
+
+      evaluate_loop_helper_expression(trimmed, item, item_name)
+    end
+
     def process_conditionals_in_loop(content, item, item_name)
       pattern = /<!--\s*@(if|unless)\s+(.+?)\s*-->(.*?)(?:<!--\s*@else\s*-->(.*?))?<!--\s*@(endif|endunless|end)\s*-->/m
       result = content.dup
@@ -288,9 +371,11 @@ module Hammer
     end
 
     def evaluate_loop_condition(condition, item, item_name)
-      if (m = condition.match(/\A@#{Regexp.escape(item_name)}\.(.+)\z/))
+      if (m = condition.match(/\A@?#{Regexp.escape(item_name)}\.(.+)\z/))
         prop = m[1]
-        val = prop.split(".").reduce(item) { |o, k| o.is_a?(Hash) ? o[k] : nil }
+        val = prop.split(".").reduce(item) do |obj, key|
+          obj.is_a?(Hash) ? (obj[key] || obj[key.to_sym]) : nil
+        end
         return truthy?(val)
       end
 

data/lib/hammer/version.rb

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

data/spec/blog_listing_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "blog listing page" do
+  let(:beachio) { File.expand_path("../../../../Beachio/Beachio", __dir__) }
+
+  it "renders sorted posts and formatted dates on export" do
+    skip "Beachio fixture not present locally" unless File.directory?(beachio)
+
+    site = Hammer::ProjectResolver.create_site(beachio)
+    builder = Hammer::Builder.new(site: site, mode: :export, clean: true)
+    builder.build
+
+    html = Hammer.read_text(File.join(beachio, "Build/blog/index.html"))
+    card_count = html.scan('class="blog-card"').length
+
+    expect(card_count).to be > 10
+    expect(html).to include('class="blog-card__date">03 Sep 2026</time>')
+    expect(html).not_to include("$helpers.formatDate")
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beachio-hammer
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre4
+  version: 0.1.0.pre6
 platform: ruby
 authors:
 - Beach.io
@@ -77,6 +77,7 @@ files:
 - scripts/test-classic.rb
 - scripts/test-content.rb
 - scripts/tree-diff.rb
+- spec/blog_listing_spec.rb
 - spec/encoding_spec.rb
 - spec/parity/classic_spec.rb
 - spec/parity/content_spec.rb