jekyll-potion 1.0.1

data/lib/jekyll-potion/processor/rewrite-img-processor.rb

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: Copyright 2022 SK TELECOM CO., LTD.
+# SPDX-License-Identifier: Apache-2.0
+
+module Jekyll::Potion
+  class RewriteImgProcessor < Processor
+    HTTP_SCHEME = %r!\Ahttp(s)?://!im.freeze
+    ABSOLUTE_PATH = %r!\A/!im.freeze
+
+    RELATIVE_SRC = %r!src\s*="(?<src>\.+[^"]*?)"!im.freeze
+
+    def page_post_render(page, html, modified)
+      if modified
+        src_count = 0
+        inline_count = 0
+
+        html.css("img[src]").each { |img_tag|
+          src = img_tag["src"]
+
+          next if img_tag.has_attribute?(@config[:skip_keyword])
+          next if src.strip.empty?
+
+          unless img_tag.parent.text.strip.empty?
+            inline_count += 1
+            img_tag.add_class(@config[:inline_image_class])
+          end
+
+          next if src =~ HTTP_SCHEME || src =~ ABSOLUTE_PATH
+
+          src_count += 1
+          img_tag["src"] = @site.base_absolute_url(File.dirname(page.path), src)
+          img_tag.add_class(@config[:internal_image_class])
+        }
+
+        if src_count > 0 || inline_count > 0
+          @logger.trace("#{page.name} #{src_count} img tags replace absolute path") if src_count > 0
+          @logger.trace("#{page.name} #{inline_count} inline img tags add class") if inline_count > 0
+          yield html
+        end
+      end
+    end
+  end
+end

data/lib/jekyll-potion/processor/search-template/search.js

@@ -0,0 +1,123 @@
+// SPDX-FileCopyrightText: Copyright 2022 SK TELECOM CO., LTD.
+// SPDX-License-Identifier: Apache-2.0
+
+(($) => {
+  class SearchResults {
+    constructor(keyword, per_size) {
+      this.page_index_line_numbers_map = new Map()
+      this.keyword = keyword
+      this.per_size = per_size
+      this.search_results = []
+    }
+
+    contains(page, index, line_number) {
+      if (!this.page_index_line_numbers_map.has(page.url)) {
+        this.page_index_line_numbers_map.set(page.url, new Map())
+      }
+
+      if (!this.page_index_line_numbers_map.get(page.url).has(index.hash)) {
+        this.page_index_line_numbers_map.get(page.url).set(index.hash, [])
+      }
+
+      return this.page_index_line_numbers_map.get(page.url).get(index.hash).find(line_numbers => line_numbers.includes(line_number))
+    }
+
+    static create_line_numbers(line_number, total_size, per_size) {
+      let start = Math.max(0, line_number - (Math.floor(per_size / 2) - (1 - (per_size % 2))))
+      let end = Math.min(total_size, start + per_size)
+
+      let n = []
+
+      for (start; start < end; start++) {
+        n.push(start)
+      }
+
+      return n
+    }
+
+    add_line_number(page, index, index_order, line_number) {
+      if (!this.contains(page, index, line_number)) {
+        let line_numbers = SearchResults.create_line_numbers(line_number, index.sentences.length, this.per_size)
+        this.page_index_line_numbers_map.get(page.url).get(index.hash).push(line_numbers)
+
+        this.search_results.push(new SearchResult(page, index, index_order, this.keyword, line_number, line_numbers))
+      }
+    }
+
+    result() {
+      this.search_results.sort((r1, r2) => {
+        if (r1.page_order === r2.page_order) {
+          if (r1.index_order === r2.index_order) {
+            return r1.line_number - r2.line_number
+          }
+
+          return r1.index_order - r2.index_order
+        }
+
+        return r1.page_order - r2.page_order
+      })
+
+      return this.search_results
+    }
+  }
+
+  class SearchResult {
+    constructor(page, index, index_order, keyword, line_number, line_numbers) {
+      this.url = page.url + index.hash
+      this.title = index.title
+      this.page_order = page.order
+      this.index_order = index_order
+      this.line_number = line_number
+      this.sentences = line_numbers.map(n => index.sentences[n].replace(new RegExp('(' + keyword + ')', 'gi'), '<code>$1</code>'))
+    }
+  }
+
+  class Search {
+    constructor(options) {
+      this.options = options
+      this.loaded = false
+      this.page_indexes = []
+    }
+
+    init() {
+    }
+
+    load_search_file(callback) {
+      $.getJSON('{{ search_file }}', data => {
+        this.loaded = true
+        this.page_indexes = data
+        if (callback) {
+          callback.call(this)
+        }
+      })
+    }
+
+    search(keyword, context, callback) {
+      if (this.loaded) {
+        let search_results = new SearchResults(keyword, 3)
+
+        this.page_indexes.forEach((page) => {
+          page.indexes.forEach((index, index_order) => {
+            index.sentences.forEach((sentence, line_number) => {
+              if (new RegExp(keyword, 'i').test(sentence)) {
+                search_results.add_line_number(page, index, index_order, line_number)
+              }
+            })
+          })
+        })
+
+        if (callback && callback instanceof Function) {
+          callback.call(context, search_results.result())
+        }
+      } else {
+        this.load_search_file(() => {
+          this.search(keyword, context, callback)
+        })
+      }
+    }
+  }
+
+  $.search = (options) => {
+    return new Search(options)
+  }
+})(jQuery)

