dmarcator 0.12.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6c289ca56b406c5f591f414ada16407028e732310ad9b4c784e2f231469828a
-  data.tar.gz: 24f260da56f98e045d262bd5fcbe3ee9d3f8be1b1bdd310e26e8b9b4b74f1021
+  metadata.gz: 7d31aa779b69d26db7ac26ef788eca2f9eca47cf5a9fc92e6522df2854e49f1f
+  data.tar.gz: 9100503cce7569587904afa95e680bd9fa0703863873a509475283c7a7f00b0a
 SHA512:
-  metadata.gz: f88871eab61d67fcccbe7ac0e6f0dfc8f97160592d97e69e58a69d9d99b069ec02e70b9126a0dc7ae114c9e50d599a0ca014ba9b02fc2514fab7db97c4bd4a08
-  data.tar.gz: 2d10f64bd4cd096f54ba2a6372a07c582dc3aad581fe556a3228be4378ba09bd9e3e5ba57c94a4cd98acc4b87899ded063ab9b886b73390267659754713297bb
+  metadata.gz: 3fe6fd5ba876573069c9802643e90c79f88ff07840f60abf00addb94564a7c4bb2ce9e6180bc1bbb0960def6fb7d36686815f9938cf8b43136927b040390cfed
+  data.tar.gz: 6238af25582f02123bf5a444522cc42b65947a443dcbcfd5cf251afa1c089a99287011dcc957e07cbc124b9d8511651541dd79ac1d6e47f852c2c827a451ace0

data/ChangeLog.md

@@ -1,3 +1,22 @@
+### 1.1.0 / 2026-10-30
+
+* Replace the Parslet grammar with a hand-written parser in `DMARCator::Internal`. Parsing behaviour is unchanged, verified differentially against the previous parser over 128 real-world and 47 edge-case records in both lenient and strict modes; record parsing is roughly 30x faster (0.84 ms to 0.03 ms per record).
+* Remove the `parslet` runtime dependency. `nokogiri` is now the only runtime dependency.
+* Messages for structurally malformed records now come from the parser itself (for example `invalid DMARC record: "..."`) and are truncated to 300 characters.
+* `DMARCator::Internal::Parser::Transform` no longer exists. It was internal, so this is not covered by the compatibility promise.
+* Reject records whose string encoding is invalid or not ASCII-compatible with `InvalidRecord`. Previously `Record.parse` could raise `ArgumentError` (invalid UTF-8) or `Encoding::CompatibilityError` (for example UTF-16), which escaped `rescue DMARCator::Error`. Binary strings from a DNS resolver, and other ASCII-compatible encodings such as ISO-8859-1, are unaffected.
+
+### 1.0.0 / 2026-10-30
+
+The public API is now frozen.
+
+* The contract spec added in 0.12.0 defines the supported surface: the module methods, constants and per-class public methods it asserts. Anything documented as `@api private` may still change in a minor release.
+* Deprecations are documentation-only, and removals happen only in a major release. `Report.max_report_bytes`, `Report.max_report_bytes=` and `Report::MAX_REPORT_BYTES` are deprecated in favour of `DMARCator.configure` and `Config::DEFAULT_MAX_REPORT_BYTES`, and will be removed in 2.0.
+* Supported Ruby is `>= 3.3.13`. Dropping a Ruby series is the one documented exception to the no-breaking-changes promise: it is announced in a minor release and removed in the next major.
+* Parsed report values are now frozen, not merely reader-only: the strings taken from the document and the arrays holding records, errors, reasons, auth results and the parsed record's `rua`/`ruf`/`fo` cannot be mutated in place. `Record` and the report value objects are therefore safe to share between threads.
+* The parser and XML helper moved to `DMARCator::Internal`, so the public constants are only documented API and the parser can be replaced in a minor release.
+* Parsing, lookup and transport behaviour are unchanged from 0.12.0; the differences above are the freeze itself.
+
 ### 0.12.0 / 2026-10-29
 
 Breaking changes, taken before 1.0:

data/README.md

@@ -312,6 +312,13 @@ A method is deprecated in a minor release by documentation only — no runtime
 warnings, so nothing is added to application logs. Deprecated methods are
 removed in the next major release.
 
+### Ruby support
+
+The minimum is Ruby 3.3.13, the first release in that series with the regular
+expression fixes the library requires. Dropping support for a Ruby series is
+the one documented exception to the no-breaking-changes promise: it is announced
+in a minor release and removed in the next major.
+
 ## Security
 
 DMARC records and XML reports are treated as untrusted input. See
@@ -341,7 +348,6 @@ for the reporting policy and scope.
 ## Requirements
 
 * [Ruby] >= 3.3.13
-* [parslet] >= 1.0.0, < 3.0.0
 * [nokogiri] >= 1.10
 
 ## Testing
@@ -410,6 +416,5 @@ created by D Salko and released under the MIT License.
 [dmarc-parser-gem]: https://rubygems.org/gems/dmarc_parser
 [Trail of Bits]: https://www.trailofbits.com
 [Ruby]: https://www.ruby-lang.org
-[parslet]: https://kschiess.github.io/parslet/
 [nokogiri]: https://nokogiri.org
 [LICENSE.txt]: LICENSE.txt

