jscontact 0.1.0

data/lib/jscontact/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jscontact
+  Violation = Struct.new(:pointer, :message, keyword_init: true)
+
+  class Error < StandardError
+    attr_reader :pointer
+
+    def initialize(message = nil, pointer: nil)
+      @pointer = pointer
+      super(message)
+    end
+  end
+
+  class ParseError < Error; end
+  class ConversionError < Error; end
+  class LimitError < Error; end
+
+  class ValidationError < Error
+    attr_reader :errors
+
+    def initialize(errors, pointer: nil)
+      @errors = errors.is_a?(Array) ? errors : [Violation.new(pointer: pointer || "", message: errors)]
+      super(@errors.map { |error| "#{error.pointer}: #{error.message}" }.join("; "), pointer: pointer || @errors.first&.pointer)
+    end
+  end
+end

data/lib/jscontact/localization.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Jscontact
+  module Localization
+    module_function
+
+    def validate(data, **limits)
+      localizations = data["localizations"]
+      return [] unless localizations.is_a?(Hash)
+
+      count = localizations.values.sum { |patch| patch.is_a?(Hash) ? patch.size : 0 }
+      raise LimitError.new("Too many localization patches", pointer: "/localizations") if count > limits.fetch(:max_patches, DEFAULT_LIMITS[:max_patches])
+
+      source = data.except("localizations")
+      localizations.flat_map do |language, patch|
+        prefix = Jscontact.pointer("/localizations", language)
+        next [] unless patch.is_a?(Hash)
+
+        forbidden = patch.keys.select { |path| path.is_a?(String) && (path == "localizations" || path.start_with?("localizations/")) }
+        unless forbidden.empty?
+          next forbidden.map { |path| Violation.new(pointer: Jscontact.pointer(prefix, path), message: "A localization cannot target localizations") }
+        end
+
+        begin
+          localized = PatchObject.new(patch, **limits).apply(source, validate: false)
+          Validator.new(**limits, validate_localizations: false).validate(localized).map do |error|
+            owner = patch.keys.find { |key| error.pointer == "/#{key}" || error.pointer.start_with?("/#{key}/") }
+            pointer = owner ? Jscontact.pointer(prefix, owner) + error.pointer.delete_prefix("/#{owner}") : prefix
+            Violation.new(pointer: pointer, message: "#{error.pointer}: #{error.message}")
+          end
+        rescue ValidationError => e
+          e.errors.map { |error| Violation.new(pointer: prefix + error.pointer.to_s, message: error.message) }
+        end
+      end
+    end
+  end
+
+  class Card
+    def localized(language)
+      raise ValidationError.new("Invalid language tag", pointer: "/language") unless language.is_a?(String) && Types.language_tag?(language)
+
+      validate!
+      source = to_h
+      localizations = source.fetch("localizations", {})
+      key = localizations.keys.find { |tag| tag.casecmp?(language) }
+      return self.class.new(source, **limits) unless key
+
+      patch = localizations.fetch(key)
+      source.delete("localizations")
+      result = PatchObject.new(patch, **limits).apply(source)
+      result["language"] = language
+      self.class.new(result, **limits).validate!
+    end
+  end
+end

