timeprice 0.2.0 → 0.4.0

data/lib/timeprice/cpi_lookup.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "granularity"
+
+module Timeprice
+  # CpiPoint pairs a CPI index value with the granularity of how it was
+  # resolved. See {Granularity} for the full set of possible tags.
+  CpiPoint = Data.define(:value, :granularity)
+
+  # Resolves CPI keys ("YYYY" or "YYYY-MM") to a CpiPoint against a single
+  # country's parsed CPI data hash. Knowing the JSON shape ("monthly" /
+  # "annual" string keys) is isolated here — Inflation just asks for points.
+  class CpiLookup
+    def initialize(data)
+      @data = data
+      @monthly = data["monthly"] || {}
+      @annual  = data["annual"]  || {}
+    end
+
+    # @param key [String] "YYYY" or "YYYY-MM"
+    # @return [CpiPoint]
+    # @raise [DataNotFound] if no CPI value covers `key`
+    # @raise [ArgumentError] on malformed `key`
+    def at(key)
+      key = key.to_s
+      case key
+      when /\A\d{4}-\d{2}\z/ then monthly_or_annual_fallback(key)
+      when /\A\d{4}\z/       then annual_or_monthly_average(key)
+      else raise ArgumentError, "Invalid date format: #{key.inspect} (use YYYY or YYYY-MM)"
+      end
+    end
+
+    private
+
+    def monthly_or_annual_fallback(month_key)
+      return CpiPoint.new(value: @monthly[month_key], granularity: Granularity::MONTHLY) if @monthly.key?(month_key)
+
+      year = month_key[0, 4]
+      raise DataNotFound, missing_message(month_key) unless @annual.key?(year)
+
+      CpiPoint.new(value: @annual[year], granularity: Granularity::MONTHLY_FROM_ANNUAL_FALLBACK)
+    end
+
+    def annual_or_monthly_average(year)
+      return CpiPoint.new(value: @annual[year], granularity: Granularity::ANNUAL) if @annual.key?(year)
+
+      months = @monthly.select { |k, _| k.start_with?("#{year}-") }
+      raise DataNotFound, missing_message(year) if months.empty?
+
+      avg = months.values.sum.to_f / months.size
+      CpiPoint.new(value: avg, granularity: Granularity::ANNUAL_FROM_MONTHLY_AVG)
+    end
+
+    def missing_message(key)
+      country = @data["country"]
+      ranges = []
+      ranges << "monthly #{@monthly.keys.min}..#{@monthly.keys.max}" if @monthly.any?
+      ranges << "annual #{@annual.keys.min}..#{@annual.keys.max}" if @annual.any?
+      hint = ranges.empty? ? "" : " (supported: #{ranges.join(", ")})"
+      "No CPI data for #{key.inspect} in #{country}#{hint}"
+    end
+  end
+end

data/lib/timeprice/data_loader.rb

@@ -2,13 +2,14 @@
 
 require "json"
 require_relative "errors"
+require_relative "supported"
 
 module Timeprice
   # Loads and caches the bundled JSON data files. Override the search root
   # by setting `TIMEPRICE_DATA_ROOT` in the environment or assigning
   # {DataLoader.data_root=}.
   module DataLoader
-    SUPPORTED_SCHEMA_VERSION = 1
+    SUPPORTED_SCHEMA_VERSION = 2
 
     DEFAULT_DATA_ROOT = File.expand_path("../../data", __dir__)
 
@@ -40,11 +41,10 @@ module Timeprice
       # @raise [DataNotFound]       if the file is missing
       # @raise [UnsupportedSchemaVersion] if the file uses a future schema
       def load_cpi(country)
-        @cpi_cache ||= {}
         key = country.to_s.downcase
         code = country.to_s.upcase
