beachio-hammer 0.1.0.pre1

data/lib/hammer/content/document.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Hammer
+  module Content
+    class Document
+      attr_reader :file_path, :body, :content_type, :collection
+      attr_accessor :metadata
+
+      def initialize(file_path:, metadata:, body:, content_type:, collection:)
+        @file_path = file_path
+        @metadata = metadata
+        @body = body
+        @content_type = content_type
+        @collection = collection
+      end
+
+      def slug
+        if (s = metadata["slug"]).is_a?(String) && !s.empty?
+          return self.class.slugify(s)
+        end
+        if (title = metadata["title"]).is_a?(String)
+          return self.class.slugify(title)
+        end
+
+        base = File.basename(file_path, ".*")
+        self.class.slugify(base)
+      end
+
+      def date
+        val = metadata["date"]
+        return val if val.is_a?(Time) || val.is_a?(Date)
+
+        self.class.parse_date(val.to_s) if val
+      end
+
+      def published?
+        return metadata["published"] if metadata.key?("published")
+
+        true
+      end
+
+      def self.slugify(text)
+        slug = text.downcase.gsub(" ", "-")
+        slug = slug.gsub(/[^a-z0-9-]/, "")
+        slug = slug.gsub(/-+/, "-")
+        slug = slug.gsub(/\A-+|-+\z/, "")
+        slug.empty? ? "untitled" : slug
+      end
+
+      def self.parse_date(date_string)
+        return nil if date_string.nil? || date_string.empty?
+
+        formats = [
+          "%Y-%m-%dT%H:%M:%S.%LZ",
+          "%Y-%m-%dT%H:%M:%SZ",
+          "%Y-%m-%d",
+          "%Y/%m/%d"
+        ]
+        formats.each do |fmt|
+          return Time.strptime(date_string, fmt)
+        rescue ArgumentError
+          next
+        end
+        Time.parse(date_string)
+      rescue ArgumentError
+        nil
+      end
+
+      def to_h
+        result = metadata.transform_values { |v| serialize_value(v) }
+        result["slug"] = slug
+        result["filePath"] = file_path
+        result["collection"] = collection
+        result["date"] = date&.utc&.iso8601(3) if date
+        result
+      end
+
+      def serialize_value(value)
+        case value
+        when Document
+          value.to_h
+        when Array
+          value.map { |v| serialize_value(v) }
+        when Hash
+          value.transform_values { |v| serialize_value(v) }
+        when Time, Date
+          value.utc.iso8601(3)
+        else
+          value
+        end
+      end
+    end
+
+    class Collection
+      attr_reader :name, :documents
+
+      def initialize(name, documents = [])
+        @name = name
+        @documents = documents
+      end
+
+      def add(doc)
+        @documents << doc
+      end
+
+      def count
+        @documents.length
+      end
+
+      def get_by_slug(slug_value)
+        @documents.find { |d| d.slug == slug_value }
+      end
+    end
+  end
+end

