beachio-hammer 0.1.0.pre3 → 0.1.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ff203a27e8f29525a3120a073279ab2e8578f9d60a49a7f1c62c7ebf1a59253
-  data.tar.gz: e706eaee172b73d6abf8c14f7d936adb48144b2c4b2fc8ebdbf44fcfb9952f81
+  metadata.gz: 761f1f1873cb333406eeab947ee2ae1edde559b69fa38497810c96bdf802f58e
+  data.tar.gz: 6721ab8889e4129b9c886fa875b92579d359a9012852d69aaa711fa1e29c08eb
 SHA512:
-  metadata.gz: 47a316f9de1c74ec4c16881c2663ab8aa172256264fe6e7aa66aa84d95f7d26a8082bdf521bc998bcb26f5e8bc621b8b05c6301034ead326e2dbb8271e292185
-  data.tar.gz: 3c5cbc689cb680d0e3adf630adfc2add3f13285aebdd2f6dae258ea83deff4a7364dfe609ac816e638dab2b732ab2cf63404b9effe1d5424afb8ac182e7e35d0
+  metadata.gz: 23c9ab030b80757ac305dc66d4f0a35c9df394e248fa22ce62e8164d96c9b1573c4771b49ea82770574c113a7c4fd56ccfd26e294bda7f4515ede443dca28bfa
+  data.tar.gz: 5b670417365cbd83d7a706f3a1dc03edaadbcde2ca5cff920651446f66c790565d97a798e3a784fed847493cd62e1051cd27a0a4b23d11d67cd46014fb85314b

data/Gemfile.lock

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

data/PUBLISH.md

@@ -38,7 +38,17 @@ gem build beachio-hammer.gemspec
 gem push beachio-hammer-*.gem
 ```
 
-Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre3`**
+Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre5`**
+
+### 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)
+
+- Fix `@path` URL encoding: stop using `tr("%20", " ")` which mangled filenames containing `2` (e.g. `forge-2.jpg` → `forge-%20.jpg`)
 
 ### 0.1.0.pre3 changes (nested @path resolution)
 
@@ -58,7 +68,7 @@ Prerelease pin for executor team: **`beachio-hammer` `0.1.0.pre3`**
 Pin the published gem version in the executor Dockerfile:
 
 ```dockerfile
-RUN gem install beachio-hammer -v 0.1.0.pre3
+RUN gem install beachio-hammer -v 0.1.0.pre5
 ```
 
 Build step in the agent:

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/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
 
@@ -371,14 +456,13 @@ module Hammer
         paths = [search_path] unless index_paths.empty?
       end
 
-      relative_path = (paths.first || search_path).tr(" ", "%20")
+      relative_path = paths.first || search_path
+      relative_path = relative_path.gsub(" ", "%20")
       relative_path = "#{relative_path}/" if preserve_slash && !relative_path.end_with?("/")
 
       @delegate&.warning(@current_file_path, "File not found: #{ref}") if paths.empty?
 
       generate_context_aware_path(relative_path, preserve_trailing_slash: preserve_slash)
-        .tr("%20", " ")
-        .gsub(" ", "%20")
     end
 
     def root_relative_path

data/lib/hammer/version.rb

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

data/spec/path_resolution_spec.rb

@@ -23,4 +23,14 @@ RSpec.describe Hammer::TagParser do
 
     expect(result).to include('href="../../"')
   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 -->" />'
+
+    result = parser.send(:parse, content)
+
+    expect(result).to include('src="../../assets/images/products/forge-2.jpg"')
+    expect(result).not_to include("forge-%20.jpg")
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beachio-hammer
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre3
+  version: 0.1.0.pre5
 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