sts 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cf9370f41e856bec3105aae63dee1ec0b7de2b0455b82e22efbcaac5356214b
-  data.tar.gz: e38776ce218347afda6384f3cd8e0f1b2d3a73ad9797e274ceb4fd9b5eed421f
+  metadata.gz: 29fa738a2be8fa8ad9b9deac71cf0ff7e6e84fdb4f6fdeef1cc7695b4eb0848d
+  data.tar.gz: 3b2538ea0daeca072954ff6ff95c78ed43da784024de3151c6fc8ffca47fb552
 SHA512:
-  metadata.gz: dc92899284afb3487523d40c6b62850b6b01dfcf87c0a60fff32d66196f3c7aedfda620e0c75a61e5cdc949fce99d0a02ed2a02e9bc55a553637dce0763c51b8
-  data.tar.gz: 36abf1f049426ea1453259cc0fe738ce113944aa37ee0d8ef4b892b02a7bb3c596ab1ff1000a2eb9c77faa45f9d2ce88d4ba8351125939a6b150ad5546c35276
+  metadata.gz: 2cc9dc6d6365b1c8bc92ba833a9064bf1e2e4961bad763655eaecf2ccdaa872622755a27308d292491b5a5b3803b74803630e944f86c21331eb11821ed47143b
+  data.tar.gz: 928162548cc113a5438b997c6b8ea208d91858b446e663a70ffacb7f7a16886fdf12cd21f8de2039b50e6ee21ca539b62e7667f973132b5edd47504e4aaa7f63

data/.github/workflows/release.yml

@@ -19,5 +19,5 @@ jobs:
     with:
       next_version: ${{ github.event.inputs.next_version }}
     secrets:
-      rubygems-api-key: ${{ secrets.METANORMA_CI_PAT_TOKEN }}
+      rubygems-api-key: ${{ secrets.METANORMA_CI_RUBYGEMS_API_KEY }}
       pat_token: ${{ secrets.METANORMA_CI_PAT_TOKEN }}

data/.rubocop.yml

@@ -0,0 +1,12 @@
+inherit_from:
+  - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
+
+# local repo-specific modifications
+# ...
+
+AllCops:
+  TargetRubyVersion: 2.6
+  NewCops: enable
+  Exclude:
+    - 'lib/sts/mapper.rb'
+    - 'vendor/**/*'

data/Gemfile

@@ -5,8 +5,14 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in sts.gemspec
 gemspec
 
+gem "pry", "~> 0.14.0"
+
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 
 gem "rubocop", "~> 1.21"
+
+gem "rubocop-performance", "~> 1.19"
+
+gem "equivalent-xml", "~> 0.6"

data/lib/sts/mapper.rb

