unaltraweb 0.3.0

data/_plugins/file-exists.rb

@@ -0,0 +1,22 @@
+module Jekyll
+  class FileExistsTag < Liquid::Tag
+    def initialize(tag_name, path, tokens)
+      super
+      @path = path
+    end
+
+    def render(context)
+      # Pipe parameter through Liquid to make additional replacements possible
+      url = Liquid::Template.parse(@path).render context
+
+      # Adds the site source, so that it also works with a custom one
+      site_source = context.registers[:site].config['source']
+      file_path = site_source + '/' + url
+
+      # Check if file exists (returns true or false)
+      "#{File.exist?(file_path.strip!)}"
+    end
+  end
+end
+
+Liquid::Template.register_tag('file_exists', Jekyll::FileExistsTag)

data/_plugins/google-scholar-citations.rb

@@ -0,0 +1,86 @@
+require "active_support/all"
+require 'nokogiri'
+require 'open-uri'
+
+module Helpers
+  extend ActiveSupport::NumberHelper
+end
+
+module Jekyll
+  class GoogleScholarCitationsTag < Liquid::Tag
+    Citations = { }
+    CITED_BY_REGEX = /Cited by (\d+[,\d]*)/
+
+    def initialize(tag_name, params, tokens)
+      super
+      splitted = params.split(" ").map(&:strip)
+      @scholar_id = splitted[0]
+      @article_id = splitted[1]
+
+      if @scholar_id.nil? || @scholar_id.empty?
+        puts "Invalid scholar_id provided"
+      end
+
+      if @article_id.nil? || @article_id.empty?
+        puts "Invalid article_id provided"
+      end
+    end
+
+    def render(context)
+      article_id = context[@article_id.strip]
+      scholar_id = context[@scholar_id.strip]
+      article_url = "https://scholar.google.com/citations?view_op=view_citation&hl=en&user=#{scholar_id}&citation_for_view=#{scholar_id}:#{article_id}"
+
+      begin
+          # If the citation count has already been fetched, return it
+          if GoogleScholarCitationsTag::Citations[article_id]
+            return GoogleScholarCitationsTag::Citations[article_id]
+          end
+
+          # Sleep for a random amount of time to avoid being blocked
+          sleep(rand(1.5..3.5))
+
+          # Fetch the article page
+          doc = Nokogiri::HTML(URI.open(article_url, "User-Agent" => "Ruby/#{RUBY_VERSION}"))
+
+          # Attempt to extract the "Cited by n" string from the meta tags
+          citation_count = 0
+
+          # Look for meta tags with "name" attribute set to "description"
+          description_meta = doc.css('meta[name="description"]')
+          og_description_meta = doc.css('meta[property="og:description"]')
+
+          if !description_meta.empty?
+            cited_by_text = description_meta[0]['content']
+            matches = cited_by_text.match(CITED_BY_REGEX)
+
+            if matches
+              citation_count = matches[1].sub(",", "").to_i
+            end
+
+          elsif !og_description_meta.empty?
+            cited_by_text = og_description_meta[0]['content']
+            matches = cited_by_text.match(CITED_BY_REGEX)
+
+            if matches
+              citation_count = matches[1].sub(",", "").to_i
+            end
+          end
+
+        citation_count = Helpers.number_to_human(citation_count, :format => '%n%u', :precision => 2, :units => { :thousand => 'K', :million => 'M', :billion => 'B' })
+
+      rescue Exception => e
+        # Handle any errors that may occur during fetching
+        citation_count = "N/A"
+
+        # Print the error message including the exception class and message
+        puts "Error fetching citation count for #{article_id} in #{article_url}: #{e.class} - #{e.message}"
+      end
+
+      GoogleScholarCitationsTag::Citations[article_id] = citation_count
+      return "#{citation_count}"
+    end
+  end
+end
+
+Liquid::Template.register_tag('google_scholar_citations', Jekyll::GoogleScholarCitationsTag)

data/_plugins/hide-custom-bibtex.rb

