atlasq 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bd73be0c020537a173190c8f4c4578405f082230a9de1364e50abcaf84807d25
+  data.tar.gz: bd5cef4f2fb398bd86e402564ffe3c7853e8f3ec37330925cd9ca386c0636687
+SHA512:
+  metadata.gz: c508e56e7b5329c15a819ca5061c17cfc7f6887d4753c26f023d33d3c04548fdecb027ace154449969b36473a1b06a004c31474bd1b5c080ec03bcd71a7d71aa
+  data.tar.gz: 838990550b22eeb3d2b2268c1a80aa3bfb2035ae4d482cb1a86d681af31252c8f2b6a2edefbfd95ae62cad950e93ad3115128013102daaffd76a5481b7078ff3

data/exe/atlasq

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+debug = true if ARGV.delete("-d")
+debug = true if ARGV.delete("--debug")
+ENV["ATLASQ_DEBUG"] = "1" if debug
+
+# Avoid warnings on Ruby 2.7 related to pattern matching.
+Warning[:experimental] = false
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "atlasq"
+
+Atlasq::Shell.start!

data/lib/atlasq/command/any.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Atlasq
+  module Command
+    class Any < Base
+      def content
+        search_terms.map do |term|
+          data = Data.any(term)
+          empty = data.empty? if data.respond_to?(:empty?)
+
+          if data && !empty
+            Format.any(data, term)
+          else
+            Atlasq.failed!
+            "Unknown search term: #{term}"
+          end
+        end.join("\n\n")
+      end
+    end
+  end
+end

data/lib/atlasq/command/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Atlasq
+  module Command
+    class Base
+      attr_reader :search_terms
+
+      # @param term [Array<String>]
+      # @return [String]
+      def self.run(terms)
+        new(terms).content
+      end
+
+      # @return [Boolean]
+      def self.to_pager?
+        true
+      end
+
+      # @param search_terms [Array<String>]
+      def initialize(search_terms)
+        @search_terms = search_terms
+      end
+
+      # @return [String]
+      def content
+        NotImplementedError
+      end
+    end
+  end
+end