-        @cpi_cache[[data_root, key]] ||= begin
-          raise UnsupportedCountry, code unless SUPPORTED_COUNTRIES.include?(code)
+        cpi_cache[[data_root, key]] ||= begin
+          raise UnsupportedCountry, code unless Supported::COUNTRIES.include?(code)
 
           path = File.join(data_root, "cpi", "#{key}.json")
           unless File.exist?(path)
@@ -61,9 +61,8 @@ module Timeprice
       # @return [Hash] parsed JSON with a "rates" map of date → currency → Float
       # @raise [DataNotFound] if the per-year file is missing
       def load_fx_year(year)
-        @fx_cache ||= {}
         key = year.to_i
-        @fx_cache[[data_root, key]] ||= begin
+        fx_cache[[data_root, key]] ||= begin
           path = File.join(data_root, "fx", "usd", "#{key}.json")
           raise DataNotFound, "No FX data for year #{key}" unless File.exist?(path)
 
@@ -73,6 +72,14 @@ module Timeprice
 
       private
 
+      def cpi_cache
+        @cpi_cache ||= {}
+      end
+
+      def fx_cache
+        @fx_cache ||= {}
+      end
+
       def parse_with_schema(path)
         data = JSON.parse(File.read(path))
         version = data["schema_version"]

data/lib/timeprice/exchange.rb

@@ -3,10 +3,12 @@
 require "date"
 require_relative "errors"
 require_relative "data_loader"
+require_relative "supported"
+require_relative "granularity"
 
 module Timeprice
   ExchangeResult = Data.define(
-    :amount, :original_amount, :from, :to, :date, :effective_date, :rate
+    :amount, :original_amount, :from, :to, :date, :effective_date, :rate, :granularity
   )
 
   # Historical FX conversion using bundled per-year USD-base rate files.
@@ -31,12 +33,12 @@ module Timeprice
     def convert(amount:, from:, to:, date:)
       from = from.to_s.upcase
       to   = to.to_s.upcase
-      raise UnsupportedCurrency, from unless SUPPORTED_CURRENCIES.include?(from)
-      raise UnsupportedCurrency, to   unless SUPPORTED_CURRENCIES.include?(to)
+      raise UnsupportedCurrency, from unless Supported::CURRENCIES.include?(from)
+      raise UnsupportedCurrency, to   unless Supported::CURRENCIES.include?(to)
 
       d = parse_date(date)
 
-      rate, eff_date = resolve_rate(from, to, d)
+      rate, eff_date, granularity = resolve_rate(from, to, d)
       ExchangeResult.new(
         amount: amount.to_f * rate,
         original_amount: amount.to_f,
@@ -44,40 +46,44 @@ module Timeprice
         to: to,
         date: d.to_s,
         effective_date: eff_date.to_s,
-        rate: rate
+        rate: rate,
+        granularity: granularity
       )
     end
 
-    # Returns [rate (Float), effective_date (Date)].
+    # Returns [rate (Float), effective_date (Date), granularity (Symbol)].
+    # Granularity is :daily when the rate came from a per-date entry, :annual
+    # when it came from the per-year `annual` fallback block. Triangulation
+    # merges both legs via Granularity.merge (worst-precision-wins).
     # Handles:
     #   - identity (from == to)
     #   - direct lookup of USD-base rate
     #   - inverse (foreign → USD)
     #   - triangulation through USD (both legs must resolve to SAME effective date)
     def resolve_rate(from, to, d)
-      return [1.0, d] if from == to
+      return [1.0, d, Granularity::DAILY] if from == to
 
       if from == BASE
-        rate, eff = lookup_usd_base(to, d)
-        [rate, eff]
+        lookup_usd_base(to, d)
       elsif to == BASE
-        rate, eff = lookup_usd_base(from, d)
-        [1.0 / rate, eff]
+        rate, eff, gran = lookup_usd_base(from, d)
+        [1.0 / rate, eff, gran]
       else
         # Triangulation: from → USD → to, both legs at the same effective date.