data/lib/jscontact/model.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Jscontact
+  # A typed view over a JSON object; nested views write into their owning model.
+  class Model
+    attr_reader :limits
+
+    def initialize(data = nil, strict: false, explicit_types: false, **limits)
+      @limits = DEFAULT_LIMITS.merge(limits).freeze
+      validator = Validator.new(**limits)
+      data = { "@type" => "Card", "version" => "2.0" } if data.nil? && instance_of?(Card)
+      data ||= {}
+      raise ValidationError, "expected a JSON object" unless data.is_a?(Hash)
+
+      @data = Jscontact.deep_copy(data, max_depth: @limits[:max_depth])
+      @explicit_types = explicit_types
+      violations = validator.validate(@data, type: type_name, root: instance_of?(Card))
+      raise ValidationError, violations if strict && !violations.empty?
+    end
+
+    def self.wrap(data, limits, explicit_types)
+      value = allocate
+      value.instance_variable_set(:@data, data)
+      value.instance_variable_set(:@limits, limits)
+      value.instance_variable_set(:@explicit_types, explicit_types)
+      value
+    end
+
+    def [](name)
+      name = name.to_s
+      rule = SCHEMA.fetch(type_name).fetch("properties")[name]
+      return @data[name] unless rule
+      return Jscontact.deep_copy(rule["default"]) if !@data.key?(name) && rule.key?("default")
+
+      wrap_value(@data[name], rule.fetch("type"))
+    end
+
+    def []=(name, value)
+      @data[name.to_s] = Jscontact.deep_copy(value, max_depth: @limits[:max_depth])
+    end
+
+    def key?(name)
+      @data.key?(name.to_s)
+    end
+
+    def delete(name)
+      @data.delete(name.to_s)
+    end
+
+    def to_h
+      output = Jscontact.deep_copy(@data, max_depth: @limits[:max_depth])
+      add_types(output, type_name) if @explicit_types
+      output
+    end
+
+    def to_json(options = nil)
+      validate!
+      data = to_h
+      data["@type"] ||= type_name
+      Jscontact.generate_json(data, options || { max_nesting: @limits[:max_depth] })
+    end
+
+    def errors
+      Validator.new(**@limits).validate(@data, type: type_name, root: instance_of?(Card))
+    end
+    alias warnings errors
+
+    def valid?
+      errors.empty?
+    end
+
+    def validate!
+      violations = errors
+      raise ValidationError, violations unless violations.empty?
+
+      self
+    end
+
+    def ==(other)
+      other.is_a?(Model) && to_h == other.to_h
+    end
+
+    protected
+
+    def type_name
+      self.class.name.split("::").last
+    end
+
+    private
+
+    def wrap_value(value, signature)
+      return value unless value.is_a?(Hash) || value.is_a?(Array)
+
+      if SCHEMA.key?(signature) && value.is_a?(Hash)
+        Jscontact.const_get(signature).wrap(value, @limits, @explicit_types)
+      elsif (match = /\A(?:Id|String)\[(\w+)\]\z/.match(signature)) && SCHEMA.key?(match[1]) && value.is_a?(Hash)
+        IdMap.new(value, type: match[1], limits: @limits, explicit_types: @explicit_types,
+                         validate_ids: signature.start_with?("Id["))
+      elsif signature.end_with?("[]") && value.is_a?(Array)
+        value.map { |item| wrap_value(item, signature.delete_suffix("[]")) }
+      elsif signature.include?("|") && value.is_a?(Hash)
+        type = value.fetch("@type", signature.split("|").first)
+        SCHEMA.key?(type) ? Jscontact.const_get(type).wrap(value, @limits, @explicit_types) : value
+      else
+        value
+      end
+    end
+
+    def add_types(value, type)
+      return unless value.is_a?(Hash)
+
+      value["@type"] ||= type
+      SCHEMA.fetch(type).fetch("properties").each do |name, definition|
+        next unless value.key?(name)
+
+        item = value[name]
+        signature = definition.fetch("type")
+        if SCHEMA.key?(signature)
+          add_types(item, signature)
+        elsif (match = /\A(?:Id|String)\[(\w+)\]\z/.match(signature)) && SCHEMA.key?(match[1]) && item.is_a?(Hash)
+          item.each_value { |entry| add_types(entry, match[1]) }
+        elsif signature.end_with?("[]") && SCHEMA.key?(signature.delete_suffix("[]")) && item.is_a?(Array)
+          item.each { |entry| add_types(entry, signature.delete_suffix("[]")) }
+        elsif signature.include?("|") && item.is_a?(Hash)
+          nested_type = item.fetch("@type", signature.split("|").first)
+          add_types(item, nested_type) if SCHEMA.key?(nested_type)
+        end
+      end
+    end
+  end
+
+  # A map preserving source identifiers and exposing typed member values.
+  class IdMap
+    include Enumerable
+
+    def initialize(data = {}, type:, limits: DEFAULT_LIMITS, explicit_types: false, validate_ids: true)
+      @data = data
+      @type = type
+      @limits = limits
+      @explicit_types = explicit_types
+      @validate_ids = validate_ids
+    end
+
+    def [](id)
+      value = @data[id.to_s]
+      value.is_a?(Hash) ? Jscontact.const_get(@type).wrap(value, @limits, @explicit_types) : value
+    end
+
+    def []=(id, value)
+      id = id.to_s
+      raise ValidationError.new("invalid map Id", pointer: Jscontact.pointer("", id)) if @validate_ids && !Types.id?(id)
+      raise LimitError, "map exceeds max_map_size" if !@data.key?(id) && @data.size >= @limits[:max_map_size]
+
+      @data[id] = Jscontact.deep_copy(value, max_depth: @limits[:max_depth])
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @data.each_key { |id| yield id, self[id] }
+      self
+    end
+
+    def keys
+      @data.keys
+    end
+
+    def values
+      map { |_id, value| value }
+    end
+
+    def size
+      @data.size
+    end
+    alias length size
+
+    def empty?
+      @data.empty?
+    end
+
+    def key?(id)
+      @data.key?(id.to_s)
+    end
+
+    def delete(id)
+      value = self[id]
+      @data.delete(id.to_s)
+      value
+    end
+
+    def add(value, prefix: "id")
+      counter = 1
+      counter += 1 while @data.key?("#{prefix}#{counter}")
+      id = "#{prefix}#{counter}"
+      self[id] = value
+      id
+    end
+
+    def to_h
+      Jscontact.deep_copy(@data, max_depth: @limits[:max_depth])
+    end
+  end
+
+  SCHEMA.each do |name, definition|
+    model = const_set(name, Class.new(Model))
+    definition.fetch("properties").each_key do |property|
+      next if property == "@type"
+
+      model.class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        # def full; self["full"]; end
+        def #{property}; self[#{property.inspect}]; end
+        # def full=(value); self["full"] = value; end
+        def #{property}=(value); self[#{property.inspect}] = value; end
+      RUBY
+      snake = property.gsub(/([A-Z])/, '_\\1').downcase
+      next if snake == property
+
+      model.alias_method(snake, property)
+      model.alias_method("#{snake}=", "#{property}=")
+    end
+  end
+
+  class Card
+    def self.build(version: "2.0", explicit_types: false, **properties)
+      card = new({ "@type" => "Card", "version" => version }.merge(properties), explicit_types: explicit_types)
+      yield card if block_given?
+      card.validate!
+    end
+
+    # Returns the stable Id allocated for the new email address.
+    def add_email(**properties)
+      self.emails = {} unless key?("emails")
+      emails.add(properties, prefix: "e")
+    end
+  end
+end

