dcc 0.2.0 → 0.2.2

data/lib/dcc/streaming/reader.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "moxml"
+
+module Dcc
+  module Streaming
+    # SAX handler that reconstructs each matched subtree as a standalone XML
+    # fragment, parses it into the version-appropriate model, yields it, and
+    # drops it. Only one subtree is buffered at a time, so peak memory tracks
+    # the largest single subtree rather than the document.
+    #
+    # The fragment reproduces the XML infoset, not the original bytes.
+    # Entity references arrive expanded, CDATA becomes text, processing
+    # instruction spacing is normalised, and every namespace in scope is
+    # re-declared on the fragment root so prefixes still resolve once the
+    # subtree is detached.
+    class Reader < ::Moxml::SAX::Handler
+      # Stream `io`, yielding one model per matched subtree.
+      #
+      # @param io [IO, StringIO] readable XML stream.
+      # @param model_id [Symbol] registered model id, `:item` or `:quantity`.
+      # @param version [Integer, nil] major DCC version. When nil it is read
+      #   from the first `schemaVersion` attribute seen outside a matched
+      #   subtree before the first model is yielded, and falls back to 3.
+      #   `Dcc.detect_version` instead scans the whole document lexically,
+      #   because it is not restricted to a single pass.
+      # @param context [Symbol, String, nil] substitution context.
+      # @return [void]
+      # @raise [Dcc::ParseError] if the stream is not well-formed XML. A
+      #   failing IO also surfaces this way, with the original IO message
+      #   replaced by the parser's — libxml2 does not pass it through.
+      def self.call(io, model_id:, version:, context:, &)
+        handler = new(model_id:, version:, context:, &)
+        adapter = ::Lutaml::Model::Config.xml_adapter_type
+        ::Moxml.new(adapter).sax_parse(io, handler)
+      end
+
+      # A handler carries one document's worth of state, so `.call` builds a
+      # fresh one per stream and construction stays closed.
+      private_class_method :new
+
+      def initialize(model_id:, version:, context:, &block)
+        super()
+        @model_id = model_id
+        @major = version
+        @context = context
+        @block = block
+        @scopes = [{}]
+        @subtree = nil
+        @depth = 0
+      end
+
+      # Declarations are merged and snapshotted before the element's own
+      # prefix is resolved, so an element that rebinds its prefix matches on
+      # its new binding rather than the inherited one.
+      def on_start_element(name, attributes = {}, namespaces = {})
+        # Almost no element declares a namespace, so merging every time would
+        # allocate a copy of the parent scope per element. Scopes are only
+        # ever read, so the unchanged ones can share one hash.
+        @scopes.push(
+          namespaces.empty? ? @scopes.last : @scopes.last.merge(namespaces),
+        )
+        return begin_subtree(name, attributes) unless @subtree
+
+        @depth += 1
+        @subtree.start_element(name, attributes, namespaces)
+      end
+
+      def on_end_element(name)
+        finish_element(name) if @subtree
+        @scopes.pop
+      end
+
+      def on_characters(text)
+        @subtree&.characters(text)
+      end
+
+      def on_cdata(text)
+        @subtree&.characters(text)
+      end
+
+      def on_comment(text)
+        @subtree&.comment(text)
+      end
+
+      def on_processing_instruction(target, data)
+        @subtree&.processing_instruction(target, data)
+      end
+
+      # Translated here rather than around the whole parse, so an exception
+      # raised by the consumer block travels untouched instead of being
+      # reported as malformed input.
+      def on_error(error)
+        raise ::Dcc::ParseError, error.message
+      end
+
+      private
+
+      # Only elements outside a matched subtree get a say in the version, so a
+      # `schemaVersion` on a descendant — or inside an opaque `dcc:xml` blob —
+      # cannot choose the parser for the whole stream.
+      def begin_subtree(name, attributes)
+        @major ||= schema_version_major(name, attributes)
+        return unless match?(name)
+
+        @depth = 0
+        @subtree = Subtree.new(name, attributes, @scopes.last)
+      end
+
+      def finish_element(name)
+        @subtree.end_element(name)
+        if @depth.zero?
+          emit(@subtree.to_xml)
+          @subtree = nil
+        else
+          @depth -= 1
+        end
+      end
+
+      def emit(xml)
+        @block.call(model_class.from_xml(xml, register: context_id))
+      end
+
+      def match?(name)
+        split(name).last == @model_id.to_s && dcc_element?(name)
+      end
+
+      def dcc_element?(name)
+        dcc_namespace?(@scopes.last[split(name).first])
+      end
+
+      # `Dcc::Namespace::Dcc` also accepts the `.xsd` alias that older PTB
+      # documents bind, so streaming matches whatever `Dcc.parse` accepts.
+      def dcc_namespace?(uri)
+        namespace = ::Dcc::Namespace::Dcc
+        uri == namespace.uri || namespace.uri_aliases.include?(uri)
+      end
+
+      def split(name)
+        prefix, local = name.split(":", 2)
+        local ? [prefix, local] : [nil, prefix]
+      end
+
+      # Resolved through the registry rather than referenced directly, so a
+      # configured custom model substitutes the root class too.
+      def model_class
+        @model_class ||=
+          ::Lutaml::Model::GlobalContext.resolve_type(@model_id, context_id)
+      end
+
+      def context_id
+        @context_id ||= ::Dcc::ContextOptions.normalize_context_option(
+          context: @context,
+          register: nil,
+          default_context: configuration.default_context_id,
+          warning_source: "Dcc::Streaming",
+        )
+      end
+
+      def configuration
+        ::Dcc.parser_for(major)::Configuration
+      end
+
+      # `schemaVersion` sits on the DCC root, which is not always the document
+      # root — a certificate can arrive wrapped in an envelope. Only a DCC
+      # element settles the version, so a wrapper carrying a `schemaVersion`
+      # of its own does not retype the certificate nested inside it.
+      def schema_version_major(name, attributes)
+        version = attributes["schemaVersion"]
+        return unless version && dcc_element?(name)
+
+        ::Dcc.major_version_from(version)
+      end
+
+      # A document that declares `schemaVersion` nowhere falls back the way an
+      # unusable one does, so `Dcc` keeps deciding that rather than a literal
+      # repeated here. The answer is written back rather than defaulted on
+      # each read: the model class and the context are memoised off this at
+      # the first yield, so a `schemaVersion` appearing later must not move
+      # the version out from under them.
+      def major
+        @major ||= ::Dcc.major_version_from(nil)
+      end
+
+      # Accumulates the raw XML of a single matched subtree.
+      #
+      # SAX hands over decoded characters, so control whitespace has to go
+      # back as character references. Written literally it would be
+      # normalised a second time on reparse — a carriage return in text
+      # would arrive as a newline, and a tab or newline in an attribute
+      # would collapse to a space.
+      #
+      # C14N mandates exactly that set of character references, so moxml's
+      # encoder is reused rather than restating the table here.
+      class Subtree
+        def initialize(name, attributes, scope)
+          @buffer = +""
+          write_start(name, attributes, scope)
+        end
+
+        def start_element(name, attributes, namespaces)
+          write_start(name, attributes, namespaces)
+        end
+
+        def end_element(name)
+          @buffer << "</#{name}>"
+        end
+
+        def characters(text)
+          @buffer << ::Moxml::C14n.escape_text(text)
+        end
+
+        def comment(text)
+          @buffer << "<!--#{text}-->"
+        end
+
+        def processing_instruction(target, data)
+          @buffer << "<?#{target} #{data}?>"
+        end
+
+        def to_xml
+          @buffer
+        end
+
+        private
+
+        def write_start(name, attributes, namespaces)
+          @buffer << "<#{name}"
+          namespaces.each do |prefix, href|
+            write_attribute(prefix ? "xmlns:#{prefix}" : "xmlns", href)
+          end
+          attributes.each do |key, value|
+            write_attribute(key, value)
+          end
+          @buffer << ">"
+        end
+
+        def write_attribute(name, value)
+          escaped = ::Moxml::C14n.escape_attribute(value)
+          @buffer << %( #{name}="#{escaped}")
+        end
+      end
+      private_constant :Subtree
+    end
+  end
+end

data/lib/dcc/streaming.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# `Dcc::Streaming` walks a DCC document one subtree at a time, so a batch
+# pipeline can process a multi-MB certificate without holding the whole
+# object tree in memory. Each matched subtree is reconstructed on its own,
+# parsed into the version-appropriate model, yielded, and dropped.
+#
+# @example Walk every calibrated item
+#   File.open("certificate.xml") do |io|
+#     Dcc::Streaming.each_item(io) { |item| puts item.id }
+#   end
+#
+# @example Take the first two quantities without reading the whole document
+#   Dcc::Streaming.each_quantity(io).first(2)
+#
+# Version detection differs from `Dcc.parse`. Streaming reads `schemaVersion`
+# off a real DCC element, so a certificate wrapped in an envelope is detected
+# from its own root even when the envelope carries a `schemaVersion` of its
+# own. `Dcc.detect_version` scans the document lexically instead, so it also
+# matches a `schemaVersion=` inside a comment, inside text or CDATA, on a
+# prefixed attribute such as `f:schemaVersion`, or on a foreign wrapper
+# element. The two can disagree on those documents, and streaming is the one
+# reading the schema's actual attribute. Pass `version:` to settle it.
+module Dcc
+  module Streaming
+    autoload :Reader, "dcc/streaming/reader"
+
+    class << self
+      # Yield each `dcc:item` in document order.
+      #
+      # @param io [IO, StringIO] readable XML stream.
+      # @param version [Integer, nil] major DCC version (2 or 3). When nil it
+      #   is detected from the first `schemaVersion` attribute seen outside a
+      #   matched subtree before the first item is yielded, and falls back to
+      #   3. See the note on version detection above.
+      # @param context [Symbol, String, nil] substitution context. Defaults
+      #   to the version's configured context.
+      # @yieldparam [Dcc::V2::Item, Dcc::V3::Item]
+      # @return [Enumerator] when no block is given.
+      # @raise [Dcc::ParseError] if the stream is not well-formed XML.
+      def each_item(io, version: nil,
+                    context: ::Dcc::UNSPECIFIED_CONTEXT, &block)
+        return enum_for(:each_item, io, version:, context:) unless block
+
+        stream(io, :item, version, context, &block)
+      end
+
+      # Yield each outermost `dcc:quantity` in document order.
+      #
+      # A quantity nested inside another quantity's `influenceConditions` is
+      # not yielded on its own — it is reachable from the outer object.
+      #
+      # @param io [IO, StringIO] readable XML stream.
+      # @param version [Integer, nil] major DCC version (2 or 3). Detected the
+      #   same way `each_item` detects it when nil.
+      # @param context [Symbol, String, nil] substitution context.
+      # @yieldparam [Dcc::V2::Quantity, Dcc::V3::Quantity]
+      # @return [Enumerator] when no block is given.
+      # @raise [Dcc::ParseError] if the stream is not well-formed XML.
+      def each_quantity(io, version: nil,
+                        context: ::Dcc::UNSPECIFIED_CONTEXT, &block)
+        return enum_for(:each_quantity, io, version:, context:) unless block
+
+        stream(io, :quantity, version, context, &block)
+      end
+
+      private
+
+      # `version` is validated here rather than on first match, so an
+      # unsupported value raises the same way regardless of what the
+      # document happens to contain.
+      def stream(io, model_id, version, context, &)
+        ::Dcc.parser_for(version) if version
+        ::Dcc.load_all!
+        Reader.call(io, model_id:, version:, context:, &)
+      end
+    end
+  end
+end

data/lib/dcc/transform/result.rb

@@ -21,4 +21,4 @@ module Dcc
       end
     end
   end
-end
+end

data/lib/dcc/transform/xslt.rb

@@ -6,9 +6,9 @@ module Dcc
   module Transform
     # `Dcc::Transform::Xslt` applies an XSLT stylesheet to a DCC XML document.
     #
-    # Nokogiri is OFFICIALLY banned outside validation, so we shell out to
-    # the system `xsltproc` (libxslt) for XSLT 1.0 transforms. For XSLT
-    # 2.0/3.0, set `ENV["SAXON_JAR"]` to point at saxon-he.jar.
+    # Nokogiri is banned outside XSD validation and the v2-to-v3 migration,
+    # so we shell out to the system `xsltproc` (libxslt) for XSLT 1.0
+    # transforms. For XSLT 2.0/3.0, set `ENV["SAXON_JAR"]` to saxon-he.jar.
     module Xslt
       class << self
         # @param xml [String, Lutaml::Model::Serializable]
@@ -21,7 +21,8 @@ module Dcc
                    when :xsltproc then run_xsltproc(xml_string, stylesheet)
                    when :saxon then run_saxon(xml_string, stylesheet)
                    else
-                     raise ::ArgumentError, "unknown XSLT engine: #{engine.inspect}"
+                     raise ::ArgumentError,
+                           "unknown XSLT engine: #{engine.inspect}"
                    end
           ::Dcc::Transform::Result.new(payload: output, engine: engine)
         end
@@ -31,22 +32,31 @@ module Dcc
         def run_xsltproc(xml, stylesheet)
           ensure_tool!("xsltproc")
           xsl_path = stylesheet_path(stylesheet)
-          out, status = ::Open3.capture2("xsltproc", xsl_path, "-", stdin_data: xml)
-          raise ::Dcc::TransformError, "xsltproc failed: #{status}" unless status.success?
+          out, status = ::Open3.capture2("xsltproc", xsl_path, "-",
+                                         stdin_data: xml)
+          unless status.success?
+            raise ::Dcc::TransformError,
+                  "xsltproc failed: #{status}"
+          end
 
           out
         end
 
         def run_saxon(xml, stylesheet)
-          jar = ENV["SAXON_JAR"]
-          raise ::Dcc::MissingDependencyError.new(gem_name: "saxon-he",
-                                                  feature: "XSLT 2.0/3.0"),
-                "SAXON_JAR env var is required for the :saxon engine" unless jar
+          jar = ENV.fetch("SAXON_JAR", nil)
+          unless jar
+            raise ::Dcc::MissingDependencyError.new(gem_name: "saxon-he",
+                                                    feature: "XSLT 2.0/3.0"),
+                  "SAXON_JAR env var is required for the :saxon engine"
+          end
 
           xsl_path = stylesheet_path(stylesheet)
           cmd = ["java", "-jar", jar, "-s:-", "-xsl:#{xsl_path}"]
           out, status = ::Open3.capture2(*cmd, stdin_data: xml)
-          raise ::Dcc::TransformError, "saxon failed: #{status}" unless status.success?
+          unless status.success?
+            raise ::Dcc::TransformError,
+                  "saxon failed: #{status}"
+          end
 
           out
         end
@@ -69,4 +79,4 @@ module Dcc
       end
     end
   end
-end
+end

data/lib/dcc/transform.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 # `Dcc::Transform` provides XSLT transformations. We cannot use Nokogiri
-# for this per project rule (only validation may touch Nokogiri); instead
-# we shell out to the system `xsltproc` CLI for XSLT 1.0, or to
-# `java -jar saxon-he.jar` for XSLT 2.0/3.0 when SAXON_JAR is set.
+# for this per project rule (only XSD validation and the v2-to-v3 migration
+# may touch Nokogiri); instead we shell out to the system `xsltproc` CLI for
+# XSLT 1.0, or to `java -jar saxon-he.jar` for XSLT 2.0/3.0 when SAXON_JAR
+# is set.
 module Dcc
   module Transform
     autoload :Xslt, "dcc/transform/xslt"
     autoload :Result, "dcc/transform/result"
   end
-end
+end

data/lib/dcc/type/base64_binary.rb

@@ -15,7 +15,8 @@ module Dcc
       def self.cast(value)
         return nil if value.nil? || value == ""
         unless value.is_a?(::String)
-          raise Lutaml::Model::Type::InvalidValueError.new(value, "expected binary String")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "expected binary String")
         end
 
         value