-        usd_to_from, eff_a = lookup_usd_base(from, d)
-        usd_to_to,   eff_b = lookup_usd_base(to,   d)
+        usd_to_from, eff_a, gran_a = lookup_usd_base(from, d)
+        usd_to_to,   eff_b, gran_b = lookup_usd_base(to,   d)
         if eff_a != eff_b
           raise DataNotFound,
                 "FX triangulation date mismatch for #{from}->#{to} on #{d}: " \
                 "USD->#{from} resolved #{eff_a}, USD->#{to} resolved #{eff_b}"
         end
-        [usd_to_to / usd_to_from, eff_a]
+        [usd_to_to / usd_to_from, eff_a, Granularity.merge(gran_a, gran_b)]
       end
     end
 
-    # Walk back up to MAX_FALLBACK_DAYS to find a rate.
-    # Returns [rate, effective_date].
+    # Walk back up to MAX_FALLBACK_DAYS to find a daily rate; if none, fall
+    # back to the year file's top-level `annual` block.
+    # Returns [rate, effective_date, granularity].
     def lookup_usd_base(currency, d)
       (0..MAX_FALLBACK_DAYS).each do |offset|
         candidate = d - offset
@@ -93,11 +99,23 @@ module Timeprice
         rate = rates_for_day[currency]
         next unless rate
 
-        return [rate.to_f, candidate]
+        return [rate.to_f, candidate, Granularity::DAILY]
       end
+
+      annual_rate = annual_fallback(currency, d.year)
+      return [annual_rate, d, Granularity::ANNUAL] if annual_rate
+
       raise DataNotFound, "No FX rate for USD->#{currency} on or before #{d}"
     end
 
+    # Consult the year file's top-level `annual` block. Returns Float or nil.
+    def annual_fallback(currency, year)
+      year_data = DataLoader.load_fx_year(year)
+      year_data.dig("annual", currency)&.to_f
+    rescue DataNotFound
+      nil
+    end
+
     def parse_date(date)
       case date
       when Date then date

data/lib/timeprice/granularity.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Timeprice
+  # Closed set of CPI-resolution granularities and the rules for combining /
+  # rendering them. Owns the lattice so callers don't hand-maintain it.
+  module Granularity
+    DAILY                        = :daily
+    MONTHLY                      = :monthly
+    ANNUAL                       = :annual
+    ANNUAL_FROM_MONTHLY_AVG      = :annual_from_monthly_avg
+    MONTHLY_FROM_ANNUAL_FALLBACK = :monthly_from_annual_fallback
+
+    # Most-degraded first — `merge` returns the first match.
+    # DAILY is the highest-precision FX tag; MONTHLY is the highest-precision
+    # CPI tag. Compare uses merge() across both legs, so the most-degraded
+    # tag in either leg wins.
+    PRECEDENCE = [
+      MONTHLY_FROM_ANNUAL_FALLBACK,
+      ANNUAL_FROM_MONTHLY_AVG,
+      ANNUAL,
+      MONTHLY,
+      DAILY,
+    ].freeze
+
+    HUMAN_LABELS = {
+      DAILY => "daily",
+      MONTHLY => "monthly",
+      ANNUAL => "annual",
+      ANNUAL_FROM_MONTHLY_AVG => "annual (avg of months)",
+      MONTHLY_FROM_ANNUAL_FALLBACK => "annual (month unavailable)",
+    }.freeze
+
+    module_function
+
+    # Worst-precision-wins merge across two or more endpoint granularities.
+    def merge(*tags)
+      PRECEDENCE.find { |t| tags.include?(t) } || MONTHLY
+    end
+
+    # Human-readable label for CLI output. Falls through to the symbol's
+    # string form so an unknown tag still renders something.
+    def humanize(tag)
+      HUMAN_LABELS.fetch(tag, tag.to_s)
+    end
+  end
+end

data/lib/timeprice/inflation.rb

@@ -2,19 +2,24 @@
 
 require_relative "errors"
 require_relative "data_loader"
