coradoc-html 1.1.18 → 1.1.19

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Errors
-        # Base error class for HTML input errors
-        # Inherits from Coradoc::Error for unified error handling
-        class Error < Coradoc::Error
-        end
-
-        # Raised when an unknown HTML tag is encountered
-        class UnknownTagError < Error
-        end
-
-        # Raised when HTML input configuration is invalid
-        class InvalidConfigurationError < Error
-        end
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      # HTML to CoreModel converter
-      #
-      # This class handles the conversion of HTML documents to CoreModel.
-      # It does NOT handle serialization to any specific output format.
-      # For serialization, use Coradoc.serialize(coremodel, to: :format)
-      #
-      # @example Basic usage - get CoreModel
-      #   coremodel = HtmlConverter.to_core_model(html_string)
-      #
-      # @example Serialize to AsciiDoc
-      #   coremodel = HtmlConverter.to_core_model(html_string)
-      #   adoc_text = Coradoc.serialize(coremodel, to: :asciidoc)
-      #
-      class HtmlConverter
-        # Convert HTML to CoreModel
-        #
-        # @param input [String, Nokogiri::XML::Document, Nokogiri::XML::Node] HTML input
-        # @param options [Hash] Conversion options
-        # @return [Coradoc::CoreModel::Base] CoreModel document
-        def self.to_core_model(input, options = {})
-          Input::Html.config.with(options) do
-            plugin_instances = prepare_plugin_instances(options)
-
-            root = track_time 'Loading input HTML document' do
-              case input
-              when String
-                Nokogiri::HTML(input).root
-              when Nokogiri::XML::Document
-                input.root
-              when Nokogiri::XML::Node
-                input
-              end
-            end
-
-            return nil unless root
-
-            plugin_instances.each do |plugin|
-              plugin.html_tree = root
-              track_time "Preprocessing document with #{plugin.name} plugin" do
-                plugin.preprocess_html_tree
-              end
-              root = plugin.html_tree
-            end
-
-            coremodel = track_time 'Converting input document tree to CoreModel' do
-              Converters.process_coradoc(
-                root,
-                plugin_instances: plugin_instances
-              )
-            end
-
-            coremodel = track_time 'Post-process CoreModel tree' do
-              Postprocessor.process(coremodel)
-            end
-
-            plugin_instances.each do |plugin|
-              plugin.coremodel_tree = coremodel
-              track_time "Postprocessing CoreModel tree with #{plugin.name} plugin" do
-                plugin.postprocess_coremodel_tree
-              end
-              coremodel = plugin.coremodel_tree
-            end
-
-            options[:plugin_instances] = plugin_instances unless options.frozen?
-
-            coremodel
-          end
-        end
-
-        def self.prepare_plugin_instances(options)
-          options[:plugin_instances] || Html.config.plugins.map(&:new)
-        end
-
-        @track_time_indentation = 0
-        def self.track_time(task)
-          if Input::Html.config.track_time
-            warn ('  ' * @track_time_indentation) + "* #{task} is starting..."
-            @track_time_indentation += 1
-            t0 = Time.now
-            ret = yield
-            time_elapsed = Time.now - t0
-            @track_time_indentation -= 1
-            warn ('  ' * @track_time_indentation) +
-                 "* #{task} took #{time_elapsed.round(3)} seconds"
-            ret
-          else
-            yield
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-# 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(&)
-          if self == Plugin
-            Class.new(Plugin, &)
-          else
-            super
-          end
-        end
-
-        def initialize
-          @html_tree_hooks_pre = {}
-          @html_tree_hooks_post = {}
-        end
-
-        def name
-          self.class.name
-        end
-
-        # Default no-op hooks. Plugins override these as needed.
-        def preprocess_html_tree; end
-        def postprocess_coremodel_tree; end
-        def postprocess_output_string; end
-
-        #### HTML Tree functionalities
-
-        attr_accessor :html_tree, :coremodel_tree, :output_string
-
-        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
-
-        # 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, &)
-          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
-
-        #### Output string functionalities
-      end
-    end
-  end
-end

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

@@ -1,214 +0,0 @@
-# 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
-            # 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_coremodel(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_coremodel(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_coremodel(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_coremodel(node).strip
-
-                "[start=#{i}]\n. #{text}\n"
-              end
-            end
-          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
-        end
-      end
-    end
-  end
-end
-
-Coradoc::Input::Html.config.plugins << Coradoc::Input::Html::Plugin::Plateau

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      # Postprocessor hook for CoreModel tree transformations after HTML parsing.
-      #
-      # Override or extend to apply post-parse cleanup. The default
-      # implementation returns the tree unchanged.
-      class Postprocessor
-        def self.process(coradoc)
-          new(coradoc).process
-        end
-
-        def initialize(coradoc)
-          @tree = coradoc
-        end
-
-        def process
-          @tree
-        end
-      end
-    end
-  end
-end

data/lib/coradoc/html/input.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest'
-require 'nokogiri'
-require 'coradoc'
-
-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.to_core_model(input, options)
-      end
-
-      def self.to_coradoc(input, options = {})
-        HtmlConverter.to_core_model(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
-
-      extend Coradoc::Html::FormatDetection
-
-      def self.processor_match?(filename)
-        html_extension?(filename)
-      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 { |v| clean_output(v, options) }
-        else
-          data
-        end
-      end
-
-      def self.clean_output(result, options = {})
-        config.with(options) do
-          plugin_instances = HtmlConverter.prepare_plugin_instances(options)
-
-          result = HtmlConverter.track_time('Cleaning up the result') do
-            cleaner.tidy(result)
-          end
-
-          plugin_instances.each do |plugin|
-            plugin.output_string = result
-            HtmlConverter.track_time("Postprocessing output string with #{plugin.name} plugin") do
-              plugin.postprocess_output_string
-            end
-            result = plugin.output_string
-          end
-
-          result
-        end
-      end
-
-      Coradoc::Input.define(self)
-    end
-  end
-
-  module Html
-    Input = Coradoc::Input::Html
-  end
-end

data/lib/coradoc/html/output.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'coradoc'
-
-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
-      extend Coradoc::Html::FormatDetection
-
-      class << self
-        def processor_id
-          :html_static
-        end
-
-        def processor_match?(filename)
-          html_extension?(filename)
-        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
-      extend Coradoc::Html::FormatDetection
-
-      class << self
-        def processor_id
-          :html_spa
-        end
-
-        def processor_match?(filename)
-          html_extension?(filename)
-        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)