json_schemer 0.2.18 → 2.2.0

data/lib/json_schemer/draft4/vocab/validation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft4
+    module Vocab
+      module Validation
+        class Type < Draft202012::Vocab::Validation::Type
+        private
+          def valid_type(type, instance)
+            type == 'integer' ? instance.is_a?(Integer) : super
+          end
+        end
+
+        class ExclusiveMaximum < Keyword
+          def error(formatted_instance_location:, **)
+            "number at #{formatted_instance_location} is greater than or equal to `maximum`"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            maximum = schema.parsed.fetch('maximum').parsed
+            valid = !instance.is_a?(Numeric) || !value || !maximum || instance < maximum
+            result(instance, instance_location, keyword_location, valid)
+          end
+        end
+
+        class ExclusiveMinimum < Keyword
+          def error(formatted_instance_location:, **)
+            "number at #{formatted_instance_location} is less than or equal to `minimum`"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            minimum = schema.parsed.fetch('minimum').parsed
+            valid = !instance.is_a?(Numeric) || !value || !minimum || instance > minimum
+            result(instance, instance_location, keyword_location, valid)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/draft4/vocab.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft4
+    module Vocab
+      ALL = Draft6::Vocab::ALL.dup
+      ALL.transform_keys! { |key| key == '$id' ? 'id' : key }
+      ALL.delete('contains')
+      ALL.delete('propertyNames')
+      ALL.delete('const')
+      ALL.delete('examples')
+      ALL.merge!(
+        'type' => Validation::Type,
+        'exclusiveMaximum' => Validation::ExclusiveMaximum,
+        'exclusiveMinimum' => Validation::ExclusiveMinimum
+      )
+    end
+  end
+end

