jekyll-aeo 1.0.0

data/lib/jekyll-aeo/generators/robots_txt.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module JekyllAeo
+  module Generators
+    class RobotsTxt < Jekyll::Generator
+      priority :low
+      safe true
+
+      def generate(site)
+        config = JekyllAeo::Config.from_site(site)
+        return if config["enabled"] == false
+
+        robots_config = config["robots_txt"] || {}
+        return if robots_config["enabled"] == false
+        return if user_robots_exists?(site)
+
+        content = build_content(robots_config, site)
+        page = Jekyll::PageWithoutAFile.new(site, site.source, "", "robots.txt")
+        page.content = content
+        page.data["layout"] = nil
+        site.pages << page
+      end
+
+      private
+
+      def user_robots_exists?(site)
+        File.exist?(File.join(site.source, "robots.txt"))
+      end
+
+      def build_content(robots_config, site)
+        lines = []
+        bot_rules(lines, robots_config["allow"] || [], "Allow")
+        bot_rules(lines, robots_config["disallow"] || [], "Disallow")
+        lines << "User-agent: *"
+        lines << "Allow: /"
+        lines << ""
+        custom_rules(lines, robots_config["custom_rules"] || [])
+        append_metadata_lines(lines, robots_config, site)
+        "#{lines.join("\n")}\n"
+      end
+
+      def bot_rules(lines, bots, directive)
+        bots.each do |bot|
+          lines << "User-agent: #{bot}"
+          lines << "#{directive}: /"
+          lines << ""
+        end
+      end
+
+      def custom_rules(lines, rules)
+        rules.each do |rule|
+          lines << "User-agent: #{rule['user_agent']}"
+          lines << "Allow: #{rule['allow']}" if rule["allow"]
+          lines << "Disallow: #{rule['disallow']}" if rule["disallow"]
+          lines << ""
+        end
+      end
+
+      def append_metadata_lines(lines, robots_config, site)
+        base_url = site.config["url"].to_s.chomp("/")
+        baseurl = site.config["baseurl"].to_s.chomp("/")
+        lines << "Sitemap: #{base_url}#{baseurl}/sitemap.xml" if robots_config["include_sitemap"] != false
+        lines << "Llms-txt: #{base_url}#{baseurl}/llms.txt" if robots_config["include_llms_txt"] != false
+      end
+    end
+  end
+end

