coradoc-html 1.1.7

data/lib/coradoc/html/input/converters/aside.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Aside < Base
+          def to_coradoc(node, state = {})
+            content = treat_children_coradoc(node, state)
+            # Use AnnotationBlock with annotation_type: "sidebar" for aside elements
+            Coradoc::CoreModel::AnnotationBlock.new(
+              annotation_type: 'sidebar',
+              block_semantic_type: :sidebar,
+              children: content
+            )
+          end
+        end
+
+        register :aside, Aside.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/audio.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Audio < Base
+          def to_coradoc(node, _state = {})
+            src = node['src']
+            id = node['id']
+            title = extract_title(node)
+            options(node)
+
+            # Use Block with custom attributes to store audio info
+            # CoreModel doesn't have a specific Audio type, so we use Block
+            # with element_attributes to store audio-specific data
+            Coradoc::CoreModel::Block.new(
+              element_type: 'audio',
+              block_semantic_type: :audio,
+              content: src,
+              title: title,
+              id: id,
+              element_attributes: {
+                autoplay: node['autoplay'],
+                loop: node['loop'],
+                controls: node['controls']
+              }.compact
+            )
+          end
+
+          def extract_title(node)
+            title = node.at('./track') || node.at('.//source')
+            return '' if title.nil?
+
+            title['label'] || title['srclang'] || ''
+          end
+
+          def options(node)
+            autoplay = node['autoplay']
+            loop_attr = node['loop']
+            controls = node['controls']
+            [autoplay, loop_attr, controls].compact
+          end
+        end
+
+        register :audio, Audio.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/base.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Base
+          # Default implementation to convert a given Nokogiri node
+          # to a CoreModel type.
+          # Can be overriden by subclasses.
+          def convert(node, state = {})
+            to_coradoc(node, state)
+          end
+
+          # NOTE: treat_children won't run plugin hooks
+          def treat_children(node, state)
+            node.children.map do |child|
+              treat(child, state)
+            end
+          end
+
+          def treat(node, state)
+            Converters.process(node, state)
+          end
+
+          def treat_children_coradoc(node, state)
+            results = node.children.map do |child|
+              treat_coradoc(child, state)
+            end.flatten
+
+            results.reject do |x|
+              x.nil? || (x.is_a?(String) && x.strip.empty?)
+            end
+          end
+
+          def treat_coradoc(node, state)
+            Converters.process_coradoc(node, state)
+          end
+
+          def extract_title(node)
+            node['title'].to_s
+          end
+
+          def node_has_ancestor?(node, name)
+            case name
+            when String
+              node.ancestors.map(&:name).include?(name)
+            when Array
+              (node.ancestors.map(&:name) & name).any?
+            end
+          end
+
+          def textnode_before_end_with?(node, str)
+            return nil unless [String, Regexp].include?(str.class)
+            return nil if str.is_a?(String) && str.empty?
+
+            str = /#{Regexp.escape(str)}/ if str.is_a?(String)
+            str = /(?:#{str})\z/
+
+            node2 = node.at_xpath('preceding-sibling::node()[1]')
+            node2.is_a?(Nokogiri::XML::Text) && node2.text.match?(str)
+          end
+
+          def textnode_after_start_with?(node, str)
+            return nil unless [String, Regexp].include?(str.class)
+            return nil if str.is_a?(String) && str.empty?
+
+            str = /#{Regexp.escape(str)}/ if str.is_a?(String)
+            str = /\A(?:#{str})/
+
+            node2 = node.at_xpath('following-sibling::node()[1]')
+            node2.is_a?(Nokogiri::XML::Text) && node2.text.match?(str)
+          end
+
+          def extract_leading_trailing_whitespace(node)
+            node.text =~ /^(\s+)/
+            leading_whitespace = ::Regexp.last_match(1)
+            unless leading_whitespace.nil?
+              first_text = node.at_xpath('./text()[1]')
+              first_text&.replace(first_text.text.lstrip)
+              leading_whitespace = ' '
+            end
+            node.text =~ /(\s+)$/
+            trailing_whitespace = ::Regexp.last_match(1)
+            unless trailing_whitespace.nil?
+              last_text = node.at_xpath('./text()[last()]')
+              last_text&.replace(last_text.text.rstrip)
+              trailing_whitespace = ' '
+            end
+            [leading_whitespace, trailing_whitespace]
+          end
+
+          def unconstrained_before?(node)
+            before = node.at_xpath('preceding::node()[1]')
+
+            before &&
+              !before.text.strip.empty? &&
+              before.text[-1]&.match?(/\w/)
+          end
+
+          def unconstrained_after?(node)
+            after = node.at_xpath('following::node()[1]')
+
+            after && !after.text.strip.empty? &&
+              after.text[0]&.match?(/\w|,|;|"|\.\?!/)
+          end
+
+          # Helper to escape text content
+          def escape_text(text)
+            text.to_s.gsub(/[<>&]/, '<' => '&lt;', '>' => '&gt;', '&' => '&amp;')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/blockquote.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Blockquote < Base
+          def to_coradoc(node, state = {})
+            id = node['id']
+            cite = node['cite']
+            content = treat_children_coradoc(node, state)
+
+            Coradoc::CoreModel::QuoteBlock.new(
+              content: content,
+              id: id,
+              attribution: cite
+            )
+          end
+        end
+
+        register :blockquote, Blockquote.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/br.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Br < Base
+          def to_coradoc(_node, _state = {})
+            Coradoc::CoreModel::InlineElement.new(
+              format_type: 'line_break'
+            )
+          end
+        end
+
+        register :br, Br.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/bypass.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Bypass < Base
+          def to_coradoc(node, state = {})
+            treat_children_coradoc(node, state)
+          end
+        end
+
+        register :document, Bypass.new
+        register :html,     Bypass.new
+        register :body,     Bypass.new
+        register :span,     Bypass.new
+        register :thead,    Bypass.new
+        register :tbody,    Bypass.new
+        register :tfoot,    Bypass.new
+        register :abbr, Bypass.new
+        register :acronym,    Bypass.new
+        register :address,    Bypass.new
+        register :applet, Bypass.new
+        register :map, Bypass.new
+        register :area, Bypass.new
+        register :bdi,    Bypass.new
+        register :bdo,    Bypass.new
+        register :big,    Bypass.new
+        register :button,    Bypass.new
+        register :canvas,    Bypass.new
+        register :data, Bypass.new
+        register :datalist, Bypass.new
+        register :del,    Bypass.new
+        register :ins,    Bypass.new
+        register :dfn,    Bypass.new
+        register :dialog, Bypass.new
+        register :embed, Bypass.new
+        register :fieldset, Bypass.new
+        register :font, Bypass.new
+        register :footer, Bypass.new
+        register :form, Bypass.new
+        register :frame, Bypass.new
+        register :frameset, Bypass.new
+        register :header,    Bypass.new
+        register :iframe,    Bypass.new
+        register :input,    Bypass.new
+        register :label,    Bypass.new
+        register :legend, Bypass.new
+        register :main,    Bypass.new
+        register :menu,    Bypass.new
+        register :menulist, Bypass.new
+        register :meter, Bypass.new
+        register :nav, Bypass.new
+        register :noframes,    Bypass.new
+        register :noscript,    Bypass.new
+        register :object, Bypass.new
+        register :optgroup, Bypass.new
+        register :option,    Bypass.new
+        register :output,    Bypass.new
+        register :param, Bypass.new
+        register :picture, Bypass.new
+        register :progress, Bypass.new
+        register :ruby, Bypass.new
+        register :rt,    Bypass.new
+        register :rp,    Bypass.new
+        register :s, Bypass.new
+        register :select, Bypass.new
+        register :small, Bypass.new
+        register :span, Bypass.new
+        register :strike, Bypass.new
+        register :details,    Bypass.new
+        register :section,    Bypass.new
+        register :summary,    Bypass.new
+        register :svg, Bypass.new
+        register :template,    Bypass.new
+        register :textarea,    Bypass.new
+        register :track, Bypass.new
+        register :u, Bypass.new
+        register :wbr, Bypass.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/code.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Code < Markup
+          def coradoc_format_type
+            'monospace'
+          end
+
+          def markup_ancestor_tag_names
+            %w[code tt kbd samp var]
+          end
+        end
+
+        register :code, Code.new
+        register :tt, Code.new
+        register :kbd, Code.new
+        register :samp, Code.new
+        register :var, Code.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/div.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Div < Base
+          def to_coradoc(node, state = {})
+            id = node['id']
+            contents = treat_children_coradoc(node, state)
+
+            Coradoc::CoreModel::OpenBlock.new(
+              content: contents,
+              id: id
+            )
+          end
+        end
+
+        register :div,     Div.new
+        register :article, Div.new
+        register :center,  Div.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/dl.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Dl < Base
+          def to_coradoc(node, state = {})
+            items = process_dl(node, state)
+
+            # Convert items to CoreModel::ListItem objects
+            # For definition lists, term goes in content, definition goes in children
+            list_items = items.map do |item|
+              term_text = extract_text_from_content(item[:name])
+              Coradoc::CoreModel::ListItem.new(
+                content: term_text,
+                children: item[:value]
+              )
+            end
+
+            # Use CoreModel::ListBlock with marker_type "definition"
+            Coradoc::CoreModel::ListBlock.new(
+              marker_type: 'definition',
+              items: list_items
+            )
+          end
+
+          def process_dl(node, state = {})
+            groups = []
+            current = { name: [], value: [] }
+
+            seen_dd = false
+            child = node.at_xpath('*[1]')
+            grandchild = nil
+            until child.nil?
+              if child.name == 'div'
+                grandchild = child.at_xpath('*[1]')
+                until grandchild.nil?
+                  groups, current, seen_dd = process_dt_or_dd(
+                    groups,
+                    current,
+                    seen_dd,
+                    grandchild,
+                    state
+                  )
+                  grandchild = grandchild.at_xpath('following-sibling::*[1]')
+                end
+              elsif %w[dt dd].include?(child.name)
+                groups, current, seen_dd = process_dt_or_dd(
+                  groups,
+                  current,
+                  seen_dd,
+                  child,
+                  state
+                )
+              end
+              child = child.at_xpath('following-sibling::*[1]')
+              groups << current if current[:name].any? && current[:value].any?
+            end
+            groups
+          end
+
+          def process_dt_or_dd(groups, current, seen_dd, subnode, state = {})
+            if subnode.name == 'dt'
+              if seen_dd
+                # groups << current
+                current = { name: [], value: [] }
+                seen_dd = false
+              end
+              current[:name] += treat_children_coradoc(subnode, state)
+            elsif subnode.name == 'dd'
+              current[:value] += treat_children_coradoc(subnode, state)
+              seen_dd = true
+            end
+            [groups, current, seen_dd]
+          end
+
+          # Extract text from content array
+          def extract_text_from_content(content)
+            return content if content.is_a?(String)
+            return '' if content.nil?
+
+            content.map do |item|
+              case item
+              when String
+                item
+              when Coradoc::CoreModel::InlineElement
+                item.content.to_s
+              when Coradoc::CoreModel::Base
+                if item.content
+                  item.content.to_s
+                else
+                  ''
+                end
+              else
+                item.to_s
+              end
+            end.join
+          end
+        end
+
+        register :dl, Dl.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/drop.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Drop < Base
+          def to_coradoc(node, state = {})
+            convert(node, state)
+          end
+
+          def convert(_node, _state = {})
+            ''
+          end
+        end
+
+        register :caption, Drop.new
+        register :figcaption, Drop.new
+        register :title, Drop.new
+        register :link, Drop.new
+        register :style, Drop.new
+        register :meta, Drop.new
+        register :script, Drop.new
+        register :comment, Drop.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/em.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Em < Markup
+          def coradoc_format_type
+            'italic'
+          end
+
+          def markup_ancestor_tag_names
+            %w[em i cite]
+          end
+        end
+
+        register :em, Em.new
+        register :i,  Em.new
+        register :cite, Em.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/figure.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Figure < Base
+          def to_coradoc(node, state = {})
+            id = node['id']
+            title_content = extract_title(node)
+            content = treat_children_coradoc(node, state)
+
+            # Use CoreModel::ExampleBlock for example/figure
+            Coradoc::CoreModel::ExampleBlock.new(
+              title: extract_text_from_content(title_content),
+              children: content,
+              id: id
+            )
+          end
+
+          def extract_title(node)
+            title = node.at('./figcaption')
+            return '' if title.nil?
+
+            treat_children_coradoc(title, {})
+          end
+
+          # Extract text from content array
+          def extract_text_from_content(content)
+            return content if content.is_a?(String)
+            return '' if content.nil?
+
+            content.map do |item|
+              case item
+              when String
+                item
+              when Coradoc::CoreModel::InlineElement
+                item.content.to_s
+              when Coradoc::CoreModel::Base
+                if item.content
+                  item.content.to_s
+                elsif item.title
+                  item.title.to_s
+                else
+                  ''
+                end
+              else
+                item.to_s
+              end
+            end.join
+          end
+        end
+
+        register :figure, Figure.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/h.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class H < Base
+          def to_coradoc(node, state = {})
+            id = node['id']
+            internal_anchor = treat_children_anchors(node, state)
+
+            # Check if it has id attribute
+            if id.to_s.empty? && internal_anchor.size.positive?
+              first_model = internal_anchor.first
+              # InlineElement (anchor) has a target attribute
+              id = first_model.target if first_model.is_a?(Coradoc::CoreModel::InlineElement) && first_model.target
+            end
+
+            level_int = node.name[/\d/].to_i
+            content = treat_children_no_anchors(node, state)
+
+            Coradoc::CoreModel::StructuralElement.new(
+              element_type: 'section',
+              title: extract_title_text(content),
+              level: level_int,
+              id: id,
+              children: []
+            )
+          end
+
+          def treat_children_no_anchors(node, state)
+            node.children.reject { |a| a.name == 'a' }
+                .map do |child|
+              treat_coradoc(child, state)
+            end.flatten.compact
+          end
+
+          def treat_children_anchors(node, state)
+            node.children.select { |a| a.name == 'a' }
+                .map do |child|
+              treat_coradoc(child, state)
+            end.flatten.compact
+          end
+
+          private
+
+          def extract_title_text(content)
+            return '' if content.nil? || content.empty?
+
+            # Extract text from content
+            if content.is_a?(Array)
+              content.map do |c|
+                if c.is_a?(Coradoc::CoreModel::InlineElement)
+                  c.content.to_s
+                else
+                  c.to_s
+                end
+              end.join.strip
+            elsif content.is_a?(Coradoc::CoreModel::InlineElement)
+              content.content.to_s
+            else
+              content.to_s
+            end
+          end
+        end
+
+        register :h1, H.new
+        register :h2, H.new
+        register :h3, H.new
+        register :h4, H.new
+        register :h5, H.new
+        register :h6, H.new
+      end
+    end
+  end
+end

data/lib/coradoc/html/input/converters/head.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class Head < Base
+          def to_coradoc(node, _state = {})
+            title = extract_title(node)
+            # Use StructuralElement with element_type "document" for document header
+            Coradoc::CoreModel::StructuralElement.new(
+              element_type: 'document',
+              title: title,
+              level: 0
+            )
+          end
+
+          def extract_title(node)
+            title = node.at('./title')
+            return '(???)' if title.nil?
+
+            title.text
+          end
+        end
+
+        register :head, Head.new
+      end
+    end
+  end
+end