@@ -0,0 +1,18 @@
+module Jekyll
+  module HideCustomBibtex
+    def hideCustomBibtex(input)
+	    keywords = @context.registers[:site].config['filtered_bibtex_keywords']
+
+	    keywords.each do |keyword|
+		    input = input.gsub(/^.*\b#{keyword}\b *= *\{.*$\n/, '')
+	    end
+
+      # Clean superscripts in author lists
+      input = input.gsub(/^.*\bauthor\b *= *\{.*$\n/) { |line| line.gsub(/[*†‡§¶‖&^]/, '') }
+
+      return input
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::HideCustomBibtex)

data/_plugins/inspirehep-citations.rb

@@ -0,0 +1,57 @@
+require "active_support/all"
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Helpers
+  extend ActiveSupport::NumberHelper
+end
+
+module Jekyll
+  class InspireHEPCitationsTag < Liquid::Tag
+    Citations = { }
+
+    def initialize(tag_name, params, tokens)
+      super
+      @recid = params.strip
+    end
+
+    def render(context)
+      recid = context[@recid.strip]
+      api_url = "https://inspirehep.net/api/literature/?fields=citation_count&q=recid:#{recid}"
+
+      begin
+        # If the citation count has already been fetched, return it
+        if InspireHEPCitationsTag::Citations[recid]
+          return InspireHEPCitationsTag::Citations[recid]
+        end
+
+        # Fetch the citation count from the API
+        uri = URI(api_url)
+        response = Net::HTTP.get(uri)
+        data = JSON.parse(response)
+
+        # # Log the response for debugging
+        # puts "API Response: #{data.inspect}"
+
+        # Extract citation count from the JSON data
+        citation_count = data["hits"]["hits"][0]["metadata"]["citation_count"].to_i
+
+        # Format the citation count for readability
+        citation_count = Helpers.number_to_human(citation_count, format: '%n%u', precision: 2, units: { thousand: 'K', million: 'M', billion: 'B' })
+
+      rescue Exception => e
+        # Handle any errors that may occur during fetching
+        citation_count = "N/A"
+
+        # Print the error message including the exception class and message
+        puts "Error fetching citation count for #{recid}: #{e.class} - #{e.message}"
+      end
+
+      InspireHEPCitationsTag::Citations[recid] = citation_count
+      return "#{citation_count}"
+    end
+  end
+end
+
+Liquid::Template.register_tag('inspirehep_citations', Jekyll::InspireHEPCitationsTag)

data/_plugins/localized_visual_sources.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Unaltraweb
+  module LocalizedVisualSources
+    module_function
+
+    VISUAL_SUFFIXES = %w[
+      .capture.edited.svg .capture.yaml .capture.yml .capture.svg
+      .mermaid.edited.svg .mermaid.svg .plantuml.edited.svg .plantuml.svg
+      .mmd.edited.svg .mmd.svg .puml.edited.svg .puml.svg .uml.edited.svg .uml.svg
+      .vl.json .vg.json .edited.svg
+      .qmd .rmd .ipynb .mermaid .plantuml .mmd .puml .uml .py .r
+      .jpeg .tiff .webp .gif .jpg .png .svg .pdf
+    ].sort_by { |suffix| -suffix.length }.freeze
+    FENCED_CODE_BLOCK = /^[ \t]*(`{3,}|~{3,})[^\n]*\n.*?^[ \t]*\1[ \t]*$/m.freeze
+    INLINE_CODE = /(`+)[^\n]*?\1/.freeze
+    BASEURL_PREFIX = /\A\{\{\s*site\.baseurl\s*\}\}/.freeze
+    REMOTE_URL = /\A(?:[a-z][a-z0-9+.-]*:)?\/\//i.freeze
+
+    def select_url(raw_url, site_source:, lang:, default_lang:, languages:)
+      value = raw_url.to_s
+      return value if value.empty?
+
+      prefix = value[BASEURL_PREFIX].to_s
+      without_prefix = prefix.empty? ? value : value[prefix.length..]
+      decoration_index = [without_prefix.index("?"), without_prefix.index("#")].compact.min
+      path = decoration_index ? without_prefix[0...decoration_index] : without_prefix
+      decoration = decoration_index ? without_prefix[decoration_index..] : ""
+      return value if path.empty? || path.start_with?("#", "data:") || path.match?(REMOTE_URL)
+
+      current = lang.to_s.strip
+      default = default_lang.to_s.strip
+      return value if current.empty? || current == default
+
+      suffix = VISUAL_SUFFIXES.find { |candidate| path.downcase.end_with?(candidate) }
+      return value unless suffix
+
+      stem = path[0...-suffix.length]
+      configured = Array(languages).map(&:to_s).map(&:strip).reject(&:empty?) | [current, default]
+      return value if configured.any? { |code| stem.downcase.end_with?(".#{code.downcase}") }
+
+      localized_path = "#{stem}.#{current}#{suffix}"
+      local_reference = localized_path.sub(%r{\A/+}, "")
+      root = File.realpath(site_source)
+      candidate = File.expand_path(local_reference, root)
+      return value unless candidate.start_with?(root + File::SEPARATOR) && File.file?(candidate)
+
+      "#{prefix}#{localized_path}#{decoration}"
+    rescue Errno::ENOENT
+      value
+    end
+
+    def rewrite(content, site_source:, lang:, default_lang:, languages:)
+      source = content.to_s
+      return source if lang.to_s.empty? || lang.to_s == default_lang.to_s
+
+      protected = []
+      protected_source = source.gsub(FENCED_CODE_BLOCK) do
+        token = "UNALTRAWEBLOCALIZEDVISUALFENCE_#{protected.length}_END"
+        protected << Regexp.last_match(0)
+        token
+      end
+      output = rewrite_chunk(
+        protected_source,
+        site_source: site_source,
+        lang: lang,
+        default_lang: default_lang,
+        languages: languages
+      )
+      (protected.length - 1).downto(0) do |index|
+        output.gsub!("UNALTRAWEBLOCALIZEDVISUALFENCE_#{index}_END", protected[index])
+      end
+      output
+    end
+
+    def rewrite_chunk(chunk, site_source:, lang:, default_lang:, languages:)
+      protected = []
+      output = chunk.gsub(INLINE_CODE) do
+        token = "UNALTRAWEBLOCALIZEDVISUALCODE_#{protected.length}_END"
+        protected << Regexp.last_match(0)
+        token
+      end
+      selector = lambda do |url|
+        select_url(url, site_source: site_source, lang: lang, default_lang: default_lang, languages: languages)
+      end
+      output.gsub!(/(!\[[^\]]*\]\()((?:\{\{\s*site\.baseurl\s*\}\})?[^)\s]+)/) do
+        "#{Regexp.last_match(1)}#{selector.call(Regexp.last_match(2))}"
+      end
+      output.gsub!(/(<img\b[^>]*\bsrc\s*=\s*["'])([^"']+)(["'])/i) do
+        "#{Regexp.last_match(1)}#{selector.call(Regexp.last_match(2))}#{Regexp.last_match(3)}"
+      end
+      (protected.length - 1).downto(0) do |index|
+        output.gsub!("UNALTRAWEBLOCALIZEDVISUALCODE_#{index}_END", protected[index])
+      end
+      output
+    end
+
+    def document_language(document, site)
+      value = document.data["lang"].to_s
+      return value unless value.empty?
+
+      relative = document.respond_to?(:relative_path) ? document.relative_path.to_s.tr("\\", "/") : ""
+      candidate = relative.split("/")[1].to_s
+      candidate.empty? ? (site.config["default_lang"] || site.config["lang"]).to_s : candidate
+    end
+  end
+
+  module LocalizedVisualFilter
+    def localized_visual(raw_url)
+      site = @context.registers[:site]
+      page = @context.registers[:page]
+      lang = page.respond_to?(:[]) ? page["lang"] : nil
+      default_lang = site.config["default_lang"] || site.config["lang"]
+      LocalizedVisualSources.select_url(
+        raw_url,
+        site_source: site.source,
+        lang: lang || default_lang,
+        default_lang: default_lang,
+        languages: site.config["languages"]
+      )
+    end
+  end
+end
+
+Liquid::Template.register_filter(Unaltraweb::LocalizedVisualFilter)
+
+class UnaltrawebLocalizedVisualSourceGenerator < Jekyll::Generator
+  safe true
+  priority :highest
+
+  def generate(site)
+    documents = site.collections.values.flat_map(&:docs) + site.pages
+    documents.each do |document|
+      lang = Unaltraweb::LocalizedVisualSources.document_language(document, site)
+      default_lang = (site.config["default_lang"] || site.config["lang"]).to_s
+      document.content = Unaltraweb::LocalizedVisualSources.rewrite(
+        document.content,
+        site_source: site.source,
+        lang: lang,
+        default_lang: default_lang,
+        languages: site.config["languages"]
+      )
+    end
+  end
+end