data/lib/dmarcator/internal/parser.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'strscan'
+require 'uri'
+
+require_relative '../exceptions'
+require_relative '../uri'
+
+module DMARCator
+  #
+  # Implementation details of the library. Nothing here is covered by the
+  # 1.0 compatibility promise.
+  #
+  # @api private
+  #
+  module Internal
+    #
+    # Parses DMARC records (RFC 7489 section 6.4).
+    #
+    # A hand-written parser rather than a parser-combinator grammar: the
+    # language is small, and this keeps record parsing allocation-light and
+    # free of a runtime dependency.
+    #
+    # @see https://www.rfc-editor.org/rfc/rfc7489#section-6.4
+    #
+    # @api private
+    #
+    class Parser
+      # Maximum accepted DMARC record size in bytes. Real records are far
+      # smaller; the cap bounds parsing work on hostile input.
+      MAX_RECORD_BYTES = 4096
+
+      # Maximum length of error messages echoed from untrusted input.
+      MAX_ERROR_MESSAGE_LENGTH = 300
+
+      # Tags whose value is one keyword from a fixed set.
+      KEYWORD_TAGS = {
+        'p' => %w[none quarantine reject],
+        'sp' => %w[none quarantine reject],
+        'adkim' => %w[r s],
+        'aspf' => %w[r s],
+        'rf' => %w[afrf iodef]
+      }.freeze
+
+      # Tags whose value is a decimal number of at most N digits.
+      DIGIT_TAGS = { 'ri' => 10, 'pct' => 3 }.freeze
+
+      # Tags whose value is a list of mailto URIs.
+      URI_TAGS = %w[rua ruf].freeze
+
+      # The `v=` tag, which may only appear first.
+      VERSION = /\Av[ \t]*=[ \t]*DMARC1\z/
+
+      # Characters allowed in a mailto local part and domain.
+      ADDRESS = /[A-Za-z0-9._%+-]+@[A-Za-z0-9._%+-]+/
+
+      # Characters allowed between tags.
+      WSP = /[ \t]*/
+
+      class << self
+        #
+        # Parses a DMARC record.
+        #
+        # @param [String] record
+        #   The raw DMARC record to parse.
+        #
+        # @param [Boolean] strict (false)
+        #   When `true`, raise on unknown tags or invalid tag values instead
+        #   of silently ignoring them.
+        #
+        # @return [Hash{Symbol => Object}]
+        #
+        # @raise [InvalidRecord]
+        #   The record is malformed, is too large, or (in strict mode)
+        #   contains an unknown tag or invalid tag value.
+        #
+        def parse(record, strict: false)
+          unless record.is_a?(String)
+            raise InvalidRecord, "DMARC record must be a String, got #{record.class}"
+          end
+
+          if record.bytesize > MAX_RECORD_BYTES
+            raise InvalidRecord, "DMARC record exceeds maximum size of #{MAX_RECORD_BYTES} bytes"
+          end
+
+          # Malformed or non-ASCII-compatible encodings make the regular
+          # expressions below raise ArgumentError or Encoding::CompatibilityError
+          # instead of InvalidRecord, which would escape `rescue DMARCator::Error`.
+          unless record.encoding.ascii_compatible?
+            raise InvalidRecord,
+                  "DMARC record must be ASCII-compatible text, got #{record.encoding}"
+          end
+
+          unless record.valid_encoding?
+            raise InvalidRecord, "DMARC record is not valid #{record.encoding} text"
+          end
+
+          tags = { v: :DMARC1 }
+
+          split(record).each do |segment|
+            status, key, value = parse_segment(segment)
+
+            case status
+            when :ok
+              raise InvalidRecord, "duplicate DMARC tag: #{key}" if tags.key?(key)
+
+              tags[key] = value
+            when :unknown
+              if strict
+                raise InvalidRecord, "unknown DMARC tag: #{truncate(segment).inspect}"
+              end
+            when :invalid
+              if strict
+                raise InvalidRecord, "invalid DMARC tag value: #{truncate(segment).inspect}"
+              end
+            end
+          end
+
+          validate!(tags)
+        end
+
+        private
+
+        #
+        # Splits a record into tag segments, validating the version tag.
+        #
+        def split(record)
+          separator = record.index(';')
+          version = (separator ? record[0, separator] : record).sub(/[ \t]+\z/, '')
+          rest = separator ? record[(separator + 1)..] : ''
+
+          unless version.match?(VERSION)
+            raise InvalidRecord, "invalid DMARC record: #{truncate(record).inspect}"
+          end
+
+          # At most one trailing separator, plus optional surrounding space.
+          rest = rest.sub(/[ \t]+\z/, '').sub(/;[ \t]*\z/, '').sub(/[ \t]+\z/, '')
+
+          return [] if rest.empty?
+
+          rest.split(';', -1).map do |segment|
+            segment = segment.sub(/\A[ \t]+/, '').sub(/[ \t]+\z/, '')
+
+            if segment.empty?
+              raise InvalidRecord, "invalid DMARC record: #{truncate(record).inspect}"
+            end
+
+            segment
+          end
+        end
+
+        #
+        # Classifies and parses one `tag=value` segment.
+        #
+        # @return [Array(Symbol, Symbol, Object), Array(Symbol)]
+        #
+        def parse_segment(segment)
+          name, value = segment.split('=', 2)
+
+          return [:unknown] if value.nil?
+
+          name = name.sub(/[ \t]+\z/, '').sub(/\A[ \t]+/, '')
+          value = value.sub(/\A[ \t]+/, '').sub(/[ \t]+\z/, '')
+
+          # A known tag with an empty value is not a tag at all.
+          return [:unknown] if value.empty?
+
+          if (keywords = KEYWORD_TAGS[name])
+            keyword(name, keywords, value)
+          elsif (max = DIGIT_TAGS[name])
+            digits(name, max, value)
+          elsif name == 'fo'
+            fo(value)
+          elsif URI_TAGS.include?(name)
+            uri_list(name, value, segment)
+          else
+            [:unknown]
+          end
+        end
+
+        def keyword(name, keywords, value)
+          return [:ok, name.to_sym, value.to_sym] if keywords.include?(value)
+
+          # A known keyword followed by junk is a malformed record, not an
+          # invalid value: the value grammar matched and the remainder did not.
+          malformed!(value) if keywords.any? { |keyword| value.start_with?(keyword) }
+
+          [:invalid]
+        end
+
+        def digits(name, max, value)
+          if value.match?(/\A\d+\z/)
+            return [:invalid] if value.length > max
+
+            return [:ok, name.to_sym, value.to_i]
+          end
+
+          malformed!(value) if value.match?(/\A\d/)
+
+          [:invalid]
+        end
+
+        def fo(value)
+          return [:ok, :fo, value.split(':')] if value.match?(/\A[01ds](?::[01ds])*\z/)
+
+          malformed!(value) if value.match?(/\A[01ds](?::[01ds])*/)
+
+          [:invalid]
+        end
+
+        def uri_list(name, value, _segment)
+          uris = []
+          scanner = StringScanner.new(value)
+
+          loop do
+            uri = parse_uri(scanner)
+
+            # Any failure inside a URI makes the whole tag invalid.
+            return [:invalid] if uri.nil?
+
+            uris << uri
+
+            scanner.skip(WSP)
+
+            break if scanner.eos?
+
+            # A valid URI followed by junk is a malformed record.
+            malformed!(value) unless scanner.scan(/,/)
+
+            scanner.skip(WSP)
+
+            # A trailing comma leaves no URI to parse.
+            return [:invalid] if scanner.eos?
+          end
+
+          [:ok, name.to_sym, uris]
+        end
+
+        #
+        # Parses one `mailto:` URI, with its optional size and unit.
+        #
+        # @return [Uri, nil]
+        #   The URI, or `nil` when the value is not a valid DMARC URI.
+        #
+        def parse_uri(scanner)
+          start = scanner.pos
+
+          return nil unless scanner.scan(/mailto:/i) && scanner.scan(ADDRESS)
+
+          uri_text = scanner.string.byteslice(start, scanner.pos - start)
+          size = unit = nil
+
+          if scanner.scan(/!/)
+            digits = scanner.scan(/\d{1,10}/)
+
+            # A bare `!` or more than ten digits is an invalid value.
+            return nil if digits.nil? || scanner.match?(/\d/)
+
+            size = digits.to_i
+            unit = scanner.scan(/[kmgt]/)&.to_sym
+
+            # A second `!` is an invalid value.
+            return nil if scanner.match?(/!/)
+          end
+
+          parsed = begin
+            URI.parse(uri_text)
+          rescue URI::Error
+            return nil
+          end
+
+          return nil unless parsed.is_a?(URI::MailTo)
+
+          Uri.new(parsed, size, unit)
+        end
+
+        #
+        # Raises for input whose valid prefix was followed by junk.
+        #
+        def malformed!(value)
+          raise InvalidRecord, "invalid DMARC record: #{truncate(value).inspect}"
+        end
+
+        #
+        # Validates parsed tag values that have a range.
+        #
+        def validate!(tags)
+          if tags[:pct] && !tags[:pct].between?(0, 100)
+            raise InvalidRecord, 'pct must be an integer between 0 and 100'
+          end
+
+          if tags[:ri] && !tags[:ri].between?(0, 2**32 - 1)
+            raise InvalidRecord, 'ri must be an integer between 0 and 4294967295'
+          end
+
+          tags
+        end
+
+        #
+        # Truncates an error message to a bounded length.
+        #
+        def truncate(message)
+          message = message.to_s
+
+          if message.length > MAX_ERROR_MESSAGE_LENGTH
+            message[0, MAX_ERROR_MESSAGE_LENGTH] + '...'
+          else
+            message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dmarcator/internal/xml_helper.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module DMARCator
+  #
+  # Implementation details of the library. Nothing here is covered by the
+  # 1.0 compatibility promise.
+  #
+  # @api private
+  #
+  module Internal
+    #
+    # Internal helper for extracting values from parsed DMARC XML reports.
+    #
+    module XmlHelper
+      private
+
+      #
+      # Returns the text of the first node matching the XPath expression.
+      #
+      # @param [String] xpath
+      #   The XPath expression to match.
+      #
+      # @return [String, nil]
+      #   The node text, or `nil` if no node matched.
+      #
+      def get_text(xpath)
+        @node.at_xpath(xpath)&.text
+      end
+
+      #
+      # Parses a Unix timestamp from raw element text.
+      #
+      # @param [String, nil] value
+      #   The element text.
+      #
+      # @return [Time, nil]
+      #
+      # @api private
+      #
+      def parse_timestamp(value)
+        seconds = parse_integer(value)
+
+        Time.at(seconds) if seconds
+      end
+
+      #
+      # Parses an integer from raw element text, returning `nil` for values that
+      # are not plain decimal digits.
+      #
+      # @param [String, nil] value
+      #   The element text.
+      #
+      # @return [Integer, nil]
+      #
+      # @api private
+      #
+      def parse_integer(value)
+        return nil if value.nil? || value.empty?
+
+        digits = value.strip
+        return nil unless digits.match?(/\A\d+\z/)
+
+        digits.to_i
+      end
+    end
+  end
+end

