obp-access 0.1.1

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Root
+          TITLE_PARTS = %w[intro main compl].freeze
+
+          attr_reader :urn, :metas
+
+          def initialize(urn:, metas:)
+            @urn = urn
+            @metas = metas
+          end
+
+          def content # rubocop:disable Metrics/AbcSize
+            Nokogiri::XML::Builder.new(namespace_inheritance: false,
+                                       encoding: "UTF-8") do |xml|
+              xml.standard("xmlns:ali": "http://www.niso.org/schemas/ali/1.0/",
+                           "xmlns:mml": "http://www.w3.org/1998/Math/MathML",
+                           "xmlns:tbx": "urn:iso:std:iso:30042:ed-2",
+                           "xmlns:xlink": "http://www.w3.org/1999/xlink",
+                           "dtd-version": "1.0") do
+                xml.front do
+                  xml.public_send(:"std-meta", "std-meta-type": "international") do
+                    std_meta_content(xml)
+                  end
+                end
+                xml.body
+                xml.back
+              end
+            end
+          end
+
+          def to_document
+            content.doc
+          end
+
+          private
+
+          def std_meta_content(xml)
+            render_titles(xml)
+            xml.public_send(:"proj-id", ref_undated)
+            xml.public_send(:"release-version", doc_type)
+            render_std_ident(xml)
+            xml.public_send(:"content-language", metas["language"])
+            xml.public_send(:"std-ref", ref_dated, type: "dated")
+            xml.public_send(:"std-ref", ref_undated, type: "undated")
+            xml.public_send(:"doc-ref", ref)
+            xml.public_send(:"self-uri", urn.to_s)
+            render_permissions(xml)
+          end
+
+          def render_std_ident(xml)
+            xml.public_send(:"std-ident") do
+              xml.originator holder
+              xml.public_send(:"doc-type", doc_type)
+              xml.public_send(:"doc-number", urn_parts[3])
+              xml.edition urn_parts[4].delete_prefix("ed-")
+              xml.version urn_parts[5].delete_prefix("v")
+            end
+          end
+
+          def render_permissions(xml)
+            xml.permissions do
+              xml.public_send(:"copyright-statement", "All rights reserved")
+              xml.public_send(:"copyright-year", copyright_year) if copyright_year
+              xml.public_send(:"copyright-holder", holder)
+            end
+          end
+
+          def render_titles(xml)
+            metas["titles"].each do |language, title|
+              next unless title
+
+              xml.public_send(:"title-wrap", "xml:lang": language) do
+                split = title.split("—")
+                TITLE_PARTS.each_with_index do |e, i|
+                  xml.public_send(e, split[i].strip) if split[i]
+                end
+                xml.full title
+              end
+            end
+          end
+
+          def holder
+            metas["caption"].split.first
+          end
+
+          def ref
+            metas["caption"]
+          end
+
+          def ref_dated
+            metas["caption"].gsub(/\(.*?\)/, "")
+          end
+
+          def ref_undated
+            @ref_undated ||= metas["caption"].split(":").first
+          end
+
+          def copyright_year
+            metas["caption"][/:(\d{4})/, 1]
+          end
+
+          def doc_type
+            case urn_parts[3]
+            when "ts" then "TS"
+            when "tr" then "TR"
+            else "IS"
+            end
+          end
+
+          def urn_parts
+            @urn_parts ||= urn.raw.split(":")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Section < Base
+          def self.classes
+            %w[sts-section]
+          end
+
+          def match_node?
+            super && id =~ /\A\d+(\.\d+)*\z/
+          end
+
+          private
+
+          def insertion_target
+            "body"
+          end
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              attrs = { id: "sec_#{id}" }
+              sec_type = SectionType.for(id)
+              attrs[:"sec-type"] = sec_type if sec_type
+              xml.sec(**attrs) do
+                xml.label id
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Section)

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class SectionTitle
+          LABEL_PATTERN = /\A(\d+(?:\.\d+)*)\s{2,}/
+
+          attr_reader :label, :text
+
+          def initialize(raw_text)
+            match = raw_text.match(LABEL_PATTERN)
+            if match
+              @label = match[1]
+              @text = raw_text[match[0].length..].strip
+            else
+              @label = nil
+              @text = raw_text.strip
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class SectionType
+          FIXED_TYPES = {
+            "1" => "scope",
+            "2" => "norm-refs",
+          }.freeze
+
+          def self.for(id)
+            FIXED_TYPES[id] || infer_from_pattern(id)
+          end
+
+          def self.infer_from_pattern(id)
+            return "terms" if id.match?(/\A\d+\.\d*\z/)
+            return "terms" if id.match?(/\A\d+\z/) && id.to_i >= 3
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class TableWrap < Base
+          def self.classes
+            %w[sts-table-wrap fig-index]
+          end
+
+          def match_node?
+            super && !inside_figure?
+          end
+
+          private
+
+          def inside_figure?
+            node.ancestors.any? { |a| a.classes == ["sts-fig"] }
+          end
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"table-wrap") do
+                xml.label caption_label if caption_label
+                if caption_text
+                  xml.caption do
+                    xml.title caption_text
+                  end
+                end
+                xml.table { xml << node.at_css("table").inner_html }
+              end
+            end
+          end
+
+          def caption_label
+            @caption_label ||= node.at_css(".sts-caption-label")&.content
+          end
+
+          def caption_text
+            @caption_text ||= node.at_css(".sts-caption")&.content
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::TableWrap)

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