@@ -0,0 +1,442 @@
+# rubocop:disable AllCops
+
+require "shale"
+
+module Sts
+  class Mapper < Shale::Mapper
+    class << self
+      # Convert XML document to Object
+      #
+      # @param [Shale::Adapter::<XML adapter>::Node] element
+      # @param [Array<Symbol>] only
+      # @param [Array<Symbol>] except
+      # @param [any] context
+      #
+      # @return [model instance]
+      #
+      # @api public
+      def of_xml(element, only: nil, except: nil, context: nil)
+        instance = model.new
+
+        attributes
+          .values
+          .select { |attr| attr.default }
+          .each { |attr| instance.send(attr.setter, attr.default.call) }
+
+        grouping = Shale::Mapping::Group::XmlGrouping.new
+        delegates = Shale::Mapping::Delegates.new
+
+        only = to_partial_render_attributes(only)
+        except = to_partial_render_attributes(except)
+
+        element.attributes.each do |key, value|
+          mapping = xml_mapping.attributes[key.to_s]
+          next unless mapping
+
+          if mapping.group
+            grouping.add(mapping, :attribute, value)
+          elsif mapping.method_from
+            mapper = new
+
+            if mapper.method(mapping.method_from).arity == 3
+              mapper.send(mapping.method_from, instance, value, context)
+            else
+              mapper.send(mapping.method_from, instance, value)
+            end
+          else
+            receiver_attributes = get_receiver_attributes(mapping)
+            attribute = receiver_attributes[mapping.attribute]
+            next unless attribute
+
+            next if only && !only.key?(attribute.name)
+            next if except&.key?(attribute.name)
+
+            casted_value = attribute.type.cast(value)
+
+            if attribute.collection?
+              if mapping.receiver
+                delegates.add_collection(
+                  attributes[mapping.receiver],
+                  attribute.setter,
+                  casted_value
+                )
+              else
+                instance.send(attribute.name) << casted_value
+              end
+            elsif mapping.receiver
+              delegates.add(attributes[mapping.receiver], attribute.setter, casted_value)
+            else
+              instance.send(attribute.setter, casted_value)
+            end
+          end
+        end
+
+        content_mapping = xml_mapping.content
+
+        if content_mapping
+          if content_mapping.group
+            grouping.add(content_mapping, :content, element)
+          elsif content_mapping.method_from
+            mapper = new
+
+            if mapper.method(content_mapping.method_from).arity == 3
+              mapper.send(content_mapping.method_from, instance, element, context)
+            else
+              mapper.send(content_mapping.method_from, instance, element)
+            end
+          else
+            get_content_value(content_mapping, element, only, except, delegates, instance)
+          end
+        end
+
+        element.instance_variable_get(:@node)&.children&.each do |nokogiri_node|
+          if nokogiri_node.name == "text"
+            next unless content_mapping
+
+            content_value = get_content_value(content_mapping, nokogiri_node, only, except, delegates, instance)
+            instance.all_content << ["content", content_value]
+            next
+          elsif nokogiri_node.name == "comment"
+            instance.all_content << ["comment", nokogiri_node.text]
+            next
+          end
+
+          node = element.class.new(nokogiri_node)
+          mapping = xml_mapping.elements[node.name]
+
+          next unless mapping
+
+          if mapping.group
+            grouping.add(mapping, :element, node)
+          elsif mapping.method_from
+            mapper = new
+
+            if mapper.method(mapping.method_from).arity == 3
+              mapper.send(mapping.method_from, instance, node, context)
+            else
+              mapper.send(mapping.method_from, instance, node)
+            end
+          else
+            receiver_attributes = get_receiver_attributes(mapping)
+            attribute = receiver_attributes[mapping.attribute]
+            next unless attribute
+
+            if only
+              attribute_only = only[attribute.name]
+              next unless only.key?(attribute.name)
+            end
+
+            if except
+              attribute_except = except[attribute.name]
+              next if except.key?(attribute.name) && attribute_except.nil?
+            end
+
+            value = attribute.type.of_xml(
+              node,
+              only: attribute_only,
+              except: attribute_except,
+              context: context
+            )
+
+            casted_value = attribute.type.cast(value)
+            instance.all_content << [mapping, casted_value]
+
+            if attribute.collection?
+              if mapping.receiver
+                delegates.add_collection(
+                  attributes[mapping.receiver],
+                  attribute.setter,
+                  casted_value
+                )
+              else
+                instance.send(attribute.name) << casted_value
+              end
+            elsif mapping.receiver
+              delegates.add(attributes[mapping.receiver], attribute.setter, casted_value)
+            else
+              instance.send(attribute.setter, casted_value)
+            end
+          end
+        end
+
+        delegates.each do |delegate|
+          receiver = get_receiver(instance, delegate.receiver_attribute)
+          receiver.send(delegate.setter, delegate.value)
+        end
+
+        grouping.each do |group|
+          mapper = new
+
+          if mapper.method(group.method_from).arity == 3
+            mapper.send(group.method_from, instance, group.dict, context)
+          else
+            mapper.send(group.method_from, instance, group.dict)
+          end
+        end
+
+        instance
+      end
+
+      # Convert Object to XML document
+      #
+      # @param [any] instance Object to convert
+      # @param [String, nil] node_name XML node name
+      # @param [Shale::Adapter::<xml adapter>::Document, nil] doc Object to convert
+      # @param [Array<Symbol>] only
+      # @param [Array<Symbol>] except
+      # @param [any] context
+      #
+      # @raise [IncorrectModelError]
+      #
+      # @return [::REXML::Document, ::Nokogiri::Document, ::Ox::Document]
+      #
+      # @api public
+      def as_xml(
+        instance,
+        node_name = nil,
+        doc = nil,
+        _cdata = nil,
+        only: nil,
+        except: nil,
+        context: nil,
+        version: nil
+      )
+        unless instance.is_a?(model)
+          msg = "argument is a '#{instance.class}' but should be a '#{model}'"
+          raise IncorrectModelError, msg
+        end
+
+        unless doc
+          doc = Shale.xml_adapter.create_document(version)
+
+          element = as_xml(
+            instance,
+            xml_mapping.prefixed_root,
+            doc,
+            only: only,
+            except: except,
+            context: context
+          )
+          doc.add_element(doc.doc, element)
+
+          return doc.doc
+        end
+
+        element = doc.create_element(node_name)
+
+        doc.add_namespace(
+          xml_mapping.default_namespace.prefix,
+          xml_mapping.default_namespace.name
+        )
+
+        grouping = Shale::Mapping::Group::XmlGrouping.new
+
+        only = to_partial_render_attributes(only)
+        except = to_partial_render_attributes(except)
+
+        xml_mapping.attributes.each_value do |mapping|
+          if mapping.group
+            grouping.add(mapping, :attribute, nil)
+          elsif mapping.method_to
+            mapper = new
+
+            if mapper.method(mapping.method_to).arity == 4
+              mapper.send(mapping.method_to, instance, element, doc, context)
+            else
+              mapper.send(mapping.method_to, instance, element, doc)
+            end
+          else
+            if mapping.receiver
+              receiver = instance.send(mapping.receiver)
+            else
+              receiver = instance
+            end
+
+            receiver_attributes = get_receiver_attributes(mapping)
+            attribute = receiver_attributes[mapping.attribute]
+            next unless attribute
+
+            next if only && !only.key?(attribute.name)
+            next if except&.key?(attribute.name)
+
+            value = receiver.send(attribute.name) if receiver
+
+            if mapping.render_nil? || !value.nil?
+              doc.add_namespace(mapping.namespace.prefix, mapping.namespace.name)
+              doc.add_attribute(element, mapping.prefixed_name, value)
+            end
+          end
+        end
+
+        instance.all_content.each do |mapping, content|
+          if mapping == "comment"
+            comment = Nokogiri::XML::Comment.new(doc.doc, content)
+            doc.add_element(element, comment)
+          elsif mapping == "content"
+            content_mapping = xml_mapping.content
+            if content_mapping
+              if content_mapping.group
+                grouping.add(content_mapping, :content, nil)
+              elsif content_mapping.method_to
+                mapper = new
+
+                if mapper.method(content_mapping.method_to).arity == 4
+                  mapper.send(content_mapping.method_to, instance, element, doc, context)
+                else
+                  mapper.send(content_mapping.method_to, instance, element, doc)
+                end
+              else
+                if content_mapping.receiver
+                  receiver = instance.send(content_mapping.receiver)
+                else
+                  receiver = instance
+                end
+
+                receiver_attributes = get_receiver_attributes(content_mapping)
+                attribute = receiver_attributes[content_mapping.attribute]
+
+                if attribute
+                  skip = false
+
+                  # rubocop:disable Metrics/BlockNesting
+                  skip = true if only && !only.key?(attribute.name)
+                  skip = true if except&.key?(attribute.name)
+
+                  unless skip
+                    # value = receiver.send(attribute.name) if receiver
+                    value = content
+
+                    if content_mapping.cdata
+                      doc.create_cdata(value, element)
+                    else
+                      a = Nokogiri::XML::Text.new(value, doc.doc)
+                      doc.add_element(element, a)
+                    end
+                  end
+                  # rubocop:enable Metrics/BlockNesting
+                end
+              end
+            end
+          else
+            if mapping.group
+              grouping.add(mapping, :element, nil)
+            elsif mapping.method_to
+              mapper = new
+
+              if mapper.method(mapping.method_to).arity == 4
+                mapper.send(mapping.method_to, instance, element, doc, context)
+              else
+                mapper.send(mapping.method_to, instance, element, doc)
+              end
+            else
+              if mapping.receiver
+                receiver = instance.send(mapping.receiver)
+              else
+                receiver = instance
+              end
+
+              receiver_attributes = get_receiver_attributes(mapping)
+              attribute = receiver_attributes[mapping.attribute]
+              next unless attribute
+
+              if only
+                attribute_only = only[attribute.name]
+                next unless only.key?(attribute.name)
+              end
+
+              if except
+                attribute_except = except[attribute.name]
+                next if except.key?(attribute.name) && attribute_except.nil?
+              end
+
+              value = content
+
+              if mapping.render_nil? || !value.nil?
+                doc.add_namespace(mapping.namespace.prefix, mapping.namespace.name)
+              end
+
+              if value.nil?
+                if mapping.render_nil?
+                  child = doc.create_element(mapping.prefixed_name)
+                  doc.add_element(element, child)
+                end
+              elsif attribute.collection?
+                [*value].each do |v|
+                  next if v.nil?
+                  child = attribute.type.as_xml(
+                    v,
+                    mapping.prefixed_name,
+                    doc,
+                    mapping.cdata,
+                    only: attribute_only,
+                    except: attribute_except,
+                    context: context
+                  )
+                  doc.add_element(element, child)
+                end
+              else
+                child = attribute.type.as_xml(
+                  value,
+                  mapping.prefixed_name,
+                  doc,
+                  mapping.cdata,
+                  only: attribute_only,
+                  except: attribute_except,
+                  context: context
+                )
+                doc.add_element(element, child)
+              end
+            end
+          end
+        end
+
+        grouping.each do |group|
+          mapper = new
+
+          if mapper.method(group.method_to).arity == 4
+            mapper.send(group.method_to, instance, element, doc, context)
+          else
+            mapper.send(group.method_to, instance, element, doc)
+          end
+        end
+
+        element
+      end
+
+      def get_content_value(content_mapping, element, only, except, delegates, instance)
+        receiver_attributes = get_receiver_attributes(content_mapping)
+        attribute = receiver_attributes[content_mapping.attribute]
+
+        if attribute
+          skip = false
+
+          # rubocop:disable Metrics/BlockNesting
+          skip = true if only && !only.key?(attribute.name)
+          skip = true if except&.key?(attribute.name)
+
+          unless skip
+            value = attribute.type.cast(attribute.type.of_xml(element))
+
+            if content_mapping.receiver
+              delegates.add(attributes[content_mapping.receiver], attribute.setter, value)
+            else
+              instance.send(attribute.setter, value)
+            end
+          end
+          # rubocop:enable Metrics/BlockNesting
+        end
+      end
+    end
+
+    attr_accessor :all_content
+
+    def initialize
+      @all_content = []
+
+      super
+    end
+  end
+end
+
+# rubocop:enable AllCops
+