data/lib/dmarcator/record.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'dmarcator/query'
-require 'dmarcator/parser'
+require 'dmarcator/internal/parser'
 require 'dmarcator/exceptions'
 
 require 'resolv'
@@ -66,13 +66,13 @@ module DMARCator
       @v     = attributes.fetch(:v)
       @adkim = attributes[:adkim]
       @aspf  = attributes[:aspf]
-      @fo    = attributes[:fo]
+      @fo    = attributes[:fo]&.freeze
       @p     = attributes[:p]
       @pct   = attributes[:pct]
       @rf    = attributes[:rf]
       @ri    = attributes[:ri]
-      @rua   = attributes[:rua]
-      @ruf   = attributes[:ruf]
+      @rua   = attributes[:rua]&.freeze
+      @ruf   = attributes[:ruf]&.freeze
       @sp    = attributes[:sp]
     end
 
@@ -277,43 +277,15 @@ module DMARCator
     # @api public
     #
     def self.parse(record, strict: false)
-      attributes = Parser.parse(record, strict: strict)
+      attributes = Internal::Parser.parse(record, strict: strict)
 
       unless attributes[:p]
         raise InvalidRecord, "DMARC record is missing the required 'p' tag"
       end
 
       new(attributes)
-    rescue Parslet::ParseFailed => error
-      # Raising inside the rescue sets this error as the cause automatically.
-      raise InvalidRecord, truncate_error_message(error.message)
     end
 
