arrolio 0.1.0 → 0.1.2

data/lib/arrolio/generic_adapter/metadata_extraction.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Arrolio
+  class GenericAdapter
+    # Extracted conversion seam (TODO 56): one module per concern,
+    # included into the adapter. The class keeps dispatch and glue.
+    module MetadataExtraction
+      def extract_metadata(root)
+        config = @rules['metadata'] || {}
+        bibdata_path = config['root'] || 'bibdata'
+        bibdata = find_first(root, bibdata_path)
+        return {} unless bibdata
+
+        result = {}
+        (config['fields'] || {}).each do |key, xpath|
+          value = text_of(find_first(bibdata, xpath))
+          result[key.to_sym] = value if value && !value.empty?
+        end
+        derive_metadata_fields(result)
+        result
+      end
+
+      def derive_metadata_fields(result)
+        lang = result[:language].to_s
+        version_date = result[:revision_date]
+        year = version_date&.[](0, 4)
+        result[:revision_year] = year if year&.match?(/\A\d{4}\z/)
+        return if lang.empty? && version_date.nil?
+
+        lang_initial = lang[0, 1].upcase
+        year_part = year&.match?(/\A\d{4}\z/) ? "#{year} " : ''
+        result[:edition_label] = "#{year_part}(#{lang_initial})"
+      end
+
+      def extract_cover(root)
+        metadata = extract_metadata(root)
+        config = @rules['cover'] || {}
+        result = {}
+        (config['fields'] || ['docidentifier', 'edition', 'title_main', 'title_part']).each do |field|
+          result[field.to_sym] = metadata[field.to_sym] if metadata[field.to_sym]
+        end
+        result.empty? ? nil : result
+      end
+    end
+  end
+end

data/lib/arrolio/generic_adapter/table_conversion.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Arrolio
+  class GenericAdapter
+    # Table conversion, split from the adapter body (TODO 56 MECE
+    # split). Converts <table> to Content::Table: rows and cells
+    # with colspan/rowspan/alignment, captions, and cell footnotes
+    # lifted to the table.
+    module TableConversion
+      def convert_table(elem)
+        header, header_footnotes = convert_table_rows(find_first(elem, selector('table_header')), true)
+        body, body_footnotes = convert_table_rows(find_first(elem, selector('table_body')), false)
+        caption = extract_table_caption(elem)
+        Content::Table.new(header: header, body: body, style_id: :table,
+                           id: elem.attribute(selector('id_attribute'))&.value,
+                           caption: caption,
+                           footnotes: header_footnotes + body_footnotes)
+      end
+
+      # The caption carries inline content (math subscripts, xrefs) —
+      # flattening to text serializes stems to their raw asciimath
+      # form ("n_(\"LC\")"). Collect runs like figure captions do.
+      def extract_table_caption(elem)
+        name = find_first(elem, selector('figure_caption')) ||
+               find_first(elem, selector('figure_caption_fallback'))
+        return nil unless name
+
+        runs = collect_inline_runs(name)
+        runs.empty? ? nil : Content::Paragraph.new(runs, style_id: :figure_caption)
+      end
+
+      def convert_table_rows(parent, is_header)
+        return [[], []] unless parent
+
+        rows = []
+        footnotes = []
+        row_name = selector('table_row')
+        cell_names = Array(selector('table_cell'))
+        each_child(parent, row_name) do |tr|
+          cells = []
+          each_element(tr) do |cell|
+            next unless cell_names.include?(cell.name)
+
+            runs, cell_footnotes = cell_runs_with_footnotes(cell)
+            footnotes.concat(cell_footnotes)
+            cells << Content::Table::Cell.new(
+              [Content::Paragraph.new(runs, style_id: is_header ? :table_header_cell : :table_cell)],
+              colspan: (cell.attribute('colspan')&.value || 1).to_i,
+              rowspan: (cell.attribute('rowspan')&.value || 1).to_i,
+              style_id: is_header ? :table_header_cell : :table_cell,
+              align: cell.attribute('align')&.value,
+              valign: cell.attribute('valign')&.value
+            )
+          end
+          rows << Content::Table::Row.new(cells)
+        end
+        [rows, footnotes]
+      end
+
+      # Footnotes referenced from table cells keep only their marker
+      # (a superscript run) in the cell; their body is collected onto
+      # the table and rendered below it — the FOP table-footnote
+      # convention. Inline collection skips the marker element's
+      # subtree so the body text never leaks into the cell.
+      def cell_runs_with_footnotes(cell)
+        fn_name = selector('footnote_marker')
+        runs = collect_inline_runs(cell, exclude: fn_name)
+        return [runs, []] unless fn_name
+
+        footnotes = []
+        cell.each_recursive do |node|
+          next unless node.is_a?(REXML::Element) && node.name == fn_name
+
+          marker = node.attribute('reference')&.value ||
+                   node.attribute('id')&.value || ''
+          unless marker.empty?
+            runs << Content::InlineRun.new(
+              marker, style_id: :inline,
+                      baseline_shift: Content::InlineRun::BASELINE_SUP,
+                      font_size_scale: 0.7
+            )
+          end
+          footnotes << table_footnote(node, marker)
+        end
+        [runs, footnotes]
+      end
+
+      def table_footnote(fn_elem, marker)
+        para_name = selector('paragraph')
+        body = []
+        each_element(fn_elem) do |child|
+          next unless child.name == para_name
+
+          body << convert_paragraph(child)
+        end
+        Content::Footnote.new(
+          marker: marker,
+          body: body,
+          id: fn_elem.attribute(selector('id_attribute'))&.value
+        )
+      end
+
+    end
+  end
+end