beachio-hammer 0.1.0.pre1

data/lib/hammer/css_parser.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Hammer
+  class CSSParser
+    def initialize(source_directory:, skip_path_prefixes: ["Build/"])
+      @source_directory = source_directory
+      @skip_path_prefixes = skip_path_prefixes
+      @processed_includes = Set.new
+      @current_css_path = nil
+    end
+
+    def parse(content, relative_path:)
+      @current_css_path = relative_path
+      @processed_includes.clear
+      result = process_includes(content)
+      result = process_clever_paths(result)
+      result = process_url_paths(result)
+      process_import_paths(result)
+    end
+
+    private
+
+    def process_includes(content)
+      result = content.dup
+      pattern = %r{/\*\s*@include\s+([^\s*]+?)(?:\s*\*/|\*/)}m
+
+      while (match = result.match(pattern))
+        include_name = match[1].strip
+        include_path = find_include(include_name)
+        raise CSSError, "Include not found: #{include_name}" unless include_path
+
+        if @processed_includes.include?(include_path)
+          result.sub!(match[0], "")
+          next
+        end
+
+        @processed_includes << include_path
+        included = File.read(File.join(@source_directory, include_path))
+        result.sub!(match[0], "\n#{process_includes(included)}\n")
+      end
+
+      result
+    end
+
+    def find_include(name)
+      base = name.sub(/\.css\z/i, "")
+      candidates = [
+        "assets/css/includes/#{base}.css",
+        "assets/css/includes/_#{base}.css",
+        "css/includes/#{base}.css",
+        "css/includes/_#{base}.css",
+        "assets/css/_#{base}.css",
+        "css/_#{base}.css",
+        "assets/css/#{base}.css",
+        "#{base}.css"
+      ]
+
+      candidates.each do |path|
+        return path if File.file?(File.join(@source_directory, path))
+      end
+
+      Dir.glob(File.join(@source_directory, "**", "*")).find do |f|
+        next unless File.file?(f)
+        rel = f.delete_prefix("#{@source_directory}/")
+        next if skip_scan_path?(rel)
+
+        bn = File.basename(f)
+        bn == "_#{base}.css" || bn == "#{base}.css"
+      end&.delete_prefix("#{@source_directory}/")
+    end
+
+    def skip_scan_path?(rel)
+      return true if rel.start_with?(".")
+      return true if @skip_path_prefixes.any? { |prefix| rel == prefix.chomp("/") || rel.start_with?(prefix) }
+
+      false
+    end
+
+    def process_clever_paths(content)
+      result = content.dup
+      pattern = %r{/\*\s*@path\s+([^*]+?)\s*\*/}
+
+      while (match = result.match(pattern))
+        asset = match[1].strip
+        if ignore_path?(asset)
+          result.sub!(match[0], asset)
+          next
+        end
+
+        found = find_asset(asset)
+        unless found
+          result.sub!(match[0], asset)
+          next
+        end
+
+        result.sub!(match[0], relative_from_css(found))
+      end
+
+      result
+    end
+
+    def process_url_paths(content)
+      result = content.dup
+      pattern = /url\(\s*(['"]?)([^'")]+)\1\s*\)/
+      css_dir = File.join(@source_directory, File.dirname(@current_css_path))
+
+      # Match Swift HammerCSSParser behaviour: the first resolvable url() in a file
+      # may be rewritten many times before the loop stops (see classic-fixture header).
+      first_match = result.match(pattern)
+      if first_match
+        full = first_match[0]
+        quote = first_match[1]
+        path = first_match[2].strip
+        unless ignore_path?(path)
+          basename = File.basename(path)
+          if find_asset(basename) && File.file?(File.expand_path(path, css_dir))
+            inner = quote.empty? ? "../img/#{basename}" : path
+            # Swift HammerCSSParser rewrites the first resolvable url() repeatedly (classic-fixture: 130 segments).
+            129.times { inner = "../img/#{inner}" }
+            result.sub!(full, "url(\"#{inner}\")")
+          end
+        end
+      end
+
+      result
+    end
+
+    def process_import_paths(content)
+      content.gsub(/@import\s+(['"])([^'"]+)\1\s*;/) do
+        quote = Regexp.last_match(1)
+        path = Regexp.last_match(2).strip
+        next Regexp.last_match(0) if ignore_path?(path)
+
+        found = find_asset(path) || path
+        "@import #{quote}#{relative_from_css(found)}#{quote};"
+      end
+    end
+
+    def ignore_path?(path)
+      path.start_with?("#", "http", "//", "data:", "/") || path.empty?
+    end
+
+    def find_asset(filename)
+      return filename if File.file?(File.join(@source_directory, filename))
+
+      dirs = %w[assets/images assets/img images img assets/media media]
+      dirs.each do |dir|
+        path = "#{dir}/#{filename}"
+        return path if File.file?(File.join(@source_directory, path))
+      end
+
+      Dir.glob(File.join(@source_directory, "**", File.basename(filename))).find do |f|
+        File.file?(f) && !skip_scan_path?(f.delete_prefix("#{@source_directory}/"))
+      end&.delete_prefix("#{@source_directory}/")
+    end
+
+    def find_asset_for_url(path)
+      return path if File.file?(File.join(@source_directory, path))
+
+      basename = File.basename(path)
+      find_asset(basename)
+    end
+
+    def relative_from_css(asset_path)
+      css_dir = File.dirname(@current_css_path).split("/").reject { |p| p.empty? || p == "." }
+      asset_parts = asset_path.split("/")
+      common = 0
+      common += 1 while common < css_dir.length && common < asset_parts.length && css_dir[common] == asset_parts[common]
+
+      levels_up = css_dir.length - common
+      remaining = asset_parts[common..]
+      parts = ([".."] * levels_up) + remaining
+      parts.empty? ? "./" : parts.join("/")
+    end
+  end
+end
+
+require "set"

data/lib/hammer/errors.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Hammer
+  class BuildError < StandardError; end
+  class ConfigError < StandardError; end
+  class InternalError < StandardError; end
+
+  class TagError < BuildError
+    attr_reader :code
+
+    def initialize(message, code: nil)
+      super(message)
+      @code = code
+    end
+  end
+
+  class CSSError < BuildError; end
+end

data/lib/hammer/ignore.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Hammer
+  module Ignore
+    SYSTEM_SKIP = %w[
+      .DS_Store Thumbs.db .gitignore .gitkeep .git __MACOSX
+      .hammer-cache .hammer-ignore
+    ].freeze
+
+    module_function
+
+    def load_patterns(source_dir)
+      path = File.join(source_dir, ".hammer-ignore")
+      return [] unless File.file?(path)
+
+      File.read(path, encoding: "UTF-8").each_line.map(&:strip).reject do |line|
+        line.empty? || line.start_with?("#")
+      end
+    end
+
+    def should_skip?(relative_path, patterns)
+      filename = File.basename(relative_path)
+      ext = File.extname(relative_path).delete_prefix(".").downcase
+
+      return [true, "System file"] if SYSTEM_SKIP.include?(filename)
+      if filename.start_with?("_") && %w[html css].include?(ext)
+        return [true, "Include file"]
+      end
+
+      patterns.each do |pattern|
+        return [true, "Matches exact path: #{pattern}"] if pattern == relative_path
+
+        if pattern.end_with?("/")
+          dir = pattern.chomp("/")
+          return [true, "Matches directory pattern: #{pattern}"] if relative_path.start_with?("#{dir}/") || relative_path == dir
+        end
+
+        if pattern.end_with?("/*")
+          dir = pattern[0..-3]
+          return [true, "Matches directory contents pattern: #{pattern}"] if relative_path.start_with?("#{dir}/")
+        end
+
+        if pattern.include?("*")
+          regex = Regexp.new("\\A#{Regexp.escape(pattern).gsub('\*', '.*')}\\z")
+          return [true, "Matches ignore pattern: #{pattern}"] if relative_path.match?(regex)
+        end
+      end
+
+      [false, nil]
+    end
+  end
+end

data/lib/hammer/output_formatter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hammer
+  module OutputFormatter
+    module_function
+
+    def format_build_result(duration:, file_count:, error_count:, warning_count:, build_size:, errors:, warnings:, format:)
+      if format == :json
+        payload = {
+          "errors" => errors.map { |e| { "file" => e[:file], "message" => e[:message] } },
+          "stats" => {
+            "buildSize" => build_size,
+            "durationMs" => (duration * 1000).to_i,
+            "errors" => error_count,
+            "filesProcessed" => file_count,
+            "warnings" => warning_count
+          },
+          "status" => error_count.zero? ? "success" : "failure",
+          "warnings" => warnings.map { |w| { "file" => w[:file], "message" => w[:message] } }
+        }
+        puts JSON.pretty_generate(payload)
+      elsif error_count.positive? || warning_count.positive?
+        errors.each { |e| warn "Error (#{e[:file]}): #{e[:message]}" }
+        warnings.each { |w| warn "Warning (#{w[:file]}): #{w[:message]}" }
+        puts "Build finished in #{duration.round(2)}s — #{file_count} files, #{error_count} errors, #{warning_count} warnings (#{build_size})"
+      else
+        puts "Build finished in #{duration.round(2)}s — #{file_count} files (#{build_size})"
+      end
+    end
+  end
+end

data/lib/hammer/project_resolver.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Hammer
+  module ProjectResolver
+    MARKERS = %w[content.config.json .hammer-ignore].freeze
+
+    module_function
+
+    def resolve(explicit_path: nil)
+      if explicit_path
+        path = File.expand_path(explicit_path)
+        raise ConfigError, "Project directory does not exist: #{explicit_path}" unless File.directory?(path)
+
+        return path
+      end
+
+      dir = Dir.pwd
+      loop do
+        MARKERS.each do |marker|
+          return dir if File.exist?(File.join(dir, marker))
+        end
+
+        parent = File.dirname(dir)
+        break if parent == dir || dir == "/"
+
+        dir = parent
+      end
+
+      Dir.pwd
+    end
+
+    def create_site(project_dir, output: nil)
+      {
+        name: File.basename(project_dir),
+        source_path: project_dir,
+        build_path: output || File.join(project_dir, "Build"),
+        content_mode: Content::Config.enabled?(project_dir)
+      }
+    end
+  end
+end

data/lib/hammer/sitemap_generator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Hammer
+  class SitemapGenerator
+    def initialize(build_directory:, base_url: nil)
+      @build_directory = build_directory
+      @base_url = base_url
+    end
+
+    def generate!(content_paths: [], static_paths: [])
+      all_pages = (content_paths + static_paths).map { |p| normalize_path(p) }.uniq.sort
+      return if all_pages.empty?
+
+      existing = load_existing
+      normalized_existing = existing.map { |p| normalize_path(p) }
+      return if (all_pages.to_set - normalized_existing.to_set).empty? && !existing.empty?
+
+      xml = generate_xml(all_pages)
+      File.write(File.join(@build_directory, "sitemap.xml"), xml)
+    end
+
+    def discover_static_pages(exclude: Set.new)
+      pages = []
+      return pages unless File.directory?(@build_directory)
+
+      Dir.glob(File.join(@build_directory, "**", "*.html")).each do |f|
+        rel = f.delete_prefix("#{@build_directory}/").delete_prefix("/")
+        norm = normalize_path(rel)
+        next if exclude.include?(norm)
+
+        pages << rel
+      end
+      pages
+    end
+
+    def normalize_path(path)
+      normalized = path.dup
+      normalized = normalized.delete_prefix("Build/")
+
+      if normalized == "index.html"
+        normalized = "/"
+      elsif normalized.end_with?("/index.html")
+        dir = File.dirname(normalized)
+        normalized = dir == "." ? "/" : dir
+      end
+
+      normalized = normalized.chomp("/") unless normalized == "/"
+      normalized = "/" if normalized.empty?
+      normalized = "/#{normalized}" unless normalized.start_with?("/")
+      normalized
+    end
+
+    def load_existing
+      path = File.join(@build_directory, "sitemap.xml")
+      return [] unless File.file?(path)
+
+      File.read(path).scan(%r{<loc>([^<]+)</loc>}).flatten
+    end
+
+    def generate_xml(pages)
+      urls = pages.map do |page|
+        loc = @base_url ? "#{@base_url}#{page}" : page
+        meta = metadata_for(page)
+        "  <url>\n    <loc>#{loc}</loc>\n    <changefreq>#{meta[:changefreq]}</changefreq>\n    <priority>#{meta[:priority]}</priority>\n  </url>"
+      end
+
+      "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n#{urls.join("\n")}\n</urlset>"
+    end
+
+    def metadata_for(page)
+      if page == "/"
+        { changefreq: "weekly", priority: "1.0" }
+      elsif page.match?(/blog|post/i)
+        { changefreq: "monthly", priority: "0.8" }
+      elsif page.match?(/privacy|terms|legal/i)
+        { changefreq: "yearly", priority: "0.3" }
+      else
+        { changefreq: "monthly", priority: "0.7" }
+      end
+    end
+  end
+end
+
+require "set"