beachio-hammer 0.1.0.pre1

data/lib/hammer/tag_parser.rb

@@ -0,0 +1,569 @@
+# frozen_string_literal: true
+
+require "json"
+require "set"
+
+module Hammer
+  class TagParser
+    attr_reader :variables, :todos
+    attr_accessor :current_file_path
+
+    def initialize(source_directory:, parent_variables: nil, build_mode: :normal, delegate: nil,
+                   content_collections: {}, content_config: nil, skip_path_prefixes: [])
+      @source_directory = source_directory
+      @skip_path_prefixes = skip_path_prefixes
+      @parent_variables = parent_variables || {}
+      @variables = {}
+      @build_mode = build_mode
+      @delegate = delegate
+      @content_collections = content_collections
+      @content_config = content_config
+      @processed_includes = Set.new
+      @todos = []
+      @current_file_path = nil
+    end
+
+    def process_file(relative_path, output_path_for_styling: nil)
+      @current_file_path = output_path_for_styling || relative_path
+      content = File.read(File.join(@source_directory, relative_path))
+      process_file_content(content, relative_path, output_path_for_styling)
+    end
+
+    def process_file_content(content, relative_path, output_path_for_styling = nil)
+      all_vars = @parent_variables.merge(@variables)
+      parser = self.class.new(
+        source_directory: @source_directory,
+        parent_variables: all_vars,
+        build_mode: @build_mode,
+        delegate: @delegate,
+        content_collections: @content_collections,
+        content_config: @content_config,
+        skip_path_prefixes: @skip_path_prefixes
+      )
+      parser.current_file_path = output_path_for_styling || relative_path
+      result = parser.parse(content)
+      @variables.merge!(parser.variables)
+      @todos.concat(parser.todos)
+      result
+    end
+
+    def parse(content)
+      result = escape_code_examples(content)
+      result = process_variable_declarations(result)
+      result = process_includes(result)
+      result = replace_variables(result)
+      result = process_loops_and_conditionals(result)
+      result = process_paths(result)
+      result = process_navigation_helpers(result)
+      result = @build_mode == :normal ? process_reload_tag(result) : strip_reload_tag(result)
+      result = process_stylesheets(result)
+      result = process_javascript(result)
+      uncomment_hammer_tags(result)
+    end
+
+    def process_variable_declarations(content)
+      content.gsub(/<!--\s*@var\s+([^=]+?)\s*=\s*(.*?)\s*-->/m) do
+        name = Regexp.last_match(1).strip
+        value = unquote_var_value(Regexp.last_match(2).strip)
+        @variables[name] = value
+        ""
+      end
+    end
+
+    def unquote_var_value(value)
+      if value.start_with?('"') && value.end_with?('"')
+        value = value[1..-2]
+        value = value.gsub("--&gt;", "-->")
+                     .gsub("\\n", "\n")
+                     .gsub("\\r", "\r")
+                     .gsub("\\t", "\t")
+                     .gsub('\\"', '"')
+                     .gsub("\\\\", "\\")
+      end
+      value
+    end
+
+    def skip_scan_path?(rel)
+      return true if rel.start_with?("Build/", ".")
+      return true if @skip_path_prefixes.any? { |prefix| rel == prefix.chomp("/") || rel.start_with?(prefix) }
+
+      false
+    end
+
+    def find_include_file(filename)
+      possible_names = ["_#{filename}.html", "#{filename}.html", "_#{filename}", filename]
+      common_dirs = %w[includes _includes partials _partials snippets _snippets]
+
+      common_dirs.each do |dir|
+        possible_names.each do |name|
+          path = "#{dir}/#{name}"
+          return path if File.file?(File.join(@source_directory, path))
+        end
+      end
+
+      possible_names.each do |name|
+        return name if File.file?(File.join(@source_directory, name))
+      end
+
+      found = []
+      Dir.glob(File.join(@source_directory, "**", "*")).each do |f|
+        next unless File.file?(f)
+        rel = f.delete_prefix("#{@source_directory}/")
+        next if rel.start_with?("Build/", ".")
+        next if @skip_path_prefixes.any? { |prefix| rel == prefix.chomp("/") || rel.start_with?(prefix) }
+
+        found << rel if possible_names.include?(File.basename(f))
+      end
+
+      return [nil, nil] if found.empty?
+
+      found.sort_by! do |path|
+        in_dir = path.match?(/includes|partials|snippets/i) ? 0 : 1
+        underscore = File.basename(path).start_with?("_") ? 0 : 1
+        [in_dir, underscore, path]
+      end
+      [found.first, nil]
+    end
+
+    private
+
+    def escape_code_examples(content)
+      content.gsub(/<code class="hammer-code">((?:(?!<code class="hammer-code").)*?)<\/code>/m) do
+        inner = Regexp.last_match(1)
+        next Regexp.last_match(0) if inner.include?("&lt;") || inner.include?("&gt;")
+
+        escaped = inner.gsub("<", "&lt;").gsub(">", "&gt;")
+        %(<code class="hammer-code">#{escaped}</code>)
+      end
+    end
+
+    def get_variable(name)
+      @variables[name] || @parent_variables[name]
+    end
+
+    def process_includes(content)
+      result = content.dup
+      count = 0
+      include_pattern = /<!--\s*@include\s+([^\s>]+)\s*-->/
+
+      while (match = result.match(include_pattern)) && count < 100
+        count += 1
+        include_ref = match[1].strip
+        if include_ref.start_with?("$")
+          var_name = include_ref[1..]
+          include_ref = get_variable(var_name) || include_ref
+        end
+
+        path, = find_include_file(include_ref)
+        unless path
+          @delegate&.warning(@current_file_path, "Include not found: #{include_ref}")
+          result.sub!(match[0], "")
+          next
+        end
+
+        if @processed_includes.include?(path)
+          result.sub!(match[0], "")
+          next
+        end
+
+        @processed_includes << path
+        included = File.read(File.join(@source_directory, path))
+        child = self.class.new(
+          source_directory: @source_directory,
+          parent_variables: @parent_variables.merge(@variables),
+          build_mode: @build_mode,
+          delegate: @delegate,
+          content_collections: @content_collections,
+          content_config: @content_config,
+          skip_path_prefixes: @skip_path_prefixes
+        )
+        child.current_file_path = @current_file_path
+        processed = child.parse(included)
+        @variables.merge!(child.variables)
+        result.sub!(match[0], processed)
+      end
+
+      result
+    end
+
+    def replace_variables(content)
+      result = content.dup
+      control_tags = %w[if unless else endif endunless loop endloop end]
+      result.gsub!(/<!--\s*@([a-zA-Z_][a-zA-Z0-9_-]*)\s*-->/) do
+        name = Regexp.last_match(1)
+        next Regexp.last_match(0) if control_tags.include?(name)
+
+        get_variable(name) || (@delegate&.warning(@current_file_path, "Variable not set: #{name}"); "")
+      end
+      result.gsub!(/<!--\s*\$([a-zA-Z_][a-zA-Z0-9_-]*)\s*-->/) do
+        name = Regexp.last_match(1)
+        get_variable(name) || ""
+      end
+      result
+    end
+
+    def process_loops_and_conditionals(content)
+      result = process_loops(content)
+      process_conditionals(result)
+    end
+
+    def process_loops(content)
+      result = content.dup
+      loop_pattern = /<!--\s*@loop\s+(.+?)\s*-->(.*?)<!--\s*@endloop\s*-->/m
+      count = 0
+
+      while (match = result.match(loop_pattern)) && count < 1000
+        count += 1
+        loop_tag = match[1]
+        template = match[2]
+        item_name, array_name = loop_tag.split(/\s+in\s+/, 2).map(&:strip)
+        array_str = get_variable(array_name)
+
+        unless array_str
+          result.sub!(match[0], "")
+          next
+        end
+
+        begin
+          json_str = array_str.gsub('\\"', '"').gsub("\\n", "\n")
+          array_data = JSON.parse(json_str)
+        rescue JSON::ParserError
+          result.sub!(match[0], "")
+          next
+        end
+
+        processed = array_data.map do |item|
+          item_content = template.dup
+          item_hash = item.is_a?(Hash) ? item.transform_keys(&:to_s) : { "value" => item.to_s }
+          item_hash.each do |key, value|
+            item_content.gsub!("@#{item_name}.#{key}", value_to_string(value))
+          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
+        end.join
+
+        result.sub!(match[0], processed)
+      end
+
+      result
+    end
+
+    def value_to_string(value)
+      case value
+      when String then value
+      when TrueClass, FalseClass then value.to_s
+      when Numeric then value.to_s
+      when NilClass then ""
+      when Hash then value["value"].to_s
+      else value.to_s
+      end
+    end
+
+    def process_nested_properties(content, item, item_name)
+      content.gsub(/@#{Regexp.escape(item_name)}\.([a-zA-Z_][a-zA-Z0-9_.-]*)/) do
+        path = Regexp.last_match(1).split(".")
+        val = path.reduce(item) do |obj, key|
+          obj.is_a?(Hash) ? obj[key] : nil
+        end
+        value_to_string(val)
+      end
+    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
+
+      while (match = result.match(pattern))
+        type = match[1]
+        condition = match[2].strip
+        true_content = match[3]
+        false_content = match[4] || ""
+        met = evaluate_loop_condition(condition, item, item_name)
+        met = !met if type == "unless"
+        result.sub!(match[0], met ? true_content : false_content)
+      end
+
+      result
+    end
+
+    def evaluate_loop_condition(condition, item, item_name)
+      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 }
+        return truthy?(val)
+      end
+
+      if condition.end_with?(".empty?")
+        var = condition.sub(".empty?", "")
+        val = get_variable(var)
+        return val.nil? || val.empty?
+      end
+
+      val = get_variable(condition)
+      truthy?(val)
+    end
+
+    def truthy?(value)
+      case value
+      when nil then false
+      when String then !value.empty? && value.downcase != "false" && value != "0"
+      when Array then !value.empty?
+      when FalseClass then false
+      else true
+      end
+    end
+
+    def process_conditionals(content)
+      result = content.dup
+      pattern = /<!--\s*@(if|unless)\s+(.+?)\s*-->(.*?)(?:<!--\s*@else\s*-->(.*?))?(?:<!--\s*@end(?:if|unless|\1)?\s*-->|<!--\s*@end\s*-->)/m
+
+      while (match = result.match(pattern))
+        type = match[1]
+        condition = match[2].strip
+        true_content = match[3]
+        false_content = match[4] || ""
+        met = if condition.end_with?(".empty?")
+                var = condition.sub(".empty?", "")
+                val = get_variable(var)
+                begin
+                  arr = JSON.parse(val.gsub('\\"', '"'))
+                  arr.empty?
+                rescue StandardError
+                  val.nil? || val.empty?
+                end
+              else
+                truthy?(get_variable(condition))
+              end
+        met = !met if type == "unless"
+        result.sub!(match[0], met ? true_content : false_content)
+      end
+
+      result
+    end
+
+    def process_paths(content)
+      content.gsub(/<!--\s*@path\s+([^>]+?)\s*-->/) do
+        ref = Regexp.last_match(1).strip
+        if ref.start_with?("$")
+          ref = get_variable(ref[1..]) || ref
+        end
+
+        if ref == "/"
+          generate_context_aware_path(".")
+        else
+          preserve_slash = ref.end_with?("/")
+          filename = preserve_slash ? ref.chomp("/") : ref
+          paths, error = find_file(File.basename(filename))
+          raise TagError, error if error
+
+          if paths.empty?
+            @delegate&.warning(@current_file_path, "File not found: #{ref}")
+            ref
+          else
+            path = paths.first
+            path = "#{path}/" if preserve_slash
+            generate_context_aware_path(path).gsub("%20", " ").gsub(" ", "%20")
+          end
+        end
+      end
+    end
+
+    def find_file(filename)
+      found = []
+      dirs = %w[assets/img assets/images assets/media images img media]
+      dirs.each do |dir|
+        path = "#{dir}/#{filename}"
+        found << path if File.exist?(File.join(@source_directory, path))
+      end
+      found << filename if File.exist?(File.join(@source_directory, filename))
+
+      if found.empty? || found.length > 1
+        Dir.glob(File.join(@source_directory, "**", "*")).each do |f|
+          next unless File.file?(f)
+          rel = f.delete_prefix("#{@source_directory}/")
+          next if skip_scan_path?(rel)
+
+          found << rel if File.basename(f) == filename && !found.include?(rel)
+        end
+      end
+
+      found.uniq!
+      return [[], "Multiple files found with name '#{filename}': #{found.join(', ')}"] if found.length > 1
+
+      [found, nil]
+    end
+
+    def generate_context_aware_path(file_path)
+      return "./#{file_path}" unless @current_file_path
+
+      path_for_processing = file_path.end_with?("/") ? file_path.chomp("/") : file_path
+      current_dir = File.dirname(@current_file_path).split("/").reject { |p| p == "." }
+      target_parts = path_for_processing.split("/")
+      common = 0
+      common += 1 while common < current_dir.length && common < target_parts.length && current_dir[common] == target_parts[common]
+
+      levels_up = current_dir.length - common
+      remaining = target_parts[common..]
+      parts = ([".."] * levels_up) + remaining
+
+      if parts.empty?
+        "./#{target_parts.last}"
+      elsif levels_up.zero? && remaining.length == 1
+        "./#{remaining[0]}"
+      else
+        parts.join("/")
+      end.tap { |r| r << "/" if file_path.end_with?("/") && !r.end_with?("/") }
+    end
+
+    def process_navigation_helpers(content)
+      return content unless @current_file_path
+
+      current = normalize_nav_path(@current_file_path)
+      content.gsub(/<a\s+([^>]*?)href\s*=\s*["']([^"'#][^"']*)["']([^>]*)>/i) do
+        before = Regexp.last_match(1)
+        href = Regexp.last_match(2)
+        after = Regexp.last_match(3)
+        next Regexp.last_match(0) if href.start_with?("http", "//", "#")
+
+        normalized_href = normalize_nav_path(href, base: File.dirname(@current_file_path))
+        classes = []
+        if normalized_href == current
+          classes << "current"
+        elsif index_page_match?(normalized_href, current)
+          classes << "current-parent"
+        end
+
+        next Regexp.last_match(0) if classes.empty?
+
+        tag = "<a #{before}href=\"#{href}\"#{after}>"
+        if tag.match?(/class\s*=/)
+          tag.sub(/class\s*=\s*["']([^"']*)["']/) { "class=\"#{Regexp.last_match(1)} #{classes.join(' ')}\"" }
+        else
+          tag.sub("<a ", "<a class=\"#{classes.join(' ')}\" ")
+        end
+      end
+    end
+
+    def normalize_nav_path(path, base: nil)
+      p = path.dup
+      p = File.expand_path(p, File.join(@source_directory, base)) if base && !p.start_with?("/")
+      p = p.delete_prefix(@source_directory).delete_prefix("/")
+      p = p.sub(%r{/index\.html\z}, "/")
+      p = p.sub(/\.html\z/, "")
+      p = "/" if p.empty? || p == "index"
+      p.start_with?("/") ? p : "/#{p}"
+    end
+
+    def index_page_match?(href, current)
+      href.end_with?("/") && current.start_with?(href.chomp("/"))
+    end
+
+    def strip_reload_tag(content)
+      content.gsub(/<!--\s*@reload\s*-->\s*/m, "")
+    end
+
+    def process_reload_tag(content)
+      script = <<~SCRIPT
+        <script>
+        (function(){var s=document.createElement('script');s.src='';var ws=new WebSocket('ws://localhost:35353');ws.onmessage=function(){location.reload()};})();
+        </script>
+      SCRIPT
+      content.gsub(/<!--\s*@reload\s*-->/, script)
+    end
+
+    def process_stylesheets(content)
+      result = content.dup
+      pattern = /<!--\s*@stylesheet\s+([^>]+?)\s*-->/
+
+      while (match = result.match(pattern))
+        files = match[1].split.map(&:strip)
+        links = files.map do |file|
+          path, = find_stylesheet(file)
+          raise TagError, "Stylesheet not found: #{file}" unless path
+
+          %(<link rel="stylesheet" href="#{generate_context_aware_path(path)}">)
+        end
+        result.sub!(match[0], links.join("\n") + "\n")
+      end
+
+      result
+    end
+
+    def find_stylesheet(filename)
+      names = filename.end_with?(".css") ? [filename, filename.sub(/\.css\z/i, "")] : [filename, "#{filename}.css"]
+      dirs = ["css", "assets/css", "styles", "assets/styles", "assets", ""]
+      found = []
+
+      dirs.each do |dir|
+        names.each do |name|
+          path = dir.empty? ? name : "#{dir}/#{name}"
+          found << path if File.file?(File.join(@source_directory, path))
+        end
+      end
+
+      if found.empty?
+        Dir.glob(File.join(@source_directory, "**", "*")).each do |f|
+          next unless File.file?(f)
+          rel = f.delete_prefix("#{@source_directory}/")
+          next if skip_scan_path?(rel) || File.basename(f).start_with?("_")
+
+          found << rel if names.include?(File.basename(f))
+        end
+      end
+
+      return [nil, "not found"] if found.empty?
+
+      found.sort_by! { |p| [p.match?(/css|styles/i) ? 0 : 1, p] }
+      [found.first, found.length > 1 ? "multiple" : nil]
+    end
+
+    def process_javascript(content)
+      result = content.dup
+      pattern = /<!--\s*@javascript\s+([^>]+?)\s*-->/
+
+      while (match = result.match(pattern))
+        files = match[1].split.map(&:strip)
+        tags = files.map do |file|
+          path, = find_javascript(file)
+          raise TagError, "JavaScript not found: #{file}" unless path
+
+          %(<script src="#{generate_context_aware_path(path)}"></script>)
+        end
+        result.sub!(match[0], tags.join("\n") + "\n")
+      end
+
+      result
+    end
+
+    def find_javascript(filename)
+      names = filename.end_with?(".js") ? [filename, filename.sub(/\.js\z/i, "")] : [filename, "#{filename}.js"]
+      dirs = %w[js assets/js scripts assets/scripts javascript assets/javascript assets ""]
+      found = []
+
+      dirs.each do |dir|
+        names.each do |name|
+          path = dir.empty? ? name : "#{dir}/#{name}"
+          found << path if File.file?(File.join(@source_directory, path))
+        end
+      end
+
+      return [nil, "not found"] if found.empty?
+
+      found.sort_by! { |p| [p.match?(/js|script/i) ? 0 : 1, p] }
+      [found.first, nil]
+    end
+
+    def uncomment_hammer_tags(content)
+      content.gsub(/(<!--\s*)(@@|\$\$)([^>]+?)(-->)/) do
+        prefix = Regexp.last_match(1)
+        symbol = Regexp.last_match(2)
+        body = Regexp.last_match(3)
+        suffix = Regexp.last_match(4)
+        single = symbol.start_with?("@") ? "@" : "$"
+        tag = "#{prefix}#{single}#{body}#{suffix}"
+        tag.gsub("<", "&lt;").gsub(">", "&gt;")
+      end
+    end
+  end
+end

data/lib/hammer/version.rb

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

data/scripts/capture-goldens.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+
+capture() {
+  local project="$1"
+  echo "Capturing golden Build/ for ${project}..."
+  hammer build --project "${ROOT}/Test Projects/${project}" --mode export --clean
+}
+
+capture "classic-fixture"
+capture "content-generation-test"
+
+echo "Golden Build/ trees updated."

data/scripts/test-classic.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "beachio-hammer"
+require "fileutils"
+
+project = File.expand_path("../../Test Projects/classic-fixture", __dir__)
+output = File.join(project, "Build-gem")
+FileUtils.rm_rf(output)
+Hammer::Builder.new(
+  site: Hammer::ProjectResolver.create_site(project, output: output),
+  mode: :export,
+  clean: true
+).build
+
+golden = File.read(File.join(project, "Build/assets/css/styles.css"))
+actual = File.read(File.join(output, "assets/css/styles.css"))
+g_url = golden[/url\("[^"]+"\)/]
+a_url = actual[/url\("[^"]+"\)/]
+puts "golden count: #{g_url.count('../img/')}"
+puts "actual count: #{a_url.count('../img/')}"
+puts "css match: #{golden == actual}"
+exit system("ruby", File.join(__dir__, "tree-diff.rb"), File.join(project, "Build"), output)

data/scripts/test-content.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "beachio-hammer"
+require "fileutils"
+require "timeout"
+
+project = File.expand_path("../../Test Projects/content-generation-test", __dir__)
+output = File.join(project, "Build-gem")
+FileUtils.rm_rf(output)
+
+Timeout.timeout(60) do
+  Hammer::Builder.new(
+    site: Hammer::ProjectResolver.create_site(project, output: output),
+    mode: :export,
+    clean: true
+  ).build
+end
+
+exit system("ruby", File.join(__dir__, "tree-diff.rb"), File.join(project, "Build"), output)

data/scripts/tree-diff.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+
+def normalize_sitemap(content)
+  content.gsub(/<lastmod>[^<]+<\/lastmod>\s*/m, "")
+end
+
+def collect_files(dir)
+  files = {}
+  return files unless File.directory?(dir)
+
+  Dir.glob(File.join(dir, "**", "*"), File::FNM_DOTMATCH).each do |path|
+    next unless File.file?(path)
+    next if File.basename(path) == ".DS_Store"
+
+    rel = path.delete_prefix("#{dir}/")
+    next if rel.start_with?(".hammer-cache/")
+    next if rel.include?("/.hammer-cache/")
+
+    files[rel] = path
+  end
+  files
+end
+
+def file_equal?(golden_path, actual_path)
+  g = File.binread(golden_path)
+  a = File.binread(actual_path)
+
+  if File.basename(golden_path) == "sitemap.xml"
+    return normalize_sitemap(g) == normalize_sitemap(a)
+  end
+
+  g == a
+end
+
+golden_dir = ARGV[0]
+actual_dir = ARGV[1]
+
+unless golden_dir && actual_dir && File.directory?(golden_dir) && File.directory?(actual_dir)
+  warn "Usage: tree-diff.rb GOLDEN_BUILD_DIR ACTUAL_BUILD_DIR"
+  exit 2
+end
+
+golden = collect_files(golden_dir)
+actual = collect_files(actual_dir)
+missing = golden.keys - actual.keys
+extra = actual.keys - golden.keys
+mismatch = []
+
+(golden.keys & actual.keys).each do |rel|
+  mismatch << rel unless file_equal?(golden[rel], actual[rel])
+end
+
+if missing.empty? && extra.empty? && mismatch.empty?
+  puts "Trees match (#{golden.length} files)"
+  exit 0
+end
+
+warn "Tree diff failed:"
+missing.each { |f| warn "  missing: #{f}" }
+extra.each { |f| warn "  extra: #{f}" }
+mismatch.each { |f| warn "  content mismatch: #{f}" }
+exit 1