+require_relative "cpi_lookup"
+require_relative "granularity"
 
 module Timeprice
-  # Value object returned by Inflation.adjust.
-  #
-  # granularity is one of:
-  #   :monthly                  — both ends resolved on monthly data
-  #   :annual                   — at least one end resolved on annual data
-  #   :annual_from_monthly_avg  — at least one end was an annual request resolved
-  #                               by averaging 12 months of monthly data
+  # Value object returned by Inflation.adjust. See {Granularity} for the set
+  # of possible `granularity` values and the worst-precision-wins merge rule.
   InflationResult = Data.define(
     :amount, :original_amount, :from, :to, :country,
     :from_index, :to_index, :granularity
-  )
+  ) do
+    # The country's primary currency (e.g. "USD" for "US"). Falls back to the
+    # uppercased country code if the country isn't in the supported map —
+    # callers can still render *some* unit rather than crashing.
+    def country_currency_label
+      require_relative "supported"
+      Supported.currency_for_country(country) || country.to_s.upcase
+    end
+  end
 
   # CPI-based inflation adjustment for the {Supported::COUNTRIES} list.
   module Inflation
@@ -32,20 +37,20 @@ module Timeprice
     # @raise [UnsupportedCountry] if `country` is not supported
     # @raise [DataNotFound]       if no CPI data covers the requested period
     def adjust(amount:, from:, to:, country:)
-      data = DataLoader.load_cpi(country)
-      from_index, from_gran = lookup_index(data, from)
-      to_index,   to_gran   = lookup_index(data, to)
+      lookup = CpiLookup.new(DataLoader.load_cpi(country))
+      from_point = lookup.at(from)
+      to_point   = lookup.at(to)
 
-      ratio = to_index.to_f / from_index
+      ratio = to_point.value.to_f / from_point.value
       InflationResult.new(
         amount: amount.to_f * ratio,
         original_amount: amount.to_f,
         from: from,
         to: to,
         country: country.to_s.upcase,
-        from_index: from_index,
-        to_index: to_index,
-        granularity: merge_granularity(from_gran, to_gran)
+        from_index: from_point.value,
+        to_index: to_point.value,
+        granularity: Granularity.merge(from_point.granularity, to_point.granularity)
       )
     end
 
@@ -59,61 +64,5 @@ module Timeprice
       result = adjust(amount: 1.0, from: from, to: to, country: country)
       result.amount - 1.0
     end
-
-    # Returns [index_value, granularity_symbol]
-    def lookup_index(data, key)
-      key = key.to_s
-      monthly = data["monthly"] || {}
-      annual  = data["annual"]  || {}
-
-      case key
-      when /\A\d{4}-\d{2}\z/
-        if monthly.key?(key)
-          [monthly[key], :monthly]
-        else
-          year = key[0, 4]
-          raise DataNotFound, missing_cpi_message(key, data, monthly, annual) unless annual.key?(year)
-
-          [annual[year], :annual]
-
-        end
-      when /\A\d{4}\z/
-        if annual.key?(key)
-          [annual[key], :annual]
-        else
-          months = monthly.select { |k, _| k.start_with?("#{key}-") }
-          raise DataNotFound, missing_cpi_message(key, data, monthly, annual) if months.empty?
-
-          avg = months.values.sum.to_f / months.size
-          [avg, :annual_from_monthly_avg]
-        end
-      else
-        raise ArgumentError, "Invalid date format: #{key.inspect} (use YYYY or YYYY-MM)"
-      end
-    end
-
-    def missing_cpi_message(key, data, monthly, annual)
-      country = data["country"]
-      ranges = []
-      if monthly.any?
-        ks = monthly.keys.sort
-        ranges << "monthly #{ks.first}..#{ks.last}"
-      end
-      if annual.any?
-        ks = annual.keys.sort
-        ranges << "annual #{ks.first}..#{ks.last}"
-      end
-      hint = ranges.empty? ? "" : " (supported: #{ranges.join(", ")})"
-      "No CPI data for #{key.inspect} in #{country}#{hint}"
-    end
-
-    # If either end fell back to annual_from_monthly_avg, propagate that label;
-    # else if either is annual, propagate :annual; else :monthly.
-    def merge_granularity(a, b)
-      return :annual_from_monthly_avg if a == :annual_from_monthly_avg || b == :annual_from_monthly_avg
-      return :annual if a == :annual || b == :annual
-
-      :monthly
-    end
   end
 end

