accept_language 2.0.2 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25f4296b38885118c1d127873d887a138bbfb6615ec0dc3d2db826e14e96e7d7
-  data.tar.gz: 9f2fac2c3818c94c5b7c7bc6d95655e3fefcb54c5ec5a3ba4ef28d05213fa00f
+  metadata.gz: c0ab90b33cf7595d9009aff633cd9bd812a4be94c9192f79b31713c05e1e7306
+  data.tar.gz: c5520587db201a89994e3fcc4b4cb9211c1f32fa8361fbf0c900dedbf2b7d5b6
 SHA512:
-  metadata.gz: b138c701a374afec0e26b9560570b3f48490a1da1e79f42daa768aa03f038f969f4670e4af57a97c109192410df0b8c66bc39bcc33f7362cc7440be6d243b0e6
-  data.tar.gz: 4a149d54102620ef411b1c1966f159840e3dec65cf5a2e33e5e045154e1234ee759be0b6ddda4cc8577f778a62e753f96642e49c5fc99e22760e6335a9bfb7aa
+  metadata.gz: bfc609d573a6febdf82e00fab5513f18aacc7746ed11f9e4c4200bdb7e82ec65a98764145fb9c0193e9af204b69f9f25842c6cccdfb1f85cfb042bd434f11cfe
+  data.tar.gz: 067ae6e1d8e55bce2de8477122bb93006c54582bb63450ce392d7776ebe3e38c8e02cdaf6e6e1aafe46fece34f84c429a0ba74cd95ed2f004e04c5c8a66ddbfe

data/LICENSE.md

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+# The MIT License
 
-Copyright (c) 2019-2022 Cyril Kato
+Copyright (c) 2019-2023 Cyril Kato
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,22 +1,32 @@
 # Accept Language 🌐
 
-A tiny library for parsing the `Accept-Language` header from browsers (as defined in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.4)).
+Web applications often need to cater to users from around the world. One of the ways they can provide a better user experience is by presenting the content in the user's preferred language. This is where the `Accept-Language` HTTP header comes into play. Sent by the client (usually a web browser), this header tells the server the list of languages the user understands, and the user's preference order.
+
+Parsing the `Accept-Language` header can be complex due to its flexible format defined in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.4). For instance, it can specify languages, countries, and scripts with varying degrees of preference (quality values).
+
+`Accept Language` is a lightweight, thread-safe Ruby library designed to parse the `Accept-Language` header, making it easier for your application to determine the best language to respond with. It calculates the intersection of the languages the user prefers and the languages your application supports, handling all the complexity of quality values and wildcards.
+
+Whether you're building a multilingual web application or just trying to make your service more accessible to users worldwide, `Accept Language` offers a reliable, simple solution.
 
 ## Status
 