@@ -25,7 +26,8 @@ module Dcc
         return nil if value.nil?
 
         unless value.is_a?(::String)
-          raise Lutaml::Model::Type::InvalidValueError.new(value, "expected binary String")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "expected binary String")
         end
 
         value
@@ -52,4 +54,4 @@ module Dcc
       end
     end
   end
-end
+end

data/lib/dcc/type/decimal_xml_list.rb

@@ -1,19 +1,86 @@
 # frozen_string_literal: true
 
 require "bigdecimal"
+require "forwardable"
 require "lutaml/model"
 
 module Dcc
   module Type
     # Space-separated list of decimals, as used by D-SI `*XMLList` elements
     # (e.g. `<si:valueXMLList>306 373 448</si:valueXMLList>`). Parses to/from
-    # an Array of BigDecimal values.
+    # a `Values` list of BigDecimal.
+    #
+    # `cast` deliberately does not return a plain Array: lutaml-model treats an
+    # Array-valued attribute as a collection and would emit one element per
+    # decimal instead of a single space-separated list.
     class DecimalXmlList < Lutaml::Model::Type::Value
+      # An ordered list of BigDecimals that renders as space-separated text and
+      # compares equal to the equivalent Array.
+      class Values
+        include Enumerable
+        extend Forwardable
+
+        def_delegators :@decimals, :size, :length, :empty?, :last, :[]
+
+        def initialize(decimals)
+          @decimals = decimals
+        end
+
+        def each(&)
+          return to_enum(:each) unless block_given?
+
+          @decimals.each(&)
+          self
+        end
+
+        # Implicit conversion, so `Array#==` delegates back here instead of
+        # returning false and making equality asymmetric.
+        def to_ary
+          @decimals.dup
+        end
+
+        # Joined over the serialized decimals, not the raw BigDecimals, so it
+        # cannot disagree with `to_s` by emitting "0.72e-1" for "0.072".
+        def join(separator = " ")
+          map { |decimal| DecimalXmlList.serialize_one(decimal) }.join(separator)
+        end
+
+        def to_s
+          DecimalXmlList.serialize(self)
+        end
+
+        # Dumped as its wire form, so YAML matches JSON rather than leaking a
+        # `!ruby/object:` tag that `safe_load` refuses to read back.
+        def encode_with(coder)
+          coder.represent_scalar(nil, to_s)
+        end
+
+        def ==(other)
+          case other
+          when Values then to_a == other.to_a
+          when ::Array then to_a == other
+          else false
+          end
+        end
+
+        # Stricter than `==`, which accepts a plain Array. Hash lookup pairs
+        # `eql?` with `hash`, and an Array keyed alongside us would hash the
+        # same while comparing equal in only one direction.
+        def eql?(other)
+          other.is_a?(Values) && to_a == other.to_a
+        end
+
+        def hash
+          to_a.hash
+        end
+      end
+
       def self.cast(value)