data/lib/hammer/content/expression_evaluator.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Hammer
+  module Content
+    class ExpressionEvaluator
+      def initialize(context:)
+        @context = context
+      end
+
+      def evaluate(expr)
+        trimmed = expr.strip
+        return evaluate_null_coalescing(trimmed) if trimmed.include?(" ?? ")
+        return evaluate_method_call(trimmed) if trimmed.include?("(")
+
+        @context.resolve(trimmed)
+      end
+
+      def evaluate_null_coalescing(expr)
+        left, right = expr.split(" ?? ", 2)
+        val = evaluate(left.strip)
+        if val.nil? || (val.is_a?(String) && val.empty?) || (val.is_a?(Array) && val.empty?)
+          return evaluate(right.strip)
+        end
+
+        val
+      end
+
+      def evaluate_method_call(expr)
+        open = expr.index("(")
+        method_name = expr[0...open].strip
+        args_str = expr[open + 1..]
+        close = find_matching_paren(args_str)
+        args = parse_arguments(args_str[0...close])
+
+        evaluated = args.map { |a| evaluate(a) }
+        if method_name.start_with?("helpers.")
+          Helpers.call(method_name.split(".", 2)[1], evaluated)
+        else
+          Helpers.call(method_name, evaluated)
+        end
+      end
+
+      def find_matching_paren(s)
+        depth = 1
+        i = 0
+        while i < s.length
+          case s[i]
+          when "(" then depth += 1
+          when ")"
+            depth -= 1
+            return i if depth.zero?
+          end
+          i += 1
+        end
+        s.length - 1
+      end
+
+      def parse_arguments(s)
+        s = s.strip
+        return [] if s.empty?
+
+        args = []
+        current = +""
+        in_quotes = false
+        quote = nil
+        depth = 0
+
+        s.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 == "("
+            depth += 1
+            current << ch
+          elsif !in_quotes && ch == ")"
+            depth -= 1
+            current << ch
+          elsif !in_quotes && depth.zero? && ch == ","
+            args << current.strip
+            current = +""
+          else
+            current << ch
+          end
+        end
+        args << current.strip unless current.strip.empty?
+        args
+      end
+
+      def stringify(value)
+        case value
+        when nil then ""
+        when String then value
+        when TrueClass, FalseClass then value.to_s
+        when Numeric then value.to_s
+        when Time, Date then value.to_s
+        when Document then value.slug
+        else value.to_s
+        end
+      end
+
+      def escape_html(value)
+        CGI.escapeHTML(stringify(value))
+      end
+    end
+  end
+end
+
+require "cgi"

data/lib/hammer/content/helpers.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Hammer
+  module Content
+    module Helpers
+      module_function
+
+      def registry
+        @registry ||= build_registry
+      end
+
+      def build_registry
+        {
+          "formatDate" => method(:format_date),
+          "slugify" => ->(args) { Document.slugify(args[0].to_s) },
+          "markdown" => ->(args) { args[0].to_s },
+          "relativePath" => method(:relative_path),
+          "join" => method(:join_helper),
+          "default" => method(:default_helper)
+        }
+      end
+
+      def call(name, args)
+        fn = registry[name]
+        raise BuildError, "Helper not found: #{name}" unless fn
+
+        fn.call(args)
+      end
+
+      def format_date(args)
+        date_val = args[0]
+        format = args[1].to_s
+        format = "medium" if format.empty? || format == "null"
+
+        time = case date_val
+               when Time, Date then date_val.to_time
+               when String then Document.parse_date(date_val)
+               else nil
+               end
+        raise BuildError, "Invalid date" unless time
+
+        case format.downcase
+        when "short" then time.strftime("%m/%d/%y")
+        when "medium" then time.strftime("%b %d, %Y")
+        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)
+        end
+      end
+
+      def relative_path(args)
+        from = args[0].to_s
+        to = args[1].to_s
+        from_dir = File.dirname(from).split("/")
+        to_parts = to.split("/")
+        common = 0
+        common += 1 while common < from_dir.length && common < to_parts.length && from_dir[common] == to_parts[common]
+        up = from_dir.length - common
+        remaining = to_parts[common..]
+        ([".."] * up + remaining).join("/")
+      end
+
+      def join_helper(args)
+        arr = array_elements(args[0]) || []
+        sep = args[1].to_s
+        sep = ", " if sep.empty? || sep == "null"
+        arr.map(&:to_s).join(sep)
+      end
+
+      def default_helper(args)
+        val = args[0]
+        fallback = args[1]
+        return fallback if val.nil? || (val.is_a?(String) && val.empty?)
+
+        val
+      end
+
+      def array_elements(value)
+        return value if value.is_a?(Array)
+        return nil if value.nil?
+
+        if value.is_a?(String) && value.start_with?("[")
+          begin
+            return JSON.parse(value)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+        nil
+      end
+    end
+  end
+end
+
+require "json"

