obp-access 0.1.1

data/lib/obp/access/elements/array.rb

@@ -0,0 +1,64 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Array < Base
+          def self.classes
+            %w[sts-array]
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.array do
+                xml.table do
+                  render_colgroup(xml)
+                  render_thead(xml)
+                  render_tbody(xml)
+                end
+              end
+            end
+          end
+
+          def render_colgroup(xml)
+            cols = node.css("colgroup col")
+            return if cols.empty?
+
+            xml.colgroup do
+              cols.each { |col| xml.col col.attributes.slice("align", "width") }
+            end
+          end
+
+          def render_thead(xml)
+            rows = node.css("thead tr")
+            return if rows.empty?
+
+            xml.thead do
+              rows.each do |tr|
+                xml.tr do
+                  tr.css("th").each { |th| xml.th sanitize_text(th.content) }
+                end
+              end
+            end
+          end
+
+          def render_tbody(xml)
+            rows = node.css("tbody tr")
+            return if rows.empty?
+
+            xml.tbody do
+              rows.each do |tr|
+                xml.tr do
+                  tr.css("td").each { |td| xml.td sanitize_text(td.content) }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Array)

data/lib/obp/access/elements/base.rb

@@ -0,0 +1,69 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Base
+          # Elements are rendered using the NISO STS spec:
+          # https://www.niso-sts.org/TagLibrary/niso-sts-TL-1-2-html/index.html
+          attr_reader :document, :metas, :node
+
+          def initialize(document:, metas:, node:)
+            @document = document
+            @metas = metas
+            @node = node
+          end
+
+          def self.classes
+            nil
+          end
+
+          def match_node?
+            node.classes == self.class.classes
+          end
+
+          def render(target:)
+            effective_target = insertion_target || target
+            effective_target = "#{effective_target}#{path_suffix}" if path_suffix
+            document.at(effective_target).public_send(insert_method, to_xml)
+          end
+
+          private
+
+          def insertion_target
+            nil
+          end
+
+          def path_suffix
+            nil
+          end
+
+          def insert_method
+            :add_child
+          end
+
+          def id
+            @id ||= node.attr("id").split("_").last
+          end
+
+          def to_xml
+            content.doc.root.to_xml
+          end
+
+          def content
+            raise NotImplementedError
+          end
+
+          def sanitize_text(text)
+            text
+              .gsub("<b>", "<bold>").gsub("</b>", "</bold>")
+              .gsub("<i>", "<italic>").gsub("</i>", "</italic>")
+          end
+
+          def local_image_path(img)
+            metas["images"][img.attr("src")]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/obp/access/elements/bibliography/bib_ref.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class BibRef
+          REF_PATTERN = /\A\[(\d+)\]\s*/
+          DATED_PATTERN = /:\d{4}/
+
+          attr_reader :index, :std_ref_text, :title_text, :std_id, :type
+
+          def initialize(td_node, anchor_node)
+            text = td_node.text
+            @index = parse_index(text)
+            @std_id = parse_std_id(anchor_node)
+            @type = infer_type(text)
+            @std_ref_text, @title_text = parse_parts(td_node)
+          end
+
+          private
+
+          def parse_index(text)
+            text[REF_PATTERN, 1].to_i
+          end
+
+          def parse_std_id(anchor)
+            return nil unless anchor
+
+            name = anchor.attr("name")
+            return nil unless name
+            return nil unless name.include?(":ref:")
+
+            name.sub(/:ref:\d+\z/, "")
+          end
+
+          def infer_type(text)
+            text.match?(DATED_PATTERN) ? "dated" : "undated"
+          end
+
+          def parse_parts(td_node)
+            content = td_node.inner_html
+            content = content.sub(REF_PATTERN, "")
+            if content.include?("<i>")
+              parts = content.split(/,\s*<i>/, 2)
+              std_ref = parts[0].strip
+              title = parts[1]&.sub(%r{</i>}, "")&.strip
+              [std_ref, title]
+            elsif content.include?(",")
+              parts = content.split(",", 2)
+              [parts[0].strip, parts[1]&.strip]
+            else
+              [content.strip, nil]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/obp/access/elements/bibliography.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "bibliography/bib_ref"
+
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Bibliography < Base
+          def self.classes
+            %w[sts-section sts-ref-list]
+          end
+
+          private
+
+          def insertion_target
+            "back"
+          end
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"ref-list", "content-type": "bibl", id: "sec_bibl") do
+                node.css("tr").drop(1).each_with_index do |row, _index|
+                  td = row.css("td:last-child")
+                  anchor = row.at_css("td:first-child a[name]")
+                  ref = BibRef.new(td, anchor)
+                  xml.ref("content-type": "standard", id: "ref_#{ref.index}") do
+                    xml.label "[#{ref.index}]"
+                    render_std(xml, ref)
+                  end
+                end
+              end
+            end
+          end
+
+          def render_std(xml, ref)
+            attrs = {}
+            attrs["std-id"] = ref.std_id if ref.std_id
+            attrs["type"] = ref.type if ref.type
+
+            xml.std(**attrs) do
+              xml.std_ref(ref.std_ref_text)
+              xml.title ref.title_text if ref.title_text
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Bibliography)