data/lib/jekyll-potion/processor.rb

@@ -0,0 +1,152 @@
+# SPDX-FileCopyrightText: Copyright 2022 SK TELECOM CO., LTD.
+# SPDX-License-Identifier: Apache-2.0
+
+require "nokogiri"
+
+module Jekyll::Potion
+  class ProcessorsConfig
+    DEFAULT_PROCESSORS_CONFIG = {
+      :make_header_link_processor => {
+        :selector => "data-header-link",
+        :hash_class => "go-hash",
+        :copy_class => "copy-link"
+      },
+      :rewrite_img_processor => {
+        :skip_keyword => "data-skip-src-to-absolute",
+        :inline_image_class => "img-inline",
+        :internal_image_class => "img-internal"
+      },
+      :rewrite_a_href_processor => {
+        :skip_keyword => "data-skip-href-to-absolute",
+        :index_page_keyword => "data-to-index-page",
+        :hash_link_class => "hash-internal",
+        :internal_link_class => "a-internal"
+      },
+      :make_search_index_processor => {
+        :skip_keyword => "data-skip-search-index",
+        :search_file_name => "search.json"
+      }
+    }.freeze
+
+    def initialize(config)
+      @config = Util.extract(DEFAULT_PROCESSORS_CONFIG, config)
+    end
+
+    def [] (processor)
+      @config[processor]
+    end
+  end
+
+  class Processor
+    @@priority = {}
+
+    DEFAULT_PRIORITY = {
+      :site_after_init => :lowest,
+      :site_pre_render => :lowest,
+      :site_post_read => :lowest,
+      :page_pre_render => :lowest,
+      :page_post_render => :lowest,
+      :site_post_render => :lowest
+    }.freeze
+
+    PRIORITY_MAP = {
+      :lowest => 0,
+      :low => 10,
+      :normal => 20,
+      :high => 30,
+      :highest => 40,
+    }.freeze
+
+    METHODS = [
+      :site_after_init,
+      :site_post_read,
+      :site_pre_render,
+      :page_pre_render,
+      :page_post_render,
+      :site_post_render
+    ].freeze
+
+    DEFAULT_PROCESSORS = [
+      :make_base_javascript_processor,
+      :make_theme_processor,
+      :make_front_matter_processor,
+      :make_title_processor,
+      :make_date_processor,
+      :make_favicon_processor
+    ].freeze
+
+    SELECTABLE_PROCESSORS = [
+      :make_navigation_processor,
+      :make_empty_content_processor,
+      :make_header_link_processor,
+      :rewrite_img_processor,
+      :rewrite_a_href_processor,
+      :make_search_index_processor,
+      :make_og_tag_processor
+    ].freeze
+
+    ALL_PROCESSORS = [DEFAULT_PROCESSORS, SELECTABLE_PROCESSORS].flatten
+
+    attr_reader :priority
+
+    def initialize(site, theme, config, tags)
+      @site = site
+      @theme = theme
+      @config = config
+      @tags = tags
+      @logger = Logger.new(self)
+      @priority = Util.extract(DEFAULT_PRIORITY, @@priority, false)
+      @@priority = {}
+    end
+
+    def site_after_init(site) end
+
+    def site_pre_render(site) end
+
+    def site_post_read(site) end
+
+    def site_post_render(site) end
+
+    def page_pre_render(page, html, modified) end
+
+    def page_post_render(page, html, modified) end
+
+    def find_priority(method)
+      if @priority[method].is_a?(Numeric)
+        @priority[method]
+      else
+        PRIORITY_MAP[@priority[method]]
+      end
+    end
+
+    def self.priority(event, priority)
+      @@priority[event] = priority
+    end
+
+    def self.load_processors(site, theme, processors, tags, processor_names)
+      active_processor_names = []
+      active_processor_names.concat(DEFAULT_PROCESSORS)
+
+      processor_names.map { |active_processor_name| active_processor_name.to_sym }
+        .select { |active_processor_symbol| SELECTABLE_PROCESSORS.any?(active_processor_symbol) }
+        .each { |active_processor_symbol| active_processor_names << active_processor_symbol }
+
+      active_processor_names.map { |processor_symbol|
+        processor_name = processor_symbol.to_s.gsub("_", "-")
+
+        require_relative "processor/#{processor_name}.rb"
+
+        constants = Jekyll::Potion.constants.select { |c|
+          c.downcase.to_s == processor_name.to_s.gsub(/-/, "").downcase
+        }
+
+        raise SyntaxError, "undefined #{processor_name} class" if constants.empty?
+        raise SyntaxError, "duplicate #{processor_name} class" if constants.size > 1
+
+        Logger.trace(name, "load processor", processor_name)
+
+        Jekyll::Potion.const_get(constants.first).new(site, theme, processors[processor_symbol], tags)
+      }
+    end
+  end
+end