data/lib/atlasq/command/country.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Atlasq
+  module Command
+    class Country < Base
+      # @return [String]
+      def content
+        if search_terms.empty?
+          countries = Data.all_countries
+          Format.countries(countries, title: "All Countries")
+        else
+          search_terms.map do |term|
+            country = Data.country(term)
+
+            if country
+              Format.country(country, term)
+            else
+              Atlasq.failed!
+              "Unknown country: #{term}"
+            end
+          end.join("\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/atlasq/command/help.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Atlasq
+  module Command
+    class Help < Base
+      # @return [String]
+      def content
+        <<~HELP
+          NAME
+            atlasq -- a utility to query country info
+
+          SYNOPSIS:
+            atlasq [query ...]
+            atlasq [option]
+            atlasq [option] [query ...]
+
+          DESCRIPTIONS
+            Atlas Query aims to be the the simplest way to query for country
+            info at the command line. It includes logic to not only find
+            countries by name but also by region and currency.
+
+            To do this we take advantage of a myriad of different ISO standards:
+              - ISO3166 : Alpha and numeric codes for countries and subdivisions
+              - ISO4217 : Alpha and numeric codes for currencies
+              - ISO639  : Alpha and numeric codes for languages
+
+          OPTIONS
+            [none]
+              : Search for countries by the following criteria
+                1. country  (like --country)
+                2. region   (like --region)
+                3. currency (like --money)
+
+            -c/--country
+              : Display all countries
+            -c/--country [query ...]
+              : Search for countries by the following criteria
+                1. alpha2 (ISO3166 standard 2 letter code)
+                2. alpha3 (ISO3166 standard 3 letter code)
+                3. number (ISO3166 standard 3 digit code)
+                4. name   (common, localized, unofficial)
+
+            -r/--region
+              : Display all countries by subregion
+            -r/--region  [query ...]
+              : Search for countries by the following criteria
+                1. region
+                2. subregion
+                3. world region (4 letter code)
+                4. continent
+
+            -m/--money
+              : Display all countries by currency
+            -m/--money   [query ...]
+              : Search for countries by the following criteria
+                1. code   (ISO4127 standard 3 letter code)
+                2. name   (ISO4127 standard name)
+                3. symbol
+
+            -h/--help
+              : Display this page
+
+            -v/--version
+              : Display the version (#{VERSION})
+
+            -d/--debug
+              : Display debug output
+        HELP
+      end
+    end
+  end
+end

data/lib/atlasq/command/money.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Atlasq
+  module Command
+    class Money < Base
+      def content
+        if search_terms.empty?
+          currencies = Data.all_currencies
+          Format.currencies(currencies)
+        else
+          search_terms.map do |term|
+            currencies = Data.currencies(term)
+
+            if currencies.empty?
+              Atlasq.failed!
+              "Unknown currency: #{term}"
+            else
+              Format.currencies(currencies)
+            end
+          end.join("\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/atlasq/command/region.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Atlasq
+  module Command
+    class Region < Base
+      def content
+        if search_terms.empty?
+          subregions = Data.all_subregions
+          Format.subregions(subregions)
+        else
+          search_terms.map do |term|
+            region = Data.region(term)
+
+            if region
+              Format.region(region)
+            else
+              Atlasq.failed!
+              "Unknown region: #{term}"
+            end
+          end.join("\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/atlasq/command/usage.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Atlasq
+  module Command
+    class Usage < Base
+      # @return [Boolean]
+      def self.to_pager?
+        false
+      end
+
+      # @return [String]
+      def content
+        <<~USAGE
+          atlasq -- a utility to query country info
+
+          usage:
+            atlasq query...
+            atlasq [command] query...
+            atlasq -h/--help
+            atlasq -v/--version
+
+          commands:
+            -c/--country : find countries
+            -r/--region  : find countries by region
+            -m/--money   : find countries by currency
+        USAGE
+      end
+    end
+  end
+end

data/lib/atlasq/command/version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Atlasq
+  module Command
+    class Version < Base
+      # @return [Boolean]
+      def self.to_pager?
+        false
+      end
+
+      # @return [String]
+      def content
+        VERSION
+      end
+    end
+  end
+end

data/lib/atlasq/command.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Atlasq
+  module Command
+    autoload :Any, "atlasq/command/any"
+    autoload :Country, "atlasq/command/country"
+    autoload :Region, "atlasq/command/region"
+    autoload :Money, "atlasq/command/money"
+    autoload :Version, "atlasq/command/version"
+    autoload :Help, "atlasq/command/help"
+    autoload :Usage, "atlasq/command/usage"
+
+    # @param command [Atlasq::Command::Base]
+    # @param args [Array<String>]
+    Options = Struct.new(:command, :args, keyword_init: true)
+
+    def self.parse(args)
+      command = parse_command(args.first)
+      args.shift unless command.to_s == "Atlasq::Command::Any"
+
+      Options.new(command: command, args: args).freeze
+    end
+
+    def self.parse_command(command)
+      case command
+      when "-c", "--country", "--countries"
+        Country
+      when "-r", "--region", "--regions"
+        Region
+      when "-m", "--money"
+        Money
+      when "-v", "--version"
+        Version
+      when "-h", "--help"
+        Help
+      when nil
+        Usage
+      else
+        Any
+      end
+    end
+  end
+end

data/lib/atlasq/data/currency.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Atlasq
+  module Data
+    class Currency
+      # @return [String]
+      attr_reader :currency_code
+
+      # @return [Array<Hash>]
+      attr_reader :countries
+
+      # @param countries [Array<Hash>]
+      # @param currency_code [String] ISO4217 currency code
+      def initialize(countries:, currency_code:)
+        @countries = countries
+        @currency_code = currency_code
+      end
+    end
+  end
+end

data/lib/atlasq/data/region.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Atlasq
+  module Data
+    class Region
+      # @return [Symbol]
+      attr_reader :type
+
+      # @return [String, nil]
+      attr_reader :name
+
+      # @return [Array<Hash>]
+      attr_reader :countries
+
+      # @param countries [Array<Hash>]
+      # @param type [Symbol] in Atlasq::Data::REGION_TYPES
+      def initialize(countries:, type:)
+        @type = type
+        @name = countries.dig(0, @type.to_s)
+        @countries = countries
+      end
+    end
+  end
+end

data/lib/atlasq/data.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "countries"
+require "iso-639"
+require "money"
+require "money-heuristics"
+
+ISO3166.configure do |config|
+  # Needed to allow us to access the `ISO3166::Country#currency`
+  # object which ends up being an instance of `Money::Currency`.
+  config.enable_currency_extension!
+
+  # Needed to allow us to search by localized country name.
+  config.locales = %i[
+    af am ar as az be bg bn br bs
+    ca cs cy da de dz el en eo es
+    et eu fa fi fo fr ga gl gu he
+    hi hr hu hy ia id is it ja ka
+    kk km kn ko ku lt lv mi mk ml
+    mn mr ms mt nb ne nl nn oc or
+    pa pl ps pt ro ru rw si sk sl
+    so sq sr sv sw ta te th ti tk
+    tl tr tt ug uk ve vi wa wo xh
+    zh zu
+  ]
+end
+
+module Atlasq
+  module Data
+    autoload :Currency, "atlasq/data/currency"
+    autoload :Region, "atlasq/data/region"
+
+    # @param term [String]
+    # @return [ISO3166::Country, Atlasq::Data::Region, Atlasq::Data::Currency, nil]
+    def self.any(term)
+      Data.country(term) ||
+        Data.region(term) ||
+        Data.currencies(term)
+    end
+
+    # @param term [String]
+    # @return [ISO3166::Country|nil]
+    def self.country(term)
+      ISO3166::Country.find_country_by_alpha2(term) ||
+        ISO3166::Country.find_country_by_alpha3(term) ||
+        ISO3166::Country.find_country_by_number(term) ||
+        ISO3166::Country.find_country_by_any_name(term)
+    end
+
+    # @return [Array<ISO3166::Country>]
+    def self.all_countries
+      @all_countries ||= ISO3166::Country.all
+    end
+
+    # Region types for querying ISO3166::Country
+    REGION_TYPES = %i[region subregion world_region continent].freeze
+
+    # @return [Atlasq::Data::Region|nil]
+    def self.region(term)
+      REGION_TYPES.each do |region_type|
+        countries = ISO3166::Country.find_all_by(region_type, term)
+        next if countries.empty?
+
+        return Region.new(countries: countries.values, type: region_type)
+      end
+      nil
+    end
+
+    # @return [Hash<String, Array<ISO3166::Country>>] Ex. { "Central Asia" => [...], ... }
+    def self.all_subregions
+      all_countries
+        .group_by(&:subregion)
+        .tap do |subregions|
+          # Multiple countries do not have a valid subregion so shouldn't be shown.
+          # (010 | AQ | ATA | Antarctica)
+          # (074 | BV | BVT | Bouvet Island)
+          # (334 | HM | HMD | Heard Island and McDonald Islands)
+          subregions.delete("")
+        end
+    end
+
+    # @param term [String]
+    # @return [Array<Atlasq::Data::Currency>]
+    def self.currencies(term)
+      currency_codes = Money::Currency.analyze(term)
+      currency_codes.filter_map do |currency_code|
+        countries = ISO3166::Country.find_all_by(:currency_code, currency_code)
+        next if countries.empty?
+
+        Currency.new(countries: countries.values, currency_code: currency_code)
+      end
+    end
+
+    # @return [Array<Atlasq::Data::Currency>]
+    def self.all_currencies
+      all_countries
+        .group_by(&:currency_code)
+        .map do |currency_code, countries|
+          Currency.new(countries: countries, currency_code: currency_code)
+        end
+    end
+
+    # @param number [String] ISO3166-1 numeric country code
+    # @return [String, nil]
+    def self.emoji_flag(iso_number)
+      @emoji_flag ||= all_countries
+        .to_h { |country| [country.number, country.emoji_flag] }
+        .freeze
+
+      @emoji_flag[iso_number]
+    end
+  end
+end

data/lib/atlasq/format.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Atlasq
+  module Format
+    # @example
+    # *
+    # * Title
+    # * * * * *
+    #
+    # @param title [String]
+    # @return [String]
+    def self.title(title)
+      [
+        "*",
+        "* #{title}",
+        "*#{" *" * ((title.size / 2) + 2)}"
+      ].join("\n")
+    end
+
+    # @example for elements [Array<String>]
+    # *
+    # * Title
+    # * * * * *
+    # (attr1 | attr2 | attr3)
+    # (attr1 | attr2 | attr3)
+    # (attr1 | attr2 | attr3)
+    #
+    # @example for elements [Hash<String, Array<String>>]
+    # *
+    # * Title
+    # * * * * *
+    # - Heading 1.0
+    #   (attr1 | attr2 | attr3)
+    #   (attr1 | attr2 | attr3)
+    # - Heading 2.0
+    #   (attr1 | attr2 | attr3)
+    #
+    # @param title [String]
+    # @param elements [Array<String>, Hash<String, Array<String>>]
+    # @return [String]
+    def self.brief_template(title:, elements:)
+      elements =
+        case elements
+        when Array
+          elements.sort
+        when Hash
+          elements
+            .sort_by(&:first)
+            .each_with_object([]) do |(key, values), array|
+              array << "- #{key}"
+              values.sort.each { |value| array << "    #{value}" }
+            end
+        else
+          raise Error, "Unknown elements type: #{elements.class}"
+        end
+
+      [
+        Format.title(title),
+        *elements
+      ].join("\n")
+    end
+
+    # @example
+    # *
+    # * Title
+    # * * * * *
+    # (attr1 | attr2 | attr3)
+    # | Info One: 1
+    #  | Info Two: 2
+    #   | Info Three: 3
+    #    |________________________________________
+    #
+    # @param title [String]
+    # @param attributes [String]
+    # @param info [Hash<String, String>]
+    # @return [String]
+    def self.verbose_template(title:, attributes:, info:)
+      info_ladder = info.map.with_index do |(name, value), index|
+        "#{" " * (index + 1)}| #{name}: #{value}"
+      end
+      info_ladder << "#{" " * (info_ladder.size + 1)}|#{"_" * 40}"
+
+      [
+        Format.title(title),
+        attributes,
+        *info_ladder
+      ].join("\n")
+    end
+
+    # @param value
+    # @param search_term [String]
+    # @return [String]
+    def self.any(value, search_term)
+      case value
+      in ISO3166::Country
+        Format.country(value, search_term)
+      in Atlasq::Data::Region
+        Format.region(value)
+      in [Atlasq::Data::Currency, *]
+        Format.currencies(value)
+      else
+        raise Error, "Unknown format type: #{value.class}"
+      end
+    end
+
+    # @param country [ISO3166::Country]
+    # @param search_term [String]
+    # @return [String]
+    def self.country(country, search_term)
+      Format.verbose_template(
+        title: "Country: #{country.iso_long_name}",
+        attributes: Format.one_line_country(country),
+        info: {
+          "Search Term" => search_term,
+          "Languages" => Format.languages(country.languages),
+          "Nationality" => country.nationality,
+          "Region" => country.subregion,
+          "Continent" => country.continent,
+          "Currency" => "#{country.currency.symbol} #{country.currency.name}"
+        }.reject do |_, value|
+          # "countries" like Antarctica can have missing language, nationality,
+          # and region data so we remove that missing data beforehand.
+          value.nil? || value.empty?
+        end.to_h
+      )
+    end
+
+    # @example "English / Shona / Ndebele, North; North Ndebele"
+    # @param language_codes [Array<String>] Ex. ["id"]
+    # @return [String]
+    def self.languages(language_codes)
+      language_codes
+        .take(4) # arbitrary limit to avoid long lines
+        .map do |lang|
+          ISO_639.find(lang).english_name
+        end
+        .join(" / ")
+    end
+
+    # @param countries [Array<ISO3166::Country|Hash>]
+    # @param title [String]
+    # @return [String]
+    def self.countries(countries, title:)
+      Format.brief_template(
+        title: title,
+        elements: countries.map do |country|
+          Format.one_line_country(country)
+        end
+      )
+    end
+
+    # @param country [ISO3166::Country|Hash]
+    # @return [String]
+    def self.one_line_country(country)
+      case country
+      when ISO3166::Country
+        [
+          country.emoji_flag,
+          country.number,
+          country.alpha2,
+          country.alpha3,
+          country.iso_short_name
+        ]
+      when Hash
+        values = country.slice(
+          "number",
+          "alpha2",
+          "alpha3",
+          "iso_short_name"
+        ).values
+
+        [
+          Data.emoji_flag(country.fetch("number")),
+          *values
+        ]
+      else
+        raise Error, "Unknown country type: #{country.class}"
+      end.then do |country_values|
+        "(#{country_values.compact.join(" | ")})"
+      end
+    end
+
+    # @param region [Atlasq::Data::Region]
+    # @return [String]
+    def self.region(region)
+      type = Util::String.titleize(region.type)
+      title = "#{type}: #{region.name}"
+
+      Format.countries(region.countries, title: title)
+    end
+
+    # @param subregions [Hash<String, Array<ISO3166::Country>>]
+    # @return [String]
+    def self.subregions(subregions)
+      subregions.transform_values! do |countries|
+        countries.map(&Format.method(:one_line_country))
+      end
+
+      Format.brief_template(title: "All Subregions", elements: subregions)
+    end
+
+    # @param currencies [Array<Atlasq::Data::Currencies]
+    # @return [String]
+    def self.currencies(currencies)
+      currencies = currencies.to_h do |currency_class|
+        currency = Money::Currency.new(currency_class.currency_code)
+
+        [
+          "[#{currency.iso_code}] #{currency.symbol} #{currency.name}",
+          currency_class.countries.map(&Format.method(:one_line_country))
+        ]
+      end
+
+      if currencies.size == 1
+        title, elements = currencies.first
+        title = "Currency: #{title}"
+        Format.brief_template(title: title, elements: elements)
+      else
+        Format.brief_template(title: "Currencies", elements: currencies)
+      end
+    end
+  end
+end

data/lib/atlasq/shell.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Atlasq
+  module Shell
+    SKIP_PAGER = %i[usage version].freeze
+
+    def self.start!(args = ARGV)
+      warn "DEBUG: args: #{args}" if DEBUG
+      options = Command.parse(args)
+      warn "DEBUG: options: #{options}" if DEBUG
+      content = options.command.run(options.args)
+
+      if content.empty?
+        Atlasq.failed!
+      elsif use_pager?(options, content)
+        require "tty-pager"
+        TTY::Pager.page(content)
+      else
+        puts content
+      end
+
+      exit(1) if Atlasq.failed?
+    end
+
+    DEFAULT_SHELL_HEIGHT = 24
+
+    def self.use_pager?(options, content)
+      $stdout.tty? &&
+        options.command.to_pager? &&
+        content.count("\n") >= DEFAULT_SHELL_HEIGHT
+    end
+  end
+end

data/lib/atlasq/util/string.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Atlasq
+  module Util
+    module String
+      # @param string [#to_s]
+      # @return [String]
+      def self.titleize(string)
+        string
+          .to_s
+          .split(/[-_ \t]+/)
+          .map(&:capitalize)
+          .join(" ")
+      end
+    end
+  end
+end

data/lib/atlasq/util.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Atlasq
+  module Util
+    autoload :String, "atlasq/util/string"
+  end
+end

data/lib/atlasq/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Atlasq
+  VERSION = "0.1.0"
+end

data/lib/atlasq.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "atlasq/version"
+
+module Atlasq
+  class Error < StandardError; end
+  DEBUG = ENV.key?("ATLASQ_DEBUG")
+
+  autoload :Command, "atlasq/command"
+  autoload :Data, "atlasq/data"
+  autoload :Format, "atlasq/format"
+  autoload :Shell, "atlasq/shell"
+  autoload :Util, "atlasq/util"
+
+  def self.failed!
+    @failed = true
+  end
+
+  def self.failed?
+    !!@failed
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: atlasq
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kevin Robell
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: countries
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+- !ruby/object:Gem::Dependency
+  name: iso-639
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: money
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.9'
+- !ruby/object:Gem::Dependency
+  name: money-heuristics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: tty-pager
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+description: |
+  Country, region, and currency info at your fingertips.
+  Query for regional info and see which countries show up.
+email:
+- apainintheneck@gmail.com
+executables:
+- atlasq
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/atlasq
+- lib/atlasq.rb
+- lib/atlasq/command.rb
+- lib/atlasq/command/any.rb
+- lib/atlasq/command/base.rb
+- lib/atlasq/command/country.rb
+- lib/atlasq/command/help.rb
+- lib/atlasq/command/money.rb
+- lib/atlasq/command/region.rb
+- lib/atlasq/command/usage.rb
+- lib/atlasq/command/version.rb
+- lib/atlasq/data.rb
+- lib/atlasq/data/currency.rb
+- lib/atlasq/data/region.rb
+- lib/atlasq/format.rb
+- lib/atlasq/shell.rb
+- lib/atlasq/util.rb
+- lib/atlasq/util/string.rb
+- lib/atlasq/version.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/apainintheneck/atlasq/
+  changelog_uri: https://github.com/apainintheneck/atlasq/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Query for countries info at the command line.
+test_files: []