data/lib/sts/niso_sts/app.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../mapper"
+
+require_relative "section"
+require_relative "title"
+require_relative "paragraph"
+require_relative "non_normative_note"
+require_relative "figure"
+require_relative "reference_list"
+require_relative "../tbx_iso_tml/table_wrap"
+
+module Sts
+  module NisoSts
+    class Title < Sts::Mapper; end
+    class ReferenceList < Sts::Mapper; end
+
+    class App < Sts::Mapper
+      attribute :id, Shale::Type::String
+      attribute :content_type, Shale::Type::String
+      attribute :label, Shale::Type::String
+      attribute :annex_type, Shale::Type::String
+      attribute :title, Title
+      attribute :fig, Figure, collection: true
+      attribute :sec, Section, collection: true
+      attribute :paragraph, Paragraph, collection: true
+      attribute :ref_list, ReferenceList, collection: true
+      attribute :non_normative_note, NonNormativeNote, collection: true
+      attribute :table_wrap, Sts::TbxIsoTml::TableWrap, collection: true
+
+      xml do
+        root "app"
+
+        map_attribute "id", to: :id
+        map_attribute "content-type", to: :content_type
+
+        map_element "label", to: :label
+        map_element "annex-type", to: :annex_type
+        map_element "title", to: :title
+        map_element "sec", to: :sec
+        map_element "fig", to: :fig
+        map_element "p", to: :paragraph
+        map_element "ref-list", to: :ref_list
+        map_element "non-normative-note", to: :non_normative_note
+        map_element "table-wrap", to: :table_wrap
+      end
+    end
+  end
+end

