beachio-hammer 0.1.0.pre1

data/lib/hammer/content/parser.rb

@@ -0,0 +1,463 @@
+# frozen_string_literal: true
+
+module Hammer
+  module Content
+    class Parser
+      def initialize(source_directory:)
+        @source_directory = source_directory
+      end
+
+      def parse_markdown_file(path)
+        content = File.read(path)
+        metadata, body = extract_front_matter(content)
+        html_body = parse_markdown_body(body)
+        collection = extract_collection(path)
+        Document.new(
+          file_path: path,
+          metadata: metadata,
+          body: html_body,
+          content_type: :markdown,
+          collection: collection
+        )
+      end
+
+      def parse_yaml_file(path)
+        metadata = parse_simple_yaml(File.read(path))
+        Document.new(
+          file_path: path,
+          metadata: metadata,
+          body: "",
+          content_type: :yaml,
+          collection: extract_collection(path)
+        )
+      end
+
+      def extract_collection(path)
+        rel = path.delete_prefix("#{@source_directory}/")
+        parts = rel.split("/")
+        parts[1] if parts[0] == "content" && parts.length > 2
+      end
+
+      def extract_front_matter(content)
+        return [{}, content] unless content.start_with?("---\n")
+
+        rest = content[4..]
+        return [{}, content] unless (end_idx = rest.index("\n---"))
+
+        yaml_text = rest[0...end_idx]
+        body = rest[(end_idx + 4)..].sub(/\A\n?/, "")
+        [parse_simple_yaml(yaml_text), body]
+      end
+
+      def parse_simple_yaml(text)
+        metadata = {}
+        current_key = nil
+        text.each_line do |line|
+          stripped = line.strip
+          next if stripped.empty?
+
+          if (m = stripped.match(/\A([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)\z/))
+            key = m[1]
+            value = m[2].strip
+            metadata[key] = parse_yaml_value(value)
+            current_key = key
+          elsif stripped.start_with?("- ") && current_key
+            metadata[current_key] ||= []
+            metadata[current_key] << parse_yaml_value(stripped[2..].strip)
+          end
+        end
+        metadata
+      end
+
+      def parse_yaml_value(value)
+        return true if value == "true"
+        return false if value == "false"
+        return nil if value == "null" || value.empty?
+        return Integer(value) if value.match?(/\A-?\d+\z/)
+        return Float(value) if value.match?(/\A-?\d+\.\d+\z/)
+        if value.start_with?("[") && value.end_with?("]")
+          inner = value[1..-2]
+          return [] if inner.strip.empty?
+
+          return inner.split(",").map { |v| parse_yaml_value(v.strip.delete_prefix('"').delete_suffix('"')) }
+        end
+
+        value.delete_prefix('"').delete_suffix('"').delete_prefix("'").delete_suffix("'")
+      end
+
+      def parse_markdown_body(markdown)
+        html = markdown.dup
+
+        html.gsub!(/```(\w+)?\s*\n([\s\S]*?)```/) do
+          lang = Regexp.last_match(1).to_s
+          code = Regexp.last_match(2)
+          code = code.gsub(/\A\n+/, "").gsub(/\n+\z/, "")
+          escaped = CGI.escapeHTML(code)
+          cls = lang.empty? ? "" : " class=\"language-#{lang}\""
+          "<pre><code#{cls}>#{escaped}</code></pre>"
+        end
+
+        {
+          /^### (.*?)$/ => "<h3>\\1</h3>",
+          /^## (.*?)$/ => "<h2>\\1</h2>",
+          /^# (.*?)$/ => "<h1>\\1</h1>"
+        }.each { |pat, repl| html.gsub!(pat, repl) }
+
+        placeholders = []
+        html.gsub!(%r{</?[a-zA-Z][^>]*>}) do |tag|
+          token = "HAMMERHTMLTAGTOKEN#{placeholders.length}ZZEND"
+          placeholders << [token, tag]
+          token
+        end
+
+        html.gsub!(/\*\*(.+?)\*\*/, '<strong>\1</strong>')
+        html.gsub!(/__(.+?)__/, '<strong>\1</strong>')
+        html.gsub!(/\*(.+?)\*/, '<em>\1</em>')
+        html.gsub!(/_(.+?)_/, '<em>\1</em>')
+
+        placeholders.each { |token, tag| html.gsub!(token, tag) }
+
+        html.gsub!(/\[([^\]]+)\]\(([^)]+)\)/, '<a href="\2">\1</a>')
+        html.gsub!(/<(https?:\/\/[^>]+)>/, '<a href="\1">\1</a>')
+        html.gsub!(/!\[([^\]]*)\]\(([^)]+)\)/, '<img src="\2" alt="\1">')
+        html.gsub!(/`([^`]+)`/, '<code>\1</code>')
+
+        process_block_level_elements(html).then { |processed| wrap_paragraphs(processed) }
+      end
+
+      BLOCK_TAG_SET = %w[
+        div pre code section article aside header footer nav main figure blockquote
+        table thead tbody tfoot tr ul ol dl fieldset form style script
+      ].freeze
+
+      WRAP_BLOCK_TAG_SET = (BLOCK_TAG_SET + %w[h1 h2 h3 h4 h5 h6 hr]).freeze
+
+      TAG_PATTERN = %r{<(/?)([a-zA-Z][a-zA-Z0-9]*)(?:\s[^>]*)?(/?)\s*>}i
+
+      def process_block_level_elements(html)
+        processed_lines = []
+        state = {
+          in_unordered_list: false,
+          in_ordered_list: false,
+          in_blockquote: false,
+          in_table: false
+        }
+        blockquote_content = []
+        table_rows = []
+        html_block_depth = 0
+        standalone_indented_block = []
+
+        flush_standalone = lambda do
+          next if standalone_indented_block.empty?
+
+          block_content = standalone_indented_block.join("\n")
+          processed_lines << %(<div class="indent">#{block_content}</div>)
+          standalone_indented_block.clear
+        end
+
+        close_blocks = lambda do
+          if state[:in_unordered_list]
+            processed_lines << "</ul>"
+            state[:in_unordered_list] = false
+          end
+          if state[:in_ordered_list]
+            processed_lines << "</ol>"
+            state[:in_ordered_list] = false
+          end
+          if state[:in_blockquote]
+            append_blockquote(processed_lines, blockquote_content)
+            state[:in_blockquote] = false
+          end
+          if state[:in_table]
+            append_table(processed_lines, table_rows)
+            state[:in_table] = false
+          end
+        end
+
+        close_other_lists = lambda do |keep|
+          if keep != :unordered && state[:in_unordered_list]
+            processed_lines << "</ul>"
+            state[:in_unordered_list] = false
+          end
+          if keep != :ordered && state[:in_ordered_list]
+            processed_lines << "</ol>"
+            state[:in_ordered_list] = false
+          end
+          if state[:in_blockquote]
+            append_blockquote(processed_lines, blockquote_content)
+            state[:in_blockquote] = false
+          end
+          if state[:in_table]
+            append_table(processed_lines, table_rows)
+            state[:in_table] = false
+          end
+        end
+
+        html.each_line(chomp: true) do |line|
+          trimmed = line.strip
+
+          depth_at_start = html_block_depth
+          depth_after = html_block_depth
+          line.scan(TAG_PATTERN) do |closing, tag_name, self_closing|
+            tag = tag_name.downcase
+            next unless BLOCK_TAG_SET.include?(tag)
+
+            if self_closing == "/"
+              next
+            elsif closing == "/"
+              depth_after = [0, depth_after - 1].max
+            else
+              depth_after += 1
+            end
+          end
+          html_block_depth = depth_after
+          in_protected_html = depth_at_start.positive? || trimmed.start_with?("<")
+
+          standalone_indented = !trimmed.empty? &&
+                                !(state[:in_unordered_list] || state[:in_ordered_list]) &&
+                                !in_protected_html &&
+                                (line.start_with?("  ") || line.start_with?("\t"))
+
+          if standalone_indented
+            content = line.dup
+            content = content[1..] if content.start_with?("\t")
+            content = content[2..] if content.start_with?("  ")
+            standalone_indented_block << content.strip
+            next
+          else
+            flush_standalone.call
+          end
+
+          if %w[--- *** ___].include?(trimmed)
+            close_blocks.call
+            processed_lines << "<hr>"
+            next
+          end
+
+          if trimmed.start_with?("|") && trimmed.end_with?("|") && trimmed.length > 2
+            without_pipes = trimmed.delete("|").strip
+            is_separator = without_pipes.include?("-") &&
+                           without_pipes.chars.all? { |c| ["-", ":", " "].include?(c) }
+            if is_separator
+              state[:in_table] = true if table_rows.any?
+              next
+            end
+
+            unless state[:in_table]
+              close_blocks.call
+              state[:in_table] = true
+              table_rows = []
+            end
+            table_rows << trimmed
+            next
+          end
+
+          if trimmed.start_with?(">")
+            close_blocks.call
+            unless state[:in_blockquote]
+              state[:in_blockquote] = true
+              blockquote_content = []
+            end
+            blockquote_content << trimmed[1..].strip
+            next
+          end
+
+          if (m = line.match(/\A\s*[-*]\s+(.+)\z/))
+            close_other_lists.call(:unordered)
+            unless state[:in_unordered_list]
+              processed_lines << "<ul>"
+              state[:in_unordered_list] = true
+            end
+            processed_lines << "<li>#{m[1].strip}</li>"
+            next
+          end
+
+          if (m = line.match(/\A\s*\d+\.\s+(.+)\z/))
+            close_other_lists.call(:ordered)
+            unless state[:in_ordered_list]
+              processed_lines << "<ol>"
+              state[:in_ordered_list] = true
+            end
+            processed_lines << "<li>#{m[1].strip}</li>"
+            next
+          end
+
+          if trimmed.empty?
+            if state[:in_table]
+              append_table(processed_lines, table_rows)
+              state[:in_table] = false
+            elsif state[:in_blockquote]
+              blockquote_content << ""
+            else
+              processed_lines << ""
+            end
+            next
+          end
+
+          if (state[:in_unordered_list] || state[:in_ordered_list]) &&
+             (line.start_with?("  ") || line.start_with?("\t"))
+            last_index = processed_lines.rindex { |l| l.start_with?("<li>") }
+            if last_index
+              continuation = trimmed
+              last_item = processed_lines[last_index]
+              if last_item.end_with?("</li>")
+                item_content = last_item[0...-5]
+                processed_lines[last_index] = "#{item_content} #{continuation}</li>"
+              end
+              next
+            end
+          end
+
+          close_blocks.call
+          processed_lines << line
+        end
+
+        flush_standalone.call
+        close_blocks.call
+        processed_lines.join("\n")
+      end
+
+      def append_blockquote(processed_lines, blockquote_content)
+        blockquote_html = []
+        current_paragraph = []
+
+        blockquote_content.each do |content|
+          if content.empty?
+            unless current_paragraph.empty?
+              blockquote_html << "<p>#{current_paragraph.join(' ')}</p>"
+              current_paragraph.clear
+            end
+          else
+            current_paragraph << content
+          end
+        end
+
+        blockquote_html << "<p>#{current_paragraph.join(' ')}</p>" unless current_paragraph.empty?
+        blockquote_html << "<p></p>" if blockquote_html.empty?
+        processed_lines << "<blockquote>#{blockquote_html.join("\n")}</blockquote>"
+        blockquote_content.clear
+      end
+
+      def append_table(processed_lines, table_rows)
+        return if table_rows.empty?
+
+        parsed_rows = table_rows.filter_map do |row|
+          cells = row.split("|").map(&:strip)
+          cells.shift if cells.first&.empty?
+          cells.pop if cells.last&.empty?
+          cells.empty? ? nil : cells
+        end
+        return if parsed_rows.empty?
+
+        table_html = ["<table>", "<thead>", "<tr>"]
+        parsed_rows.first.each { |cell| table_html << "<th>#{cell}</th>" }
+        table_html.concat(["</tr>", "</thead>"])
+
+        if parsed_rows.length > 1
+          table_html << "<tbody>"
+          parsed_rows[1..].each do |row|
+            table_html << "<tr>"
+            row.each { |cell| table_html << "<td>#{cell}</td>" }
+            table_html << "</tr>"
+          end
+          table_html << "</tbody>"
+        end
+
+        table_html << "</table>"
+        processed_lines << table_html.join("\n")
+        table_rows.clear
+      end
+
+      def wrap_paragraphs(html)
+        wrapped = []
+        current_paragraph = []
+        html_block_depth = 0
+        in_pre_block = false
+
+        html.each_line(chomp: true) do |line|
+          trimmed = in_pre_block ? line : line.strip
+          depth_at_start = html_block_depth
+          depth_after = html_block_depth
+          tag_matches = trimmed.scan(TAG_PATTERN)
+
+          tag_matches.each do |closing, tag_name, _self_closing|
+            tag = tag_name.downcase
+            if tag == "pre"
+              in_pre_block = closing != "/"
+              break
+            end
+          end
+
+          tag_matches.each do |closing, tag_name, self_closing|
+            tag = tag_name.downcase
+            next unless WRAP_BLOCK_TAG_SET.include?(tag)
+
+            if self_closing == "/"
+              next
+            elsif closing == "/"
+              depth_after = [0, depth_after - 1].max
+            else
+              depth_after += 1
+            end
+          end
+          html_block_depth = depth_after
+
+          is_inside_block = depth_at_start.positive? || depth_after.positive?
+          first_tag = tag_matches.first&.then { |m| m[1].downcase }
+          is_block_element = trimmed.start_with?("<") && first_tag && WRAP_BLOCK_TAG_SET.include?(first_tag)
+
+          if in_pre_block
+            unless current_paragraph.empty?
+              wrapped << current_paragraph.join(" ")
+              current_paragraph.clear
+            end
+            wrapped << line
+          elsif trimmed.empty?
+            unless current_paragraph.empty? && !is_inside_block
+              if !current_paragraph.empty? && !is_inside_block
+                wrapped << "<p>#{current_paragraph.join(' ')}</p>"
+                current_paragraph.clear
+              end
+            end
+          elsif is_block_element
+            unless current_paragraph.empty? && !is_inside_block
+              if !current_paragraph.empty? && !is_inside_block
+                wrapped << "<p>#{current_paragraph.join(' ')}</p>"
+                current_paragraph.clear
+              end
+            end
+            wrapped << trimmed
+          elsif trimmed.start_with?("<")
+            if is_inside_block
+              unless current_paragraph.empty?
+                wrapped << current_paragraph.join(" ")
+                current_paragraph.clear
+              end
+              wrapped << trimmed
+            else
+              current_paragraph << trimmed
+            end
+          elsif is_inside_block
+            unless current_paragraph.empty?
+              wrapped << current_paragraph.join(" ")
+              current_paragraph.clear
+            end
+            wrapped << trimmed
+          else
+            current_paragraph << trimmed
+          end
+        end
+
+        if !current_paragraph.empty? && html_block_depth.zero?
+          wrapped << "<p>#{current_paragraph.join(' ')}</p>"
+        elsif !current_paragraph.empty?
+          wrapped << current_paragraph.join(" ")
+        end
+
+        wrapped.join("\n")
+      end
+    end
+  end
+end
+
+require "cgi"

data/lib/hammer/content/relation_resolver.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hammer
+  module Content
+    class RelationResolver
+      def initialize(collections:, config:)
+        @collections = collections
+        @config = config
+      end
+
+      def resolve_all!
+        @config.collections.each do |name, collection_config|
+          populate_relations(name, collection_config)
+        end
+      end
+
+      def populate_relations(collection_name, collection_config)
+        collection = @collections[collection_name]
+        return unless collection
+
+        fields = collection_config.fields || {}
+        collection.documents.each do |doc|
+          fields.each do |field_name, field|
+            next unless field.type == "relation"
+            next unless doc.metadata.key?(field_name)
+
+            raw = doc.metadata[field_name]
+            next unless raw.is_a?(String)
+
+            resolved = resolve_relation(raw, field, collection_name)
+            doc.metadata[field_name] = resolved if resolved
+          end
+        end
+      end
+
+      def resolve_relation(relation_value, field, _from_collection)
+        target_name = field.collection
+        return nil unless target_name
+
+        target = @collections[target_name]
+        return nil unless target
+
+        slug_value = relation_value.include?("/") ? relation_value.split("/").last : relation_value
+        value_field = field.value_field || "slug"
+
+        if value_field == "slug"
+          target.get_by_slug(slug_value)
+        else
+          target.documents.find { |d| d.metadata[value_field].to_s == slug_value }
+        end
+      end
+    end
+  end
+end

data/lib/hammer/content/template_context.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Hammer
+  module Content
+    class TemplateContext
+      attr_reader :site, :collections, :doc, :helpers, :variables
+
+      def initialize(site: {}, collections: {}, doc: nil, helpers: {}, variables: {})
+        @site = site
+        @collections = collections
+        @doc = doc
+        @helpers = helpers
+        @variables = variables
+      end
+
+      def resolve(path)
+        parts = path.split(".")
+        root = parts.first
+        rest = parts[1..]
+
+        case root
+        when "doc" then resolve_doc(rest)
+        when "collections" then resolve_collections(rest)
+        when "site" then dig(@site, rest)
+        when "helpers" then rest.length == 1 ? @helpers[rest[0]] : nil
+        else
+          dig(@variables[root], rest[0..]) || nil
+        end
+      end
+
+      def resolve_doc(parts)
+        return @doc if parts.empty?
+        return nil unless @doc
+
+        if parts.length == 1
+          case parts[0]
+          when "body" then @doc.body
+          when "slug" then @doc.slug
+          when "date" then @doc.date
+          when "filePath" then @doc.file_path
+          when "collection" then @doc.collection
+          else @doc.metadata[parts[0]]
+          end
+        else
+          val = @doc.metadata[parts[0]]
+          dig(val, parts[1..])
+        end
+      end
+
+      def resolve_collections(parts)
+        return @collections if parts.empty?
+
+        coll = @collections[parts[0]]
+        return coll if parts.length == 1
+
+        coll
+      end
+
+      def dig(value, parts)
+        return value if parts.nil? || parts.empty?
+
+        current = value
+        parts.each do |part|
+          case current
+          when Document
+            current = resolve_document_property(current, part)
+          when Hash
+            current = current[part] || current[part.to_sym]
+          when Array
+            idx = Integer(part, exception: false)
+            current = idx ? current[idx] : nil
+          else
+            return nil
+          end
+        end
+        current
+      end
+
+      def resolve_document_property(document, part)
+        case part
+        when "body" then document.body
+        when "slug" then document.slug
+        when "date" then document.date
+        when "filePath" then document.file_path
+        when "collection" then document.collection
+        else document.metadata[part]
+        end
+      end
+    end
+  end
+end