beachio-hammer 0.1.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6fbc6c05d882741fa94434691763470a2a8ae5cec91713e0b0fb9e4e0cd25bca
+  data.tar.gz: 22394aa9fae0d7b44a53d511a94a7a02a052c6cab1af769f51601e4c55adf166
+SHA512:
+  metadata.gz: 8703bd2e45433905cdd2d503d70e7179d5aed28c35a6f2c32f1418dafd4267c80bd0cb6162531c18c61b0a426bd2f5a7f7d9d361a68f8caed04c414f375d9071
+  data.tar.gz: 62021958be80b18b3bd59059dc339399ca80650d1d9ea0e07d4f908093fb21f0ac8a95981d848f9495bd556ce3718e63e799186f21a28881d985c0f686d2b292

data/.ruby-version

@@ -0,0 +1 @@
+3.4.5

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    beachio-hammer (0.1.0.pre1)
+      json (~> 2.7)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.6.2)
+    json (2.21.2)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-24
+
+DEPENDENCIES
+  beachio-hammer!
+  rspec (~> 3.13)
+
+BUNDLED WITH
+   2.6.9

data/PUBLISH.md

@@ -0,0 +1,34 @@
+# Publishing beachio-hammer
+
+## Local development
+
+```bash
+cd gem
+bundle install
+bundle exec rspec
+```
+
+## Capture golden Build/ trees (macOS Swift CLI)
+
+```bash
+./scripts/capture-goldens.sh
+```
+
+## Publish to RubyGems
+
+1. Bump `Hammer::VERSION` in `lib/hammer/version.rb`.
+2. Build and push:
+
+```bash
+cd gem
+gem build beachio-hammer.gemspec
+gem push beachio-hammer-*.gem
+```
+
+## hammer-cloud integration
+
+Pin the published gem version in the executor Dockerfile:
+
+```dockerfile
+RUN gem install beachio-hammer -v 0.1.0.pre1
+```