data/_plugins/manual_release_metadata.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Unaltraweb
+  module ManualReleaseMetadata
+    SELECTOR = /\A(?:latest|v[0-9]{4}\.(?:0[1-9]|1[0-2])(?:\.[1-9][0-9]*)?)\z/
+    module_function
+
+    def metadata(site)
+      unaltraweb = site.config["unaltraweb"] || {}
+      manual = unaltraweb["manual"] || {}
+      configured = (manual["release"] || {})["selector"]
+      selector = ENV.fetch("UNALTRAWEB_MANUAL_RELEASE_SELECTOR", configured || "latest").to_s.strip
+      unless SELECTOR.match?(selector)
+        raise Jekyll::Errors::FatalException,
+              "UNALTRAWEB_MANUAL_RELEASE_SELECTOR must be latest, vYYYY.MM, or vYYYY.MM.N"
+      end
+
+      {
+        "channel" => selector == "latest" ? "latest" : "stable",
+        "schema_version" => 1,
+        "selector" => selector,
+      }
+    end
+
+    class Generator < Jekyll::Generator
+      safe true
+      priority :highest
+
+      def generate(site)
+        unaltraweb = site.config["unaltraweb"] || {}
+        return unless unaltraweb["site_profile"].to_s == "unaltremanual"
+
+        manual = unaltraweb["manual"] ||= {}
+        release = ManualReleaseMetadata.metadata(site)
+        manual["release"] = release
+
+        page = Jekyll::PageWithoutAFile.new(site, site.source, "", "manual-release.json")
+        page.content = JSON.pretty_generate(release) + "\n"
+        page.data["layout"] = nil
+        page.data["sitemap"] = false
+        site.pages << page
+      end
+    end
+  end
+end