data/lib/json_schemer/draft6/meta.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft6
+    BASE_URI = URI('http://json-schema.org/draft-06/schema#')
+    FORMATS = Draft7::FORMATS.dup
+    FORMATS.delete('date')
+    FORMATS.delete('time')
+    FORMATS.delete('idn-email')
+    FORMATS.delete('idn-hostname')
+    FORMATS.delete('iri')
+    FORMATS.delete('iri-reference')
+    FORMATS.delete('relative-json-pointer')
+    FORMATS.delete('regex')
+    CONTENT_ENCODINGS = Draft7::CONTENT_ENCODINGS
+    CONTENT_MEDIA_TYPES = Draft7::CONTENT_MEDIA_TYPES
+    SCHEMA = {
+      '$schema' => 'http://json-schema.org/draft-06/schema#',
+      '$id' => 'http://json-schema.org/draft-06/schema#',
+      'title' => 'Core schema meta-schema',
+      'definitions' => {
+        'schemaArray' => {
+          'type' => 'array',
+          'minItems' => 1,
+          'items' => { '$ref' => '#' }
+        },
+        'nonNegativeInteger' => {
+          'type' => 'integer',
+          'minimum' => 0
+        },
+        'nonNegativeIntegerDefault0' => {
+          'allOf' => [
+            { '$ref' => '#/definitions/nonNegativeInteger' },
+            { 'default' => 0 }
+          ]
+        },
+        'simpleTypes' => {
+          'enum' => [
+            'array',
+            'boolean',
+            'integer',
+            'null',
+            'number',
+            'object',
+            'string'
+          ]
+        },
+        'stringArray' => {
+          'type' => 'array',
+          'items' => { 'type' => 'string' },
+          'uniqueItems' => true,
+          'default' => []
+        }
+      },
+      'type' => ['object', 'boolean'],
+      'properties' => {
+        '$id' => {
+          'type' => 'string',
+          'format' => 'uri-reference'
+        },
+        '$schema' => {
+          'type' => 'string',
+          'format' => 'uri'
+        },
+        '$ref' => {
+          'type' => 'string',
+          'format' => 'uri-reference'
+        },
+        'title' => {
+          'type' => 'string'
+        },
+        'description' => {
+          'type' => 'string'
+        },
+        'default' => {},
+        'examples' => {
+          'type' => 'array',
+          'items' => {}
+        },
+        'multipleOf' => {
+          'type' => 'number',
+          'exclusiveMinimum' => 0
+        },
+        'maximum' => {
+          'type' => 'number'
+        },
+        'exclusiveMaximum' => {
+          'type' => 'number'
+        },
+        'minimum' => {
+          'type' => 'number'
+        },
+        'exclusiveMinimum' => {
+          'type' => 'number'
+        },
+        'maxLength' => { '$ref' => '#/definitions/nonNegativeInteger' },
+        'minLength' => { '$ref' => '#/definitions/nonNegativeIntegerDefault0' },
+        'pattern' => {
+          'type' => 'string',
+          'format' => 'regex'
+        },
+        'additionalItems' => { '$ref' => '#' },
+        'items' => {
+          'anyOf' => [
+            { '$ref' => '#' },
+            { '$ref' => '#/definitions/schemaArray' }
+          ],
+          'default' => {}
+        },
+        'maxItems' => { '$ref' => '#/definitions/nonNegativeInteger' },
+        'minItems' => { '$ref' => '#/definitions/nonNegativeIntegerDefault0' },
+        'uniqueItems' => {
+          'type' => 'boolean',
+          'default' => false
+        },
+        'contains' => { '$ref' => '#' },
+        'maxProperties' => { '$ref' => '#/definitions/nonNegativeInteger' },
+        'minProperties' => { '$ref' => '#/definitions/nonNegativeIntegerDefault0' },
+        'required' => { '$ref' => '#/definitions/stringArray' },
+        'additionalProperties' => { '$ref' => '#' },
+        'definitions' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'default' => {}
+        },
+        'properties' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'default' => {}
+        },
+        'patternProperties' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'propertyNames' => { 'format' => 'regex' },
+          'default' => {}
+        },
+        'dependencies' => {
+          'type' => 'object',
+          'additionalProperties' => {
+            'anyOf' => [
+              { '$ref' => '#' },
+              { '$ref' => '#/definitions/stringArray' }
+            ]
+          }
+        },
+        'propertyNames' => { '$ref' => '#' },
+        'const' => {},
+        'enum' => {
+          'type' => 'array',
+          'minItems' => 1,
+          'uniqueItems' => true
+        },
+        'type' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/simpleTypes' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/simpleTypes' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'format' => { 'type' => 'string' },
+        'allOf' => { '$ref' => '#/definitions/schemaArray' },
+        'anyOf' => { '$ref' => '#/definitions/schemaArray' },
+        'oneOf' => { '$ref' => '#/definitions/schemaArray' },
+        'not' => { '$ref' => '#' }
+      },
+      'default' => {}
+    }
+  end
+end

data/lib/json_schemer/draft6/vocab.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft6
+    module Vocab
+      ALL = Draft7::Vocab::ALL.dup
+      ALL.delete('$comment')
+      ALL.delete('if')
+      ALL.delete('then')
+      ALL.delete('else')
+      ALL.delete('readOnly')
+      ALL.delete('writeOnly')
+      ALL.delete('contentMediaType')
+      ALL.delete('contentEncoding')
+    end
+  end
+end

