coradoc-html 1.1.18 → 1.1.19

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Dl < Base
-          INSTANCE = new
-
-          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
-                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
-        end
-
-        register :dl, Dl::INSTANCE
-      end
-    end
-  end
-end

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

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

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

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

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Figure < Base
-          INSTANCE = new
-
-          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
-        end
-
-        register :figure, Figure::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class H < Base
-          INSTANCE = new
-
-          def to_coradoc(node, state = {})
-            id = node['id']
-            internal_anchor = treat_children_anchors(node, state)
-
-            if id.to_s.empty? && internal_anchor.size.positive?
-              first_model = internal_anchor.first
-              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::SectionElement.new(
-              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?
-
-            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::INSTANCE
-        register :h2, H::INSTANCE
-        register :h3, H::INSTANCE
-        register :h4, H::INSTANCE
-        register :h5, H::INSTANCE
-        register :h6, H::INSTANCE
-      end
-    end
-  end
-end

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

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

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Hr < Base
-          INSTANCE = new
-
-          def to_coradoc(_node, _state = {})
-            Coradoc::CoreModel::HorizontalRuleBlock.new
-          end
-        end
-
-        register :hr, Hr::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'pathname'
-require 'tempfile'
-require 'base64'
-require 'marcel'
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Img < Base
-          INSTANCE = new
-
-          def image_number
-            format(
-              Coradoc::Html::Input.config.image_counter_pattern,
-              Coradoc::Html::Input.config.image_counter
-            )
-          end
-
-          def image_number_increment
-            Coradoc::Html::Input.config.image_counter += 1
-          end
-
-          def datauri2file(src)
-            return unless src
-
-            %r{^data:image/(?:[^;]+);base64,(?<imgdata>.+)$} =~ src
-
-            dest_dir = Pathname.new(Coradoc::Html::Input.config.destination).dirname
-            images_dir = dest_dir.join('images')
-            FileUtils.mkdir_p(images_dir)
-
-            ext, image_src_path, tempfile = determine_image_src_path(
-              src,
-              imgdata
-            )
-            image_dest_path = images_dir + "#{image_number}.#{ext}"
-
-            if File.exist?(image_src_path)
-              FileUtils.cp(image_src_path, image_dest_path)
-            else
-              Kernel.warn "Image #{image_src_path} does not exist"
-            end
-
-            image_number_increment
-
-            image_dest_path.relative_path_from(dest_dir)
-          ensure
-            tempfile&.close!
-          end
-
-          def determine_image_src_path(src, imgdata)
-            return copy_temp_file(imgdata) if imgdata
-
-            ext = File.extname(src).strip.downcase[1..]
-            [ext, Pathname.new(Coradoc::Html::Input.config.sourcedir).join(src)]
-          end
-
-          def copy_temp_file(imgdata)
-            f = Tempfile.open(['radoc', '.jpg'])
-            f.binmode
-            f.write(Base64.strict_decode64(imgdata))
-            f.rewind
-            ext = Marcel::MimeType.for(f).sub(%r{^[^/]+/}, '')
-            ext = 'svg' if ext == 'svg+xml'
-            [ext, f.path, f]
-          end
-
-          def to_coradoc(node, _state = {})
-            id = node['id']
-            alt   = node['alt']
-            src   = node['src']
-            width = node['width']
-            height = node['height']
-
-            # Convert width/height to integers if they are numeric strings
-            width = width.to_i if width&.match?(/\A\d+\z/)
-            height = height.to_i if height&.match?(/\A\d+\z/)
-
-            title = extract_title(node)
-
-            src = datauri2file(src) if Coradoc::Html::Input.config.external_images
-
-            # Use CoreModel::Image
-            return unless src
-
-            Coradoc::CoreModel::Image.new(
-              src: src,
-              alt: alt,
-              caption: title,
-              width: width&.to_s,
-              height: height&.to_s,
-              id: id
-            )
-          end
-        end
-
-        register :img, Img::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Li < Base
-          INSTANCE = new
-
-          def to_coradoc(node, state = {})
-            id = node['id']
-
-            # Check if all children are <p> tags
-            p_children = node.children.select { |child| child.name == 'p' }
-            non_empty_children = node.children.reject { |c| c.text? && c.text.strip.empty? }
-
-            content = if p_children.any? && p_children.size == non_empty_children.size && p_children.size == 1
-                        # Single <p> tag - extract its content directly as inline content
-                        treat_children_coradoc(p_children.first, state)
-                      else
-                        treat_children_coradoc(node, state)
-                      end
-
-            # Use CoreModel::ListItem with children for mixed content
-            # content can be an array of inline elements or a single string
-            Coradoc::CoreModel::ListItem.new(
-              children: content,
-              id: id
-            )
-          end
-        end
-
-        register :li, Li::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Mark < Markup
-          INSTANCE = new
-
-          def coradoc_format_type
-            'highlight'
-          end
-
-          def markup_ancestor_tag_names
-            %w[mark]
-          end
-        end
-
-        register :mark, Mark::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Markup < Base
-          def to_coradoc(node, state = {})
-            u_before = unconstrained_before?(node)
-            u_after = unconstrained_after?(node)
-
-            leading_ws, trailing_ws =
-              extract_leading_trailing_whitespace(node)
-
-            # Wrap whitespace in InlineElement so it can be processed
-            leading_whitespace = if leading_ws
-                                   Coradoc::CoreModel::TextElement.new(
-                                     content: leading_ws
-                                   )
-                                 end
-            trailing_whitespace = if trailing_ws
-                                    Coradoc::CoreModel::TextElement.new(
-                                      content: trailing_ws
-                                    )
-                                  end
-
-            content = treat_children_coradoc(node, state)
-
-            if node_has_ancestor?(node, markup_ancestor_tag_names)
-              content
-            elsif node.children.empty?
-              # Return InlineElement wrapper for whitespace
-              if leading_ws
-                Coradoc::CoreModel::TextElement.new(
-                  content: leading_ws
-                )
-              end
-            else
-              u = (u_before && leading_whitespace.nil?) ||
-                  (u_after && trailing_whitespace.nil?)
-
-              # Separate text strings from InlineElements in content array
-              text_content, nested = extract_text_and_elements(content)
-
-              # Create CoreModel::InlineElement with the appropriate format type
-              inline_element = Coradoc::CoreModel::InlineElement.format_type_class(coradoc_format_type).new(
-                content: text_content,
-                nested_elements: nested.empty? ? nil : nested,
-                metadata: { unconstrained: u }
-              )
-              result = [leading_whitespace, inline_element, trailing_whitespace].compact
-              result.length == 1 ? result.first : result
-            end
-          end
-
-          # Extract text content and InlineElements from mixed content array
-          def extract_text_and_elements(content)
-            return [content, []] unless content.is_a?(Array)
-
-            text_parts = []
-            elements = []
-
-            content.each do |item|
-              case item
-              when String
-                text_parts << item
-              when Coradoc::CoreModel::InlineElement
-                elements << item
-              when Coradoc::CoreModel::Base
-                # For other block types, convert to text
-                text_parts << extract_text_from_model(item)
-              else
-                text_parts << item.to_s
-              end
-            end
-
-            [text_parts.join, elements]
-          end
-
-          # Extract text from a CoreModel object
-          def extract_text_from_model(model)
-            return '' if model.nil?
-
-            if model.is_a?(Coradoc::CoreModel::Base) && model.content.is_a?(String)
-              model.content
-            elsif model.is_a?(Coradoc::CoreModel::StructuralElement) && model.children.is_a?(Array)
-              model.children.map { |c| extract_text_from_model(c) }.join
-            elsif model.is_a?(Coradoc::CoreModel::Base) && model.title.is_a?(String)
-              model.title
-            else
-              model.to_s
-            end
-          end
-
-          # Subclasses should override this to return the format type
-          def coradoc_format_type
-            'text'
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Coradoc
-  module Input
-    module Html
-      module Converters
-        class Math < Base
-          INSTANCE = new
-
-          def to_coradoc(node, _state = {})
-            stem = node.to_s.tr("\n", ' ')
-            if Coradoc::Html::Input.config.mathml2asciimath
-              require 'plurimath'
-              stem = Plurimath::Math.parse(stem, :mathml).to_asciimath
-            end
-
-            unless stem.nil?
-              stem = stem.gsub('[', '\\[')
-              stem = stem.gsub(']', '\\]')
-              loop do
-                new_stem = stem.gsub(/\(\(([^)]{1,100})\)\)/, '(\\1)')
-                break if new_stem == stem
-
-                stem = new_stem
-              end
-            end
-
-            Coradoc::CoreModel::StemElement.new(
-              content: stem,
-              stem_type: 'mathml'
-            )
-          end
-        end
-
-        register :math, Math::INSTANCE
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# 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