data/_plugins/mermaid_mmd_images.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "shellwords"
+
+# Rewrites Markdown and HTML image references from diagram text sources to SVGs.
+# If an edited SVG exists next to the source, it wins over the generated one.
+module Unaltraweb
+  module MermaidMmdImages
+    module_function
+
+    BASEURL_PREFIX = /\A\{\{\s*site\.baseurl\s*\}\}/.freeze
+    REMOTE_PATH_PREFIX = %r{\A(?:[a-z]+:)?//}i.freeze
+    FENCED_CODE_BLOCK = /^[ \t]*(`{3,}|~{3,})[^\n]*\n.*?^[ \t]*\1[ \t]*$/m.freeze
+    DIAGRAM_EXTENSIONS = %w[.mmd .mermaid .puml .plantuml .uml].freeze
+    DIAGRAM_SOURCE = /\.(?:mmd|mermaid|puml|plantuml|uml)/i.freeze
+    DIAVISUALS_REMOTE = "git@github.com:dosquartsdedocs/diavisuals.git"
+    DIAVISUALS_UV_URL = "git+ssh://git@github.com/dosquartsdedocs/diavisuals.git"
+
+    def rewrite(content, site_source:, site_config: {})
+      return content if content.nil? || content.empty?
+
+      rewrite_outside_code_fences(content) { |chunk| rewrite_chunk(chunk, site_source: site_source, site_config: site_config) }
+    end
+
+    def rewrite_chunk(content, site_source:, site_config: {})
+      out = content.dup
+
+      out.gsub!(/!\[([^\]]*)\]\(([^)]*?#{DIAGRAM_SOURCE})(\s+"[^"]*")?\)/i) do
+        alt = Regexp.last_match(1)
+        path = svg_path_for(Regexp.last_match(2), site_source, site_config: site_config)
+        title = Regexp.last_match(3).to_s
+        "![#{alt}](#{path}#{title})"
+      end
+
+      out.gsub!(/(<img\b[^>]*\bsrc=)(["'])([^"']+?#{DIAGRAM_SOURCE})\2/i) do
+        prefix = Regexp.last_match(1)
+        quote = Regexp.last_match(2)
+        path = svg_path_for(Regexp.last_match(3), site_source, site_config: site_config)
+        "#{prefix}#{quote}#{path}#{quote}"
+      end
+
+      out
+    end
+
+    def rewrite_outside_code_fences(content)
+      source = content.to_s
+      fences = []
+      protected_source = source.gsub(FENCED_CODE_BLOCK) do
+        token = "UNALTRAWEBFENCEDCODEBLOCK#{fences.length}"
+        fences << Regexp.last_match(0)
+        token
+      end
+
+      transformed = yield(protected_source)
+      fences.each_index.reverse_each do |index|
+        transformed.gsub!("UNALTRAWEBFENCEDCODEBLOCK#{index}", fences[index])
+      end
+
+      transformed
+    end
+
+    def svg_path_for(diagram_path, site_source, site_config: {})
+      edited = "#{diagram_path}.edited.svg"
+      if local_asset_exists?(edited, site_source)
+        warn_when_edited_svg_shadows_newer_source(diagram_path, edited, site_source)
+        return edited
+      end
+
+      svg_path = "#{diagram_path}.svg"
+      render_svg(diagram_path, svg_path, site_source, site_config: site_config)
+      svg_path
+    end
+
+    def local_asset_exists?(asset_path, site_source)
+      local_path = local_asset_path(asset_path, site_source)
+      local_path && File.exist?(local_path)
+    end
+
+    def local_asset_path(asset_path, site_source)
+      local_path = asset_path
+        .sub(BASEURL_PREFIX, "")
+        .split(/[?#]/, 2)
+        .first.to_s
+        .sub(%r{\A/+}, "")
+
+      return nil if local_path.empty? || local_path.match?(REMOTE_PATH_PREFIX)
+
+      root = File.expand_path(site_source)
+      path = File.expand_path(local_path, root)
+      return nil unless path == root || path.start_with?("#{root}/")
+
+      path
+    end
+
+    def render_svg(diagram_path, svg_path, site_source, site_config: {})
+      return unless render_diagrams?(site_config)
+
+      source_path = local_asset_path(diagram_path, site_source)
+      output_path = local_asset_path(svg_path, site_source)
+      return unless source_path && output_path && File.file?(source_path)
+      return if File.file?(output_path) && File.mtime(output_path) >= File.mtime(source_path)
+
+      command, env = diavisuals_command(site_source, site_config)
+      unless command
+        warn_once("diavisuals-missing", diavisuals_install_message(site_source))
+        return
+      end
+
+      FileUtils.mkdir_p(File.dirname(output_path))
+      args = [*command, "--project", File.expand_path(site_source), "render-diagram", "--engine", engine_for(source_path), "--format", "svg"]
+      args.concat(["--family", diagram_config(site_config)["family"].to_s]) if diagram_config(site_config)["family"].to_s.strip != ""
+      profile = diagram_config(site_config)["profile"] || diagram_config(site_config)["compatibility"]
+      args.concat(["--profile", profile.to_s]) if profile.to_s.strip != ""
+      args.concat([source_path, output_path])
+
+      stdout, stderr, status = Open3.capture3(env || {}, *args, chdir: site_source)
+      return if status.success? && File.file?(output_path)
+
+      message = "diavisuals could not render #{diagram_path} to SVG"
+      detail = [stderr.to_s.strip, stdout.to_s.strip].reject(&:empty?).join("\n")
+      warn_once("diavisuals-render-#{source_path}", detail.empty? ? message : "#{message}: #{detail}")
+      raise message if fail_on_render_error?(site_config)
+    end
+
+    def warn_when_edited_svg_shadows_newer_source(diagram_path, edited_path, site_source)
+      source_path = local_asset_path(diagram_path, site_source)
+      edited_local_path = local_asset_path(edited_path, site_source)
+      return unless source_path && edited_local_path && File.file?(source_path) && File.file?(edited_local_path)
+      return unless File.mtime(source_path) > File.mtime(edited_local_path)
+
+      warn_once(
+        "edited-diagram-#{edited_local_path}",
+        "#{edited_path} exists and is older than #{diagram_path}; keeping the edited SVG. Ask before replacing it with a regenerated SVG."
+      )
+    end
+
+    def render_diagrams?(site_config)
+      env_value = ENV["UNALTRAWEB_RENDER_DIAGRAMS"].to_s.strip.downcase
+      return false if %w[0 false no off].include?(env_value)
+      return true if %w[1 true yes on].include?(env_value)
+
+      value = diagram_config(site_config).fetch("render", true)
+      ![false, "false", "0", "no", "off"].include?(value)
+    end
+
+    def fail_on_render_error?(site_config)
+      value = diagram_config(site_config)["fail_on_render_error"]
+      [true, "true", "1", "yes", "on"].include?(value)
+    end
+
+    def diagram_config(site_config)
+      unaltraweb = site_config["unaltraweb"] if site_config.respond_to?(:[])
+      diagrams = unaltraweb["diagrams"] if unaltraweb.is_a?(Hash)
+      diagrams = site_config["diagrams"] if !diagrams.is_a?(Hash) && site_config.respond_to?(:[])
+      diagrams.is_a?(Hash) ? diagrams : {}
+    end
+
+    def engine_for(path)
+      extension = File.extname(path.to_s).downcase
+      return "plantuml" if %w[.puml .plantuml .uml].include?(extension)
+
+      "mermaid"
+    end
+
+    def diavisuals_command(site_source, site_config)
+      configured = diagram_config(site_config)["diavisuals_command"].to_s.strip
+      return [Shellwords.split(configured), nil] unless configured.empty?
+
+      env_command = ENV["DIAVISUALS_COMMAND"].to_s.strip
+      return [Shellwords.split(env_command), nil] unless env_command.empty?
+
+      sibling_candidates(site_source).each do |candidate|
+        src = File.join(candidate, "src")
+        cli = File.join(src, "diavisuals", "cli.py")
+        next unless File.file?(cli)
+
+        pythonpath = [src, ENV["PYTHONPATH"]].compact.reject(&:empty?).join(File::PATH_SEPARATOR)
+        return [["python3", "-m", "diavisuals.cli"], { "PYTHONPATH" => pythonpath }]
+      end
+
+      installed = executable_on_path("diavisuals")
+      installed ? [[installed], nil] : [nil, nil]
+    end
+
+    def sibling_candidates(site_source)
+      root = File.expand_path(site_source)
+      core = File.expand_path("..", __dir__)
+      [
+        File.expand_path("../diavisuals", root),
+        File.expand_path("../diavisuals", core)
+      ].uniq
+    end
+
+    def executable_on_path(name)
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).map { |dir| File.join(dir, name) }.find do |path|
+        File.executable?(path) && !File.directory?(path)
+      end
+    end
+
+    def diavisuals_install_message(site_source)
+      checkout = File.expand_path("../diavisuals", site_source)
+      clone = ["git", "clone", DIAVISUALS_REMOTE, checkout]
+      build = ["make", "-C", checkout, "mcp-build"]
+      uv = ["uv", "tool", "install", "diavisuals[mcp] @ #{DIAVISUALS_UV_URL}"]
+      editable = ["uv", "tool", "install", "--editable", "#{checkout}[mcp]"]
+      "diavisuals CLI not found. Install with: #{shell(clone)}; #{shell(build)}. Or use: #{shell(uv)}. Existing checkout: #{shell(editable)}."
+    end
+
+    def shell(command)
+      command.map { |part| Shellwords.escape(part.to_s) }.join(" ")
+    end
+
+    def warn_once(key, message)
+      @warnings ||= {}
+      return if @warnings[key]
+
+      @warnings[key] = true
+      if defined?(Jekyll) && Jekyll.respond_to?(:logger)
+        Jekyll.logger.warn("unaltraweb-diagrams:", message)
+      else
+        warn("unaltraweb-diagrams: #{message}")
+      end
+    end
+  end
+end
+
+Jekyll::Hooks.register [:documents, :pages], :pre_render do |doc|
+  next unless doc.respond_to?(:content) && doc.content
+
+  doc.content = Unaltraweb::MermaidMmdImages.rewrite(doc.content, site_source: doc.site.source, site_config: doc.site.config)
+end if defined?(Jekyll::Hooks)

data/_plugins/profile-pages.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Unaltraweb
+  module ProfilePages
+    module_function
+
+    def active_profile(site)
+      unaltraweb_config = site.config["unaltraweb"] || {}
+      (unaltraweb_config["site_profile"] || "unaltreprojecte").to_s
+    end
+
+    def keep_item?(item, profile)
+      profiles = item.data["profiles"] || item.data["site_profiles"]
+      return true if profiles.nil? || profiles.empty?
+
+      Array(profiles).map(&:to_s).include?(profile)
+    end
+  end
+end
+
+Jekyll::Hooks.register :site, :post_read do |site|
+  active_profile = Unaltraweb::ProfilePages.active_profile(site)
+
+  site.pages.select! { |page| Unaltraweb::ProfilePages.keep_item?(page, active_profile) }
+  site.collections.each_value do |collection|
+    collection.docs.select! { |doc| Unaltraweb::ProfilePages.keep_item?(doc, active_profile) }
+  end
+end

data/_plugins/remove-accents.rb

@@ -0,0 +1,32 @@
+# based on https://distresssignal.org/busting-css-cache-with-jekyll-md5-hash
+# https://gist.github.com/BryanSchuetz/2ee8c115096d7dd98f294362f6a667db
+module Jekyll
+  module CleanString
+    class RemoveAccents
+      require 'i18n'
+      I18n.config.available_locales = :en
+
+      attr_accessor :string
+
+      def initialize(string:)
+        self.string = string
+      end
+
+      def digest!
+        remove_accents
+      end
+
+      private
+
+      def remove_accents
+        I18n.transliterate(string)
+      end
+    end
+
+    def remove_accents(string)
+      RemoveAccents.new(string: string).digest!
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::CleanString)