-    # Maximum length of error messages echoed from parsing untrusted input.
-    MAX_ERROR_MESSAGE_LENGTH = 500
-
-    #
-    # Truncates error messages to avoid echoing large amounts of untrusted
-    # input in exceptions.
-    #
-    # @param [String] message
-    #   The error message to truncate.
-    #
-    # @return [String]
-    #   The truncated error message.
-    #
-    def self.truncate_error_message(message)
-      message = message.to_s
-
-      if message.length > MAX_ERROR_MESSAGE_LENGTH
-        message[0, MAX_ERROR_MESSAGE_LENGTH] + "..."
-      else
-        message
-      end
-    end
-
-    private_class_method :truncate_error_message
-
     #
     # Looks up and parses the DMARC record for a domain.
     #

data/lib/dmarcator/report/auth_result.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../xml_helper'
+require_relative '../internal/xml_helper'
 
 module DMARCator
   class Report
@@ -8,7 +8,7 @@ module DMARCator
     # Represents an `auth_results` entry (DKIM/SPF) in a DMARC XML report.
     #
     class AuthResult
-      include XmlHelper
+      include Internal::XmlHelper
 
       # Attribute names exposed by this class.
       ATTRIBUTES = [:type, :domain, :result, :selector, :scope]
@@ -27,18 +27,18 @@ module DMARCator
 
       def initialize(node)
         @node = node
-        @type = node.name
+        @type = node.name.freeze
 
         node.element_children.each do |element|
           case element.name
           when 'domain'
-            @domain ||= element.text
+            @domain ||= element.text.freeze
           when 'result'
-            @result ||= element.text
+            @result ||= element.text.freeze
           when 'selector'
-            @selector ||= element.text
+            @selector ||= element.text.freeze
           when 'scope'
-            @scope ||= element.text
+            @scope ||= element.text.freeze
           end
         end
       end

data/lib/dmarcator/report/metadata.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../xml_helper'
+require_relative '../internal/xml_helper'
 
 module DMARCator
   class Report
@@ -8,7 +8,7 @@ module DMARCator
     # Represents the `report_metadata` element of a DMARC XML report.
     #
     class Metadata
