ya_multilingual_markdown 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 461ba09dd9d70bb8fdc0c7faf1ec95c34ad28a608eac30cd5c6eb1f7e039e7aa
+  data.tar.gz: 5312109dee3c9600782046f26e72dd73c08bdfbde3e73cba88a7b3d13c8563fe
+SHA512:
+  metadata.gz: a39a6be3c2f75f93b65833d9f9dee104a6c663a80cfc6b7914be62e5456bf70aa75f23c23f1bb946e578595387ba7b199aab4ec3ba9d8b17adbdb9f52b423881
+  data.tar.gz: a55008caa80072df3b578bb075d5667340d936f1f7b3589a51ec3afbd747d6ef026d8561d746efad94fa88bb7e560f9b091ef0cb9cf51a38c6c7032c7ee46bf9

data/bin/ya_multilingual_markdown

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "ya_multilingual_markdown"
+
+YAMultilingualMarkdown::CLI.run

data/lib/ya_multilingual_markdown.rb

@@ -0,0 +1,937 @@
+# frozen_string_literal: true
+
+require "kramdown"
+require "kramdown-parser-gfm"
+require "kramdown-math-katex"
+require "yaml"
+require "uri"
+require "pathname"
+require "logger"
+require "optparse"
+
+module Kramdown
+  module Parser
+    class YaMultilingualMarkdown < ::Kramdown::Parser::GFM
+      module Common
+        ALD_ANY_CHARS = ::Kramdown::Parser::Kramdown::ALD_ANY_CHARS
+        OPT_SPACE = ::Kramdown::Parser::Kramdown::OPT_SPACE
+
+        ML_IAL_BLOCK = %r{\{:(?!:|/)(?<ald>#{ALD_ANY_CHARS}+)\}\s*?\n}
+        ML_IAL_BLOCK_START = /^#{OPT_SPACE}#{ML_IAL_BLOCK}/
+
+        ML_DEFAULT_HEADING_LANG_SEP = " / "
+      end
+
+      module FrontMatter
+        class InvalidInputError < StandardError; end
+
+        ML_FRONT_MATTER = %r{
+          \A---(?:\r\n|\r|\n)
+          (?<contents>.*?)(?:\r\n|\r|\n)
+          ---(?:\r\n|\r|\n)
+          }mx
+
+        private
+
+        def parse_ml_front_matter
+          front_matter = ML_FRONT_MATTER.match(@src.matched) { |m| m[:contents] }
+
+          if (yaml = YAML.load(front_matter))
+            if yaml.is_a? Hash
+              @root.metadata = yaml
+            else
+              raise InvalidInputError, <<~EOS
+                front matter must be Hash, but was \
+                #{yaml.class}: #{yaml.inspect}
+                EOS
+            end
+          end
+
+          @src.current_line_number
+          @src.pos += @src.matched_size
+        end
+
+        ::Kramdown::Parser::Kramdown.define_parser(:ml_front_matter, ML_FRONT_MATTER)
+      end
+
+      module HeadingCommon
+        HEADER_ID = ::Kramdown::Parser::Kramdown::HEADER_ID
+
+        private
+
+        def parse_ml_heading_contents(contents)
+          contents_normalized = contents.rstrip
+          id_match = HEADER_ID.match(contents_normalized)
+          text, id =
+            if id_match
+              id = id_match["id"]
+              contents_without_id = contents_normalized[0...-id_match[0].length].rstrip
+              [contents_without_id, id]
+            else
+              [contents_normalized, nil]
+            end
+          [text, id]
+        end
+
+        def add_ml_heading(level, text)
+          start_line_number = @src.current_line_number
+          @src.pos += @src.matched_size
+
+          heading = new_block_el(
+            :header,
+            nil,
+            nil,
+            level: level,
+            raw_text: text,
+            location: start_line_number,
+          )
+
+          add_text(text, heading)
+
+          @tree.children << heading
+        end
+      end
+
+      module ATXHeading
+        include Common
+        include HeadingCommon
+
+        # NOTE: ALD for each heading must be placed _after_ the
+        # heading. This compromise allows us to write id at the beginning of
+        # headings as well as at the end, with less code.
+
+        ML_CONSECUTIVE_ATX_HEADING = %r{
+          (?<num_signs>\#{1,6})  # Number signs
+          \s
+          (?<contents>[^\r\n]+)  # Contents
+          (?:\r\n|\r|\n)         # EOL
+          #{ML_IAL_BLOCK_START}? # IAL
+          }x
+
+        ML_CONSECUTIVE_ATX_HEADINGS = %r{
+          (?<num_signs>\#{1,6})  # Number signs
+          \s
+          ([^\r\n]+)             # Contents
+          (?:\r\n|\r|\n)         # EOL
+          #{ML_IAL_BLOCK_START}? # IAL
+          (?:
+            (?:\r\n|\r|\n)         # EOL
+            \k<num_signs>          # Number signs
+            \s
+            [^\r\n]+               # Contents
+            (?:\r\n|\r|\n)         # EOL
+            #{ML_IAL_BLOCK_START}? # IAL
+          )+}mx
+
+        private
+
+        def parse_ml_consecutive_atx_headings
+          return false unless after_block_boundary?
+
+          matched_str = @src.matched
+          headings = matched_str.scan(/.+?(?:(?:\r\n|\r|\n){2,}|\z)/m)
+          merged_text = headings.reduce([]) do |merged, heading|
+            ML_CONSECUTIVE_ATX_HEADING.match(heading) do |m|
+              _num_signs = m[:num_signs]
+              contents = m[:contents]
+              ald = m[:ald]
+              text, id = parse_ml_heading_contents(contents)
+
+              attrs = id ? { id: id } : {}
+              parse_attribute_list(ald, attrs) if ald
+
+              new_contents =
+                if attrs.empty?
+                  text
+                else
+                  attrs_str = attrs.map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
+                  "<span #{attrs_str}>#{text}</span>"
+                end
+
+              merged << new_contents
+            end
+          end.join
+
+          return false if merged_text.empty?
+
+          first_num_signs = ML_CONSECUTIVE_ATX_HEADINGS.match(matched_str) { |m| m[:num_signs] }
+          level = first_num_signs.size
+          add_ml_heading(level, merged_text)
+        end
+
+        ::Kramdown::Parser::Kramdown.define_parser(:ml_consecutive_atx_headings, ML_CONSECUTIVE_ATX_HEADINGS)
+      end
+
+      module SetextHeading
+        include Common
+        include HeadingCommon
+
+        # NOTE: ALD for each heading must be placed _after_ the
+        # heading. This compromise allows us to write id at the beginning of
+        # headings as well as at the end, with less code.
+
+        ML_CONSECUTIVE_SETEXT_HEADING = %r{
+          (?<contents>[^\r\n]+?) # Contents
+          (?:\r\n|\r|\n)         # EOL
+          (?<underline>[-=]+)    # Underline
+          (?:\r\n|\r|\n)         # EOL
+          #{ML_IAL_BLOCK_START}? # IAL
+          }x
+
+        ML_CONSECUTIVE_SETEXT_HEADINGS = %r{
+          [^\r\n]+?              # Contents
+          (?:\r\n|\r|\n)         # EOL
+          (?<underline>[-=]+)    # Underline
+          (?:\r\n|\r|\n)         # EOL
+          #{ML_IAL_BLOCK_START}? # IAL
+          (?:
+            (?:\r\n|\r|\n)+        # EOL (Blank line)
+            [^\r\n]+?              # Contents
+            (?:\r\n|\r|\n)         # EOL
+            \k<underline>          # Underline
+            (?:\r\n|\r|\n)         # EOL
+            #{ML_IAL_BLOCK_START}? # IAL
+          )+}mx
+
+        private
+
+        def parse_ml_consecutive_setext_headings
+          return false unless after_block_boundary?
+
+          matched_str = @src.matched
+          headings = matched_str.scan(/.+?(?:(?:\r\n|\r|\n){2,}|\z)/m)
+          lang_sep = @options[:ml_heading_lang_sep] || ML_DEFAULT_HEADING_LANG_SEP
+          merged_text = headings.reduce([]) do |merged, heading|
+            ML_CONSECUTIVE_SETEXT_HEADING.match(heading) do |m|
+              contents = m[:contents]
+              _underline = m[:underline]
+              ald = m[:ald]
+              text, id = parse_ml_heading_contents(contents)
+
+              attrs = id ? { id: id } : {}
+              parse_attribute_list(ald, attrs) if ald
+
+              new_contents =
+                if attrs.empty?
+                  text
+                else
+                  attrs_str = attrs.map { |k, v| "#{k}=\"#{v}\"" }.join(" ")
+                  "<span #{attrs_str}>#{text}</span>"
+                end
+
+              merged << new_contents
+            end
+          end.join(lang_sep)
+
+          return false if merged_text.empty?
+
+          first_underline = ML_CONSECUTIVE_SETEXT_HEADINGS.match(matched_str) { |m| m[:underline] }
+          level =
+            case first_underline.chars.first
+            when "=" then 1
+            when "-" then 2
+            else          raise "Invalid setext headings: #{matched_str.inspect}"
+            end
+
+          add_ml_heading(level, merged_text)
+        end
+
+        ::Kramdown::Parser::Kramdown.define_parser(:ml_consecutive_setext_headings, ML_CONSECUTIVE_SETEXT_HEADINGS)
+      end
+
+      module EmphasisForNonASCIILanguages
+        EMPHASIS_START = ::Kramdown::Parser::Kramdown::EMPHASIS_START
+
+        # NOTE: This method is a derivation from kramdown's
+        # `parse_emphasis`, slightly modified so that emphasis using
+        # underbar (`_`) works for non-ASCII languages such as Japanese.
+        #
+        # Change(s):
+        #   * `[[:alpha;]]` and `[[:alnum:]]` are replaced with `[\w]`
+        #
+        # Original: https://github.com/gettalong/kramdown/blob/fc051a9d93e4dc3ff05bf41b70a79297ebdb669f/lib/kramdown/parser/kramdown/emphasis.rb#L17
+        def parse_ml_emphasis
+          start_line_number = @src.current_line_number
+          saved_pos = @src.save_pos
+
+          result = @src.scan(EMPHASIS_START)
+          element = (result.length == 2 ? :strong : :em)
+          type = result[0..0]
+
+          if (type == '_' && @src.pre_match =~ /[\w]-?[\w]*_*\z/) || @src.check(/\s/) ||
+             @tree.type == element || @stack.any? {|el, _| el.type == element }
+            add_text(result)
+            return
+          end
+
+          warnings_pos = @warnings.size
+          sub_parse = lambda do |delim, elem|
+            el = Element.new(elem, nil, nil, location: start_line_number)
+            stop_re = /#{Regexp.escape(delim)}/
+            found = parse_spans(el, stop_re) do
+              (@src.pre_match[-1, 1] !~ /\s/) &&
+                (elem != :em || !@src.match?(/#{Regexp.escape(delim * 2)}(?!#{Regexp.escape(delim)})/)) &&
+                (type != '_' || !@src.match?(/#{Regexp.escape(delim)}[\w]/)) && !el.children.empty?
+            end
+            [found, el, stop_re]
+          end
+
+          found, el, stop_re = sub_parse.call(result, element)
+          if !found && element == :strong && @tree.type != :em
+            @src.revert_pos(saved_pos)
+            @src.pos += 1
+            found, el, stop_re = sub_parse.call(type, :em)
+          end
+          if found
+            # Useful for implementing underlines.
+            el.options[:char] = type
+
+            @src.scan(stop_re)
+            @tree.children << el
+          else
+            @warnings.slice!(0...warnings_pos)
+            @src.revert_pos(saved_pos)
+            @src.pos += result.length
+            add_text(result)
+          end
+        end
+
+        ::Kramdown::Parser::Kramdown.define_parser(:ml_emphasis, EMPHASIS_START, '\*|_')
+      end
+
+      include FrontMatter
+      include ATXHeading
+      include SetextHeading
+      include EmphasisForNonASCIILanguages
+
+      module HasMetadata
+        attr_accessor :metadata
+      end
+
+      private
+
+      def initialize(source, options)
+        super
+        @block_parsers.unshift(:ml_front_matter)
+        @block_parsers.unshift(:ml_consecutive_atx_headings)
+        @block_parsers.unshift(:ml_consecutive_setext_headings)
+        @span_parsers.unshift(:ml_emphasis)
+        @root.extend(HasMetadata)
+      end
+    end
+  end
+
+  module Converter
+    class YaMultilingualHtml < ::Kramdown::Converter::Html
+      module Metadata
+        module Utils
+          include ::Kramdown::Utils::Html
+          module_function :escape_html
+        end
+
+        private
+
+        def title_element(value)
+          case value
+          in String
+            "<title>#{Utils.escape_html(value, :text)}</title>"
+          else
+            raise "title must be String but was #{value.inspect}"
+          end
+        end
+
+        def meta_elements(value)
+          case value
+          in Array if value.all?(Hash) &&
+            value.map(&:keys).flatten.all?(String) &&
+            value.map(&:values).flatten.all?(String)
+            value.map do |item|
+              attributes = item.map do |k, v|
+                "#{k}=\"#{Utils.escape_html(v, :attribute)}\""
+              end.join(" ")
+              "<meta #{attributes} />"
+            end
+          else
+            raise <<~EOS.chomp
+              meta value must be Array(Hash(String, String)) \
+              but was #{value.inspect}
+            EOS
+          end
+        end
+
+        def link_elements(value)
+          case value
+          in Array if value.all?(Hash)
+            value.map do |item|
+              attributes = item.map do |k, v|
+                case [k, v]
+                in String, String
+                  "#{k}=\"#{Utils.escape_html(v, :attribute)}\""
+                in String, NilClass
+                  k
+                else
+                  raise <<~EOS.chomp
+                    link value must be Array(Hash(String, String|NilClass)) \
+                    but was #{value.inspect}
+                  EOS
+                end
+              end.compact.join(" ")
+              "<link #{attributes} />"
+            end
+          else
+            raise <<~EOS.chomp
+              link value must be Array(Hash(String, String|NilClass)) \
+              but was #{value.inspect}
+            EOS
+          end
+        end
+
+        def script_elements(value)
+          case value
+          in String
+            ["<script>#{Utils.escape_html(value, :text)}</script>"]
+          in Array if value.all?(Hash)
+            value.map do |item|
+              attributes = item.map do |k, v|
+                case [k, v]
+                in String, String
+                  "#{k}=\"#{Utils.escape_html(v, :attribute)}\""
+                in String, NilClass
+                  k
+                in NilClass, String
+                  nil
+                else
+                  raise <<~EOS.chomp
+                    script value must be String or Array of Hash with \
+                    Null to String entry but was #{value.inspect}
+                  EOS
+                end
+              end.compact.join(" ")
+              if item[nil]
+                escaped = Utils.escape_html(item[nil], :text)
+                "<script #{attributes}>#{escaped}</script>"
+              else
+                "<script #{attributes} />"
+              end
+            end
+          else
+            raise <<~EOS.chomp
+              script value must be String or Array of Hash with \
+              Null to String entry but was #{value.inspect}
+            EOS
+          end
+        end
+
+        def guessed_meta_elements(key, value)
+          case value
+          in String
+            escaped = Utils.escape_html(value, :attribute)
+            ["<meta name=\"#{key}\" content=\"#{escaped}\" />"]
+          in Array if value.all?(String)
+            value.map do |item|
+              escaped = Utils.escape_html(item, :attribute)
+              "<meta name=\"#{key}\" content=\"#{escaped}\" />"
+            end
+          else
+            raise <<~EOS.chomp
+              meta value must be String | Array(Hash(String, String)) \
+              but was #{value.inspect}
+            EOS
+          end
+        end
+
+        public
+
+        def to_html_elements(metadata: self)
+          return if metadata.nil? || metadata.empty?
+
+          metadata.reduce([]) do |elements, key_value|
+            key, value = key_value
+            case key
+            in "title"  then elements << title_element(value)
+            in "meta"   then elements + meta_elements(value)
+            in "link"   then elements + link_elements(value)
+            in "script" then elements + script_elements(value)
+            in String   then elements + guessed_meta_elements(key, value)
+            else raise "front matter key must be String"
+            end
+          end
+        end
+      end
+
+      module RewriteLinkSuffixes
+        def edit_url_path_suffix(url_str,
+          suffixes = @options[:ml_link_suffixes] || {},
+          rewrite_relative_only = true)
+          uri = URI(url_str)
+          if uri.path &&
+              (path = Pathname.new(uri.path)) &&
+              (rewrite_relative_only ? path.relative? : true) &&
+              suffixes.keys.include?(path.extname)
+            edited_path = path.sub_ext(suffixes[path.extname])
+            new_uri = uri.dup
+            new_uri.path.replace(edited_path.to_s)
+            new_uri
+          end
+        end
+
+        def convert_a(el, indent)
+          if (href = el.attr["href"]) &&
+              (edited_href = edit_url_path_suffix(href))
+            el.attr["href"] = edited_href
+          end
+          super
+        end
+      end
+
+      module LangSelectorCommon
+        def has_lang_to_remove?(el,
+          langs: @options[:ml_langs],
+          lang_attr_name: @options[:ml_lang_attr_name])
+          if @stack.any? { |ancestor| ancestor.attr[lang_attr_name] }
+            # keep descendants of elements with language attribute, because
+            # the decision has already been made
+            false
+          else
+            # remove subtree with unwanted language attribute
+            (a = el.attr) && (l = a[lang_attr_name]) &&
+              langs && !langs.include?(l)
+          end
+        end
+      end
+
+      module ElementsToBeLangSelected
+        include LangSelectorCommon
+
+        def convert(el, indent = -@indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def inner(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_blank(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_text(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_p(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_standalone_image(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_codeblock(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_blockquote(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_header(el, indent)
+          lang_sep = @options[:ml_heading_lang_sep] || ML_DEFAULT_HEADING_LANG_SEP
+          lang_attr_name = @options[:ml_lang_attr_name]
+          if has_lang_to_remove?(el)
+            ""
+          elsif el.children&.all? do |c|
+                  c.type == :html_element &&
+                      c.value == "span" &&
+                      c.attr &&
+                      c.attr[lang_attr_name]
+                end
+
+            # check redundant lang values
+            children_by_lang =
+              el.children.reduce({}){|tally, child|
+                lang = child.attr && child.attr[lang_attr_name]
+                if lang
+                  tally[lang] ||= []
+                  tally[lang] << child
+                end
+                tally
+              }
+            children_by_lang.each{|lang, elements|
+              if elements.size > 1
+                @options[:ml_logger].warn <<~EOS.chomp
+                  lang="#{lang}" appears more than once in a single sequence \
+                  of multilingual headings: #{elements.map{|e| convert(e)}}
+                EOS
+              end
+            }
+
+            el.children = el.children.each_with_object([]) do |e, acc|
+              if has_lang_to_remove?(e)
+                acc
+              elsif acc.empty? && !has_lang_to_remove?(e)
+                acc << e
+              else
+                acc << Element.new(:text, lang_sep) << e
+              end
+            end
+            super
+          else
+            super
+          end
+        end
+
+        def convert_hr(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_ul(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_dl(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_li(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_dt(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_html_element(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_xml_comment(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_table(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_td(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_comment(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_br(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_a(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_img(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_codespan(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_footnote(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_raw(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_em(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_entity(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_typographic_sym(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_smart_quote(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_math(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_abbreviation(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+
+        def convert_root(el, indent)
+          has_lang_to_remove?(el) ? "" : super
+        end
+      end
+
+      module UseMetadata
+        def initialize(root, options)
+          super
+
+          root.metadata&.extend(Metadata)
+        end
+      end
+
+      include RewriteLinkSuffixes
+      include ElementsToBeLangSelected
+      include UseMetadata
+    end
+  end
+end
+
+module YAMultilingualMarkdown
+  VERSION = "0.0.2"
+  LOG_LEVEL = {
+    unknown: Logger::UNKNOWN,
+    fatal:   Logger::FATAL,
+    error:   Logger::ERROR,
+    warn:    Logger::WARN,
+    info:    Logger::INFO,
+    debug:   Logger::DEBUG,
+  }
+
+  class Document
+    DEFAULT_OPTIONS = {
+      langs: nil,
+      lang_attr_name: "lang",
+      heading_lang_sep: " / ",
+      output_type: :auto,
+      template: nil,
+      link_suffixes: {".md" => ".html"},
+      log_level: LOG_LEVEL[:warn],
+    }
+    DEFAULT_KRAMDOWN_OPTIONS = {
+      auto_ids: false,
+      smart_quotes: ["apos", "apos", "quot", "quot"],
+      typographic_symbols: {
+        hellip: "...",
+        mdash: "---",
+        ndash: "--",
+        laquo: "<<",
+        raquo: ">>",
+        laquo_space: "<< ",
+        raquo_space: " >>",
+      },
+      input: "YaMultilingualMarkdown",
+      math_engine: "katex",
+      syntax_highlighter: "rouge",
+      syntax_highlighter_opts: {},
+    }
+    # we want to keep "\n" as-is for --show-default-template
+    DEFAULT_TEMPLATE = '
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <%=
+            if metadata = @converter.root.metadata
+              elements = metadata.to_html_elements
+              elements.unshift("<title></title>") if not(metadata["title"])
+              elements.join("\n")
+            else
+              "<title></title>"
+            end
+           %>
+        </head>
+        <body>
+          <%= @body.chomp %>
+        </body>
+      </html>
+      '.gsub(/^ {6}/, "").strip + "\n"
+
+    module Utils
+      include ::Kramdown::Utils::Html
+      module_function :escape_html
+    end
+
+    class Error < StandardError; end
+
+    def initialize(source, options: nil, kramdown_options: nil)
+      @source = source
+
+      options ||= DEFAULT_OPTIONS.dup
+      kramdown_options ||= DEFAULT_KRAMDOWN_OPTIONS.dup
+
+      if options && (langs = options[:langs])
+        kramdown_options[:ml_langs] = langs
+      end
+
+      if options && (lang_attr_name = options[:lang_attr_name])
+        kramdown_options[:ml_lang_attr_name] = lang_attr_name
+      end
+
+      if options && (sep = options[:heading_lang_sep])
+        kramdown_options[:ml_heading_lang_sep] = sep
+      end
+
+      if options && (link_suffixes = options[:link_suffixes])
+        kramdown_options[:ml_link_suffixes] = link_suffixes
+      end
+
+      if options && (template = options[:template])
+        kramdown_options[:template] = "string://#{template}"
+      end
+
+      if options && (log_level = options[:log_level])
+        kramdown_options[:ml_logger] = Logger.new($stderr, level: log_level)
+      end
+
+      @options = options
+      @kramdown_options = kramdown_options
+    end
+
+    private
+
+    def to_html_fragment
+      doc = Kramdown::Document.new(@source, @kramdown_options)
+      # we have to call Kramdown::Document#to_ya_multilingual_html first, so
+      # that YaMultilingualHtml is instantiated, its @root.metadata is
+      # extended with Metadata, thus #to_html_elements becomes callable
+      body = doc.to_ya_multilingual_html
+      if (metadata = doc.root.metadata)
+        head_contents = metadata.to_html_elements
+        head_contents.join("\n") + "\n" + body
+      else
+        body
+      end
+    end
+
+    def to_html_document
+      kramdown_options =
+        if @options[:template]
+          @kramdown_options
+        else
+          default_template = Document::DEFAULT_TEMPLATE.dup
+          @kramdown_options.merge({ template: "string://#{default_template}" })
+        end
+      doc = Kramdown::Document.new(@source, kramdown_options)
+      doc.to_ya_multilingual_html
+    end
+
+    public
+
+    def to_html
+      case @options[:output_type]
+      when :auto
+        doc = Kramdown::Document.new(@source, @kramdown_options)
+        if doc.root.metadata
+          to_html_document
+        else
+          to_html_fragment
+        end
+      when :fragment
+        to_html_fragment
+      when :document
+        to_html_document
+      else
+        raise Error, <<~EOS
+          output_type must be :auto, :fragment or :document but was \
+          #{@options[:output_type].inspect}
+        EOS
+      end
+    end
+  end
+
+  module CLI
+    DEFAULT_OPTIONS = {
+      show_default_template: nil,
+      help: nil,
+      version: nil,
+    }
+
+    class Error < StandardError
+    end
+
+    class << self
+      def run
+        options = Document::DEFAULT_OPTIONS.merge(DEFAULT_OPTIONS)
+
+        option_parser = OptionParser.new do |o|
+          o.banner = <<~EOS
+            Convert Yet Another Multilingual Markdown to HTML
+
+            Usage:
+              #{o.program_name} [OPTIONS] [FILE]
+
+            Options:
+          EOS
+          o.on("--langs=LANG1,LANG2,...", String, <<~EOS.chomp) do |s|
+            Languages to be included in the output \
+            (default: #{options[:langs].to_s.inspect}; empty implies all)
+          EOS
+            options[:langs] = s.split(",")
+          end
+          o.on("--lang-attr-name=STRING", String, <<~EOS.chomp) do |s|
+            Attribute name for language (default: #{options[:lang_attr_name].inspect})
+          EOS
+            options[:lang_attr_name] = s
+          end
+          o.on("--heading-lang-sep=STRING", String, <<~EOS.chomp) do |s|
+            Languages separator in headings (default: #{options[:heading_lang_sep].inspect})
+          EOS
+            options[:heading_lang_sep] = s
+          end
+          o.on("--output-type=auto|fragment|document", [:auto, :fragment, :document], <<~EOS.chomp) do |s|
+            Output type (default: #{options[:output_type].to_s.inspect})
+          EOS
+            options[:output_type] = s.intern
+          end
+          o.on("--template-file=FILE", String, <<~EOS.chomp) do |s|
+            Document template file in eRuby format to embed contents
+          EOS
+            options[:template] =
+              case
+              when !File.exist?(s)
+                raise Error, "template file does not exist: #{s.inspect}"
+              when !File.readable?(s)
+                raise Error, "template file not readable: #{s.inspect}"
+              else
+                File.read(s)
+              end
+          end
+          o.on("--link-suffixes=FROM:TO,...", String, <<~EOS.chomp) do |s|
+            Link suffixes to rewrite (default: #{options[:link_suffixes]&.
+            map { |from, to| "#{from}:#{to}" }&.join(",").to_s.inspect})
+          EOS
+            options[:link_suffixes] = s.split(",").map { |pair| pair.split(":") }.to_h
+          end
+          o.on("--show-default-template", "Show default document template") {
+            options[:show_default_template] = true
+          }
+          o.on("--log-level=#{LOG_LEVEL.keys.join("|")}", LOG_LEVEL.keys, "Log level (default: warn)") do |s|
+            options[:log_level] = LOG_LEVEL[s.intern]
+          end
+          o.on("--help", "Show help message") { options[:help] = true }
+          o.on("--version", "Show version number") { options[:version] = true }
+        end
+        option_parser.parse!
+
+        case
+        when options[:show_default_template]
+          puts Document::DEFAULT_TEMPLATE
+        when options[:help]
+          puts option_parser
+        when options[:version]
+          v = ::YAMultilingualMarkdown::VERSION
+          $stdout.tty? ? puts(v) : print(v)
+        else
+          doc = Document.new(ARGF.set_encoding("UTF-8").read, options: options)
+          print(doc.to_html)
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  YAMultilingualMarkdown::CLI.run
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: ya_multilingual_markdown
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Hisashi Morita
+bindir: bin
+cert_chain: []
+date: 2025-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: kramdown-parser-gfm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: kramdown-math-katex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+executables:
+- ya_multilingual_markdown
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ya_multilingual_markdown
+- lib/ya_multilingual_markdown.rb
+homepage: https://github.com/hisashim/ya_multilingual_markdown
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Yet Another Multilingual Markdown processor
+test_files: []