-        return [] if value.nil?
-        return value.map { |v| cast_one(v) } if value.is_a?(::Array)
+        return value if value.is_a?(Values)
+        return Values.new([]) if value.nil?
 
-        value.to_s.split(/\s+/).reject(&:empty?).map { |s| cast_one(s) }
+        tokens = value.is_a?(::Array) ? value : value.to_s.split
+        Values.new(tokens.map { |token| cast_one(token) })
       end
 
       def self.serialize(value)
@@ -22,24 +89,43 @@ module Dcc
         Array(value).map { |v| serialize_one(v) }.join(" ")
       end
 
+      # One decimal in the notation D-SI writes, e.g. 0.072 rather than
+      # BigDecimal's own "0.72e-1". `to_s("F")` renders every BigDecimal,
+      # finite or not, and `sub` only trims a trailing ".0". That is what
+      # lets `NaN` through, which D-SI admits in every decimal type
+      # (SI_Format.xsd:1195).
+      def self.serialize_one(value)
+        reject_infinite!(value)
+
+        case value
+        when ::BigDecimal then value.to_s("F").sub(/\.0\z/, "")
+        when ::Float then format("%.15g", value)
+        else value.to_s
+        end
+      end
+
       class << self
         private
 
         def cast_one(token)
-          return token if token.is_a?(::BigDecimal)
-
-          BigDecimal(token.to_s)
+          decimal = token.is_a?(::BigDecimal) ? token : BigDecimal(token.to_s)
+          reject_infinite!(decimal)
+          decimal
         rescue ::ArgumentError => e
           raise Lutaml::Model::Type::InvalidValueError.new(token,
                                                            "invalid decimal in XML list: #{e.message}")
         end
 