-      include XmlHelper
+      include Internal::XmlHelper
 
       # Attribute names exposed by this class.
       ATTRIBUTES = [
@@ -37,24 +37,25 @@ module DMARCator
         @errors = []
 
         metadata = node.at_xpath('feedback/report_metadata')
-        return unless metadata
 
         metadata.element_children.each do |element|
           case element.name
           when 'org_name'
-            @org_name ||= element.text
+            @org_name ||= element.text.freeze
           when 'email'
-            @email ||= element.text
+            @email ||= element.text.freeze
           when 'extra_contact_info'
-            @extra_contact_info ||= element.text
+            @extra_contact_info ||= element.text.freeze
           when 'report_id'
-            @report_id ||= element.text
+            @report_id ||= element.text.freeze
           when 'error'
-            errors << element.text
+            errors << element.text.freeze
           when 'date_range'
             parse_date_range(element)
           end
         end
+      ensure
+        @errors.freeze
       end
 
       private
@@ -63,9 +64,9 @@ module DMARCator
         date_range.element_children.each do |element|
           case element.name
           when 'begin'
-            @begin_at ||= parse_timestamp(element.text)
+            @begin_at ||= parse_timestamp(element.text.freeze)
           when 'end'
-            @end_at ||= parse_timestamp(element.text)
+            @end_at ||= parse_timestamp(element.text.freeze)
           end
         end
       end

data/lib/dmarcator/report/policy.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../xml_helper'
+require_relative '../internal/xml_helper'
 
 module DMARCator
   class Report
@@ -8,7 +8,7 @@ module DMARCator
     # Represents the `policy_published` element of a DMARC XML report.
     #
     class Policy
-      include XmlHelper
+      include Internal::XmlHelper
 
       # Attribute names exposed by this class.
       ATTRIBUTES = [:domain, :adkim, :aspf, :p, :sp, :pct, :fo]
@@ -38,19 +38,19 @@ module DMARCator
         policy.element_children.each do |element|
           case element.name
           when 'pct'
-            @pct ||= parse_integer(element.text)
+            @pct ||= parse_integer(element.text.freeze)
           when 'domain'
-            @domain ||= element.text
+            @domain ||= element.text.freeze
           when 'adkim'
-            @adkim ||= element.text
+            @adkim ||= element.text.freeze
           when 'aspf'
-            @aspf ||= element.text
+            @aspf ||= element.text.freeze
           when 'p'
-            @p ||= element.text
+            @p ||= element.text.freeze
           when 'sp'
-            @sp ||= element.text
+            @sp ||= element.text.freeze
           when 'fo'
-            @fo ||= element.text
+            @fo ||= element.text.freeze
           end
         end
       end

data/lib/dmarcator/report/reason.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../xml_helper'
+require_relative '../internal/xml_helper'
 
 module DMARCator
   class Report
@@ -8,7 +8,7 @@ module DMARCator
     # Represents a `reason` element of a DMARC XML report record.
     #
     class Reason
-      include XmlHelper
+      include Internal::XmlHelper
 
       # Attribute names exposed by this class.
       ATTRIBUTES = [:type, :comment]
@@ -25,9 +25,9 @@ module DMARCator
         node.element_children.each do |element|
           case element.name
           when 'type'
-            @type ||= element.text
+            @type ||= element.text.freeze
           when 'comment'
-            @comment ||= element.text
+            @comment ||= element.text.freeze
           end
         end
       end

data/lib/dmarcator/report/row.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../xml_helper'
+require_relative '../internal/xml_helper'
 require_relative 'auth_result'
 require_relative 'reason'
 
@@ -13,7 +13,7 @@ module DMARCator
     # DMARC TXT record.
     #
     class Row
-      include XmlHelper
+      include Internal::XmlHelper
 
       # Attribute names exposed by this class.
       ATTRIBUTES = [
@@ -64,7 +64,7 @@ module DMARCator
       def reasons
         return @reasons if defined?(@reasons)
 
-        @reasons = @reason_nodes.map { |reason_node| Reason.new(reason_node) }
+        @reasons = @reason_nodes.map { |reason_node| Reason.new(reason_node) }.freeze
       end
 
       #
@@ -77,7 +77,7 @@ module DMARCator
 
         @auth_results = @auth_result_nodes.map do |auth_result_node|
           AuthResult.new(auth_result_node)
-        end
+        end.freeze
       end
 
       private
@@ -86,9 +86,9 @@ module DMARCator
         row.element_children.each do |element|
           case element.name
           when 'source_ip'
-            @source_ip ||= element.text
+            @source_ip ||= element.text.freeze
           when 'count'
-            @count ||= parse_integer(element.text)
+            @count ||= parse_integer(element.text.freeze)
           when 'policy_evaluated'
             parse_policy_evaluated(element)
           end
@@ -99,11 +99,11 @@ module DMARCator
         policy_evaluated.element_children.each do |element|
           case element.name
           when 'disposition'
-            @disposition ||= element.text
+            @disposition ||= element.text.freeze
           when 'dkim'
-            @dkim ||= element.text
+            @dkim ||= element.text.freeze
           when 'spf'
-            @spf ||= element.text
+            @spf ||= element.text.freeze
           when 'reason'
             @reason_nodes << element
           end
@@ -114,11 +114,11 @@ module DMARCator
         identifiers.element_children.each do |element|
           case element.name
           when 'envelope_to'
-            @envelope_to ||= element.text
+            @envelope_to ||= element.text.freeze
           when 'envelope_from'
-            @envelope_from ||= element.text
+            @envelope_from ||= element.text.freeze
           when 'header_from'
-            @header_from ||= element.text
+            @header_from ||= element.text.freeze
           end
         end
       end

data/lib/dmarcator/report.rb

@@ -3,7 +3,7 @@
 require 'nokogiri'
 
 require_relative 'config'
-require_relative 'xml_helper'
+require_relative 'internal/xml_helper'
 require_relative 'exceptions'
 require_relative 'report/metadata'
 require_relative 'report/policy'
@@ -17,11 +17,11 @@ module DMARCator
   # resolved or fetched; treat report XML as untrusted input.
   #
   class Report
-    include XmlHelper
+    include Internal::XmlHelper
 
     # Default maximum accepted report size in bytes (25 MiB).
     #
-    # @deprecated Use {Config::DEFAULT_MAX_REPORT_BYTES}.
+    # @deprecated Use {Config::DEFAULT_MAX_REPORT_BYTES}. Removed in 2.0.
     #
     MAX_REPORT_BYTES = Config::DEFAULT_MAX_REPORT_BYTES
 
@@ -30,6 +30,7 @@ module DMARCator
       # The maximum accepted report size in bytes.
       #
       # @deprecated Use {DMARCator.configure} with `config.max_report_bytes`.
+      #   Removed in 2.0.
       #
       # @return [Integer]
       #
@@ -41,6 +42,7 @@ module DMARCator
       # Sets the maximum accepted report size in bytes.
       #
       # @deprecated Use {DMARCator.configure} with `config.max_report_bytes`.
+      #   Removed in 2.0.
       #
       # @param [Integer, nil] value
       #
@@ -100,7 +102,7 @@ module DMARCator
         value = get_text('feedback/version')
         value = value.strip if value
 
-        value if value && value.match?(/\A\d+(?:\.\d+)*\z/)
+        value.freeze if value && value.match?(/\A\d+(?:\.\d+)*\z/)
       end
     end
 
@@ -130,7 +132,7 @@ module DMARCator
     def records
       @records ||= @node.xpath('feedback/record').map do |node|
         Row.new(node)
-      end
+      end.freeze
     end
   end
 end

data/lib/dmarcator/version.rb

@@ -2,5 +2,5 @@
 
 module DMARCator
   # dmarcator version
-  VERSION = '0.12.0'
+  VERSION = '1.1.0'
 end

data/lib/dmarcator.rb

@@ -3,7 +3,7 @@
 require 'dmarcator/exceptions'
 require 'dmarcator/query'
 require 'dmarcator/record'
-require 'dmarcator/parser'
+require 'dmarcator/internal/parser'
 require 'dmarcator/report'
 require 'dmarcator/version'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dmarcator
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Noah Berman
@@ -9,26 +9,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: parslet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -57,7 +37,8 @@ files:
 - lib/dmarcator.rb
 - lib/dmarcator/config.rb
 - lib/dmarcator/exceptions.rb
-- lib/dmarcator/parser.rb
+- lib/dmarcator/internal/parser.rb
+- lib/dmarcator/internal/xml_helper.rb
 - lib/dmarcator/query.rb
 - lib/dmarcator/record.rb
 - lib/dmarcator/report.rb
@@ -72,7 +53,6 @@ files:
 - lib/dmarcator/resolver/encrypted.rb
 - lib/dmarcator/uri.rb
 - lib/dmarcator/version.rb
-- lib/dmarcator/xml_helper.rb
 homepage: https://github.com/bermannoah/dmarcator
 licenses:
 - MIT

data/lib/dmarcator/parser.rb

@@ -1,348 +0,0 @@
-# frozen_string_literal: true
-
-require 'dmarcator/exceptions'
-require 'dmarcator/uri'
-
-require 'parslet'
-require 'uri'
-
-module DMARCator
-  #
-  # DMARC parser.
-  #
-  # An implementation detail: use {Record.parse} rather than this class.
-  #
-  # @api private
-  #
-  # @see https://tools.ietf.org/html/rfc7489#section-6.4
-  #
-  class Parser < Parslet::Parser
-
-    # Maximum accepted DMARC record size in bytes. Real records are far
-    # smaller; the cap bounds parsing work on hostile input.
-    #
-    MAX_RECORD_BYTES = 4096
-
-    root :dmarc_record
-
-    rule(:dmarc_record) do
-      dmarc_version.repeat(1,1) >>
-      (dmarc_sep >> dmarc_tag).repeat >>
-      dmarc_sep.maybe >>
-      wsp?.maybe
-    end
-
-    rule(:dmarc_sep) { wsp? >> str(';') >> wsp? }
-
-    rule(:dmarc_version) do
-      str('v') >> wsp? >>
-      str('=') >> wsp? >>
-      str('DMARC1').as(:v)
-    end
-
-    rule(:dmarc_tag) do
-      dmarc_request   |
-      dmarc_srequest  |
-      dmarc_auri      |
-      dmarc_furi      |
-      dmarc_adkim     |
-      dmarc_aspf      |
-      dmarc_ainterval |
-      dmarc_fo        |
-      dmarc_rfmt      |
-      dmarc_percent   |
-      unknown_tag
-    end
-
-    #
-    # Defines a rule for a `tag=value` DMARC tag, capturing values that do not
-    # match the rule as `:invalid_tag` so strict mode can reject them.
-    #
-    # @param [Symbol] name
-    #   The rule name, used as `dmarc_<name>`.
-    #
-    # @param [String] tag
-    #   The DMARC tag name.
-    #
-    # @yieldreturn [Parslet::Atoms::Base]
-    #   The parslet matching the tag's value.
-    #
-    # @api private
-    #
-    def self.tag_rule(name,tag,&block)
-      rule(:"dmarc_#{name}") do
-        (
-          str(tag) >> wsp? >> str('=') >> wsp? >>
-          instance_eval(&block).as(tag.to_sym)
-        ) |
-        (
-          str(tag) >> wsp? >> str('=') >> wsp? >>
-          match["^; \t"].repeat(1)
-        ).as(:invalid_tag)
-      end
-    end
-
-    tag_rule(:request,'p') do
-      str('none') | str('quarantine') | str('reject')
-    end
-
-    tag_rule(:srequest,'sp') do
-      str('none') | str('quarantine') | str('reject')
-    end
-
-    tag_rule(:auri, 'rua') do
-      dmarc_uri >> (uri_list_sep.present? >> uri_list_sep).repeat >> (wsp? >> str(',')).absent?
-    end
-
-    tag_rule(:ainterval,'ri') { digit.repeat(1, 10) >> digit.absent? }
-
-    tag_rule(:furi,'ruf') do
-      dmarc_uri >> (uri_list_sep.present? >> uri_list_sep).repeat >> (wsp? >> str(',')).absent?
-    end
-
-    tag_rule(:fo,'fo') do
-      fo_opt >> (wsp? >> str(':') >> wsp? >> fo_opt).repeat
-    end
-
-    rule(:fo_opt) { match['01ds'].as(:fo_opt) }
-
-    tag_rule(:rfmt,'rf') { str('afrf') | str('iodef') }
-
-    tag_rule(:percent,'pct') { digit.repeat(1,3) >> digit.absent? }
-
-    tag_rule(:adkim, 'adkim') { match['rs'] }
-    tag_rule(:aspf, 'aspf')   { match['rs'] }
-
-    rule(:unknown_tag) { match["^; \t"].repeat(1).as(:unknown_tag) }
-
-    rule(:dmarc_uri) do
-      mailto_uri.as(:uri) >> (
-        str('!') >> digit.repeat(1, 10).as(:size) >> digit.absent? >> (
-          match['kmgt']
-        ).as(:unit).maybe
-      ).maybe >> str('!').absent?
-    end
-
-    rule(:uri_list_sep) { wsp? >> str(',') >> wsp? >> dmarc_uri }
-
-    rule(:mailto_uri) do
-      match['mM'] >> match['aA'] >> match['iI'] >> match['lL'] >> match['tT'] >> match['oO'] >>
-      str(':') >> mailto_address
-    end
-
-    rule(:mailto_address) do
-      mailto_local >> str('@') >> mailto_domain
-    end
-
-    rule(:mailto_local)  { mailto_char.repeat(1) }
-    rule(:mailto_domain) { mailto_char.repeat(1) }
-    rule(:mailto_char)   { match["A-Za-z0-9._%+-"] }
-
-    rule(:digit) { match('[0-9]') }
-    rule(:wsp) { str(' ') | str("\t") }
-    rule(:wsp?) { wsp.repeat }
-
-    #
-    # Converts the raw parse tree into tag attributes.
-    #
-    # @api private
-    #
-    class Transform < Parslet::Transform
-
-      rule(fo_opt: simple(:fo_opt)) { fo_opt }
-      rule(fo: simple(:fo_opt)) { {fo: [fo_opt]} }
-
-      rule(v: simple(:version)) { {v: version.to_sym} }
-      rule(p:  simple(:p))  { {p:  p.to_sym } }
-      rule(sp: simple(:sp)) { {sp: sp.to_sym} }
-      rule(rf: simple(:rf)) { {rf: rf.to_sym} }
-      rule(adkim: simple(:adkim)) { {adkim: adkim.to_sym} }
-      rule(aspf:  simple(:aspf))  { {aspf: aspf.to_sym} }
-
-      rule(pct: simple(:pct)) { {pct: pct.to_i} }
-      rule(ri:  simple(:ri))  { {ri:  ri.to_i}  }
-
-      rule(uri: simple(:uri), size: simple(:size), unit: simple(:unit)) do
-        Uri.new(
-          Transform.parse_uri(uri),
-          size.to_i,
-          unit.to_sym
-        )
-      end
-      rule(uri: simple(:uri), size: simple(:size)) do
-        Uri.new(
-          Transform.parse_uri(uri),
-          size.to_i
-        )
-      end
-      rule(uri: simple(:uri)) { Uri.new(Transform.parse_uri(uri)) }
-      rule(rua: subtree(:uris)) { {rua: Array(uris)} }
-      rule(ruf: subtree(:uris)) { {ruf: Array(uris)} }
-
-      # Maximum length of error messages echoed from untrusted input.
-      MAX_ERROR_MESSAGE_LENGTH = 300
-
-      #
-      # Parses a `mailto:` URI from a parse tree slice.
-      #
-      # @param [Parslet::Slice] value
-      #
-      # @return [URI::MailTo]
-      #
-      # @raise [InvalidRecord]
-      #   The URI is not a valid `mailto:` URI.
-      #
-      # @api private
-      #
-      def self.parse_uri(value)
-        uri = value.to_s
-
-        begin
-          parsed = URI.parse(uri)
-        rescue URI::Error => error
-          raise InvalidRecord, truncate(error.message)
-        end
-
-        unless parsed.is_a?(URI::MailTo)
-          raise InvalidRecord, "invalid DMARC report URI (expected mailto): #{truncate(uri)}"
-        end
-
-        parsed
-      end
-
-      #
-      # Truncates an error message to a bounded length.
-      #
-      # @param [String] message
-      #
-      # @return [String]
-      #
-      # @api private
-      #
-      def self.truncate(message)
-        message = message.to_s
-
-        if message.length > MAX_ERROR_MESSAGE_LENGTH
-          message[0, MAX_ERROR_MESSAGE_LENGTH] + "..."
-        else
-          message
-        end
-      end
-
-    end
-
-    #
-    # Parses a DMARC record.
-    #
-    # @param [String] record
-    #   The raw DMARC record to parse.
-    #
-    # @param [Boolean] strict (false)
-    #   When `true`, raise on unknown tags or invalid tag values instead of
-    #   silently ignoring them.
-    #
-    # @return [Hash{Symbol => Object}]
-    #   The Hash of tags within the record.
-    #
-    # @raise [InvalidRecord]
-    #   The record is not a String, is malformed, is too large, or (in strict
-    #   mode) contains an unknown tag or invalid tag value.
-    #
-    def self.parse(record, strict: false)
-      unless record.is_a?(String)
-        raise InvalidRecord, "DMARC record must be a String, got #{record.class}"
-      end
-
-      if record.bytesize > MAX_RECORD_BYTES
-        raise InvalidRecord, "DMARC record exceeds maximum size of #{MAX_RECORD_BYTES} bytes"
-      end
-
-      tree = parser.parse(record)
-
-      if strict
-        tree.each do |node|
-          next unless ignored?(node)
-
-          if node.key?(:unknown_tag)
-            raise InvalidRecord, "unknown DMARC tag: #{Transform.truncate(node[:unknown_tag].to_s).inspect}"
-          else
-            raise InvalidRecord, "invalid DMARC tag value: #{Transform.truncate(node[:invalid_tag].to_s).inspect}"
-          end
-        end
-      end
-
-      tags = transform.apply(tree.reject { |node| ignored?(node) })
-      hash = {}
-
-      tags.each do |tag|
-        tag.each_key do |key|
-          if hash.key?(key)
-            raise InvalidRecord, "duplicate DMARC tag: #{key}"
-          end
-        end
-
-        hash.merge!(tag)
-      end
-
-      validate!(hash)
-
-      return hash
-    end
-
-    #
-    # Determines whether a parse-tree node represents a tag that the lenient
-    # parser dropped because it was unknown or had an invalid value.
-    #
-    # @param [Object] node
-    #   The parse-tree node.
-    #
-    # @return [Boolean]
-    #
-    def self.ignored?(node)
-      node.is_a?(Hash) && (node.key?(:unknown_tag) || node.key?(:invalid_tag))
-    end
-
-    #
-    # The memoized parser instance. Parslet caches rules per instance, so
-    # reusing it avoids rebuilding the grammar on every call.
-    #
-    # @return [Parser]
-    #
-    # @api private
-    #
-    def self.parser
-      @parser ||= new
-    end
-
-    #
-    # The memoized transform instance.
-    #
-    # @return [Transform]
-    #
-    # @api private
-    #
-    def self.transform
-      @transform ||= Transform.new
-    end
-
-    #
-    # Validates the parsed tags.
-    #
-    # @param [Hash{Symbol => Object}] tags
-    #   The parsed tags.
-    #
-    # @raise [InvalidRecord]
-    #   One of the tags has an invalid value.
-    #
-    def self.validate!(tags)
-      if tags[:pct] && !(tags[:pct].is_a?(Integer) && tags[:pct].between?(0, 100))
-        raise InvalidRecord, "pct must be an integer between 0 and 100"
-      end
-
-      if tags[:ri] && !(tags[:ri].is_a?(Integer) && tags[:ri].between?(0, 2**32 - 1))
-        raise InvalidRecord, "ri must be an integer between 0 and 4294967295"
-      end
-    end
-
-  end
-end

data/lib/dmarcator/xml_helper.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'nokogiri'
-
-module DMARCator
-  #
-  # Internal helper for extracting values from parsed DMARC XML reports.
-  #
-  module XmlHelper
-    private
-
-    #
-    # Returns the text of the first node matching the XPath expression.
-    #
-    # @param [String] xpath
-    #   The XPath expression to match.
-    #
-    # @return [String, nil]
-    #   The node text, or `nil` if no node matched.
-    #
-    def get_text(xpath)
-      @node.at_xpath(xpath)&.text
-    end
-
-    #
-    # Parses a Unix timestamp from raw element text.
-    #
-    # @param [String, nil] value
-    #   The element text.
-    #
-    # @return [Time, nil]
-    #
-    # @api private
-    #
-    def parse_timestamp(value)
-      seconds = parse_integer(value)
-
-      Time.at(seconds) if seconds
-    end
-
-    #
-    # Parses an integer from raw element text, returning `nil` for values that
-    # are not plain decimal digits.
-    #
-    # @param [String, nil] value
-    #   The element text.
-    #
-    # @return [Integer, nil]
-    #
-    # @api private
-    #
-    def parse_integer(value)
-      return nil if value.nil? || value.empty?
-
-      digits = value.strip
-      return nil unless digits.match?(/\A\d+\z/)
-
-      digits.to_i
-    end
-  end
-end