data/lib/json_schemer/draft7/meta.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft7
+    BASE_URI = URI('http://json-schema.org/draft-07/schema#')
+    FORMATS = Draft201909::FORMATS.dup
+    FORMATS.delete('duration')
+    FORMATS.delete('uuid')
+    CONTENT_ENCODINGS = Draft201909::CONTENT_ENCODINGS
+    CONTENT_MEDIA_TYPES = Draft201909::CONTENT_MEDIA_TYPES
+    SCHEMA = {
+      '$schema' => 'http://json-schema.org/draft-07/schema#',
+      '$id' => 'http://json-schema.org/draft-07/schema#',
+      'title' => 'Core schema meta-schema',
+      'definitions' => {
+        'schemaArray' => {
+          'type' => 'array',
+          'minItems' => 1,
+          'items' => { '$ref' => '#' }
+        },
+        'nonNegativeInteger' => {
+          'type' => 'integer',
+          'minimum' => 0
+        },
+        'nonNegativeIntegerDefault0' => {
+          'allOf' => [
+            { '$ref' => '#/definitions/nonNegativeInteger' },
+            { 'default' => 0 }
+          ]
+        },
+        'simpleTypes' => {
+          'enum' => [
+            'array',
+            'boolean',
+            'integer',
+            'null',
+            'number',
+            'object',
+            'string'
+          ]
+        },
+        'stringArray' => {
+          'type' => 'array',
+          'items' => { 'type' => 'string' },
+          'uniqueItems' => true,
+          'default' => []
+        }
+      },
+      'type' => ['object', 'boolean'],
+      'properties' => {
+        '$id' => {
+          'type' => 'string',
+          'format' => 'uri-reference'
+        },
+        '$schema' => {
+          'type' => 'string',
+          'format' => 'uri'
+        },
+        '$ref' => {
+          'type' => 'string',
+          'format' => 'uri-reference'
+        },
+        '$comment' => {
+          'type' => 'string'
+        },
+        'title' => {
+          'type' => 'string'
+        },
+        'description' => {
+          'type' => 'string'
+        },
+        'default' => true,
+        'readOnly' => {
+          'type' => 'boolean',
+          'default' => false
+        },
+        'writeOnly' => {
+          'type' => 'boolean',
+          'default' => false
+        },
+        'examples' => {
+          'type' => 'array',
+          'items' => true
+        },
+        'multipleOf' => {
+          'type' => 'number',
+          'exclusiveMinimum' => 0
+        },
+        'maximum' => {
+          'type' => 'number'
+        },
+        'exclusiveMaximum' => {
+          'type' => 'number'
+        },
+        'minimum' => {
+          'type' => 'number'
+        },
+        'exclusiveMinimum' => {
+          'type' => 'number'
+        },
+        'maxLength' => { '$ref' => '#/definitions/nonNegativeInteger' },
+        'minLength' => { '$ref' => '#/definitions/nonNegativeIntegerDefault0' },
+        'pattern' => {
+          'type' => 'string',
+          'format' => 'regex'
+        },
+        'additionalItems' => { '$ref' => '#' },
+        'items' => {
+          'anyOf' => [
+            { '$ref' => '#' },
+            { '$ref' => '#/definitions/schemaArray' }
+          ],
+          'default' => true
+        },
+        'maxItems' => { '$ref' => '#/definitions/nonNegativeInteger' },
+        'minItems' => { '$ref' => '#/definitions/nonNegativeIntegerDefault0' },
+        'uniqueItems' => {
+          'type' => 'boolean',
+          'default' => false
+        },
+        'contains' => { '$ref' => '#' },
+        'maxProperties' => { '$ref' => '#/definitions/nonNegativeInteger' },
+        'minProperties' => { '$ref' => '#/definitions/nonNegativeIntegerDefault0' },
+        'required' => { '$ref' => '#/definitions/stringArray' },
+        'additionalProperties' => { '$ref' => '#' },
+        'definitions' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'default' => {}
+        },
+        'properties' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'default' => {}
+        },
+        'patternProperties' => {
+          'type' => 'object',
+          'additionalProperties' => { '$ref' => '#' },
+          'propertyNames' => { 'format' => 'regex' },
+          'default' => {}
+        },
+        'dependencies' => {
+          'type' => 'object',
+          'additionalProperties' => {
+            'anyOf' => [
+              { '$ref' => '#' },
+              { '$ref' => '#/definitions/stringArray' }
+            ]
+          }
+        },
+        'propertyNames' => { '$ref' => '#' },
+        'const' => true,
+        'enum' => {
+          'type' => 'array',
+          'items' => true,
+          'minItems' => 1,
+          'uniqueItems' => true
+        },
+        'type' => {
+          'anyOf' => [
+            { '$ref' => '#/definitions/simpleTypes' },
+            {
+              'type' => 'array',
+              'items' => { '$ref' => '#/definitions/simpleTypes' },
+              'minItems' => 1,
+              'uniqueItems' => true
+            }
+          ]
+        },
+        'format' => { 'type' => 'string' },
+        'contentMediaType' => { 'type' => 'string' },
+        'contentEncoding' => { 'type' => 'string' },
+        'if' => { '$ref' => '#' },
+        'then' => { '$ref' => '#' },
+        'else' => { '$ref' => '#' },
+        'allOf' => { '$ref' => '#/definitions/schemaArray' },
+        'anyOf' => { '$ref' => '#/definitions/schemaArray' },
+        'oneOf' => { '$ref' => '#/definitions/schemaArray' },
+        'not' => { '$ref' => '#' }
+      },
+      'default' => true
+    }
+  end
+end

