openemail 0.0.1

data/lib/openemail/credentials.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Credentials
+    module_function
+
+    def api_key?(value)
+      value.is_a?(String) && Protocol::API_KEY_PREFIXES.values.any? { |prefix| value.start_with?(prefix) }
+    end
+
+    def access_token?(value)
+      value.is_a?(String) &&
+        !value.empty? &&
+        value.length <= Protocol::ACCESS_TOKEN_RULES[:MAX_LENGTH] &&
+        !value.start_with?(Protocol::ACCESS_TOKEN_RULES[:RESERVED_PREFIX])
+    end
+
+    def present?(value)
+      !value.nil? && value != ""
+    end
+
+    def mode_of(api_key)
+      return Protocol::API_KEY_MODES[:TEST] if api_key.is_a?(String) && api_key.start_with?(Protocol::API_KEY_PREFIXES[:TEST])
+
+      Protocol::API_KEY_MODES[:LIVE]
+    end
+
+    def assert_api_key(api_key, subject)
+      raise ArgumentError, Defaults::MESSAGES[:API_KEY_REQUIRED] unless present?(api_key)
+      raise ArgumentError, "#{subject} #{Defaults::MESSAGES[:API_KEY_SHAPE]}" unless api_key?(api_key)
+    end
+
+    def assert_access_token(access_token, subject)
+      return if access_token.respond_to?(:call)
+      raise ArgumentError, "#{subject} #{Defaults::MESSAGES[:ACCESS_TOKEN_SHAPE]}" unless access_token?(access_token)
+    end
+
+    def assert_credential(api_key, access_token, required:)
+      with_key = present?(api_key)
+      with_token = present?(access_token)
+
+      raise ArgumentError, Defaults::MESSAGES[:CREDENTIAL_CONFLICT] if with_key && with_token
+
+      if with_key
+        assert_api_key(api_key, "The api_key")
+      elsif with_token
+        assert_access_token(access_token, "The access_token")
+      elsif required
+        raise ArgumentError, Defaults::MESSAGES[:CREDENTIAL_REQUIRED]
+      end
+    end
+  end
+end

data/lib/openemail/decode.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Decode
+    BYTE_ORDER_MARK = ""
+    ESCAPE = /\\u(d[89ab]\h\h)(\\u(d[c-f]\h\h))?|\\u(d[c-f]\h\h)|\\./i
+    REPLACEMENT_ESCAPE = "\\ufffd"
+
+    module_function
+
+    def text(bytes)
+      bytes.to_s.dup.force_encoding(Encoding::UTF_8).scrub.delete_prefix(BYTE_ORDER_MARK)
+    end
+
+    def json(text)
+      JSON.parse(text, symbolize_names: true)
+    rescue JSON::ParserError
+      repaired = without_lone_surrogates(text)
+      raise if repaired == text
+
+      JSON.parse(repaired, symbolize_names: true)
+    end
+
+    def without_lone_surrogates(text)
+      text.gsub(ESCAPE) do |escape|
+        high, pair, _low, lone_low = Regexp.last_match.captures
+        next escape if high.nil? && lone_low.nil?
+        next escape if high && pair
+
+        REPLACEMENT_ESCAPE
+      end
+    end
+  end
+end