data/lib/jekyll-aeo/generators/url_map.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module JekyllAeo
+  module Generators
+    module UrlMap
+      COLUMN_HEADERS = {
+        "page_id" => "Page ID",
+        "url" => "URL",
+        "lang" => "Lang",
+        "layout" => "Layout",
+        "path" => "Path",
+        "redirects" => "Redirects",
+        "markdown_copy" => "Markdown Copy",
+        "skipped" => "Skipped"
+      }.freeze
+
+      def self.generate(site)
+        config = JekyllAeo::Config.from_site(site)
+        return if config["enabled"] == false
+
+        url_map_config = config["url_map"] || {}
+        return if url_map_config["enabled"] == false
+
+        columns = url_map_config["columns"] || COLUMN_HEADERS.keys
+        items = collect_all_items(site, config, columns)
+        sections = build_sections(items)
+        markdown = build_markdown(sections, columns, url_map_config)
+
+        output_file = File.join(project_root(site), url_map_config["output_filepath"] || "docs/Url-Map.md")
+        FileUtils.mkdir_p(File.dirname(output_file))
+        File.write(output_file, markdown)
+      end
+
+      def self.collect_all_items(site, config, columns)
+        items = []
+        needs_skip = columns.include?("skipped")
+        needs_md = columns.include?("markdown_copy")
+        baseurl = site.config["baseurl"].to_s.chomp("/")
+
+        site.documents.each do |doc|
+          next unless doc.output_ext == ".html"
+          next if doc.respond_to?(:collection) && doc.collection&.label == "assets"
+
+          items << build_item(doc, doc.collection&.label, site, config, needs_skip, needs_md, baseurl)
+        end
+
+        site.pages.each do |page|
+          next unless page.output_ext == ".html"
+
+          items << build_item(page, nil, site, config, needs_skip, needs_md, baseurl)
+        end
+
+        items
+      end
+
+      def self.build_item(obj, collection_label, site, config, needs_skip, needs_md, baseurl = "")
+        redirect_from = obj.data["redirect_from"]
+        redirects_str = case redirect_from
+                        when Array then redirect_from.join(", ")
+                        when String then redirect_from
+                        else ""
+                        end
+
+        item = {
+          url: obj.url,
+          page_id: obj.data["page_id"] || "",
+          lang: obj.data["lang"] || "",
+          layout: obj.data["layout"] || "",
+          path: obj.relative_path,
+          redirects: redirects_str,
+          collection: collection_label
+        }
+
+        item[:skipped] = JekyllAeo::Utils::SkipLogic.skip_reason(obj, site, config) || "" if needs_skip
+        item[:markdown_copy] = md_url(obj.url, baseurl) if needs_md && (!needs_skip || item[:skipped].empty?)
+        item[:markdown_copy] ||= "" if needs_md
+
+        item
+      end
+
+      def self.build_sections(items)
+        grouped = items.group_by { |item| item[:collection] }
+        sections = []
+
+        sections << { title: "Pages", items: grouped.delete(nil).sort_by { |i| i[:url] } } if grouped.key?(nil)
+
+        sorted_keys = grouped.keys.compact.sort
+        sorted_keys.each do |key|
+          sections << { title: titleize(key), items: grouped[key].sort_by { |i| i[:url] } }
+        end
+
+        sections
+      end
+
+      def self.build_markdown(sections, columns, url_map_config)
+        lines = []
+        lines << "# Url Map"
+        if url_map_config["show_created_at"] != false
+          lines << "Generated by Jekyll-AEO on #{Time.now.strftime('%Y-%m-%d at %H:%M:%S')}"
+        end
+        lines << ""
+
+        sections.each do |section|
+          next if section[:items].empty?
+
+          lines << "## #{section[:title]}"
+          lines << ""
+          lines << table_header(columns)
+          lines << table_separator(columns)
+
+          section[:items].each do |item|
+            lines << table_row(item, columns)
+          end
+
+          lines << ""
+        end
+
+        "#{lines.join("\n").rstrip}\n"
+      end
+
+      def self.table_header(columns)
+        cells = columns.map { |col| COLUMN_HEADERS[col] || col }
+        "| #{cells.join(' | ')} |"
+      end
+
+      def self.table_separator(columns)
+        cells = columns.map { |col| "-" * (COLUMN_HEADERS[col] || col).length }
+        "| #{cells.join(' | ')} |"
+      end
+
+      def self.table_row(item, columns)
+        cells = columns.map { |col| escape_pipe(item[col.to_sym].to_s) }
+        "| #{cells.join(' | ')} |"
+      end
+
+      def self.escape_pipe(value)
+        value.gsub("|", "\\|")
+      end
+
+      def self.md_url(url, baseurl = "")
+        JekyllAeo::Utils::MdUrl.for(url, baseurl)
+      end
+
+      def self.titleize(label)
+        case label
+        when "posts"
+          "Posts"
+        else
+          label.split(/[_-]/).map(&:capitalize).join(" ")
+        end
+      end
+
+      def self.project_root(site)
+        pwd = Dir.pwd
+        if %w[_config.yml _config.yaml _config.toml].any? { |f| File.exist?(File.join(pwd, f)) }
+          pwd
+        else
+          site.source
+        end
+      end
+
+      private_class_method :collect_all_items, :build_item, :build_sections,
+                           :build_markdown, :table_header, :table_separator,
+                           :table_row, :escape_pipe, :md_url, :titleize,
+                           :project_root
+    end
+  end
+end

data/lib/jekyll-aeo/hooks.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+Jekyll::Hooks.register :documents, :pre_render do |doc|
+  JekyllAeo::LinkTag.set_data(doc, doc.site)
+end
+
+Jekyll::Hooks.register :pages, :pre_render do |page|
+  JekyllAeo::LinkTag.set_data(page, page.site)
+end
+
+Jekyll::Hooks.register :documents, :post_render do |doc|
+  JekyllAeo::LinkTag.inject(doc, doc.site)
+end
+
+Jekyll::Hooks.register :pages, :post_render do |page|
+  JekyllAeo::LinkTag.inject(page, page.site)
+end
+
+Jekyll::Hooks.register :documents, :post_write do |doc|
+  JekyllAeo::Generators::MarkdownPage.process(doc, doc.site)
+end
+
+Jekyll::Hooks.register :pages, :post_write do |page|
+  JekyllAeo::Generators::MarkdownPage.process(page, page.site)
+end
+
+Jekyll::Hooks.register :site, :post_write do |site|
+  JekyllAeo::Generators::LlmsTxt.generate(site)
+  JekyllAeo::Generators::LlmsFullTxt.generate(site)
+  JekyllAeo::Generators::UrlMap.generate(site)
+  JekyllAeo::Generators::DomainProfile.generate(site)
+end

