coradoc-html 1.1.7 → 1.1.13

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        class MediaBase < Base
+          def to_coradoc(node, _state = {})
+            src = node['src']
+            id = node['id']
+            title = extract_title(node)
+
+            Coradoc::CoreModel::Block.new(
+              block_semantic_type: semantic_type,
+              content: src,
+              title: title,
+              id: id,
+              element_attributes: build_attributes(node)
+            )
+          end
+
+          def extract_title(node)
+            track = node.at('./track') || node.at('.//source')
+            return '' if track.nil?
+
+            track['label'] || track['srclang'] || ''
+          end
+
+          private
+
+          def semantic_type
+            raise NotImplementedError
+          end
+
+          def base_attributes(node)
+            {
+              autoplay: node['autoplay'],
+              loop: node['loop'],
+              controls: node['controls']
+            }.compact
+          end
+
+          def build_attributes(node)
+            base_attributes(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,13 +5,11 @@ module Coradoc
     module Html
       module Converters
         class Ol < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             id = node['id']
-            ol_count = state.fetch(:ol_count, 0) + 1
-            items = treat_children_coradoc(
-              node,
-              state.merge(ol_count: ol_count)
-            )
+            items = treat_children_coradoc(node, state)
 
             marker_type = get_list_type(node, state)
 
@@ -37,9 +35,9 @@ module Coradoc
           end
         end
 
-        register :ol, Ol.new
-        register :ul, Ol.new
-        register :dir, Ol.new
+        register :ol,  Ol::INSTANCE
+        register :ul,  Ol::INSTANCE
+        register :dir, Ol::INSTANCE
       end
     end
   end

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

@@ -5,16 +5,15 @@ module Coradoc
     module Html
       module Converters
         class P < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             id = node['id']
             content = treat_children_coradoc(node, state)
 
-            # Strip full-width spaces from paragraph content
             content = strip_fullwidth_spaces(content)
 
-            Coradoc::CoreModel::Block.new(
-              block_semantic_type: :paragraph,
-              element_type: 'paragraph',
+            Coradoc::CoreModel::ParagraphBlock.new(
               children: content,
               id: id
             )
@@ -25,38 +24,51 @@ module Coradoc
           def strip_fullwidth_spaces(content)
             return content unless content.is_a?(Array)
 
-            # Strip full-width spaces from all inline elements
             content.each do |item|
-              if item.is_a?(Coradoc::CoreModel::InlineElement) && item.content.is_a?(String)
-                item.content = item.content.gsub(/\A　+|　+\z/, '')
-              elsif item.is_a?(String)
-                item.gsub(/\A　+|　+\z/, '')
-              end
-            end
+              next unless item.is_a?(Coradoc::CoreModel::InlineElement)
+              next unless item.content.is_a?(String)
 
-            # Strip leading space from first text element
-            first_text = content.find { |item| item.is_a?(Coradoc::CoreModel::InlineElement) || item.is_a?(String) }
-            if first_text.is_a?(Coradoc::CoreModel::InlineElement) && first_text.content.is_a?(String)
-              first_text.content = first_text.content.lstrip
-            elsif first_text.is_a?(String)
-              first_text.lstrip
+              item.content = item.content.gsub(/\A　+|　+\z/, '')
             end
 
-            # Strip trailing space from last text element
-            last_text = content.reverse.find do |item|
-              item.is_a?(Coradoc::CoreModel::InlineElement) || item.is_a?(String)
+            strip_edge_whitespace(content)
+            reject_empty_elements(content)
+          end
+
+          def strip_edge_whitespace(content)
+            first = content.find { |item| text_element?(item) }
+            strip_left(first) if first
+
+            last = content.reverse.find { |item| text_element?(item) }
+            strip_right(last) if last
+          end
+
+          def strip_left(item)
+            case item
+            when Coradoc::CoreModel::InlineElement
+              item.content = item.content.lstrip if item.content.is_a?(String)
+            when String
+              item.replace(item.lstrip)
             end
-            if last_text.is_a?(Coradoc::CoreModel::InlineElement) && last_text.content.is_a?(String)
-              last_text.content = last_text.content.rstrip
-            elsif last_text.is_a?(String)
-              last_text.rstrip
+          end
+
+          def strip_right(item)
+            case item
+            when Coradoc::CoreModel::InlineElement
+              item.content = item.content.rstrip if item.content.is_a?(String)
+            when String
+              item.replace(item.rstrip)
             end
+          end
 
-            # Remove empty text elements after stripping
-            # But keep InlineElements that have nested_elements (e.g., bold with nested text)
+          def text_element?(item)
+            item.is_a?(Coradoc::CoreModel::InlineElement) || item.is_a?(String)
+          end
+
+          def reject_empty_elements(content)
             content.reject do |item|
               if item.is_a?(Coradoc::CoreModel::InlineElement)
-                item.content.to_s.empty? && !item_has_nested_content?(item)
+                item.content.to_s.empty? && !has_nested_content?(item)
               elsif item.is_a?(String)
                 item.empty?
               else
@@ -65,16 +77,13 @@ module Coradoc
             end
           end
 
-          # Check if InlineElement has meaningful nested content
-          def item_has_nested_content?(item)
-            return false unless item.is_a?(Coradoc::CoreModel::InlineElement)
-            return false if item.nested_elements.nil? || item.nested_elements.empty?
-
-            true
+          def has_nested_content?(item)
+            item.is_a?(Coradoc::CoreModel::InlineElement) &&
+              item.nested_elements && !item.nested_elements.empty?
           end
         end
 
-        register :p, P.new
+        register :p, P::INSTANCE
       end
     end
   end

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

@@ -5,13 +5,11 @@ module Coradoc
     module Html
       module Converters
         class PassThrough < Base
+          INSTANCE = new
+
           def to_coradoc(node, _state = {})
             node.to_s
           end
-
-          def convert(node, state = {})
-            to_coradoc(node, state)
-          end
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module Input
+    module Html
+      module Converters
+        # Shared logic for superscript/subscript converters.
+        #
+        # Subclasses must implement `element_class` returning the
+        # CoreModel class (e.g., SuperscriptElement, SubscriptElement).
+        module PositionalFormatting
+          def to_coradoc(node, state = {})
+            leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
+
+            content = treat_children_coradoc(node, state)
+
+            return nil if content_empty?(content)
+
+            e = element_class.new(content: content)
+            result = [leading_whitespace, e, trailing_whitespace].compact
+            result.length == 1 ? result.first : result
+          end
+
+          private
+
+          def content_empty?(content)
+            return true if content.nil?
+            return content.strip.empty? if content.is_a?(String)
+            return content.empty? if content.is_a?(Array)
+
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,8 @@ module Coradoc
     module Html
       module Converters
         class Pre < Base
+          INSTANCE = new
+
           def to_coradoc(node, _state = {})
             id = node['id']
             lang = language(node)
@@ -12,14 +14,12 @@ module Coradoc
 
             if lang
               Coradoc::CoreModel::SourceBlock.new(
-                element_type: 'source',
                 content: content,
                 id: id,
                 language: lang
               )
             else
               Coradoc::CoreModel::LiteralBlock.new(
-                element_type: 'literal',
                 content: content,
                 id: id
               )
@@ -52,7 +52,7 @@ module Coradoc
           end
         end
 
-        register :pre, Pre.new
+        register :pre, Pre::INSTANCE
       end
     end
   end

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

@@ -5,19 +5,22 @@ module Coradoc
     module Html
       module Converters
         class Q < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             content = treat_children_coradoc(node, state)
             cite = node['cite']
 
             Coradoc::CoreModel::InlineElement.new(
               format_type: 'quotation',
-              content: content,
-              metadata: cite ? { cite: cite } : {}
+              nested_elements: content,
+              content: extract_text_from_content(content),
+              target: cite
             )
           end
         end
 
-        register :q, Q.new
+        register :q, Q::INSTANCE
       end
     end
   end

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

@@ -5,6 +5,8 @@ module Coradoc
     module Html
       module Converters
         class Strong < Markup
+          INSTANCE = new
+
           def coradoc_format_type
             'bold'
           end
@@ -14,8 +16,8 @@ module Coradoc
           end
         end
 
-        register :strong, Strong.new
-        register :b,      Strong.new
+        register :strong, Strong::INSTANCE
+        register :b,      Strong::INSTANCE
       end
     end
   end

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

@@ -1,39 +1,23 @@
 # frozen_string_literal: true
 
+require_relative 'positional_formatting'
+
 module Coradoc
   module Input
     module Html
       module Converters
         class Sub < Base
-          def to_coradoc(node, state = {})
-            leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
-
-            content = treat_children_coradoc(node, state)
-
-            # Check if content is empty
-            return nil if content_empty?(content)
-
-            # Create CoreModel::InlineElement with format_type "subscript"
-            e = Coradoc::CoreModel::InlineElement.new(
-              format_type: 'subscript',
-              content: content
-            )
-            result = [leading_whitespace, e, trailing_whitespace].compact
-            result.length == 1 ? result.first : result
-          end
+          INSTANCE = new
+          include PositionalFormatting
 
           private
 
-          def content_empty?(content)
-            return true if content.nil?
-            return content.strip.empty? if content.is_a?(String)
-            return content.empty? if content.is_a?(Array)
-
-            false
+          def element_class
+            Coradoc::CoreModel::SubscriptElement
           end
         end
 
-        register :sub, Sub.new
+        register :sub, Sub::INSTANCE
       end
     end
   end

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

@@ -1,39 +1,23 @@
 # frozen_string_literal: true
 
+require_relative 'positional_formatting'
+
 module Coradoc
   module Input
     module Html
       module Converters
         class Sup < Base
-          def to_coradoc(node, state = {})
-            leading_whitespace, trailing_whitespace = extract_leading_trailing_whitespace(node)
-
-            content = treat_children_coradoc(node, state)
-
-            # Check if content is empty
-            return nil if content_empty?(content)
-
-            # Create CoreModel::InlineElement with format_type "superscript"
-            e = Coradoc::CoreModel::InlineElement.new(
-              format_type: 'superscript',
-              content: content
-            )
-            result = [leading_whitespace, e, trailing_whitespace].compact
-            result.length == 1 ? result.first : result
-          end
+          INSTANCE = new
+          include PositionalFormatting
 
           private
 
-          def content_empty?(content)
-            return true if content.nil?
-            return content.strip.empty? if content.is_a?(String)
-            return content.empty? if content.is_a?(Array)
-
-            false
+          def element_class
+            Coradoc::CoreModel::SuperscriptElement
           end
         end
 
-        register :sup, Sup.new
+        register :sup, Sup::INSTANCE
       end
     end
   end

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

@@ -5,6 +5,8 @@ module Coradoc
     module Html
       module Converters
         class Table < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             id = node['id']
             title = extract_title(node)
@@ -57,7 +59,7 @@ module Coradoc
           end
         end
 
-        register :table, Table.new
+        register :table, Table::INSTANCE
       end
     end
   end

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

@@ -5,8 +5,9 @@ module Coradoc
     module Html
       module Converters
         class Td < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
-            node['id']
             colspan = node['colspan']&.to_i
             rowspan = node['rowspan']&.to_i
             alignment = extract_alignment(node)
@@ -16,7 +17,6 @@ module Coradoc
 
             content = treat_children_coradoc(node, state)
 
-            # Use CoreModel::TableCell
             Coradoc::CoreModel::TableCell.new(
               content: extract_text_from_content(content),
               alignment: alignment,
@@ -28,42 +28,16 @@ module Coradoc
 
           def extract_alignment(node)
             align = node['align']
-            node['valign']
-            # Combine horizontal and vertical alignment
             case align
             when 'left' then 'left'
             when 'center' then 'center'
             when 'right' then 'right'
             end
-            # Return alignment string (can be extended to include vertical)
-          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 :td, Td.new
-        register :th, Td.new
+        register :td, Td::INSTANCE
+        register :th, Td::INSTANCE
       end
     end
   end

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

@@ -5,6 +5,8 @@ module Coradoc
     module Html
       module Converters
         class Text < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             return treat_empty(node, state) if node.text.strip.empty?
 
@@ -12,8 +14,7 @@ module Coradoc
             cleaned_content = cleanup_html_text(node.text)
 
             # Return as CoreModel::InlineElement with format_type "text"
-            Coradoc::CoreModel::InlineElement.new(
-              format_type: 'text',
+            Coradoc::CoreModel::TextElement.new(
               content: cleaned_content
             )
           end
@@ -60,7 +61,7 @@ module Coradoc
           end
         end
 
-        register :text, Text.new
+        register :text, Text::INSTANCE
       end
     end
   end

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

@@ -5,6 +5,8 @@ module Coradoc
     module Html
       module Converters
         class Tr < Base
+          INSTANCE = new
+
           def to_coradoc(node, state = {})
             content = treat_children_coradoc(node, state)
             header = table_header_row?(node)
@@ -16,12 +18,11 @@ module Coradoc
           end
 
           def table_header_row?(node)
-            # node.element_children.all? {|child| child.name.to_sym == :th}
             node.previous_element.nil?
           end
         end
 
-        register :tr, Tr.new
+        register :tr, Tr::INSTANCE
       end
     end
   end

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

@@ -1,52 +1,30 @@
 # frozen_string_literal: true
 
+require_relative 'media_base'
+
 module Coradoc
   module Input
     module Html
       module Converters
-        class Video < Base
-          def to_coradoc(node, _state = {})
-            src = node['src']
-            id = node['id']
-            title = extract_title(node)
-            options(node)
+        class Video < MediaBase
+          INSTANCE = new
 
-            # Use Block with custom attributes to store video info
-            # CoreModel doesn't have a specific Video type, so we use Block
-            # with element_attributes to store video-specific data
-            Coradoc::CoreModel::Block.new(
-              element_type: 'video',
-              block_semantic_type: :video,
-              content: src,
-              title: title,
-              id: id,
-              width: node['width'],
-              height: node['height'],
-              element_attributes: {
-                autoplay: node['autoplay'],
-                loop: node['loop'],
-                controls: node['controls'],
-                poster: node['poster']
-              }.compact
-            )
-          end
+          private
 
-          def extract_title(node)
-            title = node.at('./track') || node.at('.//source')
-            return '' if title.nil?
-
-            title['label'] || title['srclang'] || ''
+          def semantic_type
+            :video
           end
 
-          def options(node)
-            autoplay = node['autoplay']
-            loop_attr = node['loop']
-            controls = node['controls']
-            [autoplay, loop_attr, controls].compact
+          def build_attributes(node)
+            base_attributes(node).merge(
+              poster: node['poster'],
+              width: node['width'],
+              height: node['height']
+            ).compact
           end
         end
 
-        register :video, Video.new
+        register :video, Video::INSTANCE
       end
     end
   end