-        def serialize_one(value)
-          case value
-          when ::BigDecimal then value.to_i.to_s == value.to_s("F") ? value.to_i.to_s : value.to_s("F").sub(/\.0\z/, "")
-          when ::Float then format("%.15g", value)
-          else value.to_s
-          end
+        # Called from `cast_one` and from the public `serialize_one`, since
+        # `serialize` takes a raw BigDecimal and casting is not the only way in.
+        def reject_infinite!(value)
+          return unless value.is_a?(::BigDecimal) && value.infinite?
+
+          raise Lutaml::Model::Type::InvalidValueError.new(
+            value,
+            "infinity is not a D-SI decimal: SI_Format.xsd:1195 admits " \
+            "numbers and NaN only",
+          )
         end
       end
     end

data/lib/dcc/type/iso_country_code.rb

@@ -7,13 +7,14 @@ module Dcc
     # ISO 3166-1 alpha-2 country code (two uppercase letters, e.g. `"DE"`).
     # Used by `dcc:countryCodeISO3166_1`.
     class IsoCountryCode < Lutaml::Model::Type::String
-      PATTERN = /\A[A-Z]{2}\z/.freeze
+      PATTERN = /\A[A-Z]{2}\z/
 
       def self.cast(value)
         return nil unless value.is_a?(::String) && value != ""
 
         unless PATTERN.match?(value)