data/lib/hammer/content/page_generator.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+
+module Hammer
+  module Content
+    class PageGenerator
+      def self.pre_process_collection_loops(content, collections:, source_directory:, build_mode:, delegate: nil)
+        return content unless content.include?("@loop") && content.include?("collections.")
+
+        generator = new(
+          source_directory: source_directory,
+          build_directory: source_directory,
+          config: Config.new(collections: {}),
+          collections: collections,
+          build_mode: build_mode,
+          delegate: delegate
+        )
+        site = { "title" => "My Site" }
+        context = TemplateContext.new(site: site, collections: collections, helpers: Helpers.registry)
+        evaluator = ExpressionEvaluator.new(context: context)
+        processed, loop_vars = generator.convert_loop_expressions(content, evaluator)
+        processed = generator.convert_loop_expressions_to_at_syntax(processed)
+        unless loop_vars.empty?
+          processed = loop_vars.join("\n") + "\n" + processed
+        end
+        processed
+      end
+
+      def initialize(source_directory:, build_directory:, config:, collections:, build_mode:, delegate: nil)
+        @source_directory = source_directory
+        @build_directory = build_directory
+        @config = config
+        @collections = collections
+        @build_mode = build_mode
+        @delegate = delegate
+      end
+
+      def generate_all_pages!
+        @config.collections.each_key do |name|
+          generate_detail_pages(name)
+        end
+      end
+
+      def generate_detail_pages(collection_name)
+        collection = @collections[collection_name]
+        collection_config = @config.get_collection(collection_name)
+        return unless collection && collection_config&.template && collection_config.output_path_pattern
+
+        template_path = File.join(@source_directory, collection_config.template)
+        collection.documents.each do |doc|
+          output_path = resolve_output_path(doc, collection_config)
+          next if output_path.empty?
+
+          generate_page(template_path, doc, output_path)
+        end
+      end
+
+      def resolve_output_path(doc, collection_config)
+        pattern = collection_config.output_path_pattern
+        slug_field = collection_config.slug&.dig("field") || "slug"
+        slug = resolve_slug(doc, collection_config.slug)
+        interpolate_output_path(pattern, slug, slug_field)
+      end
+
+      def resolve_slug(doc, slug_config)
+        if slug_config
+          field = slug_config["field"] || slug_config[:field]
+          fallback = slug_config["fallback"] || slug_config[:fallback]
+          if (v = doc.metadata[field]).is_a?(String) && !v.empty?
+            return Document.slugify(v)
+          end
+          if fallback && (v = doc.metadata[fallback]).is_a?(String) && !v.empty?
+            return Document.slugify(v)
+          end
+        end
+        doc.slug
+      end
+
+      def interpolate_output_path(pattern, slug, slug_field)
+        result = pattern.dup
+        result.gsub!(/\{\{\s*#{Regexp.escape(slug_field)}\s*\}\}/, slug)
+        result.gsub!(/\{\{\s*slug\s*\}\}/, slug)
+        result.gsub!(/\{#{Regexp.escape(slug_field)}\}/, slug)
+        result.gsub!("{slug}", slug)
+        result
+      end
+
+      def generate_page(template_path, doc, output_path)
+        template = File.read(template_path)
+        site = { "title" => "My Site" }
+        context = TemplateContext.new(
+          site: site,
+          collections: @collections,
+          doc: doc,
+          helpers: Helpers.registry
+        )
+        evaluator = ExpressionEvaluator.new(context: context)
+
+        content, cond_vars = convert_conditional_expressions(template, evaluator)
+        content, loop_vars = convert_loop_expressions(content, evaluator)
+        content = convert_closing_tags(content)
+        content = convert_loop_expressions_to_at_syntax(content)
+        all_vars = cond_vars + loop_vars
+        content = all_vars.join("\n") + "\n" + content unless all_vars.empty?
+        content = evaluate_variable_declarations(content, evaluator)
+        content = process_expressions_outside_blocks(content, evaluator)
+
+        tag_parser = TagParser.new(
+          source_directory: @source_directory,
+          build_mode: @build_mode,
+          delegate: @delegate,
+          content_collections: @collections,
+          content_config: @config
+        )
+        final = tag_parser.process_file_content(content, "_temp_page.html", output_path)
+        final = process_expressions(final, evaluator)
+        final = cleanup_remaining_hammer_tags(final)
+
+        dest = File.join(@build_directory, output_path)
+        FileUtils.mkdir_p(File.dirname(dest))
+        final += "\n" unless final.end_with?("\n")
+        File.write(dest, final)
+        @delegate&.processed_file(output_path, dest)
+      end
+
+      def convert_conditional_expressions(content, evaluator)
+        vars = []
+        result = content.dup
+        pattern = /<!--\s*@(if|unless)\s+(.+?)\s*-->/m
+        matches = []
+        result.scan(pattern) { matches << Regexp.last_match(0) }
+
+        matches.reverse_each do |original|
+          m = original.match(pattern)
+          next unless m
+
+          type = m[1]
+          condition = m[2].strip
+          next if condition.start_with?("_cond_")
+
+          var_name = "_cond_#{SecureRandom.hex(8)}"
+          met = evaluate_condition(condition, evaluator)
+          met = !met if type == "unless"
+          vars << "<!-- @var #{var_name} = \"#{met ? 'true' : 'false'}\" -->"
+          result.sub!(original, "<!-- @#{type} #{var_name} -->")
+        end
+
+        [result, vars]
+      end
+
+      def evaluate_condition(condition, evaluator)
+        if condition.include?("&&") || condition.include?("||")
+          and_parts = condition.split("&&")
+          and_parts.all? do |and_part|
+            if and_part.include?("||")
+              and_part.split("||").any? { |p| evaluate_condition_part(p.strip, evaluator) }
+            else
+              evaluate_condition_part(and_part.strip, evaluator)
+            end
+          end
+        else
+          evaluate_condition_part(condition, evaluator)
+        end
+      end
+
+      def evaluate_condition_part(expr, evaluator)
+        if expr.match?(/[<>!=]=?/)
+          return numeric_compare(expr, evaluator)
+        end
+
+        val = evaluator.evaluate(expr)
+        truthy?(val)
+      end
+
+      def numeric_compare(expr, evaluator)
+        ops = [">=", "<=", "!=", "==", ">", "<"]
+        op = ops.find { |o| expr.include?(o) }
+        return truthy?(evaluator.evaluate(expr)) unless op
+
+        left, right = expr.split(op, 2).map(&:strip)
+        l = numeric_value(left, evaluator)
+        r = numeric_value(right, evaluator)
+        return truthy?(evaluator.evaluate(expr)) if l.nil? || r.nil?
+
+        case op
+        when ">" then l > r
+        when "<" then l < r
+        when ">=" then l >= r
+        when "<=" then l <= r
+        when "==" then l == r
+        when "!=" then l != r
+        else false
+        end
+      end
+
+      def numeric_value(expr, evaluator)
+        return Integer(expr) if expr.match?(/\A-?\d+\z/)
+
+        val = evaluator.evaluate(expr)
+        if val.is_a?(Array)
+          val.length
+        elsif val.is_a?(Integer)
+          val
+        elsif val.is_a?(Numeric)
+          val.to_i
+        elsif val.is_a?(String) && val.match?(/\A-?\d+\z/)
+          Integer(val)
+        end
+      end
+
+      def truthy?(value)
+        case value
+        when nil then false
+        when false then false
+        when Array then !value.empty?
+        when String then !value.empty?
+        else true
+        end
+      end
+
+      def convert_loop_expressions(content, evaluator)
+        vars = []
+        result = content.dup
+        pattern = /<!--\s*@loop\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+in\s+(.+?)\s*-->/m
+        matches = []
+        result.scan(pattern) { matches << Regexp.last_match(0) }
+
+        matches.reverse_each do |original|
+          m = original.match(pattern)
+          next unless m
+
+          item_name = m[1]
+          collection_expr = m[2].strip
+          next if collection_expr.start_with?("_loop_")
+
+          collection_value = evaluator.evaluate(collection_expr)
+          items = collection_to_json_items(collection_value)
+          json_array = JSON.generate(items)
+          escaped = json_array.gsub("\\", "\\\\").gsub('"', '\\"').gsub("\n", "\\n")
+          var_name = "_loop_#{item_name}_#{SecureRandom.hex(8)}"
+          vars << "<!-- @var #{var_name} = \"#{escaped}\" -->"
+          result.sub!(original, "<!-- @loop #{item_name} in #{var_name} -->")
+        end
+
+        [result, vars]
+      end
+
+      def collection_to_json_items(value)
+        value = parse_json_collection(value) if value.is_a?(String)
+
+        case value
+        when Collection
+          value.documents.map(&:to_h)
+        when Array
+          value.map do |item|
+            case item
+            when Document then item.to_h
+            when String then { "value" => item }
+            when Hash then item
+            else { "value" => item.to_s }
+            end
+          end
+        when Document
+          [value.to_h]
+        else
+          [{ "value" => value.to_s }]
+        end
+      end
+
+      def parse_json_collection(value)
+        trimmed = value.strip
+        return value unless trimmed.start_with?("[") || trimmed.start_with?("{")
+
+        JSON.parse(trimmed)
+      rescue JSON::ParserError
+        value
+      end
+
+      def convert_closing_tags(content)
+        content
+      end
+
+      def convert_loop_expressions_to_at_syntax(content)
+        content.gsub(/<!--\s*@loop\s+([a-zA-Z_][a-zA-Z0-9_]*)\s+(in\s+[^>]+?)\s*-->(.*?)<!--\s*@endloop\s*-->/m) do
+          item = Regexp.last_match(1)
+          loop_in = Regexp.last_match(2)
+          body = Regexp.last_match(3)
+          converted = body.gsub(/<!--\s*\$!?#{Regexp.escape(item)}(\.[a-zA-Z_][a-zA-Z0-9_.-]*)?\s*-->/) do
+            prop = Regexp.last_match(1) || ".value"
+            "@#{item}#{prop}"
+          end
+          "<!-- @loop #{item} #{loop_in} -->#{converted}<!-- @endloop -->"
+        end
+      end
+
+      def evaluate_variable_declarations(content, evaluator)
+        content.gsub(/<!--\s*@var\s+([^=]+?)\s*=\s*(.*?)\s*-->/m) do
+          name = Regexp.last_match(1).strip
+          value = Regexp.last_match(2).strip
+          if value.include?("$") || value.match?(/\bdoc\./)
+            evaluated = value.gsub(/\$([a-zA-Z_][a-zA-Z0-9_.]*)/) do
+              evaluator.stringify(evaluator.evaluate(Regexp.last_match(1)))
+            end
+            "<!-- @var #{name} = #{evaluated} -->"
+          else
+            Regexp.last_match(0)
+          end
+        end
+      end
+
+      def process_expressions_outside_blocks(content, evaluator)
+        protected = []
+        content.scan(/<!--\s*@(if|unless|loop)\s+[^>]+?-->(.*?)<!--\s*@(end|endloop|endif|endunless)\s*-->/m) do
+          # mark protected ranges - simplified: process all for template pages
+        end
+        process_expressions(content, evaluator)
+      end
+
+      def process_expressions(content, evaluator)
+        result = content.dup
+        result.gsub!(/<!--\s*\$!([^>]+?)\s*-->/) do
+          evaluator.stringify(evaluator.evaluate(Regexp.last_match(1).strip))
+        end
+        result.gsub!(/<!--\s*\$([^>!][^>]*?)\s*-->/) do
+          evaluator.escape_html(evaluator.evaluate(Regexp.last_match(1).strip))
+        end
+        result
+      end
+
+      def cleanup_remaining_hammer_tags(content)
+        patterns = [
+          /<!--\s*@if\s+[^>]+?-->/,
+          /<!--\s*@unless\s+[^>]+?-->/,
+          /<!--\s*@loop\s+[^>]+?-->/,
+          /<!--\s*@(endif|endunless|endloop|end|else)\s*-->/
+        ]
+        result = content.dup
+        patterns.each { |pat| result.gsub!(pat, "") }
+        result.gsub!(/(\S)\s*,\s*\n\s*(?=<\/)/, '\1')
+
+        cleaned_lines = []
+        last_was_empty = false
+        result.each_line(chomp: true) do |line|
+          if line.strip.empty?
+            unless last_was_empty
+              cleaned_lines << ""
+              last_was_empty = true
+            end
+          else
+            cleaned_lines << line.rstrip
+            last_was_empty = false
+          end
+        end
+        cleaned_lines.join("\n")
+      end
+    end
+  end
+end
+
+require "fileutils"