-[![Version](https://img.shields.io/github/v/tag/cyril/accept_language.rb?label=Version&logo=github)](https://github.com/cyril/accept_language.rb/releases)
+[![Version](https://img.shields.io/github/v/tag/cyril/accept_language.rb?label=Version&logo=github)](https://github.com/cyril/accept_language.rb/tags)
 [![Yard documentation](https://img.shields.io/badge/Yard-documentation-blue.svg?logo=github)](https://rubydoc.info/github/cyril/accept_language.rb/main)
-[![CI](https://github.com/cyril/accept_language.rb/workflows/CI/badge.svg?branch=main)](https://github.com/cyril/accept_language.rb/actions?query=workflow%3Aci+branch%3Amain)
+[![Ruby](https://github.com/cyril/accept_language.rb/workflows/Ruby/badge.svg?branch=main)](https://github.com/cyril/accept_language.rb/actions?query=workflow%3Aruby+branch%3Amain)
 [![RuboCop](https://github.com/cyril/accept_language.rb/workflows/RuboCop/badge.svg?branch=main)](https://github.com/cyril/accept_language.rb/actions?query=workflow%3Arubocop+branch%3Amain)
 [![License](https://img.shields.io/github/license/cyril/accept_language.rb?label=License&logo=github)](https://github.com/cyril/accept_language.rb/raw/main/LICENSE.md)
 
 ## Why this tool?
 
-- Thread-safe implementation.
-- Small algorithm that can handle tricky cases.
-- Match strings and symbols ignoring the case.
-- Works also well without Rails, Rack, i18n.
-- Comes with [BCP 47](https://www.rfc-editor.org/bcp/bcp47.txt) support.
+## Why Choose Accept Language?
+
+There are a myriad of tools out there, so why should you consider Accept Language for your next project? Here's why:
+
+- **Thread-Safe**: Multithreading can present unique challenges when dealing with shared resources. Our implementation is designed to be thread-safe, preventing potential concurrency issues.
+- **Compact and Robust**: Despite being small in size, Accept Language can handle even the trickiest cases with grace, ensuring you have a reliable tool at your disposal.
+- **Case-Insensitive Matching**: In line with the principle of robustness, our tool matches both strings and symbols regardless of case, providing greater flexibility.
+- **Independent of Framework**: While many tools require Rails, Rack, or i18n to function, Accept Language stands on its own. It works perfectly well without these dependencies, increasing its adaptability.
+- **BCP 47 Support**: BCP 47 defines a standard for language tags. This is crucial for specifying languages unambiguously. Accept Language complies with this standard, ensuring accurate language identification.
 
 ## Installation
 
@@ -29,7 +39,7 @@ gem "accept_language"
 And then execute:
 
 ```sh
-bundle
+bundle install
 ```
 
 Or install it yourself as:
@@ -40,28 +50,41 @@ gem install accept_language
 
 ## Usage
 
-It's intended to be used in a Web server that supports some level of internationalization (i18n), but can be used anytime an `Accept-Language` header string is available.
-
-In order to help facilitate better i18n, the lib try to find the intersection of the languages the user prefers and the languages your application supports.
+`Accept Language` library is primarily designed to assist web servers in serving multilingual content based on user preferences expressed in the `Accept-Language` header. This library finds the best matching language from the available languages your application supports and the languages the user prefers.
 
-Some examples:
+Below are some examples of how you might use the library:
 
 ```ruby
-AcceptLanguage.parse("da, en-GB;q=0.8, en;q=0.7").match(:en, :da)       # => :da
-AcceptLanguage.parse("da, en;q=0.8, ug;q=0.9").match("en-GB", "ug-CN")  # => "ug-CN"
-AcceptLanguage.parse("da, en-GB;q=0.8, en;q=0.7").match(:ja)            # => nil
-AcceptLanguage.parse("fr-CH").match(:fr)                                # => nil
-AcceptLanguage.parse("de, zh;q=0.4, fr;q=0").match(:fr)                 # => nil
-AcceptLanguage.parse("de, zh;q=0.4, *;q=0.5, fr;q=0").match(:ar)        # => :ar
-AcceptLanguage.parse("uz-latn-uz").match("uz-Latn-UZ")                  # => "uz-Latn-UZ"
-AcceptLanguage.parse("foo;q=0.1").match(:FoO)                           # => :FoO
-AcceptLanguage.parse("foo").match("bar")                                # => nil
-AcceptLanguage.parse("*").match("BaZ")                                  # => "BaZ"
-AcceptLanguage.parse("*;q=0").match("foobar")                           # => nil
-AcceptLanguage.parse("en, en;q=0").match("en")                          # => nil
-AcceptLanguage.parse("*, en;q=0").match("en")                           # => nil
+# The user prefers Danish, then British English, and finally any kind of English.
+# Since your application supports English and Danish, it selects Danish as it's the user's first choice.
+AcceptLanguage.parse("da, en-GB;q=0.8, en;q=0.7").match(:en, :da) # => :da
+
+# The user prefers Danish, then English, and finally Uyghur. Your application supports British English and Chinese Uyghur.
+# Here, the library will return Chinese Uyghur because it's the highest ranked language in the user's list that your application supports.
+AcceptLanguage.parse("da, en;q=0.8, ug;q=0.9").match("en-GB", "ug-CN") # => "ug-CN"
+
+# The user prefers Danish, then British English, and finally any kind of English. Your application only supports Japanese.
+# Since none of the user's preferred languages are supported, it returns nil.
+AcceptLanguage.parse("da, en-GB;q=0.8, en;q=0.7").match(:ja) # => nil
+
+# The user only accepts Swiss French, but your application only supports French. Since Swiss French and French are not the same, it returns nil.
+AcceptLanguage.parse("fr-CH").match(:fr) # => nil
+
+# The user prefers German, then any language except French. Your application supports French.
+# Even though the user specified a wildcard, they explicitly excluded French. Therefore, it returns nil.
+AcceptLanguage.parse("de, zh;q=0.4, *;q=0.5, fr;q=0").match(:fr) # => nil
+
+# The user prefers Uyghur (in Latin script, as used in Uzbekistan). Your application supports this exact variant of Uyghur.
+# Since the user's first choice matches a language your application supports, it returns that language.
+AcceptLanguage.parse("uz-latn-uz").match("uz-Latn-UZ") # => "uz-Latn-UZ"
+
+# The user doesn't mind what language they get, but they'd prefer not to have English. Your application supports English.
+# Even though the user specified a wildcard, they explicitly excluded English. Therefore, it returns nil.
+AcceptLanguage.parse("*, en;q=0").match("en") # => nil
 ```
 
+These examples show the flexibility and power of `Accept Language`. By giving your application a deep understanding of the user's language preferences, `Accept Language` can significantly improve user satisfaction and engagement with your application.
+
 ### Rails integration example
 
 ```ruby
@@ -90,6 +113,11 @@ class ApplicationController < ActionController::Base
 end
 ```
 
+## Read more
+
+- [Language negotiation with Ruby](https://dev.to/cyri_/language-negotiation-with-ruby-5166)
+- [Rubyで言語ネゴシエーション](https://qiita.com/cyril/items/45dc233edb7be9d614e7)
+
 ## Versioning
 
 __AcceptLanguage__ uses [Semantic Versioning 2.0.0](https://semver.org/)

data/lib/accept_language/matcher.rb

@@ -1,24 +1,30 @@
 # frozen_string_literal: true
 
 module AcceptLanguage
-  # @note Compare an Accept-Language header value with your application's
-  #   supported languages to find the common languages that could be presented
-  #   to a user.
+  # A utility class that provides functionality to match the Accept-Language header value
+  # against the languages supported by your application. This helps in identifying the most
+  # suitable languages to present to the user based on their preferences.
+  #
   # @example
   #   Matcher.new("da" => 1.0, "en-GB" => 0.8, "en" => 0.7).call(:ug, :kk, :ru, :en) # => :en
   #   Matcher.new("da" => 1.0, "en-GB" => 0.8, "en" => 0.7).call(:fr, :en, :"en-GB") # => :"en-GB"
   class Matcher
+    WILDCARD = "*"
+
     attr_reader :excluded_langtags, :preferred_langtags
 
-    # @param [Hash<String, BigDecimal>] languages_range A list of accepted
-    #   languages with their respective qualities.
+    # Initialize a new Matcher object with the languages_range parameter representing the user's
+    # preferred languages and their respective quality values.
+    #
+    # @param [Hash<String, BigDecimal>] languages_range A hash where keys represent languages and
+    #   values are the quality of preference for each language. A value of zero means the language is not acceptable.
     def initialize(**languages_range)
-      @excluded_langtags = Set[]
+      @excluded_langtags = ::Set[]
       langtags = []
 
       languages_range.select do |langtag, quality|
         if quality.zero?
-          @excluded_langtags << langtag unless langtag.eql?("*")
+          @excluded_langtags << langtag unless wildcard?(langtag)
         else
           level = (quality * 1_000).to_i
           langtags[level] = langtag
@@ -28,16 +34,20 @@ module AcceptLanguage
       @preferred_langtags = langtags.compact.reverse
     end
 
-    # @param [Array<String, Symbol>] available_langtags The list of available
-    #   languages.
-    # @example Uyghur, Kazakh, Russian and English languages are available.
+    # Matches the user's preferred languages against the available languages of your application.
+    # It prioritizes higher quality values and returns the most suitable match.
+    #
+    # @param [Array<String, Symbol>] available_langtags An array representing the languages available in your application.
+    #
+    # @example When Uyghur, Kazakh, Russian and English languages are available.
     #   call(:ug, :kk, :ru, :en)
-    # @return [String, Symbol, nil] The language that best matches.
+    #
+    # @return [String, Symbol, nil] The language that best matches the user's preferences, or nil if there is no match.
     def call(*available_langtags)
       available_langtags = drop_unacceptable(*available_langtags)
 
       preferred_langtags.each do |preferred_tag|
-        if preferred_tag.eql?("*")
+        if wildcard?(preferred_tag)
           langtag = any_other_langtag(*available_langtags)
           return langtag unless langtag.nil?
         else
@@ -54,7 +64,7 @@ module AcceptLanguage
 
     def any_other_langtag(*available_langtags)
       available_langtags.find do |available_langtag|
-        langtags = preferred_langtags - ["*"]
+        langtags = preferred_langtags - [WILDCARD]
 
         langtags.none? do |langtag|
           available_langtag.match?(/\A#{langtag}/i)
@@ -63,10 +73,10 @@ module AcceptLanguage
     end
 
     def drop_unacceptable(*available_langtags)
-      available_langtags.inject(Set[]) do |langtags, available_langtag|
+      available_langtags.inject(::Set[]) do |langtags, available_langtag|
         next langtags if unacceptable?(available_langtag)
 
-        langtags + Set[available_langtag]
+        langtags + ::Set[available_langtag]
       end
     end
 
@@ -75,6 +85,10 @@ module AcceptLanguage
         langtag.match?(/\A#{excluded_langtag}/i)
       end
     end
+
+    def wildcard?(value)
+      value.eql?(WILDCARD)
+    end
   end
 end
 

data/lib/accept_language/parser.rb

@@ -1,45 +1,62 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+
 module AcceptLanguage
-  # @note Parser for Accept-Language header fields.
+  # Parser is a utility class responsible for parsing Accept-Language header fields.
+  # It processes the field to extract language tags and their respective quality values.
+  #
   # @example
-  #   Parser.new("da, en-GB;q=0.8, en;q=0.7") # => #<AcceptLanguage::Parser:0x00007 @languages_range={"da"=>0.1e1, "en-GB"=>0.8e0, "en"=>0.7e0}>
-  # @see https://tools.ietf.org/html/rfc2616#section-14.4
+  #   Parser.new("da, en-GB;q=0.8, en;q=0.7")
+  #   # => #<AcceptLanguage::Parser:0x00007 @languages_range={"da"=>1.0, "en-GB"=>0.8, "en"=>0.7}>
+  #
+  # @see https://tools.ietf.org/html/rfc2616#section-14.4 for more information on Accept-Language header fields.
   class Parser
+    DEFAULT_QUALITY = BigDecimal("1")
+    SEPARATOR = ","
+    SPACE = " "
+    SUFFIX = ";q="
+
     attr_reader :languages_range
 
+    # Initializes a new Parser instance by importing and processing the given Accept-Language header field.
+    #
     # @param [String] field The Accept-Language header field to parse.
-    # @see https://tools.ietf.org/html/rfc2616#section-14.4
     def initialize(field)
       @languages_range = import(field)
     end
 
-    # @param [Array<String, Symbol>] available_langtags The list of available
-    #   languages.
-    # @example Uyghur, Kazakh, Russian and English languages are available.
+    # Uses the Matcher class to find the best language match from the list of available languages.
+    #
+    # @param [Array<String, Symbol>] available_langtags An array of language tags that are available for matching.
+    #
+    # @example When Uyghur, Kazakh, Russian and English languages are available.
     #   match(:ug, :kk, :ru, :en)
-    # @return [String, Symbol, nil] The language that best matches.
+    #
+    # @return [String, Symbol, nil] The language tag that best matches the parsed languages from the Accept-Language header, or nil if no match found.
     def match(*available_langtags)
       Matcher.new(**languages_range).call(*available_langtags)
     end
 
     private
 
+    # Processes the Accept-Language header field to extract language tags and their respective quality values.
+    #
     # @example
-    #   import('da, en-GB;q=0.8, en;q=0.7') # => {"da"=>0.1e1, "en-GB"=>0.8e0, "en"=>0.7e0}
-    # @return [Hash<String, BigDecimal>] A list of accepted languages with their
-    #   respective qualities.
+    #   import('da, en-GB;q=0.8, en;q=0.7')
+    #   # => {"da"=>1.0, "en-GB"=>0.8, "en"=>0.7}
+    #
+    # @return [Hash<String, BigDecimal>] A hash where keys represent language tags and values are their respective quality values.
     def import(field)
-      field.delete(" ").split(",").inject({}) do |hash, lang|
-        tag, quality = lang.split(/;q=/i)
+      field.delete(SPACE).split(SEPARATOR).inject({}) do |hash, lang|
+        tag, quality = lang.split(SUFFIX)
         next hash if tag.nil?
 
-        quality = quality.nil? ? BigDecimal("1") : BigDecimal(quality)
+        quality = quality.nil? ? DEFAULT_QUALITY : BigDecimal(quality)
         hash.merge(tag => quality)
       end
     end
   end
 end
 
-require "bigdecimal"
 require_relative "matcher"

data/lib/accept_language.rb

@@ -1,17 +1,31 @@
 # frozen_string_literal: true
 
-# Tiny library for parsing the Accept-Language header.
+# This module provides a tiny library for parsing the Accept-Language header as specified in RFC 2616.
+# It transforms the Accept-Language header field into a language range, providing a flexible way to determine
+# user's language preferences and match them with the available languages in your application.
+#
 # @example
-#   AcceptLanguage.parse("da, en-GB;q=0.8, en;q=0.7") # => #<AcceptLanguage::Parser:0x00007 @languages_range={"da"=>0.1e1, "en-GB"=>0.8e0, "en"=>0.7e0}>
+#   AcceptLanguage.parse("da, en-GB;q=0.8, en;q=0.7")
+#   # => #<AcceptLanguage::Parser:0x00007 @languages_range={"da"=>1.0, "en-GB"=>0.8, "en"=>0.7}>
+#
 # @see https://tools.ietf.org/html/rfc2616#section-14.4
 module AcceptLanguage
-  # @note Parse an Accept-Language header field into a language range.
+  # Parses an Accept-Language header field value into a Parser object, which can then be used to match
+  # user's preferred languages against the languages your application supports.
+  # This method accepts a string argument in the format as described in RFC 2616 Section 14.4, and returns
+  # a Parser object which responds to the #match method.
+  #
+  # @param field [String] the Accept-Language header field value.
+  #
   # @example
-  #   parse("da, en-GB;q=0.8, en;q=0.7") # => #<AcceptLanguage::Parser:0x00007 @languages_range={"da"=>0.1e1, "en-GB"=>0.8e0, "en"=>0.7e0}>
-  # @return [#match] a parser that responds to #match.
+  #   AcceptLanguage.parse("da, en-GB;q=0.8, en;q=0.7")
+  #   # => #<AcceptLanguage::Parser:0x00007 @languages_range={"da"=>1.0, "en-GB"=>0.8, "en"=>0.7}>
+  #
+  # @return [Parser] a Parser object that responds to #match method.
   def self.parse(field)
     Parser.new(field)
   end
 end
 
-require_relative "accept_language/parser"
+# Load the Parser class
+require_relative File.join("accept_language", "parser")

metadata

@@ -1,155 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: accept_language
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.4
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-08 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: r_spec-clone
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-md
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-thread_safety
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2023-05-24 00:00:00.000000000 Z
+dependencies: []
 description: Parses the Accept-Language header from an HTTP request and produces a
   hash of languages and qualities.
 email: contact@cyril.email
@@ -175,14 +35,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.5
+      version: 3.1.4
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: "Parser for Accept-Language request HTTP header \U0001F310"