data/lib/jscontact/patch_object.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Jscontact
+  class PatchObject
+    def initialize(patches, max_patches: 1_000, **limits)
+      raise ArgumentError, "max_patches must be a nonnegative integer" unless max_patches.is_a?(Integer) && max_patches >= 0
+      raise ValidationError, "PatchObject must be an object" unless patches.is_a?(Hash)
+      raise LimitError.new("Too many patches", pointer: "") if patches.size > max_patches
+
+      @limits = limits.merge(max_patches: max_patches)
+      @patches = Jscontact.deep_copy(patches, max_depth: @limits.fetch(:max_depth, 32))
+    end
+
+    def to_h
+      Jscontact.deep_copy(@patches, max_depth: @limits.fetch(:max_depth, 32))
+    end
+
+    # RFC 9553 section 1.4.3: resolve every path before modifying the copy.
+    def apply(data, validate: true)
+      raise ValidationError, "Patch target must be an object" unless data.is_a?(Hash)
+
+      result = Jscontact.deep_copy(data, max_depth: @limits.fetch(:max_depth, 32))
+      type = result["@type"]
+      validator = Validator.new(**@limits, validate_localizations: false)
+      errors = validator.validate_json(result) + validator.validate_json(@patches)
+      raise ValidationError, errors unless errors.empty?
+
+      paths = @patches.keys.map { |path| [tokens(path), path] }.sort_by(&:first)
+      paths.each_cons(2) do |(first, _), (second, path)|
+        invalid(path, "Patch paths must not overlap") if second.first(first.size) == first
+      end
+      operations = paths.map do |parts, path|
+        parent = parts[0...-1].reduce(result) { |value, token| member(value, token, path) }
+        key = parts.last
+        if parent.is_a?(Array)
+          key = array_index(parent, key, path)
+          invalid(path, "Array members cannot be removed") if @patches[path].nil?
+        elsif !parent.is_a?(Hash)
+          invalid(path, "Patch parent must be an object or array")
+        end
+        [parent, key, @patches[path]]
+      end
+      operations.each do |parent, key, value|
+        if value.nil?
+          parent.delete(key)
+        else
+          parent[key] = Jscontact.deep_copy(value, max_depth: @limits.fetch(:max_depth, 32))
+        end
+      end
+      errors = if validate && (type || result["@type"])
+                 raise ValidationError.new("Unknown patch target type", pointer: "/@type") unless SCHEMA.key?(type || result["@type"])
+
+                 validator.validate(result, type: type || result["@type"], root: true)
+               else
+                 validator.validate_json(result)
+               end
+      raise ValidationError, errors unless errors.empty?
+
+      result
+    end
+
+    private
+
+    def tokens(path)
+      invalid(path, "Invalid JSON Pointer escape") if path.match?(/~(?:[^01]|\z)/)
+      (path.empty? ? [""] : path.split("/", -1)).map { |token| token.gsub(/~[01]/) { |escape| escape == "~0" ? "~" : "/" } }
+    end
+
+    def array_index(array, token, path)
+      valid = token.match?(/\A(?:0|[1-9][0-9]*)\z/) && token.bytesize <= array.size.to_s.size && token.to_i < array.size
+      invalid(path, "Array index must refer to an existing member") unless valid
+      token.to_i
+    end
+
+    def member(parent, key, path)
+      if parent.is_a?(Array)
+        parent[array_index(parent, key, path)]
+      elsif parent.is_a?(Hash) && parent.key?(key)
+        parent[key]
+      else
+        invalid(path, "Intermediate reference token does not exist")
+      end
+    end
+
+    def invalid(path, message)
+      raise ValidationError.new(message, pointer: "/#{path.gsub("~", "~0").gsub("/", "~1")}")
+    end
+  end
+end