data/lib/jekyll-aeo/link_tag.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module JekyllAeo
+  module LinkTag
+    def self.inject(obj, site)
+      config = JekyllAeo::Config.from_site(site)
+      dotmd_config = config["dotmd"]
+      return unless dotmd_config["link_tag"] == "auto"
+      return if JekyllAeo::Utils::SkipLogic.skip?(obj, site, config)
+
+      md_url = JekyllAeo::Utils::MdUrl.for(obj.url, site.config["baseurl"])
+      tag = %(<link rel="alternate" type="text/markdown" href="#{md_url}">)
+      obj.output = obj.output.sub("</head>", "#{tag}\n</head>")
+    end
+
+    def self.set_data(obj, site)
+      config = JekyllAeo::Config.from_site(site)
+      dotmd_config = config["dotmd"]
+      return unless dotmd_config["link_tag"] == "data"
+      return if JekyllAeo::Utils::SkipLogic.skip?(obj, site, config)
+
+      md_url = JekyllAeo::Utils::MdUrl.for(obj.url, site.config["baseurl"])
+      obj.data["md_url"] = md_url
+      obj.data["md_link_tag"] = %(<link rel="alternate" type="text/markdown" href="#{md_url}">)
+    end
+  end
+end

data/lib/jekyll-aeo/schema/article.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module JekyllAeo
+  module Schema
+    module Article
+      def self.build(page, site_config, _aeo_config = {})
+        return nil unless page["date"]
+        return nil if seo_tag_present?
+
+        base_url = site_config["url"].to_s.chomp("/")
+        baseurl = site_config["baseurl"].to_s.chomp("/")
+
+        schema = {
+          "@context" => "https://schema.org",
+          "@type" => "Article",
+          "headline" => page["title"] || "",
+          "url" => "#{base_url}#{baseurl}#{page['url']}",
+          "datePublished" => format_date(page["date"])
+        }
+
+        description = page["description"] || page["excerpt"]
+        schema["description"] = description.to_s if description
+
+        author = page["author"]
+        if author
+          schema["author"] = {
+            "@type" => "Person",
+            "name" => author
+          }
+        end
+
+        lm = page["last_modified_at"]
+        schema["dateModified"] = format_date(lm) if lm
+
+        schema
+      end
+
+      def self.seo_tag_present?
+        !Liquid::Template.tags["seo"].nil?
+      rescue StandardError
+        false
+      end
+
+      def self.format_date(value)
+        case value
+        when Time, DateTime
+          value.iso8601
+        else
+          value.to_s
+        end
+      end
+
+      private_class_method :seo_tag_present?, :format_date
+    end
+  end
+end

data/lib/jekyll-aeo/schema/breadcrumb_list.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module JekyllAeo
+  module Schema
+    module BreadcrumbList
+      def self.build(page, site_config, _aeo_config = {})
+        url = page["url"]
+        return nil if url.nil? || url == "/"
+
+        base_url = site_config["url"].to_s.chomp("/")
+        baseurl = site_config["baseurl"].to_s.chomp("/")
+        segments = url.split("/").reject(&:empty?)
+        return nil if segments.empty?
+
+        {
+          "@context" => "https://schema.org",
+          "@type" => "BreadcrumbList",
+          "itemListElement" => build_items(page, segments, base_url, baseurl)
+        }
+      end
+
+      def self.build_items(page, segments, base_url, baseurl)
+        items = [{
+          "@type" => "ListItem", "position" => 1,
+          "name" => "Home", "item" => "#{base_url}#{baseurl}/"
+        }]
+        accumulated = ""
+        segments.each_with_index do |segment, index|
+          accumulated += "/#{segment}"
+          name = if page["title"] && index == segments.length - 1
+                   page["title"]
+                 else
+                   segment.split(/[_-]/).map(&:capitalize).join(" ")
+                 end
+          items << {
+            "@type" => "ListItem", "position" => index + 2,
+            "name" => name, "item" => "#{base_url}#{baseurl}#{accumulated}/"
+          }
+        end
+        items
+      end
+
+      private_class_method :build_items
+    end
+  end
+end

data/lib/jekyll-aeo/schema/faq_page.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module JekyllAeo
+  module Schema
+    module FaqPage
+      def self.build(page, _site_config, _aeo_config = {})
+        faq = page["faq"]
+        return nil unless faq.is_a?(Array) && faq.any?
+
+        entities = faq.filter_map do |item|
+          next unless item.is_a?(Hash) && item["q"] && item["a"]
+
+          {
+            "@type" => "Question",
+            "name" => item["q"],
+            "acceptedAnswer" => {
+              "@type" => "Answer",
+              "text" => item["a"]
+            }
+          }
+        end
+
+        return nil if entities.empty?
+
+        {
+          "@context" => "https://schema.org",
+          "@type" => "FAQPage",
+          "mainEntity" => entities
+        }
+      end
+    end
+  end
+end