-          raise Lutaml::Model::Type::InvalidValueError.new(value, "invalid ISO 3166-1 alpha-2 country code: #{value.inspect}")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "invalid ISO 3166-1 alpha-2 country code: #{value.inspect}")
         end
 
         value

data/lib/dcc/type/iso_language_code.rb

@@ -7,13 +7,14 @@ module Dcc
     # ISO 639-1 language code (two lowercase letters, e.g. `"en"`).
     # Used by `dcc:usedLangCodeISO639_1` and `dcc:mandatoryLangCodeISO639_1`.
     class IsoLanguageCode < Lutaml::Model::Type::String
-      PATTERN = /\A[a-z]{2}\z/.freeze
+      PATTERN = /\A[a-z]{2}\z/
 
       def self.cast(value)
         return nil unless value.is_a?(::String) && value != ""
 
         unless PATTERN.match?(value)
-          raise Lutaml::Model::Type::InvalidValueError.new(value, "invalid ISO 639-1 language code: #{value.inspect}")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "invalid ISO 639-1 language code: #{value.inspect}")
         end
 
         value

data/lib/dcc/type/schema_version.rb

@@ -12,13 +12,14 @@ module Dcc
         (?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)
         (?:-(?<pre>[0-9A-Za-z.-]+))?
         (?:\+(?<build>[0-9A-Za-z.-]+))?