data/lib/jekyll-potion/site.rb

@@ -0,0 +1,155 @@
+# SPDX-FileCopyrightText: Copyright 2022 SK TELECOM CO., LTD.
+# SPDX-License-Identifier: Apache-2.0
+
+module Jekyll::Potion
+  class Url
+    attr_reader :url
+    attr_reader :path
+    attr_reader :name
+
+    def initialize(path)
+      @url = "/#{path}"
+      @path = File.dirname(path)
+      @name = File.basename(path)
+    end
+  end
+
+  class Site
+    DEFAULT_SITE_CONFIG = {
+      :index_page => "",
+      :permalink => "",
+      :title => "",
+      :icon => "",
+      :theme => "proto",
+      :favicon => "",
+      :exclude => []
+    }
+
+    def initialize(potion_base_dir, site, config)
+      @site = site
+      @config = Util.extract(DEFAULT_SITE_CONFIG, config)
+      @config[:potion_base_dir] = potion_base_dir
+      @config[:processor_base_dir] = File.join(potion_base_dir, "processor")
+
+      @navigation = nil
+      @navigation_result = ""
+    end
+
+    def [] (key)
+      @config[key]
+    end
+
+    def empty?(key)
+      not @config.has_key?(key) or @config[key].nil? or @config[key].empty?
+    end
+
+    def baseurl
+      @site.config["baseurl"] ||= ""
+    end
+
+    def url
+      @site.config["url"] ||= ""
+    end
+
+    def absolute_url(base, path, *args)
+      Pathname.new(File.join(base, File.join(path, *args))).cleanpath.to_s
+    end
+
+    def base_absolute_url(path, *args)
+      absolute_url(baseurl, path, *args)
+    end
+
+    def base_url(*args)
+      File.join(baseurl, *args)
+    end
+
+    def to_url(base, path, *args)
+      Url.new(absolute_url(base, path, args))
+    end
+
+    def index_url
+      base_url("")
+    end
+
+    def full_url(*args)
+      File.join(url, base_url(*args))
+    end
+
+    def page_title(page)
+      if empty?(:title)
+        page.data["title"]
+      else
+        "#{@config[:title]} - #{page.data["title"]}"
+      end
+    end
+
+    def static_file(base, dir, name, target)
+      PotionStaticFile.new(@site, base, dir, name, target)
+    end
+
+    def potion_page(base, dir, name, target)
+      PotionPage.new(@site, base, dir, name, target)
+    end
+
+    def page(base, dir, name)
+      Jekyll::Page.new(@site, base, dir, name)
+    end
+
+    def static_to_page(static_page)
+      base = static_page.instance_variable_get("@base")
+      dir = static_page.instance_variable_get("@dir")
+      name = static_page.instance_variable_get("@name")
+
+      page(base, dir, name)
+    end
+
+    def markdown_converter
+      @site.find_converter_instance(Jekyll::Converters::Markdown)
+    end
+
+    def markdown_pages
+      @site.pages.select { |page| markdown_converter.matches(page.extname) }
+    end
+
+    def static_markdown_files
+      @site.static_files.select { |file| markdown_converter.matches(file.extname) }
+    end
+
+    def scss_converter
+      @site.find_converter_instance(Jekyll::Converters::Scss)
+    end
+
+    def scss_convert(body)
+      scss_converter.convert(body)
+    end
+
+    def markdown_convert(body)
+      markdown_converter.convert(body)
+    end
+
+    def replace_scss_ext(file_name)
+      "#{File.basename(file_name, ".*")}#{scss_converter.output_ext(File.extname(file_name))}"
+    end
+
+    def read_file(path)
+      File.read(path)
+    end
+
+    def load_template(path)
+      Liquid::Template.parse(read_file(path))
+    end
+
+    def jsonify(path)
+      JSON.parse(read_file(File.join(@site.source, path)))
+    end
+
+    def navigation(root_potions)
+      @navigation = root_potions
+    end
+
+    def render_navigation(tag)
+      @navigation_result = tag.render_only_one(@navigation) if @navigation_result.empty?
+      @navigation_result
+    end
+  end
+end