data/lib/timeprice/point.rb

@@ -21,23 +21,42 @@ module Timeprice
     # @return [Point]
     # @raise [ArgumentError] if shape can't be recognised
     def self.coerce(input)
-      return input if input.is_a?(Point)
+      case input
+      in Point
+        input
+      in [_, _]
+        a, b = input.map(&:to_s)
+        currency = [a, b].find { |s| s.match?(/\A[A-Za-z]{3}\z/) }
+        date     = [a, b].find { |s| s.match?(/\A\d{4}(-\d{2}(-\d{2})?)?\z/) }
+        raise ArgumentError, malformed_pair_message(input) if currency.nil? || date.nil?
 
-      unless input.is_a?(Array) && input.size == 2
+        new(currency: currency.upcase, date: date)
+      else
         raise ArgumentError, "Expected Timeprice::Point or [currency, date] tuple, got #{input.inspect}"
       end
+    end
 
-      a, b = input.map(&:to_s)
-      currency = [a, b].find { |s| s.match?(/\A[A-Za-z]{3}\z/) }
-      date     = [a, b].find { |s| s.match?(/\A\d{4}(-\d{2}(-\d{2})?)?\z/) }
+    def self.malformed_pair_message(input)
+      "Could not detect currency + date in #{input.inspect} " \
+        "(expected a 3-letter currency and a YYYY[-MM[-DD]] date)"
+    end
 
-      if currency.nil? || date.nil?
-        raise ArgumentError,
-              "Could not detect currency + date in #{input.inspect} " \
-              "(expected a 3-letter currency and a YYYY[-MM[-DD]] date)"
+    # Resolve `date` to a full YYYY-MM-DD for FX lookup.
+    #
+    # Coarser grains anchor to a representative day:
+    #   - "YYYY"    → mid-year (YYYY-06-30)
+    #   - "YYYY-MM" → mid-month (YYYY-MM-15)
+    #   - "YYYY-MM-DD" → passes through
+    #
+    # @return [String]
+    # @raise [ArgumentError] if `date` doesn't match any supported shape
+    def fx_anchor_date
+      case date.to_s
+      when /\A\d{4}\z/         then "#{date}-06-30"
+      when /\A\d{4}-\d{2}\z/   then "#{date}-15"
+      when /\A\d{4}-\d{2}-\d{2}\z/ then date.to_s
+      else raise ArgumentError, "Invalid date for Point: #{date.inspect}"
       end
-
-      new(currency: currency.upcase, date: date)
     end
   end
 end