data/lib/jekyll-aeo/schema/how_to.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module JekyllAeo
+  module Schema
+    module HowTo
+      def self.build(page, _site_config, _aeo_config = {})
+        howto = page["howto"]
+        return nil unless howto.is_a?(Hash)
+
+        steps = howto["steps"]
+        return nil unless steps.is_a?(Array) && steps.any?
+
+        step_entities = steps.each_with_index.filter_map { |step, i| build_step(step, i) }
+        return nil if step_entities.empty?
+
+        schema = { "@context" => "https://schema.org", "@type" => "HowTo", "step" => step_entities }
+        add_optional_fields(schema, howto, page)
+        schema
+      end
+
+      def self.build_step(step, index)
+        return unless step.is_a?(Hash) && step["text"]
+
+        entity = { "@type" => "HowToStep", "position" => index + 1, "text" => step["text"] }
+        entity["name"] = step["name"] if step["name"]
+        entity["url"] = step["url"] if step["url"]
+        entity["image"] = step["image"] if step["image"]
+        entity
+      end
+
+      def self.add_optional_fields(schema, howto, page)
+        schema["name"] = howto["name"] || page["title"] if howto["name"] || page["title"]
+        schema["description"] = howto["description"] if howto["description"]
+        schema["totalTime"] = howto["totalTime"] if howto["totalTime"]
+      end
+
+      private_class_method :build_step, :add_optional_fields
+    end
+  end
+end

data/lib/jekyll-aeo/schema/organization.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JekyllAeo
+  module Schema
+    module Organization
+      def self.build(page, site_config, aeo_config = {})
+        return nil unless page["url"] == "/"
+
+        name = site_config["title"] || site_config["name"]
+        return nil unless name
+
+        base_url = site_config["url"].to_s.chomp("/")
+
+        schema = {
+          "@context" => "https://schema.org",
+          "@type" => "Organization",
+          "name" => name,
+          "url" => base_url.empty? ? "/" : base_url
+        }
+
+        description = site_config["description"]
+        schema["description"] = description if description && !description.to_s.empty?
+
+        logo = aeo_config.dig("domain_profile", "logo")
+        schema["logo"] = logo if logo
+
+        same_as = aeo_config.dig("domain_profile", "jsonld", "sameAs")
+        schema["sameAs"] = same_as if same_as.is_a?(Array) && same_as.any?
+
+        schema
+      end
+    end
+  end
+end

data/lib/jekyll-aeo/schema/speakable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JekyllAeo
+  module Schema
+    module Speakable
+      def self.build(page, site_config, _aeo_config = {})
+        return nil unless page["speakable"] == true
+
+        base_url = site_config["url"].to_s.chomp("/")
+        baseurl = site_config["baseurl"].to_s.chomp("/")
+        url = "#{base_url}#{baseurl}#{page['url']}"
+
+        selectors = [
+          ".post-title, .page-title, h1",
+          ".post-content p:first-of-type, .page-content p:first-of-type"
+        ]
+
+        {
+          "@context" => "https://schema.org",
+          "@type" => "WebPage",
+          "name" => page["title"] || "",
+          "url" => url,
+          "speakable" => {
+            "@type" => "SpeakableSpecification",
+            "cssSelector" => selectors
+          }
+        }
+      end
+    end
+  end
+end

data/lib/jekyll-aeo/tags/aeo_json_ld.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "json"
+
+module JekyllAeo
+  module Tags
+    class AeoJsonLd < Liquid::Tag
+      BUILDERS = [
+        JekyllAeo::Schema::FaqPage,
+        JekyllAeo::Schema::HowTo,
+        JekyllAeo::Schema::BreadcrumbList,
+        JekyllAeo::Schema::Organization,
+        JekyllAeo::Schema::Speakable,
+        JekyllAeo::Schema::Article
+      ].freeze
+
+      def render(context)
+        site = context.registers[:site]
+        page = context.registers[:page]
+
+        aeo_config = JekyllAeo::Config.from_site(site)
+        results = BUILDERS.filter_map { |builder| builder.build(page, site.config, aeo_config) }
+
+        results.map do |schema|
+          json = JSON.pretty_generate(schema).gsub("</", "<\\/")
+          "<script type=\"application/ld+json\">\n#{json}\n</script>"
+        end.join("\n")
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("aeo_json_ld", JekyllAeo::Tags::AeoJsonLd)