data/lib/openemail/defaults.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Defaults
+    BASE_URL = "https://api.openemail.uk"
+    MAX_RETRIES = 2
+    TIMEOUT = 30
+    UPLOAD_TIMEOUT = 600
+    USER_AGENT = "openemail-ruby/#{VERSION}"
+    KEEP_ALIVE_TIMEOUT = 2
+    MAX_IDLE_CONNECTIONS = 8
+    BODYLESS_WRITES = %w[POST PUT PATCH].freeze
+    REDACTED = "[redacted]"
+
+    LOOPBACK_IPV4_PATTERN = /\A127\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/
+    ENDPOINT_SCHEME_PATTERN = %r{\A[a-z][a-z0-9+.-]*://}i
+    LANGUAGE_SUBTAG_PATTERN = /[-_]/
+    PATH_PARAM = /:([A-Za-z0-9_]+)(?:\{[^}]*\})?/
+    OPTIONAL_PATH_PARAM = %r{/:([A-Za-z0-9_]+)\?}
+    URI_COMPONENT_UNSAFE = /[^A-Za-z0-9\-_.!~*'()]/
+    DOT_SEGMENT = /\A\.+\z/
+    TRAILING_SLASHES = %r{/+\z}
+    IPV4_DECIMAL_PART = /\A(?:0|[1-9]\d*)\z/
+    IPV4_OCTAL_PART = /\A0[0-7]+\z/
+    IPV4_HEX_PART = /\A0x[0-9a-f]*\z/i
+
+    CONTENT_TYPES_BY_EXTENSION = {
+      ".png" => "image/png",
+      ".jpg" => "image/jpeg",
+      ".jpeg" => "image/jpeg",
+      ".webp" => "image/webp",
+      ".gif" => "image/gif",
+      ".svg" => "image/svg+xml",
+      ".pdf" => "application/pdf",
+      ".txt" => "text/plain",
+      ".csv" => "text/csv",
+      ".html" => "text/html",
+      ".json" => "application/json",
+      ".ics" => "text/calendar",
+      ".eml" => "message/rfc822",
+      ".mbox" => "application/mbox",
+      ".zip" => "application/zip",
+      ".gz" => "application/gzip",
+      ".tgz" => "application/gzip"
+    }.freeze
+
+    UPDATE_NOTICE = {
+      ENV_DISABLE: "OPENEMAIL_DISABLE_UPDATE_NOTICE",
+      TIMEOUT: 2,
+      PACKAGE: "openemail",
+      REGISTRY_URL: "https://rubygems.org/api/v1/versions/openemail/latest.json",
+      PAGE_URL: "https://rubygems.org/gems/openemail",
+      ICON: "ℹ"
+    }.freeze
+
+    MESSAGES = {
+      API_KEY_REQUIRED: "An OpenEmail API key is required. Pass api_key: or set OPENEMAIL_API_KEY. " \
+        "Create one in OpenEmail under Settings, API keys.",
+      CREDENTIAL_REQUIRED: "An OpenEmail API key or OAuth access token is required. Pass api_key: or access_token:, " \
+        "or set OPENEMAIL_API_KEY or OPENEMAIL_ACCESS_TOKEN. Create a key in OpenEmail under Settings, API keys.",
+      CREDENTIAL_CONFLICT: "Pass api_key: or access_token:, not both. Every request carries one credential, " \
+        "so the client cannot tell which of the two you meant.",
+      KEY_TWICE: "Pass the API key once, either as the first argument or as api_key:.",
+      API_KEY_SHAPE: "is not an OpenEmail API key. The API accepts only keys beginning \"oe_live_\" or \"oe_test_\", " \
+        "so a session cookie, a session token or a key for another service is refused. " \
+        "Pass an OAuth access token as access_token: instead.",
+      ACCESS_TOKEN_SHAPE: "is not an OAuth access token. Pass the access token OpenEmail issued when the app was " \
+        "connected: a string of 1 to 512 characters that does not begin \"oe_\". An API key goes in api_key: instead.",
+      ACCESS_TOKEN_PROVIDED: "The value the access_token: callable returned",
+      BASE_URL_SHAPE: "is not a usable base URL. Pass an https origin such as \"https://api.openemail.uk\". " \
+        "Plain http is for a server on this machine only, at localhost, a 127.x.x.x address or ::1, " \
+        "because the client never sends a credential over plain http to any other host.",
+      BASE_URL_USERINFO: "A base URL must not carry a user name or password. Pass the origin alone and the " \
+        "credential as api_key: or access_token:.",
+      CLEARTEXT: "Refused to send a credential to %<base_url>s over plain http, where anyone on the network can read " \
+        "it. Use an https base URL. Plain http is accepted only for a server on this machine: localhost, " \
+        "a 127.x.x.x address or ::1.",
+      UNSPECIFIED_HOST: "%<value>s names %<host>s, an address a server listens on, not one to send requests to. " \
+        "For a server on this machine, use %<suggestion>s.",
+      PATH_SHAPE: "is not a usable request path. Pass a path on the API that begins with a single \"/\", such as " \
+        "\"/threads\". Anything else could send the request, and the credential it carries, to another host.",
+      OFF_ORIGIN: "leaves the API origin, so the request was not sent. Pass a path on the API that begins with a " \
+        "single \"/\", such as \"/threads\".",
+      EMPTY_SEGMENT: "An id must not be empty.",
+      DOT_SEGMENT: "is not a usable id: a path segment made only of dots is removed by URL parsers, so the request " \
+        "would reach a different endpoint.",
+      FILENAME_REQUIRED: "A file name is required. Pass it as filename:, the name the file is stored and " \
+        "downloaded under.",
+      BODY_SHAPE: "Pass the request body as a Hash, or as keyword arguments.",
+      RAW_BODY_SHAPE: "Pass the bytes as a String, an IO or a Pathname.",
+      HEADER_SHAPE: "A header name must be a token and a header value must not contain a line break.",
+      TIMEOUT_SHAPE: "Pass timeout: as a number of seconds, or 0 for no timeout.",
+      ATTACHMENT_CONTENT_SHAPE: "An attachment's content must be base64 text, or the raw bytes as a binary String " \
+        "(File.binread), an IO or a Pathname, which are encoded for you.",
+      SEGMENT_ENCODING: "An id must be valid UTF-8 text.",
+      TIMED_OUT: "Request timed out after %<seconds>ss.",
+      UNREACHABLE: "Could not reach %<base_url>s: %<reason>s",
+      NOT_JSON: "The API answered %<status>s with a body that is not JSON.",
+      UNRECOGNISED_BODY: "The API responded %<status>s with a body this client did not recognise.",
+      WEBHOOK_MISSING_HEADER: "Missing the X-OpenEmail-Signature header.",
+      WEBHOOK_MALFORMED_HEADER: "X-OpenEmail-Signature is not in the form t=<seconds>,v1=<hex>.",
+      WEBHOOK_OUT_OF_TOLERANCE: "Webhook timestamp is %<drift>ss out of tolerance (%<tolerance>ss).",
+      WEBHOOK_MISMATCH: "Webhook signature does not match the payload.",
+      WEBHOOK_PAYLOAD_SHAPE: "Pass the raw request body as a String, exactly as it arrived. A parsed or re-encoded " \
+        "body no longer matches its signature.",
+      WEBHOOK_SECRET_REQUIRED: "A webhook signing secret is required. Pass the secret the webhook was created " \
+        "with as secret:.",
+      UPDATE_AVAILABLE: "%<icon>s %<package>s %<latest>s is available, you are on %<current>s. %<page>s"
+    }.freeze
+  end
+end

data/lib/openemail/endpoint.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Endpoint
+    module_function
+
+    def valid_base_url(value)
+      text = value.to_s.strip.sub(Defaults::TRAILING_SLASHES, "")
+      uri = parse_http(text)
+
+      raise ArgumentError, "#{value.to_s.inspect} #{Defaults::MESSAGES[:BASE_URL_SHAPE]}" if uri.nil?
+      raise ArgumentError, Defaults::MESSAGES[:BASE_URL_USERINFO] unless uri.userinfo.nil?
+      raise ArgumentError, unspecified_host_message(value, uri) if unspecified_host?(uri.host)
+
+      text
+    end
+
+    def normalise(value)
+      return nil if value.nil?
+
+      text = value.to_s.strip.sub(Defaults::TRAILING_SLASHES, "")
+      return nil if text.empty?
+      return text if Defaults::ENDPOINT_SCHEME_PATTERN.match?(text)
+
+      "#{local_host?(hostname_of(text)) ? "http" : "https"}://#{text}"
+    end
+
+    def secure_origin?(url)
+      uri = parse_http(url)
+      return false if uri.nil?
+
+      uri.is_a?(URI::HTTPS) || loopback_host?(uri.host)
+    end
+
+    def build_url(base_url, path, query)
+      url = api_url(base_url, path)
+      pairs = (query || {}).filter_map do |key, value|
+        next if value.nil? || value == ""
+
+        [key.to_s, query_text(value)]
+      end
+
+      pairs.empty? ? url : "#{url}?#{URI.encode_www_form(pairs)}"
+    end
+
+    def query_text(value)
+      return Wire.list(value).map { |item| query_text(item) }.join(",") if Wire.collection?(value)
+
+      Wire.scalar(value).to_s
+    end
+
+    def api_url(base_url, path)
+      unless path.is_a?(String) && path.start_with?("/") && !path.start_with?("//") && !path.start_with?("/\\")
+        raise ArgumentError, "#{path.inspect} #{Defaults::MESSAGES[:PATH_SHAPE]}"
+      end
+
+      url = "#{base_url.sub(Defaults::TRAILING_SLASHES, "")}#{path}"
+      origin = origin_of(url)
+
+      raise ArgumentError, "#{path.inspect} #{Defaults::MESSAGES[:OFF_ORIGIN]}" if origin.nil? || origin != origin_of(base_url)
+
+      url
+    end
+
+    def loopback_host?(host)
+      canonical = canonical_host(host)
+      Protocol::LOOPBACK_HOSTNAMES.include?(canonical) || Defaults::LOOPBACK_IPV4_PATTERN.match?(canonical)
+    end
+
+    def local_host?(host)
+      canonical = canonical_host(host)
+      Protocol::LOCAL_HOSTS.include?(canonical) || Defaults::LOOPBACK_IPV4_PATTERN.match?(canonical)
+    end
+
+    def unspecified_host?(host)
+      Protocol::UNSPECIFIED_HOSTNAMES.include?(canonical_host(host))
+    end
+
+    def canonical_host(host)
+      text = host.to_s.downcase
+      return text if text.empty?
+      return ipv6_host(text) if text.start_with?("[")
+
+      parts = text.split(".", -1)
+      parts.pop if parts.size > 1 && parts.last.empty?
+      numbers = parts.map { |part| ipv4_number(part) }
+      return text if parts.empty? || parts.size > 4 || numbers.any?(&:nil?)
+
+      ipv4_address(numbers) || text
+    end
+
+    def ipv6_host(text)
+      "[#{IPAddr.new(text.delete_prefix("[").delete_suffix("]"))}]"
+    rescue ArgumentError
+      text
+    end
+
+    def ipv4_number(part)
+      return (part.length == 2) ? 0 : part[2..].to_i(16) if Defaults::IPV4_HEX_PART.match?(part)
+      return part.to_i(8) if Defaults::IPV4_OCTAL_PART.match?(part)
+
+      part.to_i if Defaults::IPV4_DECIMAL_PART.match?(part)
+    end
+
+    def ipv4_address(numbers)
+      *leading, last = numbers
+      return nil if leading.any? { |number| number > 255 } || last >= 256**(5 - numbers.size)
+
+      value = leading.each_with_index.sum { |number, index| number * (256**(3 - index)) } + last
+      [24, 16, 8, 0].map { |shift| (value >> shift) & 255 }.join(".")
+    end
+
+    def parse_http(text)
+      uri = URI.parse(text)
+      return nil unless uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
+
+      uri
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def origin_of(url)
+      uri = URI.parse(url)
+      return nil if uri.scheme.nil? || uri.host.nil?
+
+      [uri.scheme.downcase, canonical_host(uri.host), uri.port]
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def hostname_of(authority)
+      URI.parse("http://#{authority}").host.to_s
+    rescue URI::InvalidURIError
+      ""
+    end
+
+    def unspecified_host_message(value, uri)
+      substitute = uri.host.start_with?("[") ? Protocol::LOOPBACK_IPV6_ADDRESS : Protocol::LOOPBACK_IPV4_ADDRESS
+      suggestion = uri.dup.tap { |copy| copy.host = substitute }.to_s.sub(Defaults::TRAILING_SLASHES, "")
+
+      format(Defaults::MESSAGES[:UNSPECIFIED_HOST], value: value.to_s.inspect, host: canonical_host(uri.host), suggestion:)
+    end
+  end
+end

data/lib/openemail/errors.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  class Error < StandardError
+  end
+
+  class ApiError < Error
+    attr_reader :status, :type, :code, :param, :doc_url, :request_id, :retry_after_seconds, :fields, :body
+
+    def self.build(type:, **properties)
+      TYPED_ERRORS.fetch(type, ApiError).new(type:, **properties)
+    end
+
+    def initialize(message:, status:, type:, code:, param: nil, doc_url: nil, request_id: nil,
+      retry_after_seconds: nil, fields: nil, body: nil)
+      super(message)
+      @status = status
+      @type = type
+      @code = code
+      @param = param
+      @doc_url = doc_url
+      @request_id = request_id
+      @retry_after_seconds = retry_after_seconds
+      @fields = fields
+      @body = body
+    end
+
+    def auth?
+      type == ERROR_TYPES[:AUTHENTICATION_ERROR]
+    end
+
+    def permission?
+      type == ERROR_TYPES[:PERMISSION_ERROR]
+    end
+
+    def scope_missing?
+      code == Protocol::ERROR_CODES[:INSUFFICIENT_SCOPE]
+    end
+
+    def step_up_required?
+      code == STEP_UP_ERROR_CODES[:STEP_UP_REQUIRED]
+    end
+
+    def invalid_request?
+      type == ERROR_TYPES[:INVALID_REQUEST_ERROR]
+    end
+
+    def validation?
+      type == ERROR_TYPES[:VALIDATION_ERROR]
+    end
+
+    def not_found?
+      type == ERROR_TYPES[:NOT_FOUND_ERROR]
+    end
+
+    def conflict?
+      type == ERROR_TYPES[:CONFLICT_ERROR]
+    end
+
+    def rate_limited?
+      type == ERROR_TYPES[:RATE_LIMIT_ERROR]
+    end
+
+    def server_error?
+      !status.nil? && status >= 500
+    end
+
+    def retryable?
+      !status.nil? && Protocol::RETRY[:STATUSES].include?(status)
+    end
+  end
+
+  class InvalidRequestError < ApiError
+  end
+
+  class AuthenticationError < ApiError
+  end
+
+  class PermissionError < ApiError
+  end
+
+  class NotFoundError < ApiError
+  end
+
+  class ConflictError < ApiError
+  end
+
+  class ValidationError < ApiError
+  end
+
+  class RateLimitError < ApiError
+  end
+
+  TYPED_ERRORS = {
+    ERROR_TYPES[:INVALID_REQUEST_ERROR] => InvalidRequestError,
+    ERROR_TYPES[:AUTHENTICATION_ERROR] => AuthenticationError,
+    ERROR_TYPES[:PERMISSION_ERROR] => PermissionError,
+    ERROR_TYPES[:NOT_FOUND_ERROR] => NotFoundError,
+    ERROR_TYPES[:CONFLICT_ERROR] => ConflictError,
+    ERROR_TYPES[:VALIDATION_ERROR] => ValidationError,
+    ERROR_TYPES[:RATE_LIMIT_ERROR] => RateLimitError
+  }.freeze
+  private_constant :TYPED_ERRORS
+
+  class NetworkError < Error
+    attr_reader :original
+
+    def initialize(message, original: nil, timeout: false)
+      super(message)
+      @original = original
+      @timeout = timeout
+    end
+
+    def timeout?
+      @timeout
+    end
+  end
+
+  class WebhookSignatureError < Error
+  end
+end

data/lib/openemail/http.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  HttpRequest = Data.define(:method, :url, :headers, :body, :timeout) do
+    def inspect
+      shown = headers.to_h do |name, value|
+        [name, name.to_s.casecmp?(Protocol::HEADER_KEYS[:AUTHORIZATION]) ? Defaults::REDACTED : value]
+      end
+      size = body.nil? ? "nil" : "#{body.bytesize} bytes"
+
+      "#<data #{self.class.name} method=#{method.inspect}, url=#{url.inspect}, headers=#{shown.inspect}, " \
+        "body=#{size}, timeout=#{timeout.inspect}>"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def pretty_print(printer)
+      printer.text(inspect)
+    end
+  end
+
+  HttpResponse = Data.define(:status, :headers, :body) do
+    def ok?
+      status.between?(200, 299)
+    end
+
+    def header(name)
+      headers[name.to_s.downcase]
+    end
+  end
+
+  class NetHttpAdapter
+    def initialize(max_idle: Defaults::MAX_IDLE_CONNECTIONS, keep_alive_timeout: Defaults::KEEP_ALIVE_TIMEOUT)
+      @max_idle = max_idle
+      @keep_alive_timeout = keep_alive_timeout
+      @idle = Hash.new { |pools, key| pools[key] = [] }
+      @lock = Mutex.new
+      @pid = Process.pid
+    end
+
+    def call(request)
+      deadline = request.timeout && (clock + request.timeout)
+      uri = URI.parse(request.url)
+      connection = checkout(uri, remaining(deadline))
+
+      begin
+        response = perform(connection, uri, request, deadline)
+      rescue
+        finish(connection)
+        raise
+      end
+
+      checkin(uri, connection)
+      response
+    end
+
+    def close
+      connections = @lock.synchronize do
+        drained = @idle.values.flatten
+        @idle.clear
+        drained
+      end
+
+      connections.each { |connection| finish(connection) }
+      nil
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+
+    private
+
+    def perform(connection, uri, request, deadline)
+      limit(connection, deadline)
+
+      outbound = Net::HTTPGenericRequest.new(request.method, !request.body.nil?, request.method != "HEAD",
+        uri.request_uri, headers_for(request))
+      outbound.body = request.body unless request.body.nil?
+
+      body = "".b
+      response = connection.request(outbound) do |incoming|
+        incoming.read_body do |chunk|
+          body << chunk
+          limit(connection, deadline)
+        end
+      end
+
+      HttpResponse.new(status: response.code.to_i, headers: response.each_header.to_h, body:)
+    end
+
+    def limit(connection, deadline)
+      left = remaining(deadline)
+      raise Net::ReadTimeout if left && left <= 0
+
+      connection.read_timeout = left
+      connection.write_timeout = left
+    end
+
+    def remaining(deadline)
+      deadline && (deadline - clock)
+    end
+
+    def clock
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def headers_for(request)
+      return request.headers unless request.body.nil? && Defaults::BODYLESS_WRITES.include?(request.method)
+
+      request.headers.merge("Content-Length" => "0")
+    end
+
+    def checkout(uri, timeout)
+      key = pool_key(uri)
+      pooled = @lock.synchronize do
+        forget_inherited_connections
+        @idle[key].pop
+      end
+
+      pooled || connect(uri, timeout)
+    end
+
+    def checkin(uri, connection)
+      kept = @lock.synchronize do
+        next false unless @pid == Process.pid && @idle[pool_key(uri)].size < @max_idle
+
+        @idle[pool_key(uri)].push(connection)
+        true
+      end
+
+      finish(connection) unless kept
+    end
+
+    def connect(uri, timeout)
+      proxy = uri.find_proxy
+      connection = Net::HTTP.new(uri.hostname, uri.port, proxy&.hostname, proxy&.port, decoded(proxy&.user),
+        decoded(proxy&.password))
+      connection.use_ssl = uri.is_a?(URI::HTTPS)
+      connection.min_version = OpenSSL::SSL::TLS1_2_VERSION if connection.use_ssl?
+      connection.open_timeout = timeout
+      connection.read_timeout = timeout
+      connection.write_timeout = timeout
+      connection.keep_alive_timeout = @keep_alive_timeout
+      connection.max_retries = 0
+      connection.start
+    end
+
+    def decoded(text)
+      text && URI.decode_uri_component(text)
+    end
+
+    def finish(connection)
+      connection.finish if connection.started?
+    rescue IOError, SystemCallError, OpenSSL::SSL::SSLError
+      nil
+    end
+
+    def forget_inherited_connections
+      return if @pid == Process.pid
+
+      @idle.clear
+      @pid = Process.pid
+    end
+
+    def pool_key(uri)
+      [uri.scheme.downcase, uri.hostname.downcase, uri.port]
+    end
+  end
+end

data/lib/openemail/languages.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module OpenEmail
+  module Languages
+    module_function
+
+    def key(value)
+      value.to_s.strip.downcase
+    end
+
+    BY_CODE = LANGUAGES.to_h { |language| [key(language[:code]), language] }.freeze
+    BY_LABEL = LANGUAGES.to_h { |language| [key(language[:label]), language] }.freeze
+    BY_NATIVE = LANGUAGES.to_h { |language| [key(language[:native]), language] }.freeze
+    ALIASES = Protocol::LANGUAGE_ALIASES.to_h { |(name, code)| [key(name), key(code)] }.freeze
+
+    def by_code(code)
+      return nil if code.nil? || code == ""
+
+      BY_CODE[key(code)]
+    end
+
+    def resolve(input)
+      return nil if input.nil? || input == ""
+
+      wanted = key(input)
+      return nil if wanted.empty?
+      return BY_CODE[ALIASES[wanted]] if ALIASES.key?(wanted)
+
+      direct = BY_CODE[wanted] || BY_LABEL[wanted] || BY_NATIVE[wanted]
+      return direct if direct
+
+      base = wanted.split(Defaults::LANGUAGE_SUBTAG_PATTERN).first
+      return nil if base.nil? || base.empty? || base == wanted
+
+      BY_CODE[ALIASES.fetch(base, base)]
+    end
+
+    def rtl?(code)
+      resolve(code)&.fetch(:rtl, false) == true
+    end
+  end
+end