data/lib/sts/niso_sts/app_group.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../mapper"
+
+require_relative "app"
+
+module Sts
+  module NisoSts
+    class AppGroup < Sts::Mapper
+      attribute :app, Sts::NisoSts::App, collection: true
+
+      xml do
+        root "app-group"
+
+        map_element "app", to: :app
+      end
+    end
+  end
+end

data/lib/sts/niso_sts/back.rb

@@ -1,17 +1,27 @@
 # frozen_string_literal: true
 
-require "shale"
+require_relative "../mapper"
 
 require_relative "reference_list"
+require_relative "section"
+require_relative "app_group"
+require_relative "fn_group"
 
 module Sts
   module NisoSts
-    class Back < Shale::Mapper
+    class Back < Sts::Mapper
       attribute :ref_list, ReferenceList
+      attribute :app_group, AppGroup
+      attribute :sec, Section
+      attribute :fn_group, FnGroup
 
       xml do
         root "back"
+
         map_element "ref-list", to: :ref_list
+        map_element "app-group", to: :app_group
+        map_element "sec", to: :sec
+        map_element "fn-group", to: :fn_group
       end
     end
   end

data/lib/sts/niso_sts/body.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "shale"
+require_relative "../mapper"
 
 require_relative "section"
 
 module Sts
   module NisoSts