data/beachio-hammer.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "lib/hammer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "beachio-hammer"
+  spec.version       = Hammer::VERSION
+  spec.authors       = ["Beach.io"]
+  spec.email         = ["support@beach.io"]
+  spec.summary       = "Hammer static site compiler (Ruby port of Hammer-Swift)"
+  spec.description   = "Build static sites with Hammer tags, CSS includes, and content collections."
+  spec.homepage      = "https://github.com/beachio/hammer-swift"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.4.0"
+
+  spec.files = Dir.chdir(__dir__) do
+    tracked = `git ls-files -z 2>/dev/null`.split("\x0")
+    tracked = Dir["lib/**/*.rb", "exe/*", "scripts/*"] if tracked.empty?
+    tracked.reject { |f| f.end_with?(".gem") || f.start_with?("spec/fixtures/") }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = ["hammer"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "json", "~> 2.7"
+  spec.add_development_dependency "rspec", "~> 3.13"
+end

data/exe/hammer

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "beachio-hammer"
+
+exit Hammer::CLI.run(ARGV)

data/lib/beachio-hammer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "hammer/version"
+require_relative "hammer/errors"
+require_relative "hammer/ignore"
+require_relative "hammer/tag_parser"
+require_relative "hammer/css_parser"
+require_relative "hammer/sitemap_generator"
+require_relative "hammer/project_resolver"
+require_relative "hammer/output_formatter"
+require_relative "hammer/content/config"
+require_relative "hammer/content/document"
+require_relative "hammer/content/parser"
+require_relative "hammer/content/helpers"
+require_relative "hammer/content/template_context"
+require_relative "hammer/content/expression_evaluator"
+require_relative "hammer/content/relation_resolver"
+require_relative "hammer/content/page_generator"
+require_relative "hammer/content/builder"
+require_relative "hammer/builder"
+require_relative "hammer/build_command"
+require_relative "hammer/cli"
+
+module Hammer
+end

data/lib/hammer/build_command.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Hammer
+  module BuildCommand
+    module_function
+
+    def run(argv)
+      options = parse_options(argv)
+      project_dir = ProjectResolver.resolve(explicit_path: options[:project])
+      site = ProjectResolver.create_site(project_dir, output: options[:output])
+
+      unless options[:quiet]
+        puts "Building #{site[:name]}..."
+        puts "  Source: #{site[:source_path]}"
+        puts "  Output: #{site[:build_path]}"
+        puts ""
+      end
+
+      delegate = BuildDelegate.new(format: options[:format], quiet: options[:quiet])
+      builder = Builder.new(
+        site: site,
+        mode: options[:mode],
+        log_level: options[:log_level],
+        clean: options[:clean],
+        delegate: delegate
+      )
+
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      builder.build
+      duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+
+      OutputFormatter.format_build_result(
+        duration: duration,
+        file_count: delegate.file_count,
+        error_count: delegate.error_count,
+        warning_count: delegate.warning_count,
+        build_size: format_size(site[:build_path]),
+        errors: delegate.errors,
+        warnings: delegate.warnings,
+        format: options[:format]
+      )
+
+      delegate.error_count.positive? ? 1 : 0
+    end
+
+    def parse_options(argv)
+      options = {
+        project: nil,
+        output: nil,
+        mode: :export,
+        format: :human,
+        log_level: :normal,
+        clean: false,
+        quiet: false,
+        verbose: false
+      }
+
+      i = 0
+      while i < argv.length
+        arg = argv[i]
+        case arg
+        when "--project"
+          options[:project] = argv[i += 1]
+        when "--output"
+          options[:output] = argv[i += 1]
+        when "--mode"
+          mode = argv[i += 1].to_s.downcase
+          options[:mode] = case mode
+                           when "normal" then :normal
+                           when "export" then :export
+                           when "publish" then :publish
+                           else
+                             warn "Error: Unknown build mode '#{mode}'. Use: normal, export, or publish"
+                             raise ConfigError, "Unknown build mode"
+                           end
+        when "--format"
+          fmt = argv[i += 1].to_s.downcase
+          options[:format] = fmt == "json" ? :json : :human
+        when "--clean"
+          options[:clean] = true
+        when "--verbose"
+          options[:verbose] = true
+          options[:log_level] = :verbose
+        when "--quiet"
+          options[:quiet] = true
+          options[:log_level] = :quiet
+        else
+          warn "Unknown option: #{arg}"
+          raise ConfigError, "Unknown option: #{arg}"
+        end
+        i += 1
+      end
+
+      options
+    end
+
+    def format_size(path)
+      return "0 KB" unless File.directory?(path)
+
+      total = Dir.glob(File.join(path, "**", "*"), File::FNM_DOTMATCH).sum do |f|
+        File.file?(f) ? File.size(f) : 0
+      end
+      if total >= 1_048_576
+        "#{(total / 1_048_576.0).round(1)} MB"
+      else
+        "#{(total / 1024.0).round(1)} KB"
+      end
+    end
+
+    class BuildDelegate
+      attr_reader :file_count, :error_count, :warning_count, :errors, :warnings
+
+      def initialize(format:, quiet:)
+        @format = format
+        @quiet = quiet
+        @file_count = 0
+        @error_count = 0
+        @warning_count = 0
+        @errors = []
+        @warnings = []
+      end
+
+      def log(message)
+        puts message unless @quiet
+      end
+
+      def processed_file(_source, _dest)
+        @file_count += 1
+      end
+
+      def ignored_file(file, reason)
+        log("Ignored #{file}: #{reason}") unless @quiet
+      end
+
+      def error(file, message)
+        @error_count += 1
+        @errors << { file: file, message: message }
+      end
+
+      def warning(file, message)
+        @warning_count += 1
+        @warnings << { file: file, message: message }
+      end
+    end
+  end
+end

data/lib/hammer/builder.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Hammer
+  class Builder
+    def initialize(site:, mode: :export, log_level: :normal, clean: false, delegate: nil)
+      @site = site
+      @source = site[:source_path]
+      @build = site[:build_path]
+      @mode = mode
+      @log_level = log_level
+      @clean = clean
+      @delegate = delegate
+      @ignore_patterns = Ignore.load_patterns(@source)
+      @content_collections = {}
+      @content_config = nil
+    end
+
+    def build
+      clear_build_directory if @clean || %i[export publish].include?(@mode)
+
+      run_content_generation if Content::Config.enabled?(@source)
+      copy_public_directory
+      files = enumerate_files
+      process_files(files)
+      generate_sitemap
+    end
+
+    private
+
+    def clear_build_directory
+      FileUtils.rm_rf(@build) if File.directory?(@build)
+      FileUtils.mkdir_p(@build)
+    end
+
+    def run_content_generation
+      content_builder = Content::Builder.new(
+        source_directory: @source,
+        build_mode: @mode,
+        delegate: @delegate
+      )
+      content_builder.load_config!
+      content_builder.parse_all_content!
+
+      resolver = Content::RelationResolver.new(
+        collections: content_builder.collections,
+        config: content_builder.config
+      )
+      resolver.resolve_all!
+
+      generator = Content::PageGenerator.new(
+        source_directory: @source,
+        build_directory: @build,
+        config: content_builder.config,
+        collections: content_builder.collections,
+        build_mode: @mode,
+        delegate: @delegate
+      )
+      generator.generate_all_pages!
+
+      @content_collections = content_builder.collections
+      @content_config = content_builder.config
+    rescue StandardError => e
+      @delegate&.error("content.config.json", e.message)
+    end
+
+    def copy_public_directory
+      src = File.join(@source, "public")
+      dest = File.join(@build, "public")
+      return unless File.directory?(src)
+
+      FileUtils.rm_rf(dest) if File.directory?(dest)
+      FileUtils.cp_r(src, dest)
+    end
+
+    def enumerate_files
+      files = []
+      content_enabled = Content::Config.enabled?(@source)
+      build_prefix = @build.delete_prefix("#{@source}/").delete_prefix("/")
+      build_prefix = "#{build_prefix}/" unless build_prefix.empty?
+
+      Dir.glob(File.join(@source, "**", "*"), File::FNM_DOTMATCH).each do |abs|
+        next unless File.file?(abs)
+
+        rel = abs.delete_prefix("#{@source}/")
+        next if rel.start_with?("Build/", ".hammer-cache/", ".")
+        next if !build_prefix.empty? && (rel == build_prefix.chomp("/") || rel.start_with?(build_prefix))
+
+        if content_enabled
+          next if rel.start_with?("content/", "templates/", "public/")
+        end
+
+        skip, reason = Ignore.should_skip?(rel, @ignore_patterns)
+        if skip
+          @delegate&.ignored_file(rel, reason)
+          next
+        end
+
+        files << rel
+      end
+      files.sort
+    end
+
+    def build_skip_prefixes
+      prefixes = ["Build/"]
+      if @build.start_with?(@source)
+        rel = @build.delete_prefix("#{@source}/")
+        prefixes << "#{rel}/" unless rel.empty?
+      end
+      prefixes
+    end
+
+    def process_files(files)
+      tag_parser = TagParser.new(
+        source_directory: @source,
+        build_mode: @mode,
+        delegate: @delegate,
+        content_collections: @content_collections,
+        content_config: @content_config,
+        skip_path_prefixes: build_skip_prefixes
+      )
+      css_parser = CSSParser.new(source_directory: @source, skip_path_prefixes: build_skip_prefixes)
+
+      files.each do |rel|
+        process_file(rel, tag_parser, css_parser)
+      end
+    end
+
+    def process_file(rel, tag_parser, css_parser)
+      src = File.join(@source, rel)
+      dest = File.join(@build, rel)
+      ext = File.extname(rel).downcase
+
+      case ext
+      when ".html"
+        content = File.read(src)
+        if !@content_collections.empty? && content.include?("@loop") && content.include?("collections.")
+          content = Content::PageGenerator.pre_process_collection_loops(
+            content,
+            collections: @content_collections,
+            source_directory: @source,
+            build_mode: @mode,
+            delegate: @delegate
+          )
+        end
+        processed = tag_parser.process_file_content(content, rel)
+        FileUtils.mkdir_p(File.dirname(dest))
+        File.write(dest, processed)
+      when ".css"
+        processed = css_parser.parse(File.read(src), relative_path: rel)
+        FileUtils.mkdir_p(File.dirname(dest))
+        File.write(dest, processed)
+      else
+        FileUtils.mkdir_p(File.dirname(dest))
+        FileUtils.cp(src, dest)
+      end
+
+      @delegate&.processed_file(rel, dest)
+    rescue StandardError => e
+      @delegate&.error(rel, e.message)
+    end
+
+    def generate_sitemap
+      content_paths = []
+      if @content_config && @content_collections.any?
+        generator = Content::PageGenerator.new(
+          source_directory: @source,
+          build_directory: @build,
+          config: @content_config,
+          collections: @content_collections,
+          build_mode: @mode
+        )
+        @content_collections.each do |name, coll|
+          cfg = @content_config.get_collection(name)
+          next unless cfg
+
+          coll.documents.each do |doc|
+            path = generator.resolve_output_path(doc, cfg)
+            content_paths << path if File.file?(File.join(@build, path))
+          end
+        end
+      end
+
+      exclude = Set.new(content_paths.map { |p| SitemapGenerator.new(build_directory: @build).normalize_path(p) })
+      static = SitemapGenerator.new(build_directory: @build).discover_static_pages(exclude: exclude)
+      SitemapGenerator.new(build_directory: @build).generate!(
+        content_paths: content_paths,
+        static_paths: static
+      )
+    end
+  end
+end
+
+require "set"

data/lib/hammer/cli.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hammer
+  module CLI
+    module_function
+
+    def run(argv)
+      command = argv.first == "build" ? argv.shift : "build"
+      case command
+      when "build"
+        BuildCommand.run(argv)
+      else
+        warn "Unknown command: #{command}"
+        2
+      end
+    rescue ConfigError => e
+      warn "Error: #{e.message}"
+      2
+    rescue InternalError => e
+      warn "Internal error: #{e.message}"
+      3
+    rescue BuildError => e
+      warn "Build failed: #{e.message}"
+      1
+    end
+  end
+end

data/lib/hammer/content/builder.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Hammer
+  module Content
+    class Builder
+      attr_reader :config, :collections
+
+      def initialize(source_directory:, build_mode:, delegate: nil)
+        @source_directory = source_directory
+        @build_mode = build_mode
+        @delegate = delegate
+        @parser = Parser.new(source_directory: source_directory)
+        @config = nil
+        @collections = {}
+      end
+
+      def load_config!
+        path = File.join(@source_directory, "content.config.json")
+        raise ConfigError, "Content config not found" unless File.file?(path)
+
+        @config = Config.load(path)
+      end
+
+      def parse_all_content!
+        raise ConfigError, "Config not loaded" unless @config
+
+        @collections.clear
+        @config.collections.each do |name, collection_config|
+          files = discover_content_files(collection_config)
+          collection = Collection.new(name)
+          files.each do |file|
+            doc = parse_file(file)
+            next unless doc
+            next unless should_process?(doc)
+
+            collection.add(doc)
+          end
+          @collections[name] = collection
+        end
+      end
+
+      def discover_content_files(collection_config)
+        dir = File.join(@source_directory, collection_config.path)
+        return [] unless File.directory?(dir)
+
+        ext = collection_config.format&.downcase
+        Dir.glob(File.join(dir, "**", "*")).select do |f|
+          next false unless File.file?(f)
+
+          e = File.extname(f).delete_prefix(".").downcase
+          case ext
+          when "md", "markdown" then e == "md"
+          when "yaml", "yml" then %w[yaml yml].include?(e)
+          else %w[md yaml yml].include?(e)
+          end
+        end
+      end
+
+      def parse_file(path)
+        ext = File.extname(path).delete_prefix(".").downcase
+        case ext
+        when "md" then @parser.parse_markdown_file(path)
+        when "yaml", "yml" then @parser.parse_yaml_file(path)
+        end
+      rescue StandardError => e
+        @delegate&.error(path, e.message)
+        nil
+      end
+
+      def should_process?(doc)
+        return true if doc.published?
+
+        @build_mode == :normal
+      end
+    end
+  end
+end

data/lib/hammer/content/config.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hammer
+  module Content
+    FieldConfig = Struct.new(:type, :required, :default, :collection, :value_field, keyword_init: true) do
+      def self.from_hash(hash)
+        collection = hash["collection"] || hash["to"]
+        new(
+          type: hash["type"],
+          required: hash["required"],
+          default: hash["default"],
+          collection: collection,
+          value_field: hash["valueField"]
+        )
+      end
+    end
+
+    CollectionConfig = Struct.new(:path, :format, :template, :output_path, :output, :slug, :fields, keyword_init: true) do
+      def output_path_pattern
+        output&.dig("filename") || output_path
+      end
+
+      def self.from_hash(hash)
+        fields = (hash["fields"] || {}).transform_values { |f| FieldConfig.from_hash(f) }
+        new(
+          path: hash["path"],
+          format: hash["format"],
+          template: hash["template"],
+          output_path: hash["outputPath"],
+          output: hash["output"],
+          slug: hash["slug"],
+          fields: fields
+        )
+      end
+    end
+
+    class Config
+      attr_reader :collections, :site_url
+
+      def initialize(collections:, site_url: nil)
+        @collections = collections
+        @site_url = site_url
+      end
+
+      def self.load(path)
+        data = JSON.parse(File.read(path))
+        collections = data.fetch("collections", {}).transform_values { |c| CollectionConfig.from_hash(c) }
+        new(collections: collections, site_url: data["siteUrl"])
+      end
+
+      def self.enabled?(source_dir)
+        path = File.join(source_dir, "content.config.json")
+        return false unless File.file?(path)
+
+        cfg = load(path)
+        !cfg.collections.empty?
+      rescue StandardError
+        false
+      end
+
+      def get_collection(name)
+        @collections[name]
+      end
+    end
+  end
+end