data/lib/obp/access/elements/copyright.rb

@@ -0,0 +1,27 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Copyright < Base
+          def self.classes
+            %w[sts-copyright]
+          end
+
+          private
+
+          def insertion_target
+            "front/std-meta/permissions"
+          end
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"copyright-year", node.content.scan(/\d+/).first)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Copyright)

data/lib/obp/access/elements/figure.rb

@@ -0,0 +1,58 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Figure < Base
+          def self.classes
+            %w[sts-fig]
+          end
+
+          def match_node?
+            super && node.css("img").any?
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.fig do
+                render_caption(xml)
+                xml.graphic("xlink:href": local_image_path(node.at_css("img")))
+
+                legend_table = node.at_css("div.sts-table-wrap.fig-index")
+                render_legend(xml, legend_table) if legend_table
+              end
+            end
+          end
+
+          def render_caption(xml)
+            caption = node.at_css(".sts-caption")
+            return unless caption
+
+            label = caption.at_css(".sts-caption-label")
+            xml.label label.content if label
+            title = caption.at_css(".sts-caption-title")
+            xml.caption do
+              xml.title title.content if title
+            end
+          end
+
+          def render_legend(xml, table_node)
+            xml.public_send(:"table-wrap", "content-type": "legend") do
+              caption = table_node.at_css(".sts-caption")
+              if caption
+                xml.caption do
+                  title = caption.at_css(".sts-caption-title")
+                  xml.title title.content if title
+                end
+              end
+              xml.table { xml << table_node.at_css("table").inner_html }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Figure)

data/lib/obp/access/elements/figure_group.rb

@@ -0,0 +1,48 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class FigureGroup < Base
+          def self.classes
+            %w[sts-fig]
+          end
+
+          def match_node?
+            super && node.css("img").count > 1
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"fig-group") do
+                render_caption(xml, node)
+                node.css("img").each { |img| render_figure(xml, img) }
+              end
+            end
+          end
+
+          def render_caption(xml, children)
+            xml.label children.at(".sts-caption-label").content
+            xml.caption do
+              xml.title children.at(".sts-caption-title").content
+            end
+          end
+
+          def render_figure(xml, img)
+            xml.fig do
+              div = img.previous
+              xml.label div.at(".sts-caption-label").content
+              xml.caption do
+                xml.title div.at(".sts-caption-title").content
+              end
+              xml.graphic("xlink:href": local_image_path(img))
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::FigureGroup)

data/lib/obp/access/elements/index.rb