@@ -0,0 +1,27 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class Base < Elements::Base
+            include InlineRenderer
+
+            def self.classes
+              nil
+            end
+
+            private
+
+            def path_suffix
+              "/tbx:termEntry/tbx:langSet"
+            end
+
+            def bold_term?(node)
+              node.inner_html.start_with?("<b>") || node.inner_html.include?("<b>")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/obp/access/elements/terminology/definition.rb

@@ -0,0 +1,44 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class Definition < Base
+            def self.classes
+              %w[sts-tbx-def]
+            end
+
+            private
+
+            def insert_method
+              :prepend_child
+            end
+
+            def content
+              extracted = DomainExtractor.extract(node)
+              @fragment = Nokogiri::XML::DocumentFragment.new(document)
+
+              Nokogiri::XML::Builder.with(@fragment) do |xml|
+                extracted.domains.each do |domain|
+                  xml.public_send(:"tbx:subjectField") { xml << domain }
+                end
+                xml.public_send(:"tbx:definition") do
+                  extracted.clean_children.each { |child| render_inline(xml, child) }
+                end
+              end
+
+              @fragment
+            end
+
+            def to_xml
+              content
+              @fragment.to_xml
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology::Definition)

data/lib/obp/access/elements/terminology/example.rb

@@ -0,0 +1,27 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class Example < Base
+            def self.classes
+              %w[sts-tbx-example]
+            end
+
+            private
+
+            def content
+              Nokogiri::XML::Builder.new do |xml|
+                xml.public_send(:"tbx:example") do
+                  node.css(".sts-tbx-example-content").children.each { |children| render_inline(xml, children) }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology::Example)

data/lib/obp/access/elements/terminology/note.rb

@@ -0,0 +1,27 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class Note < Base
+            def self.classes
+              %w[sts-tbx-note]
+            end
+
+            private
+
+            def content
+              Nokogiri::XML::Builder.new do |xml|
+                xml.public_send(:"tbx:note") do
+                  node.children.each { |children| render_inline(xml, children) }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology::Note)

data/lib/obp/access/elements/terminology/source.rb