data/lib/json_schemer/draft7/vocab/validation.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft7
+    module Vocab
+      module Validation
+        class Ref < Draft202012::Vocab::Core::Ref
+          def self.exclusive?
+            true
+          end
+        end
+
+        class AdditionalItems < Keyword
+          def error(formatted_instance_location:, **)
+            "array items at #{formatted_instance_location} do not match `additionalItems` schema"
+          end
+
+          def parse
+            subschema(value)
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            items = schema.parsed['items']&.parsed
+
+            if !instance.is_a?(Array) || !items.is_a?(Array) || items.size >= instance.size
+              return result(instance, instance_location, keyword_location, true)
+            end
+
+            offset = items.size
+
+            nested = instance.slice(offset..-1).map.with_index do |item, index|
+              parsed.validate_instance(item, join_location(instance_location, (offset + index).to_s), keyword_location, context)
+            end
+
+            result(instance, instance_location, keyword_location, nested.all?(&:valid), nested, :annotation => nested.any?)
+          end
+        end
+
+        class ContentEncoding < Draft202012::Vocab::Content::ContentEncoding
+          def error(formatted_instance_location:, **)
+            "string at #{formatted_instance_location} could not be decoded using encoding: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, _context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(String)
+
+            valid, annotation = parsed.call(instance)
+
+            result(instance, instance_location, keyword_location, valid, :annotation => annotation)
+          end
+        end
+
+        class ContentMediaType < Draft202012::Vocab::Content::ContentMediaType
+          def error(formatted_instance_location:, **)
+            "string at #{formatted_instance_location} could not be parsed using media type: #{value}"
+          end
+
+          def validate(instance, instance_location, keyword_location, context)
+            return result(instance, instance_location, keyword_location, true) unless instance.is_a?(String)
+
+            decoded_instance = context.adjacent_results[ContentEncoding]&.annotation || instance
+            valid, annotation = parsed.call(decoded_instance)
+
+            result(instance, instance_location, keyword_location, valid, :annotation => annotation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_schemer/draft7/vocab.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Draft7
+    module Vocab
+      ALL = Draft201909::Vocab::CORE.dup
+      ALL.delete('$recursiveAnchor')
+      ALL.delete('$recursiveRef')
+      ALL.delete('$vocabulary')
+      ALL.delete('$anchor')
+      ALL.delete('$defs')
+      ALL.merge!(Draft201909::Vocab::APPLICATOR)
+      ALL.delete('dependentSchemas')
+      ALL.delete('unevaluatedItems')
+      ALL.delete('unevaluatedProperties')
+      ALL.merge!(Draft201909::Vocab::VALIDATION)
+      ALL.delete('dependentRequired')
+      ALL.delete('maxContains')
+      ALL.delete('minContains')
+      ALL.merge!(Draft202012::Vocab::FORMAT_ANNOTATION)
+      ALL.merge!(Draft201909::Vocab::META_DATA)
+      ALL.delete('deprecated')
+      ALL.merge!(
+        '$ref' => Validation::Ref,
+        'additionalItems' => Validation::AdditionalItems,
+        'contentEncoding' => Validation::ContentEncoding,
+        'contentMediaType' => Validation::ContentMediaType
+      )
+    end
+  end
+end

data/lib/json_schemer/ecma_regexp.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module JSONSchemer
+  class EcmaRegexp
+    class Syntax < Regexp::Syntax::Base
+      # regexp_parser >= 2.3.0 uses syntax classes directly instead of instances
+      # :nocov:
+      SYNTAX = respond_to?(:implements) ? self : new
+      # :nocov:
+      SYNTAX.implements :anchor, Anchor::Extended
+      SYNTAX.implements :assertion, Assertion::All
+      # literal %i[number] to support regexp_parser < 2.2.0 (Backreference::Plain)
+      SYNTAX.implements :backref, %i[number] + Backreference::Name
+      # :meta_sequence, :bell, and :escape are not supported in ecma
+      SYNTAX.implements :escape, Escape::Basic + (Escape::Control - %i[meta_sequence]) + (Escape::ASCII - %i[bell escape]) + Escape::Unicode + Escape::Meta + Escape::Hex + Escape::Octal
+      SYNTAX.implements :property, UnicodeProperty::All
+      SYNTAX.implements :nonproperty, UnicodeProperty::All
+      # :comment is not supported in ecma
+      SYNTAX.implements :free_space, (FreeSpace::All - %i[comment])
+      SYNTAX.implements :group, Group::Basic + Group::Named + Group::Passive
+      SYNTAX.implements :literal, Literal::All
+      SYNTAX.implements :meta, Meta::Extended
+      SYNTAX.implements :quantifier, Quantifier::Greedy + Quantifier::Reluctant + Quantifier::Interval + Quantifier::IntervalReluctant
+      SYNTAX.implements :set, CharacterSet::Basic
+      SYNTAX.implements :type, CharacterType::Extended
+    end
+
+    RUBY_EQUIVALENTS = {
+      :anchor => {
+        :bol => '\A',
+        :eol => '\z'
+      },
+      :type => {
+        :space => '[\t\r\n\f\v\uFEFF\u2029\p{Zs}]',
+        :nonspace => '[^\t\r\n\f\v\uFEFF\u2029\p{Zs}]'
+      }
+    }.freeze
+
+    class << self
+      def ruby_equivalent(pattern)
+        Regexp::Scanner.scan(pattern).map do |type, token, text|
+          Syntax::SYNTAX.check!(*Syntax::SYNTAX.normalize(type, token))
+          RUBY_EQUIVALENTS.dig(type, token) || text
+        rescue Regexp::Syntax::NotImplementedError
+          raise InvalidEcmaRegexp, "invalid token #{text.inspect} (#{type}:#{token}) in #{pattern.inspect}"
+        end.join
+      rescue Regexp::Scanner::ScannerError
+        raise InvalidEcmaRegexp, "invalid pattern #{pattern.inspect}"
+      end
+    end
+  end
+end

data/lib/json_schemer/errors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Based on code from @robacarp found in issue 48:
 # https://github.com/davishmcclurg/json_schemer/issues/48
 #

data/lib/json_schemer/format/duration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Format
+    module Duration
+      # https://datatracker.ietf.org/doc/html/rfc3339#appendix-A
+      DUR_SECOND = '\d+S'                                              # dur-second        = 1*DIGIT "S"
+      DUR_MINUTE = "\\d+M(#{DUR_SECOND})?"                             # dur-minute        = 1*DIGIT "M" [dur-second]
+      DUR_HOUR = "\\d+H(#{DUR_MINUTE})?"                               # dur-hour          = 1*DIGIT "H" [dur-minute]
+      DUR_TIME = "T(#{DUR_HOUR}|#{DUR_MINUTE}|#{DUR_SECOND})"          # dur-time          = "T" (dur-hour / dur-minute / dur-second)
+      DUR_DAY = '\d+D'                                                 # dur-day           = 1*DIGIT "D"
+      DUR_WEEK = '\d+W'                                                # dur-week          = 1*DIGIT "W"
+      DUR_MONTH = "\\d+M(#{DUR_DAY})?"                                 # dur-month         = 1*DIGIT "M" [dur-day]
+      DUR_YEAR = "\\d+Y(#{DUR_MONTH})?"                                # dur-year          = 1*DIGIT "Y" [dur-month]
+      DUR_DATE = "(#{DUR_DAY}|#{DUR_MONTH}|#{DUR_YEAR})(#{DUR_TIME})?" # dur-date          = (dur-day / dur-month / dur-year) [dur-time]
+      DURATION = "P(#{DUR_DATE}|#{DUR_TIME}|#{DUR_WEEK})"              # duration          = "P" (dur-date / dur-time / dur-week)
+      DURATION_REGEX = /\A#{DURATION}\z/
+
+      def valid_duration?(data)
+        DURATION_REGEX.match?(data)
+      end
+    end
+  end
+end

data/lib/json_schemer/format/email.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module JSONSchemer
+  module Format
+    module Email
+      # https://datatracker.ietf.org/doc/html/rfc6531#section-3.3
+      # I think this is the same as "UTF8-non-ascii"? (https://datatracker.ietf.org/doc/html/rfc6532#section-3.1)
+      UTF8_NON_ASCII = '[^[:ascii:]]'
+      # https://datatracker.ietf.org/doc/html/rfc5321#section-4.1.2
+      A_TEXT = "([\\w!#$%&'*+\\-/=?\\^`{|}~]|#{UTF8_NON_ASCII})"              # atext           = ALPHA / DIGIT /    ; Printable US-ASCII
+                                                                              #                   "!" / "#" /        ;  characters not including
+                                                                              #                   "$" / "%" /        ;  specials.  Used for atoms.
+                                                                              #                   "&" / "'" /
+                                                                              #                   "*" / "+" /
+                                                                              #                   "-" / "/" /
+                                                                              #                   "=" / "?" /
+                                                                              #                   "^" / "_" /
+                                                                              #                   "`" / "{" /
+                                                                              #                   "|" / "}" /
+                                                                              #                   "~"
+      Q_TEXT_SMTP = "([\\x20-\\x21\\x23-\\x5B\\x5D-\\x7E]|#{UTF8_NON_ASCII})" # qtextSMTP       = %d32-33 / %d35-91 / %d93-126
+                                                                              #                 ; i.e., within a quoted string, any
+                                                                              #                 ; ASCII graphic or space is permitted
+                                                                              #                 ; without blackslash-quoting except
+                                                                              #                 ; double-quote and the backslash itself.
+      QUOTED_PAIR_SMTP = '\x5C[\x20-\x7E]'                                    # quoted-pairSMTP = %d92 %d32-126
+                                                                              #                 ; i.e., backslash followed by any ASCII
+                                                                              #                 ; graphic (including itself) or SPace
+      Q_CONTENT_SMTP = "#{Q_TEXT_SMTP}|#{QUOTED_PAIR_SMTP}"                   # QcontentSMTP    = qtextSMTP / quoted-pairSMTP
+      QUOTED_STRING = "\"(#{Q_CONTENT_SMTP})*\""                              # Quoted-string   = DQUOTE *QcontentSMTP DQUOTE
+      ATOM = "#{A_TEXT}+"                                                     # Atom            = 1*atext
+      DOT_STRING = "#{ATOM}(\\.#{ATOM})*"                                     # Dot-string      = Atom *("."  Atom)
+      LOCAL_PART = "#{DOT_STRING}|#{QUOTED_STRING}"                           # Local-part      = Dot-string / Quoted-string
+                                                                              #                 ; MAY be case-sensitive
+                                                                              # IPv4-address-literal  = Snum 3("."  Snum)
+      # using `valid_id?` to check ip addresses because it's complicated.     # IPv6-address-literal  = "IPv6:" IPv6-addr
+      ADDRESS_LITERAL = '\[(IPv6:(?<ipv6>[\h:]+)|(?<ipv4>[\d.]+))\]'          # address-literal = "[" ( IPv4-address-literal /
+                                                                              #                 IPv6-address-literal /
+                                                                              #                 General-address-literal ) "]"
+                                                                              #                 ; See Section 4.1.3
+      # using `valid_hostname?` to check domain because it's complicated
+      MAILBOX = "(#{LOCAL_PART})@(#{ADDRESS_LITERAL}|(?<domain>.+))"          # Mailbox         = Local-part "@" ( Domain / address-literal )
+      EMAIL_REGEX = /\A#{MAILBOX}\z/
+
+      def valid_email?(data)
+        return false unless match = EMAIL_REGEX.match(data)
+        if ipv4 = match.named_captures.fetch('ipv4')
+          valid_ip?(ipv4, Socket::AF_INET)
+        elsif ipv6 = match.named_captures.fetch('ipv6')
+          valid_ip?(ipv6, Socket::AF_INET6)
+        else
+          valid_hostname?(match.named_captures.fetch('domain'))
+        end
+      end
+    end
+  end
+end