data/lib/timeprice/sources/coverage.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../data_loader"
+
+module Timeprice
+  module Sources
+    # Computes coverage strings for bundled data sources at runtime. All
+    # filesystem reads happen here so the Sources attribution registry stays
+    # a pure data table.
+    module Coverage
+      module_function
+
+      # @param src [Hash] one entry from Sources::ATTRIBUTIONS
+      # @return [String]
+      def for(src)
+        case src[:kind]
+        when "cpi" then cpi(src[:country])
+        when "fx"  then fx(src[:id])
+        else "n/a"
+        end
+      rescue StandardError => e
+        "(coverage unavailable: #{e.message})"
+      end
+
+      def cpi(country)
+        data = DataLoader.load_cpi(country)
+        monthly = (data["monthly"] || {}).keys.sort
+        annual  = (data["annual"]  || {}).keys.sort
+        parts = []
+        parts << "monthly #{monthly.first}..#{monthly.last} (#{monthly.size})" unless monthly.empty?
+        parts << "annual #{annual.first}..#{annual.last} (#{annual.size})" unless annual.empty?
+        parts.join(", ")
+      end
+
+      def fx(id)
+        years = fx_years
+        return "no data" if years.empty?
+
+        id == "fx_vnd" ? vnd_summary(years) : ecb_summary(years)
+      end
+
+      def fx_years
+        Dir[File.join(fx_root, "*.json")].map { |f| File.basename(f, ".json").to_i }.sort
+      end
+
+      def vnd_summary(years)
+        with_vnd = years.select { |y| year_has_currency?(y, %w[VND]) }
+        return "no VND data" if with_vnd.empty?
+
+        "USD↔VND #{with_vnd.first}..#{with_vnd.last}"
+      end
+
+      def ecb_summary(years)
+        ecb_years = years.select { |y| year_has_currency?(y, %w[EUR GBP JPY]) }
+        return "no ECB data" if ecb_years.empty?
+
+        "USD↔EUR/GBP/JPY daily #{ecb_years.first}..#{ecb_years.last}"
+      end
+
+      def year_has_currency?(year, codes)
+        rates = JSON.parse(File.read(File.join(fx_root, "#{year}.json")))["rates"]
+        rates.any? { |_, v| v.keys.intersect?(codes) }
+      end
+
+      def fx_root
+        File.join(DataLoader.data_root, "fx", "usd")
+      end
+    end
+  end
+end

data/lib/timeprice/sources.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "data_loader"
+require_relative "sources/coverage"
 
 module Timeprice
   # Enumerate bundled data sources with license/attribution and the actual
@@ -48,10 +48,10 @@ module Timeprice
         id: "vn_cpi",
         kind: "cpi",
         country: "VN",