@@ -0,0 +1,45 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class Source < Base
+            def self.classes
+              %w[sts-tbx-source]
+            end
+
+            private
+
+            def content
+              Nokogiri::XML::Builder.new do |xml|
+                xml.public_send(:"tbx:source") do
+                  node.children.each do |child|
+                    if child.classes == ["sts-xref"]
+                      render_ref(xml, child)
+                    else
+                      render_text(xml, child)
+                    end
+                  end
+                end
+              end
+            end
+
+            def render_ref(xml, child)
+              rid = child.attr("href").split(":").last
+              xml.xref("ref-type": "bibr", rid: "ref_#{rid}") do
+                xml << child.inner_html
+              end
+            end
+
+            def render_text(xml, child)
+              content = child.to_s.strip.gsub(/^\[SOURCE:|\]$/, "")
+              xml << content
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology::Source)

data/lib/obp/access/elements/terminology/tig.rb

@@ -0,0 +1,59 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class Tig < Base
+            def self.classes
+              %w[sts-tbx-term]
+            end
+
+            private
+
+            def id
+              node.parent.at_css("div.sts-tbx-label").text.strip
+            end
+
+            def index
+              node.path.match(/\[(\d+)\](?=\z)/)[1].to_i - 1
+            end
+
+            def normative_authorization
+              bold_term?(node) ? "admittedTerm" : "preferredTerm"
+            end
+
+            def content
+              Nokogiri::XML::Builder.new do |xml|
+                xml.public_send(:"tbx:tig", id: "term_#{id}-#{index}") do
+                  render_tig_content(xml)
+                end
+              end
+            end
+
+            def render_tig_content(xml)
+              result = GrammarParser.parse(parsed_html)
+              xml.public_send(:"tbx:term") { xml << result.term }
+              xml.public_send(:"tbx:partOfSpeech", value: result.pos)
+              render_genders(xml, result.genders)
+              xml.public_send(:"tbx:normativeAuthorization", value: normative_authorization)
+            end
+
+            def parsed_html
+              node.inner_html
+            end
+
+            def render_genders(xml, genders)
+              return unless genders.any?
+
+              genders.each do |gender|
+                xml.public_send(:"tbx:gram", value: gender, type: "gender")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology::Tig)

data/lib/obp/access/elements/terminology/tig_admitted.rb

@@ -0,0 +1,23 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class TigAdmitted < Tig
+            def self.classes
+              %w[sts-tbx-term admittedTerm]
+            end
+
+            private
+
+            def normative_authorization
+              "admittedTerm"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology::TigAdmitted)

data/lib/obp/access/elements/terminology/tig_deprecated.rb

@@ -0,0 +1,39 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class TigDeprecated < Tig
+            def self.classes
+              %w[sts-tbx-term deprecatedTerm]
+            end
+
+            private
+
+            def normative_authorization
+              "deprecatedTerm"
+            end
+
+            def content
+              Nokogiri::XML::Builder.new do |xml|
+                xml.public_send(:"tbx:tig", id: "term_#{id}-#{index}") do
+                  render_tig_content(xml)
+                end
+              end
+            end
+
+            def parsed_html
+              strip_deprecation_label(node.inner_html)
+            end
+
+            def strip_deprecation_label(html)
+              html.gsub(%r{<span class="sts-tbx-term-depr-label">.*?</span>}, "")
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology::TigDeprecated)

data/lib/obp/access/elements/terminology/tig_preferred.rb

@@ -0,0 +1,23 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology
+          class TigPreferred < Tig
+            def self.classes
+              %w[sts-tbx-term preferredTerm]
+            end
+
+            private
+
+            def normative_authorization
+              "preferredTerm"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology::TigPreferred)

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

@@ -0,0 +1,28 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Terminology < Base
+          def self.classes
+            %w[sts-section sts-tbx-sec]
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"term-sec", id: "sec_#{id}") do
+                xml.label id
+                xml.public_send(:"tbx:termEntry", id: "term_#{id}") do
+                  xml.public_send(:"tbx:langSet", "xml:lang": metas["language"])
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Terminology)

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class Title < Base
+          def self.classes
+            %w[sts-sec-title]
+          end
+
+          private
+
+          def insert_method
+            :add_child
+          end
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.title sanitize_text(section_title.text)
+            end
+          end
+
+          def section_title
+            @section_title ||= SectionTitle.new(node.content)
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Title)