@@ -0,0 +1,113 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Index < Base
+          def self.classes
+            %w[sts-section]
+          end
+
+          def match_node?
+            super && index_section?
+          end
+
+          private
+
+          def index_section?
+            node_id = node.attr("id").to_s
+            node_id.include?("sec_index") || index_title?
+          end
+
+          def index_title?
+            title = node.at_css("h1.sts-sec-title")
+            title&.text&.match?(/index|Index|verzeichnis/i)
+          end
+
+          def insertion_target
+            "body"
+          end
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.sec(id: "sec_index") do
+                xml.title index_title_text
+                xml.index do
+                  render_index_divs(xml)
+                end
+              end
+            end
+          end
+
+          def render_index_divs(xml)
+            grouped_entries.each do |letter, entries|
+              xml.public_send(:"index-div") do
+                xml.title letter
+                entries.each { |entry| render_index_entry(xml, entry) }
+              end
+            end
+          end
+
+          def render_index_entry(xml, entry)
+            xml.public_send(:"index-entry") do
+              xml.term entry[:term]
+              entry[:refs].each do |ref|
+                xml.xref("ref-type": "sec", rid: "sec_#{ref[:rid]}") { xml << ref[:text] }
+              end
+            end
+          end
+
+          def index_title_text
+            node.at_css("h1.sts-sec-title")&.text || "Index"
+          end
+
+          def grouped_entries
+            groups = {}
+            current_letter = nil
+
+            node.css("div.sts-p").each do |para|
+              letter = letter_heading(para)
+              if letter
+                current_letter = letter
+                groups[current_letter] ||= []
+              elsif current_letter && index_entry?(para)
+                groups[current_letter] << parse_entry(para)
+              end
+            end
+
+            groups
+          end
+
+          def letter_heading(para)
+            return nil unless para.inner_html.match?(/\A<b>[A-Z0-9À-Ü]<\/b>\z/)
+
+            para.at_css("b")&.text
+          end
+
+          def index_entry?(para)
+            !para.at_css("a.sts-xref").nil?
+          end
+
+          def parse_entry(para)
+            term_node = para.at_css("a.sts-xref")
+            { term: entry_term_text(term_node), refs: entry_refs(para) }
+          end
+
+          def entry_term_text(term_node)
+            preceding = term_node.previous
+            return "" unless preceding.is_a?(Nokogiri::XML::Text)
+
+            preceding.text.strip.gsub(/[[:space:]]+/, " ").strip
+          end
+
+          def entry_refs(para)
+            para.css("a.sts-xref").map do |xref|
+              { rid: xref.attr("href").split(":").last, text: xref.text.strip }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Index)

data/lib/obp/access/elements/introduction.rb

@@ -0,0 +1,31 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Introduction < Base
+          def self.classes
+            %w[sts-section]
+          end
+
+          def match_node?
+            super && %w[foreword intro].include?(id)
+          end
+
+          private
+
+          def insertion_target
+            "front"
+          end
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.sec(id: "sec_#{id}", "sec-type": id)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Introduction)

data/lib/obp/access/elements/list.rb

@@ -0,0 +1,58 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class List < Base
+          include InlineRenderer
+
+          def self.classes
+            %w[list]
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.list("list-type": "dash") do
+                node.xpath("./ul/li").each do |li|
+                  xml.public_send(:"list-item") do
+                    render_li(xml, li)
+                  end
+                end
+              end
+            end
+          end
+
+          def render_li(xml, item)
+            render_li_label(xml, item)
+            render_li_paragraph(xml, item)
+            render_nested_list(xml, item)
+          end
+
+          def render_li_label(xml, item)
+            label = item.at_css("span.sts-label")
+            xml.label label.text if label
+          end
+
+          def render_li_paragraph(xml, item)
+            p_node = item.at_css(".sts-p")
+            return unless p_node
+
+            xml.p { p_node.children.each { |c| render_inline(xml, c) } }
+          end
+
+          def render_nested_list(xml, item)
+            nested = item.at_css(".list")
+            return unless nested
+
+            nested.xpath("./ul/li").each do |nested_item|
+              xml.public_send(:"list-item") { render_li(xml, nested_item) }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::List)

data/lib/obp/access/elements/non_normative_note.rb

@@ -0,0 +1,47 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class NonNormativeNote < Base
+          include InlineRenderer
+
+          def self.classes
+            %w[sts-non-normative-note]
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"non-normative-note") do
+                label_node = node.at_css(".sts-non-normative-note-label")
+                xml.label label_node.text if label_node
+
+                p_node = node.at_css("p")
+                if p_node
+                  xml.p do
+                    p_node.children.each { |child| render_inline(xml, child) }
+                  end
+                end
+              end
+            end
+          end
+
+          def inline_type(node)
+            if node.is_a?(Nokogiri::XML::Text)
+              :text
+            elsif node.is_a?(Nokogiri::XML::Element)
+              if node.classes == ["sts-non-normative-note-label"]
+                :label
+              else
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::NonNormativeNote)

data/lib/obp/access/elements/paragraph.rb

@@ -0,0 +1,31 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Paragraph < Base
+          include InlineRenderer
+
+          def self.classes
+            %w[sts-p]
+          end
+
+          def match_node?
+            super && node.parent.name != "li"
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.p do
+                node.children.each { |child| render_inline(xml, child) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Paragraph)