coradoc-html 1.1.7

data/lib/coradoc/html/input/plugin.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      class Plugin
+        #### Plugin system general
+
+        # Allow building plugins with a shorthand syntax:
+        # plugin = Coradoc::Html::Input::Plugin.new do
+        #   def name = "Test"
+        # end
+
+        def self.new(&block)
+          if self == Plugin
+            Class.new(Plugin, &block)
+          else
+            super
+          end
+        end
+
+        def initialize
+          @html_tree_hooks_pre = {}
+          @html_tree_hooks_post = {}
+        end
+
+        # define name to name a Plugin
+        def name
+          self.class.name
+        end
+
+        #### HTML Tree functionalities
+
+        attr_accessor :html_tree, :coremodel_tree, :output_string
+
+        # Legacy accessors for backward compatibility
+        # @deprecated Use coremodel_tree instead. Will be removed in v2.0.
+        def coradoc_tree
+          warn '[DEPRECATION] `coradoc_tree` is deprecated. Use `coremodel_tree` instead.'
+          coremodel_tree
+        end
+
+        def coradoc_tree=(value)
+          warn '[DEPRECATION] `coradoc_tree=` is deprecated. Use `coremodel_tree=` instead.'
+          self.coremodel_tree = value
+        end
+
+        # @deprecated Use output_string instead. Will be removed in v2.0.
+        def asciidoc_string
+          warn '[DEPRECATION] `asciidoc_string` is deprecated. Use `output_string` instead.'
+          output_string
+        end
+
+        def asciidoc_string=(value)
+          warn '[DEPRECATION] `asciidoc_string=` is deprecated. Use `output_string=` instead.'
+          self.output_string = value
+        end
+
+        def html_tree_change_tag_name_by_css(css, new_name)
+          html_tree.css(css).each do |e|
+            e.name = new_name
+          end
+        end
+
+        def html_tree_change_properties_by_css(css, properties)
+          html_tree.css(css).each do |e|
+            properties.each do |k, v|
+              e[k.to_s] = v
+            end
+          end
+        end
+
+        def html_tree_remove_by_css(css)
+          html_tree.css(css).each(&:remove)
+        end
+
+        def html_tree_replace_with_children_by_css(css)
+          html_tree.css(css).each do |e|
+            e.replace(e.children)
+          end
+        end
+
+        def html_tree_process_to_coremodel(tree, state = {})
+          Coradoc::Html::Input::Converters.process_coradoc(tree, state)
+        end
+
+        # @deprecated Use html_tree_process_to_coremodel instead. Will be removed in v2.0.
+        def html_tree_process_to_coradoc(tree, state = {})
+          warn '[DEPRECATION] `html_tree_process_to_coradoc` is deprecated. Use `html_tree_process_to_coremodel` instead.'
+          html_tree_process_to_coremodel(tree, state)
+        end
+
+        def html_tree_preview
+          Tempfile.open(%w[coradoc .html]) do |i|
+            i << html_tree.to_html
+            system 'chromium-browser', '--no-sandbox', i.path
+          end
+        end
+
+        # define preprocess_html_tree to process HTML trees
+
+        # Creates a hook to be called instead of converting an element
+        # to a CoreModel node.
+        #
+        # proc |html_node, state|
+        #   coremodel_node
+        # end
+        def html_tree_add_hook_pre(element, &block)
+          @html_tree_hooks_pre[element] = block
+        end
+
+        def html_tree_add_hook_pre_by_css(css, &block)
+          html_tree.css(css).each do |e|
+            html_tree_add_hook_pre(e, &block)
+          end
+        end
+
+        # Creates a hook to be called after converting an element
+        # to a CoreModel node.
+        #
+        # proc |html_node, coremodel_node, state|
+        #   coremodel_node
+        # end
+        def html_tree_add_hook_post(element, &block)
+          @html_tree_hooks_post[element] = block
+        end
+
+        def html_tree_add_hook_post_by_css(css, &block)
+          html_tree.css(css).each do |e|
+            html_tree_add_hook_post(e, &block)
+          end
+        end
+
+        def html_tree_run_hooks(node, state, &_block)
+          hook_pre = @html_tree_hooks_pre[node]
+          hook_post = @html_tree_hooks_post[node]
+
+          coremodel = hook_pre.call(node, state) if hook_pre
+          coremodel ||= yield node, state
+
+          coremodel = hook_post.call(node, coremodel, state) if hook_post
+
+          coremodel
+        end
+
+        #### CoreModel tree functionalities
+
+        # define postprocess_coremodel_tree to change CoreModel tree
+
+        # @deprecated Use postprocess_coremodel_tree instead. Will be removed in v2.0.
+        def postprocess_coradoc_tree
+          warn '[DEPRECATION] `postprocess_coradoc_tree` is deprecated. Use `postprocess_coremodel_tree` instead.'
+          postprocess_coremodel_tree if public_methods.include?(:postprocess_coremodel_tree)
+        end
+
+        #### Output string functionalities
+
+        # define postprocess_output_string to change the output string
+        # (regardless of target format)
+
+        # @deprecated Use postprocess_output_string instead. Will be removed in v2.0.
+        def postprocess_asciidoc_string
+          warn '[DEPRECATION] `postprocess_asciidoc_string` is deprecated. Use `postprocess_output_string` instead.'
+          postprocess_output_string if public_methods.include?(:postprocess_output_string)
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/plugins/plateau.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      class Plugin
+        # This plugin enhances documents from the PLATEAU project
+        # to extract more data.
+        #
+        # Usage:
+        # coradoc convert -rcoradoc/input/html/plugins/plateau
+        #   --external-images -u raise --output _out/index.adoc index.html
+        class Plateau < Plugin
+          def name
+            'PLATEAU'
+          end
+
+          def preprocess_html_tree
+            # Let's simplify the tree by removing what's extraneous
+            # html_tree_remove_by_css("script, style, img.container_imagebox:not([src])")
+            # html_tree_replace_with_children_by_css("div.container_box")
+            # html_tree_replace_with_children_by_css("div.col.col-12")
+            # html_tree_replace_with_children_by_css(".tabledatatext, .tabledatatextY")
+            # html_tree_replace_with_children_by_css("div.row")
+            #
+            # We can remove that, but it messes up the images and paragraphs.
+
+            # Remove side menu, so we can generate TOC ourselves
+            html_tree_remove_by_css('.sideMenu')
+
+            # Correct non-semantic classes into semantic HTML tags
+            html_tree_change_tag_name_by_css('.titledata', 'h1')
+            html_tree_change_tag_name_by_css('.subtitledata', 'h2')
+            html_tree_change_tag_name_by_css('.pitemdata', 'h3')
+            html_tree_change_tag_name_by_css('.sitemdata', 'h4')
+            html_tree_change_tag_name_by_css('td[bgcolor="#D0CECE"]', 'th')
+            html_tree_change_tag_name_by_css('td[bgcolor="#d0cece"]', 'th')
+            html_tree_change_tag_name_by_css(
+              '.framedata, .frame_container_box',
+              'aside'
+            )
+            html_tree_change_tag_name_by_css('.frame2data', 'pre')
+            # Assumption that all code snippets in those documents are XML...
+            html_tree_change_properties_by_css(
+              '.frame2data',
+              class: 'brush:xml;'
+            )
+
+            # Remove some CSS ids that are not important to us
+            html_tree_change_properties_by_css('#__nuxt', id: nil)
+            html_tree_change_properties_by_css('#__layout', id: nil)
+            html_tree_change_properties_by_css('#app', id: nil)
+
+            # Handle lists of document 02
+            html_tree_replace_with_children_by_css('.list_num-wrap')
+
+            # Convert table/img caption to become a caption
+            html_tree.css('.imagedata').each do |e|
+              table = e.parent.next&.children&.first
+              if table&.name == 'table'
+                e.name = 'caption'
+                table.prepend_child(e)
+                next
+              end
+
+              img = e.parent.previous&.children&.first
+              next unless img&.name == 'img' && img['src']
+
+              title = e.text.strip
+              img['title'] = title
+              e.remove
+              next
+            end
+
+            # Add hooks for H1, H2, H3, H4
+            html_tree_add_hook_post_by_css(
+              'h1, h2, h3',
+              &method(:handle_headers)
+            )
+            html_tree_add_hook_post_by_css('h4', &method(:handle_headers_h4))
+
+            # Table cells aligned to center
+            html_tree_change_properties_by_css(
+              '.tableTopCenter',
+              align: 'center'
+            )
+
+            # Handle non-semantic lists and indentation
+            html_tree_add_hook_pre_by_css '.text2data' do |node,|
+              text = html_tree_process_to_adoc(node).strip
+              next '' if text.empty? || text == "\u3000"
+
+              if text.start_with?(/\d+\./)
+                text = text.sub(/\A\d+.\s*/, '')
+                ".. #{text}\n"
+              else
+                text = text.gsub(/^/, '** ')
+                "\n\n//-PT2D\n#{text}\n//-ENDPT2D\n\n"
+              end
+            end
+
+            (3..4).each do |i|
+              html_tree_add_hook_pre_by_css ".text#{i}data" do |node,|
+                text = html_tree_process_to_adoc(node).strip
+                next '' if text.empty? || text == "\u3000"
+
+                text = text.strip.gsub(/^/, "#{'*' * i} ")
+                "\n\n//-PT#{i}D\n#{text}\n//-ENDPT#{i}D\n\n"
+              end
+            end
+
+            (2..3).each do |i|
+              html_tree_add_hook_pre_by_css ".text#{i}data_point ul" do |node,|
+                text = html_tree_process_to_adoc(node.children.first.children).strip
+
+                "#{'*' * i} #{text}\n"
+              end
+            end
+
+            (1..20).each do |i|
+              html_tree_add_hook_pre_by_css ".numtextdata_num .list_num#{i}" do |node,|
+                text = html_tree_process_to_adoc(node).strip
+
+                "[start=#{i}]\n. #{text}\n"
+              end
+            end
+
+            # html_tree_preview
+          end
+
+          IM = /[A-Z0-9]{1,3}/
+
+          def handle_headers(node, coradoc, _state)
+            content = coradoc.content.map(&:content).join
+
+            if %w[toc0 toc_0].any? { |i| coradoc.id&.start_with?(i) }
+              # Special content
+              case content.strip
+              when 'はじめに' # Introduction
+                coradoc.style = 'abstract' # The older version document has ".preface"
+                coradoc.level_int = 1
+              when '改定の概要' # Revision overview
+                coradoc.style = 'abstract' # The older version document has ".preface"
+                coradoc.level_int = 1
+              when '参考文献' # Bibliography
+                coradoc.style = 'bibliography'
+                coradoc.level_int = 1
+              when '改訂履歴' # Document history
+                coradoc.style = 'appendix'
+                coradoc.level_int = 1
+              when '0　概要' # Overview
+                coradoc.style = 'abstract' # I'm not sure this is correct
+                coradoc.level_int = 1
+              when '索引' # Index
+                coradoc.style = 'index' # I'm not sure this is correct
+                coradoc.level_int = 1
+              else
+                warn "Unknown section #{content.inspect}"
+              end
+            end
+
+            if node.name == 'h1' && content.start_with?('Annex')
+              coradoc.style = 'appendix'
+              coradoc.content.first.content.sub!(/\AAnnex [A-Z]/, '')
+            end
+
+            # Remove numbers
+            coradoc.content.first.content.sub!(
+              /\A(#{IM}\.)*#{IM}[[:space:]]/o,
+              ''
+            )
+
+            coradoc
+          end
+
+          def handle_headers_h4(_node, coradoc, _state)
+            title = Coradoc.strip_unicode(coradoc.content.first.content)
+            case title
+            when /\A\(\d+\)(.*)/
+              coradoc.level_int = 4
+              coradoc.content.first.content = ::Regexp.last_match(1).strip
+              coradoc
+            when /\A\d+\)(.*)/
+              coradoc.level_int = 5
+              coradoc.content.first.content = ::Regexp.last_match(1).strip
+              coradoc
+            when /\A#{IM}\.#{IM}\.#{IM}\.#{IM}(.*)/o
+              coradoc.level_int = 4
+              coradoc.content.first.content = ::Regexp.last_match(1).strip
+            else
+              if title.empty?
+                # Strip instances of faulty empty paragraphs
+                nil
+              else
+                ["// Unhandled h4 content\n", coradoc]
+              end
+            end
+          end
+
+          def postprocess_output_string
+            str = output_string
+
+            ### Custom indentation handling
+            # If there's a step up, add [none]
+            str = str.gsub(%r{\s+//-ENDPT2D\s+//-PT3D\s+}, "\n[none]\n")
+            str = str.gsub(%r{\s+//-ENDPT2D\s+//-PT4D\s+}, "\n[none]\n")
+            str = str.gsub(%r{\s+//-ENDPT3D\s+//-PT4D\s+}, "\n[none]\n")
+            # Collapse blocks of text[2,3]data
+            str = str.gsub(%r{\s+//-ENDPT[234]D\s+//-PT[234]D\s+}, "\n\n")
+            # In the beginning, add [none]
+            str = str.gsub(%r{\s+//-PT[234]D\s+}, "\n\n[none]\n")
+            # If following with another list, ensure we readd styling
+            str = str.gsub(%r{\s+//-ENDPT[234]D\s+\*}, "\n\n[disc]\n*")
+            # Otherwise, clean up
+            str = str.gsub(%r{\s+//-ENDPT[234]D\s+}, "\n\n")
+
+            self.output_string = str
+          end
+
+          # Legacy alias for backward compatibility
+          # @deprecated Use postprocess_output_string instead. Will be removed in v2.0.
+          alias postprocess_asciidoc_string postprocess_output_string
+        end
+      end
+    end
+  end
+end
+
+Coradoc::Input::Html.config.plugins << Coradoc::Input::Html::Plugin::Plateau

data/lib/coradoc/html/input/postprocessor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      # Postprocessor's aim is to convert a Coradoc tree from
+      # a mess that has been created from HTML into a tree that
+      # is compatible with what we would get out of Coradoc, if
+      # it parsed it directly.
+      #
+      # Now operates on CoreModel types exclusively.
+      class Postprocessor
+        def self.process(coradoc)
+          new(coradoc).process
+        end
+
+        def initialize(coradoc)
+          @tree = coradoc
+        end
+
+        # Main processing entry point
+        def process
+          # For now, just return the tree as-is since CoreModel
+          # structure is already clean and well-formed.
+          # Future: implement CoreModel-based postprocessing
+          @tree
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/input.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'nokogiri'
+require 'coradoc/input'
+
+module Coradoc
+  module Input
+    module Html
+      # Autoload all components
+      autoload :Errors, 'coradoc/html/input/errors'
+      autoload :Cleaner, 'coradoc/html/input/cleaner'
+      autoload :Config, 'coradoc/html/input/config'
+      autoload :Plugin, 'coradoc/html/input/plugin'
+      autoload :Postprocessor, 'coradoc/html/input/postprocessor'
+      autoload :Converters, 'coradoc/html/input/converters'
+      autoload :HtmlConverter, 'coradoc/html/input/html_converter'
+
+      def self.convert(input, options = {})
+        HtmlConverter.convert(input, options)
+      end
+
+      def self.to_coradoc(input, options = {})
+        HtmlConverter.to_coradoc(input, options)
+      end
+
+      def self.config
+        @config ||= Config.new
+        yield @config if block_given?
+        @config
+      end
+
+      def self.cleaner
+        @cleaner ||= Cleaner.new
+      end
+
+      def self.processor_id
+        :html
+      end
+
+      def self.processor_match?(filename)
+        %w[.html .htm].any? { |i| filename.downcase.end_with?(i) }
+      end
+
+      def self.processor_execute(input, options = {})
+        to_coradoc(input, options)
+      end
+
+      def self.processor_postprocess(data, options)
+        if options[:output_processor] == :adoc
+          data.transform_values do |v|
+            Input::Html::HtmlConverter.cleanup_result(v, options)
+          end
+        else
+          data
+        end
+      end
+
+      Coradoc::Input.define(self)
+    end
+  end
+
+  # Backward compatibility alias
+  # Some legacy code references Coradoc::Html::Input instead of Coradoc::Input::Html
+  module Html
+    Input = Coradoc::Input::Html
+  end
+end

data/lib/coradoc/html/output.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'coradoc/output'
+
+module Coradoc
+  module Output
+    # Static HTML output processor
+    #
+    # Generates static HTML documents from CoreModel using the classic
+    # rendering approach without JavaScript frameworks.
+    #
+    # @example Using the processor directly
+    #   html = Coradoc::Output::HtmlStatic.processor_execute({ "doc.html" => document }, {})
+    #
+    # @example Using through Output module
+    #   result = Coradoc::Output.process(document, format: :html_static)
+    #
+    class HtmlStatic
+      class << self
+        # Processor identifier for registration
+        # @return [Symbol] the processor ID
+        def processor_id
+          :html_static
+        end
+
+        # Check if this processor matches a given filename
+        # @param filename [String] the filename to check
+        # @return [Boolean] true if this processor handles the file type
+        def processor_match?(filename)
+          %w[.html .htm].any? { |ext| filename.downcase.end_with?(ext) }
+        end
+
+        # Process documents to static HTML
+        # @param input [Hash<String, Object>] mapping of filenames to documents
+        # @param options [Hash] processing options
+        # @return [Hash<String, String>] mapping of filenames to HTML output
+        def processor_execute(input, options = {})
+          result = {}
+          input.each do |filename, document|
+            html = Coradoc::Html::Static.convert(document, options)
+            result[filename] = html
+          end
+          result
+        end
+      end
+    end
+
+    # SPA (Single Page Application) HTML output processor
+    #
+    # Generates modern Vue.js + Tailwind CSS HTML documents from CoreModel.
+    #
+    # @example Using the processor directly
+    #   html = Coradoc::Output::HtmlSpa.processor_execute({ "doc.html" => document }, {})
+    #
+    # @example Using through Output module
+    #   result = Coradoc::Output.process(document, format: :html_spa)
+    #
+    class HtmlSpa
+      class << self
+        # Processor identifier for registration
+        # @return [Symbol] the processor ID
+        def processor_id
+          :html_spa
+        end
+
+        # Check if this processor matches a given filename
+        # @param filename [String] the filename to check
+        # @return [Boolean] true if this processor handles the file type
+        def processor_match?(filename)
+          %w[.html .htm].any? { |ext| filename.downcase.end_with?(ext) }
+        end
+
+        # Process documents to SPA HTML
+        # @param input [Hash<String, Object>] mapping of filenames to documents
+        # @param options [Hash] processing options
+        # @return [Hash<String, String>] mapping of filenames to SPA HTML output
+        def processor_execute(input, options = {})
+          result = {}
+          input.each do |filename, document|
+            html = Coradoc::Html::Spa.convert(document, options)
+            result[filename] = html
+          end
+          result
+        end
+      end
+    end
+
+    # Alias for HtmlSpa
+    Spa = HtmlSpa
+  end
+end
+
+# Register processors with the Output module
+Coradoc::Output.define(Coradoc::Output::HtmlStatic)
+Coradoc::Output.define(Coradoc::Output::HtmlSpa)