-        name: "World Bank — FP.CPI.TOTL (annual)",
-        license: "CC BY 4.0",
-        license_url: "https://datacatalog.worldbank.org/public-licenses#cc-by",
-        attribution: "Source: World Bank, FP.CPI.TOTL",
+        name: "IMF Data Portal CPI dataflow (monthly primary) + World Bank FP.CPI.TOTL (annual fallback)",
+        license: "IMF: free reuse with attribution; World Bank: CC BY 4.0",
+        license_url: "https://www.imf.org/external/terms.htm",
+        attribution: "Sources: IMF Data Portal CPI dataflow; World Bank FP.CPI.TOTL",
       },
       {
         id: "fx_ecb",
@@ -66,7 +66,7 @@ module Timeprice
         id: "fx_vnd",
         kind: "fx",
         country: "VN",
-        name: "World Bank — PA.NUS.FCRF (VND annual average, broadcast daily)",
+        name: "World Bank — PA.NUS.FCRF (VND annual average, annual-granularity fallback)",
         license: "CC BY 4.0",
         license_url: "https://datacatalog.worldbank.org/public-licenses#cc-by",
         attribution: "VND FX: World Bank, PA.NUS.FCRF",
@@ -79,54 +79,7 @@ module Timeprice
     # :attribution, :coverage (string like "1990-01 to 2026-03 (monthly+annual)").
     # @return [Array<Hash>]
     def list
-      ATTRIBUTIONS.map { |s| s.merge(coverage: coverage_for(s)) }
-    end
-
-    def coverage_for(src)
-      case src[:kind]
-      when "cpi" then cpi_coverage(src[:country])
-      when "fx"  then fx_coverage(src[:id])
-      else "n/a"
-      end
-    rescue StandardError => e
-      "(coverage unavailable: #{e.message})"
-    end
-
-    def cpi_coverage(country)
-      data = DataLoader.load_cpi(country)
-      monthly = (data["monthly"] || {}).keys.sort
-      annual  = (data["annual"]  || {}).keys.sort
-      parts = []
-      parts << "monthly #{monthly.first}..#{monthly.last} (#{monthly.size})" unless monthly.empty?
-      parts << "annual #{annual.first}..#{annual.last} (#{annual.size})" unless annual.empty?
-      parts.join(", ")
-    end
-
-    def fx_coverage(id)
-      root = File.join(DataLoader.data_root, "fx", "usd")
-      years = Dir[File.join(root, "*.json")].map { |f| File.basename(f, ".json").to_i }.sort
-      return "no data" if years.empty?
-
-      case id
-      when "fx_vnd"
-        # VND broadcast-from-annual covers earlier years too.
-        with_vnd = years.select do |y|
-          d = JSON.parse(File.read(File.join(root, "#{y}.json")))
-          d["rates"].any? { |_, v| v.key?("VND") }
-        end
-        return "no VND data" if with_vnd.empty?
-
-        "USD↔VND #{with_vnd.first}..#{with_vnd.last}"
-      else
-        # ECB pairs (EUR/GBP/JPY) start 1999
-        ecb_years = years.select do |y|
-          d = JSON.parse(File.read(File.join(root, "#{y}.json")))
-          d["rates"].any? { |_, v| v.keys.intersect?(%w[EUR GBP JPY]) }
-        end
-        return "no ECB data" if ecb_years.empty?
-
-        "USD↔EUR/GBP/JPY daily #{ecb_years.first}..#{ecb_years.last}"
-      end
+      ATTRIBUTIONS.map { |s| s.merge(coverage: Coverage.for(s)) }
     end
   end
 end

data/lib/timeprice/supported.rb

@@ -21,8 +21,20 @@ module Timeprice
 
     CURRENCY_TO_COUNTRY = COUNTRY_TO_CURRENCY.invert.freeze
 
+    # Currencies with no minor unit — formatted as whole numbers.
+    ZERO_DECIMAL_CURRENCIES = %w[JPY VND].freeze
+
     module_function
 
+    # ISO 4217 minor-unit count for a currency. Falls back to 2 for unknown
+    # codes so callers can still render *some* value rather than crashing.
+    #
+    # @param currency [String]
+    # @return [Integer]
+    def decimals_for(currency)
+      ZERO_DECIMAL_CURRENCIES.include?(currency.to_s.upcase) ? 0 : 2
+    end
+
     # @param country [String]
     # @return [Boolean]
     def country?(country)
@@ -47,9 +59,4 @@ module Timeprice
       COUNTRY_TO_CURRENCY[country.to_s.upcase]
     end
   end
-
-  # Back-compat aliases — keep the old top-level constants pointing at the
-  # canonical lists so existing requires of "errors" keep working.
-  SUPPORTED_COUNTRIES  = Supported::COUNTRIES
-  SUPPORTED_CURRENCIES = Supported::CURRENCIES
 end

data/lib/timeprice/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Timeprice
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timeprice
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Patrick
@@ -157,13 +157,21 @@ files:
 - exe/timeprice
 - lib/timeprice.rb
 - lib/timeprice/cli.rb
+- lib/timeprice/cli/formatting.rb
+- lib/timeprice/cli/presenters/compare.rb
+- lib/timeprice/cli/presenters/exchange.rb
+- lib/timeprice/cli/presenters/inflation.rb
+- lib/timeprice/cli/presenters/sources.rb
 - lib/timeprice/compare.rb
+- lib/timeprice/cpi_lookup.rb
 - lib/timeprice/data_loader.rb
 - lib/timeprice/errors.rb
 - lib/timeprice/exchange.rb
+- lib/timeprice/granularity.rb
 - lib/timeprice/inflation.rb
 - lib/timeprice/point.rb
 - lib/timeprice/sources.rb
+- lib/timeprice/sources/coverage.rb
 - lib/timeprice/supported.rb
 - lib/timeprice/version.rb
 homepage: https://github.com/patrick204nqh/timeprice