data/lib/jekyll-potion/tag.rb

@@ -0,0 +1,176 @@
+# SPDX-FileCopyrightText: Copyright 2022 SK TELECOM CO., LTD.
+# SPDX-License-Identifier: Apache-2.0
+
+module Jekyll::Potion
+  class TagsConfig
+    DEFAULT_TAGS_CONFIG = {
+      :alerts => {
+        :info => "info",
+        :warning => "warning",
+        :danger => "danger",
+        :success => "success"
+      },
+      :code => {
+        :code_class => "code",
+        :success_class => "copy-text",
+        :success_show_class => "show"
+      },
+      :tabs => {
+        :tabs_class => "tabs",
+        :active_class => "active"
+      },
+      :navigation => {
+        :active_class => "active",
+        :fold_class => "fold"
+      }
+    }.freeze
+
+    def initialize(config)
+      @config = Util.extract(DEFAULT_TAGS_CONFIG, config)
+    end
+
+    def [] (tag_name)
+      Util.string_key_hash(@config[tag_name])
+    end
+  end
+
+  module PotionTag
+    TEMPLATE_DELIMITER = "-"
+    ATTRIBUTES_REGEX = /(\S*)="(.*?[^\\])"/
+    POTION_TAG_PARAM_REGEX = /(?:#{TEMPLATE_DELIMITER}(\S*) )?((?:#{ATTRIBUTES_REGEX}\s?)*)/
+    POTION_BLOCK_DELIMITER = "::"
+    POTION_BLOCK_DELIMITER_REPLACE = "="
+
+    attr_accessor :id
+    attr_accessor :template_name
+    attr_accessor :logger
+
+    @@registry = {}
+
+    def initialize(tag_name, markup, options)
+      super
+      @tag_name = tag_name
+      @end_tag_name = "{% end#{tag_name} %}"
+      @options = options
+      @id = id_format
+
+      @template_name = "#{tag_name}"
+      @params = {}
+
+      if markup =~ POTION_TAG_PARAM_REGEX
+        @template_name << "-#{$1}" unless $1.nil?
+        @params = attr_to_hash($2) unless $2.nil?
+      end
+
+      @logger = Logger.new(self)
+
+      if @template_name.include?(POTION_BLOCK_DELIMITER)
+        @template_name.sub!(POTION_BLOCK_DELIMITER, POTION_BLOCK_DELIMITER_REPLACE)
+      end
+    end
+
+    def id_format
+      "#{@tag_name}-#{@options.line_number}"
+    end
+
+    def attr_to_hash(str)
+      str.scan(ATTRIBUTES_REGEX).to_h.map { |k, v| [k.strip, v.strip] }.to_h
+    end
+
+    def ensure_valid_attr(*keys)
+      keys.each { |key|
+        unless @params.has_key?(key)
+          raise SyntaxError, "#{@tag_name} required #{key} attribute"
+        end
+      }
+    end
+  end
+
+  class PotionBlock < Liquid::Block
+    include PotionTag
+
+    attr_accessor :elements
+
+    FULL_TOKEN = /\A\{%\s*(\w+#{PotionTag::POTION_BLOCK_DELIMITER}(\w+))\s*(.*?)%}\z/om
+
+    def initialize(tag_name, markup, options)
+      super
+      @elements = []
+    end
+
+    def parse(tokens)
+      options.line_number = tokens.line_number
+      while (token = tokens.shift)
+        next if token.empty?
+
+        if token == @end_tag_name
+          return
+        end
+
+        if token =~ FULL_TOKEN
+          tag_name = $1
+          markup = $3
+
+          child_tag_class = @@registry[$2]
+
+          unless child_tag_class.nil?
+            @elements << child_tag_class.parse(tag_name, markup, tokens, options)
+          end
+        end
+        @options.line_number = tokens.line_number
+      end
+    end
+
+    def nodelist
+      @elements
+    end
+
+    def blank?
+      @elements.empty?
+    end
+
+    def self.registered_tag(tag_name)
+      return nil unless @@registry.has_key?(tag_name)
+      @@registry[tag_name]
+    end
+
+    def self.register_tag(tag_name, tag_class)
+      @@registry[tag_name] = tag_class
+    end
+  end
+
+  module PotionBlockElement
+    include PotionTag
+
+    MAX_DEPTH = 100
+
+    def block_delimiter
+      "end#{tag_name}"
+    end
+
+    def parse_body(body, tokens)
+      if parse_context.depth >= MAX_DEPTH
+        raise StackLevelError, "Nesting too deep".freeze
+      end
+      parse_context.depth += 1
+      begin
+        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
+          @blank &&= body.blank?
+
+          return false if "#{end_tag_name}#{end_tag_params}".strip == block_delimiter
+          unless end_tag_name
+            raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
+          end
+
+          # this tag is not registered with the system
+          # pass it to the current block for special handling or error reporting
+          unknown_tag(end_tag_name, end_tag_params, tokens)
+        end
+      ensure
+        parse_context.depth -= 1
+      end
+
+      true
+    end
+  end
+end

data/lib/jekyll-potion/tags/alerts.rb

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: Copyright 2022 SK TELECOM CO., LTD.
+# SPDX-License-Identifier: Apache-2.0
+
+module Jekyll::Potion
+  class AlertsTag < Liquid::Block
+    include PotionTag
+
+    def initialize(tag_name, markup, options)
+      super
+      ensure_valid_attr("style")
+    end
+
+    def render(page_context)
+      config = Potion[:tags][:alerts]
+
+      @params["style"] = config[@params["style"]] if config.has_key?(@params["style"])
+      @params["body"] = Potion[:site].markdown_convert(super)
+
+      Potion[:theme].render_template(@template_name, @params)
+    end
+  end
+end
+
+Liquid::Template.register_tag("alerts", Jekyll::Potion::AlertsTag)