data/lib/jscontact/types.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module Jscontact
+  DEFAULT_LIMITS = { max_input_size: 16 * 1024 * 1024, max_depth: 32, max_map_size: 10_000,
+                     max_data_uri_size: 1024 * 1024, max_patches: 1000 }.freeze
+  MAX_INTEGER = (2**53) - 1
+
+  class << self
+    def generate_json(value, options = nil)
+      value = precise_json_floats(value) if RUBY_ENGINE == "truffleruby"
+      JSON.generate(value, options)
+    end
+
+    # TruffleRuby Float#to_s can round away significant digits used by json's generator.
+    def precise_json_floats(value)
+      case value
+      when Hash then value.transform_values { |item| precise_json_floats(item) }
+      when Array then value.map { |item| precise_json_floats(item) }
+      when Float
+        raise JSON::GeneratorError, "#{value} not allowed in JSON" unless value.finite?
+
+        number = format("%.17g", value)
+        number += ".0" unless number.match?(/[.eE]/)
+        JSON::Fragment.new(number)
+      else value
+      end
+    end
+    private :precise_json_floats
+
+    # Copies JSON-compatible values without sharing mutable caller-owned containers.
+    def deep_copy(value, max_depth: DEFAULT_LIMITS[:max_depth], depth: 0, ancestors: [], pointer: "")
+      case value
+      when Hash, Array
+        raise LimitError.new("JSON nesting exceeds max_depth", pointer: pointer) if depth >= max_depth
+        raise ValidationError.new("cyclic JSON data", pointer: pointer) if ancestors.include?(value.object_id)
+
+        nested = ancestors + [value.object_id]
+        if value.is_a?(Array)
+          value.each_with_index.map do |item, index|
+            deep_copy(item, max_depth: max_depth, depth: depth + 1, ancestors: nested, pointer: self.pointer(pointer, index))
+          end
+        else
+          value.each_with_object({}) do |(key, item), result|
+            raise ValidationError.new("JSON object keys must be strings", pointer: pointer) unless key.is_a?(String) || key.is_a?(Symbol)
+
+            key = key.to_s
+            unless key.valid_encoding? && (key.encoding == Encoding::UTF_8 || key.ascii_only?)
+              raise ValidationError.new("invalid JSON object key encoding", pointer: pointer)
+            end
+            raise ValidationError.new("duplicate JSON object key #{key}", pointer: self.pointer(pointer, key)) if result.key?(key)
+
+            result[key.dup] = deep_copy(item, max_depth: max_depth, depth: depth + 1, ancestors: nested,
+                                              pointer: self.pointer(pointer, key))
+          end
+        end
+      when String then value.dup
+      when Integer, Float, TrueClass, FalseClass, NilClass then value
+      when Model, IdMap then value.to_h
+      else raise ValidationError.new("value is not JSON-compatible", pointer: pointer)
+      end
+    end
+
+    def deep_freeze(value)
+      if value.is_a?(Hash)
+        value.each do |key, item|
+          deep_freeze(key)
+          deep_freeze(item)
+        end
+      end
+      value.each { |item| deep_freeze(item) } if value.is_a?(Array)
+      value.freeze
+    end
+
+    def pointer(parent, key)
+      "#{parent}/#{key.to_s.gsub("~", "~0").gsub("/", "~1")}"
+    end
+  end
+
+  SCHEMA = deep_freeze(YAML.safe_load_file(File.expand_path("../../data/types.yml", __dir__)))
+  ENUMS = deep_freeze(YAML.safe_load_file(File.expand_path("../../data/enums.yml", __dir__)))
+
+  module Types
+    module_function
+
+    def id?(value)
+      value.is_a?(String) && value.bytesize.between?(1, 255) && value.match?(/\A[A-Za-z0-9_-]+\z/)
+    end
+
+    def integer?(value, minimum: -MAX_INTEGER, maximum: MAX_INTEGER)
+      value.is_a?(Integer) && value.between?(minimum, maximum)
+    end
+
+    def script?(value)
+      value.is_a?(String) && value.match?(/\A[A-Za-z]{4}\z/) &&
+        (ENUMS.fetch("script").include?(value.capitalize) || value.downcase.between?("qaaa", "qabx"))
+    end
+
+    def vendor?(value)
+      return false unless value.is_a?(String) && value.valid_encoding?
+
+      prefix, name = value.split(":", 2)
+      return false unless name && !prefix.empty? && !name.empty? && !name.match?(%r{[\x00-\x08\x0A-\x1F\x7F"/~]})
+
+      prefix.split(".", -1).all? do |label|
+        label.match?(/\A[A-Za-z0-9\u0080-\u{10ffff}](?:[A-Za-z0-9\u0080-\u{10ffff}-]*[A-Za-z0-9\u0080-\u{10ffff}])?\z/)
+      end
+    rescue ArgumentError, Encoding::CompatibilityError
+      false
+    end
+
+    def uri?(value)
+      value.is_a?(String) && value.ascii_only? && !value.match?(/%(?![0-9a-fA-F]{2})/) && !URI.parse(value).scheme.nil?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def utc_date_time?(value)
+      return false unless value.is_a?(String)
+
+      match = /\A(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d*[1-9])?Z\z/.match(value)
+      return false unless match
+
+      year, month, day, hour, minute, second = match.captures.map(&:to_i)
+      Date.valid_date?(year, month, day, Date::GREGORIAN) && hour < 24 && minute < 60 && second <= 60 &&
+        (second < 60 || (hour == 23 && minute == 59 && [6, 12].include?(month) && day == Date.new(year, month, -1).day))
+    end
+
+    def jcard_temporal?(value, type)
+      return false unless value.is_a?(String)
+
+      case type
+      when "date" then jcard_date?(value)
+      when "time" then jcard_time?(value)
+      when "utc-offset"
+        match = /\A[+-](\d{2})(?::(\d{2}))?\z/.match(value)
+        match && match[1].to_i <= 23 && match[2].to_i <= 59
+      when "date-and-or-time"
+        if value.start_with?("T")
+          jcard_time?(value[1..])
+        else
+          jcard_temporal?(value, value.include?("T") ? "date-time" : "date")
+        end
+      else
+        day, clock, extra = value.split("T", -1)
+        return false if extra || !clock || !jcard_date?(day) || !jcard_time?(clock)
+        return false unless day.match?(/\A(?:\d{4}-\d{2}-\d{2}|--\d{2}-\d{2}|---\d{2})\z/) && !clock.start_with?("-")
+
+        type != "timestamp" || (day.match?(/\A\d{4}-\d{2}-\d{2}\z/) && clock.match?(/\A\d{2}:\d{2}:\d{2}(?:Z|[+-]\d{2}(?::\d{2})?)?\z/))
+      end
+    end
+
+    def jcard_date?(value)
+      if (match = /\A(?:(\d{4})-|--)(\d{2})-(\d{2})\z/.match(value))
+        return Date.valid_date?((match[1] || "2000").to_i, match[2].to_i, match[3].to_i, Date::GREGORIAN)
+      end
+      return true if value.match?(/\A\d{4}\z/)
+      return (1..31).cover?(match[1].to_i) if (match = /\A---(\d{2})\z/.match(value))
+
+      match = /\A(?:\d{4}-|--)(\d{2})\z/.match(value)
+      match && (1..12).cover?(match[1].to_i)
+    end
+
+    def jcard_time?(value)
+      match = /\A(\d{2}(?::\d{2}){0,2}|-\d{2}(?::\d{2})?|--\d{2})(Z|[+-]\d{2}(?::\d{2})?)?\z/.match(value)
+      return false unless match
+
+      clock, zone = match.captures
+      return false if zone && zone != "Z" && !jcard_temporal?(zone, "utc-offset")
+
+      offset = clock[/\A-*/].length
+      units = clock.delete_prefix("-" * offset).split(":").map(&:to_i)
+      units.each_with_index.all? { |unit, index| unit <= [23, 59, 60][index + offset] }
+    end
+
+    GRANDFATHERED_LANGUAGES = %w[art-lojban cel-gaulish en-gb-oed i-ami i-bnn i-default i-enochian i-hak i-klingon
+                                 i-lux i-mingo i-navajo i-pwn i-tao i-tay i-tsu no-bok no-nyn sgn-be-fr sgn-be-nl
+                                 sgn-ch-de zh-guoyu zh-hakka zh-min zh-min-nan zh-xiang].freeze
+
+    def language_tag?(value)
+      return false unless value.is_a?(String)
+      return true if GRANDFATHERED_LANGUAGES.include?(value.downcase)
+      return true if value.match?(/\Ax(?:-[A-Za-z0-9]{1,8})+\z/i)
+
+      parts = value.split("-", -1)
+      language = parts.shift
+      return false unless language&.match?(/\A[A-Za-z]{2,8}\z/)
+
+      3.times { parts.shift if parts.first&.match?(/\A[A-Za-z]{3}\z/) } if language.size <= 3
+      parts.shift if parts.first&.match?(/\A[A-Za-z]{4}\z/)
+      parts.shift if parts.first&.match?(/\A(?:[A-Za-z]{2}|[0-9]{3})\z/)
+      variants = []
+      while parts.first&.match?(/\A(?:[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3})\z/)
+        variant = parts.shift.downcase
+        return false if variants.include?(variant)
+
+        variants << variant
+      end
+      singletons = []
+      until parts.empty?
+        singleton = parts.shift.downcase
+        return false unless singleton.match?(/\A[A-Za-z0-9]\z/) && !singletons.include?(singleton)
+        return !parts.empty? && parts.all? { |part| part.match?(/\A[A-Za-z0-9]{1,8}\z/) } if singleton == "x"
+
+        singletons << singleton
+        count = 0
+        while parts.first&.match?(/\A[A-Za-z0-9]{2,8}\z/)
+          parts.shift
+          count += 1
+        end
+        return false if count.zero?
+      end
+      true
+    end
+
+    def email?(value)
+      return false unless value.is_a?(String) && value.ascii_only?
+
+      value = value.gsub(/\r\n(?=[ \t])/, "")
+      return false if value.match?(/[^\x09\x20-\x7E]/)
+
+      value = without_email_comments(value)
+      return false unless value
+
+      atom = %q([A-Za-z0-9!#$%&'*+\-/=?^_`{|}~]+)
+      quoted = '"(?:[^"\\\\\r\n]|\\\\[\\x20-\\x7E])*"'
+      word = "(?:#{atom}|#{quoted})"
+      local = "#{word}(?:[ \\t]*\\.[ \\t]*#{word})*"
+      domain = "(?:#{atom}(?:[ \\t]*\\.[ \\t]*#{atom})*|\\[(?:[^\\[\\]\\\\\\r\\n]|\\\\[\\x20-\\x7E])*\\])"
+      value.match?(/\A[ \t]*#{local}[ \t]*@[ \t]*#{domain}[ \t]*\z/)
+    end
+
+    def without_email_comments(value)
+      result = +""
+      depth = 0
+      quoted = nil
+      escaped = false
+      value.each_char do |character|
+        if escaped
+          result << character if depth.zero?
+          escaped = false
+        elsif character == "\\" && (depth.positive? || quoted)
+          escaped = true
+          result << character if depth.zero?
+        elsif depth.positive?
+          depth += 1 if character == "("
+          depth -= 1 if character == ")"
+          result << " " if depth.zero?
+        elsif quoted
+          result << character
+          quoted = nil if character == quoted
+        elsif character == "("
+          depth = 1
+        else
+          result << character
+          quoted = character == "[" ? "]" : '"' if ['"', "["].include?(character)
+        end
+      end
+      result if depth.zero? && !quoted && !escaped
+    end
+  end
+end