-      \z/x.freeze
+      \z/x
 
       def self.cast(value)
         return nil unless value.is_a?(::String) && value != ""
 
         unless PATTERN.match?(value)
-          raise Lutaml::Model::Type::InvalidValueError.new(value, "invalid schemaVersion")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "invalid schemaVersion")
         end
 
         value

data/lib/dcc/type/si_unit.rb

@@ -10,13 +10,14 @@ module Dcc
     # check: the string must not contain whitespace (Schematron rule), and the
     # non-SI declaration prefix (`|unit`) is allowed.
     class SiUnit < Lutaml::Model::Type::String
-      NO_WHITESPACE_PATTERN = /\A\S+\z/.freeze
+      NO_WHITESPACE_PATTERN = /\A\S+\z/
 
       def self.cast(value)
         return nil unless value.is_a?(::String) && value != ""
 
         unless NO_WHITESPACE_PATTERN.match?(value)
-          raise Lutaml::Model::Type::InvalidValueError.new(value, "invalid SI unit expression (whitespace not allowed): #{value.inspect}")
+          raise Lutaml::Model::Type::InvalidValueError.new(value,
+                                                           "invalid SI unit expression (whitespace not allowed): #{value.inspect}")
         end
 
         value

data/lib/dcc/type_guards.rb

@@ -130,11 +130,11 @@ module Dcc
     end
 
     # Safe method call: invokes the method if the node's class declares it.
-    def call_if_present(node, method_name, *args)
+    def call_if_present(node, method_name, *)
       return nil unless node.is_a?(::Lutaml::Model::Serializable)
       return nil unless node.class.attributes.key?(method_name)
 
-      node.public_send(method_name, *args)
+      node.public_send(method_name, *)
     end
   end
-end
+end