-    class Body < Shale::Mapper
+    class Body < Sts::Mapper
       attribute :sec, Section, collection: true
 
       xml do

data/lib/sts/niso_sts/caption.rb

@@ -0,0 +1,47 @@
+require_relative "../mapper"
+
+require_relative "paragraph"
+require_relative "title"
+require_relative "non_normative_note"
+
+# rubocop:disable Layout/LineLength
+# <caption>
+#   <title>Overview of risk assessment/risk reduction</title>
+#   <p><def-list list-type="footnotes">
+#       <def-item>
+#         <term>a</term>
+#         <def>
+#           <p>Refers to <std><std-id-group>
+#                 <std-id std-id-link-type="internal-pub-id" std-id-type="dated">e1d167f5</std-id>
+#                 <std-id std-id-link-type="fpi" std-id-type="dated">+//ISO 9070/RA::A00007::GE::DIN German
+#                   Institute for Standardization::Standards//DOCUMENT ISO 12100-1:2003-11-00//EN</std-id>
+#               </std-id-group>ISO 12100-1:2003</std>.</p>
+#         </def>
+#       </def-item>
+#       <def-item>
+#         <term>b</term>
+#         <def>
+#           <p>Refers to this part of ISO 13849.</p>
+#         </def>
+#       </def-item>
+#     </def-list></p>
+# </caption>
+# rubocop:enable Layout/LineLength
+
+module Sts
+  module NisoSts
+    class Caption < Sts::Mapper
+      attribute :title, Title
+      attribute :paragraphs, Paragraph, collection: true
+      attribute :non_normative_note, NonNormativeNote, collection: true
+
+      xml do
+        root "caption"
+
+        map_element "p", to: :paragraphs
+        map_element "non-normative-note", to: :non_normative_note
+        map_element "title", to: :title
+      end
+    end
+  end
+end

data/lib/sts/niso_sts/custom_meta.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../mapper"
+
+module Sts
+  module NisoSts
+    class CustomMeta < Sts::Mapper
+      attribute :lang, Shale::Type::String
+      attribute :meta_name, Shale::Type::String
+      attribute :meta_value, Shale::Type::String
+
+      xml do
+        root "custom-meta"
+
+        map_attribute "lang", to: :lang,
+                              namespace: "http://www.w3.org/XML/1998/namespace",
+                              prefix: "xml"
+        map_element "meta-name", to: :meta_name
+        map_element "meta-value", to: :meta_value
+      end
+    end
+  end
+end

data/lib/sts/niso_sts/custom_meta_group.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../mapper"
+
+require_relative "custom_meta"
+
+module Sts
+  module NisoSts
+    class CustomMetaGroup < Sts::Mapper
+      attribute :custom_meta, CustomMeta, collection: true
+
+      xml do
+        root "custom-meta-group"
+        map_attribute "custom-meta", to: :custom_meta
+      end
+    end
+  end
+end