rate-card 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f117b9526f8fe1f4dbde79da9e35bbc8ff432871c3b9736f0a0699d7542ac189
-  data.tar.gz: d50336d03593f510d841f4e2e2b7bbe280eff3c5fd2f063664deef532dea0182
+  metadata.gz: ccc684b0241775fa979051ffd3b9aeed1b08e9eaf8a5bb40bc8560d8f0e2ab39
+  data.tar.gz: e3fe60187c6db2cf746a7adabe90a139da79cd655a2b0445e92060db23db2d35
 SHA512:
-  metadata.gz: 6879442c47e5188d2792bd1d002d67e8a36fb4b3e9d3bc0ec9d14652c39854915f972171cba58f04be38cef50d747fb5bf1f9af50b8cbec81360a9e7367796ce
-  data.tar.gz: b5545e4ee1a80c13833861b1b6301bc2ca2b094aa316bb59b49433cabd4a22a54e9f89eca2e2a0d69427b1c5e7544b7e73a16bc11c491a8f868b1272f3a7e6e5
+  metadata.gz: 67bb66aab90c7942ec5cf6d29ce62b23240dd347fdd27c8665d4c1d191c398f97d75ec2b2ddaad989ee21c0645ab5120c00dfa9c2a953d7f176298850aa635bc
+  data.tar.gz: 6997aabfddff427e90ecfb38153c3262513d31160af889109da5fe729cfd00b239d63c62137a9f733b47c8d5199bee4e7593b91dc29fefe36291d8b608a584ba

data/exe/rate-card

@@ -102,7 +102,13 @@ else
   exit 1
 end
 
-spec = app.spec
-spec.show_table = options[:show_table]
+# Usually one pass. UPS rural mode with more than one surcharge type checked
+# produces several - each is its own card with its own files, run and
+# reported independently so one failing does not stop the others from
+# writing. The process exit code is the worst of all of them.
+exit_codes = app.results.map do |result|
+  result[:spec].show_table = options[:show_table]
+  RateCard::Runner.new(spec: result[:spec], grid: result[:grid], ui: ui).run
+end
 
-exit RateCard::Runner.new(spec: spec, grid: app.grid, ui: ui).run
+exit exit_codes.max

data/lib/rate_card/constants/addresses.rb

@@ -72,6 +72,40 @@ module RateCard
 
       BY_CARRIER = { 'USPS' => USPS, 'UPS' => UPS, 'FedEx' => FEDEX, 'DHL' => DHL_ECOMMERCE, 'OSM' => OSM }.freeze
 
+      # Rural/remote-area surcharge test addresses. These aren't zone charts
+      # (rural surcharge eligibility is a property of the destination zip on
+      # a carrier's rural list, not something for_carrier's zone lookup
+      # models), so they live outside BY_CARRIER and are looked up directly
+      # by callers that need them.
+      #
+      # Ported from ../rate_table_builder/constants.rb. USPS_RURAL_DAS zones
+      # 4-8 were tagged 'maybe' or unverified in the source file - re-verify
+      # against USPS's rural lookup before relying on them for a real card.
+      USPS_RURAL_DAS = {
+        0 => { address1: '12078 W 4000 N', city: 'Bluebell', state: 'UT', postal_code: '84007', country: 'US' },
+        1 => { address1: '6074 N 4700 W', city: 'Bear River City', state: 'UT', postal_code: '84301', country: 'US' },
+        2 => { address1: '25670 Buffalo Run', city: 'Moran', state: 'WY', postal_code: '83013', country: 'US' },
+        3 => { address1: '17 Texs Loop', city: 'Alder', state: 'MT', postal_code: '59710', country: 'US' },
+        4 => { address1: '1250 153rd St SE', city: 'Norwich', state: 'ND', postal_code: '58768', country: 'US' },
+        5 => { address1: '103 Stonegate Ct', city: 'Gurdon', state: 'AR', postal_code: '71743', country: 'US' },
+        6 => { address1: '31 Edsel Rd', city: 'Webbville', state: 'KY', postal_code: '41180', country: 'US' },
+        7 => { address1: '295 Old Waterford Road', city: 'Littleton', state: 'NH', postal_code: '03561', country: 'US' },
+        8 => { address1: '77 Main Street', city: 'Mars Hill', state: 'ME', postal_code: '04758', country: 'US' }
+      }.freeze
+
+      # UPS has no per-zone rural chart - just one known address per DAS
+      # variant. EDAS = Extended Delivery Area Surcharge, RDAS = Remote
+      # Delivery Area Surcharge.
+      UPS_EDAS_EXCEPTION = { address1: '149 Pheasant Runn Road', city: 'Goshen', state: 'NH', postal_code: '03752',
+                              country: 'US' }.freeze
+
+      UPS_RDAS_EXCEPTION = { address1: '106 Yellow Hammer Rd', city: 'Tyner', state: 'NC', postal_code: '27980',
+                              country: 'US' }.freeze
+
+      # Looked up by surcharge-type symbol rather than zone, since UPS rural
+      # mode sweeps surcharge types instead of zones — see RunSpec#address_for.
+      UPS_RURAL = { edas: UPS_EDAS_EXCEPTION, rdas: UPS_RDAS_EXCEPTION }.freeze
+
       module_function
 
       # Raises rather than falling back. The old USPS default meant asking for

data/lib/rate_card/constants/carriers.rb

@@ -30,6 +30,11 @@ module RateCard
         'dhl' => 'DHL Express', 'dhl_ecommerce' => 'DHL', 'osm' => 'OSM', 'amazon' => 'Amazon'
       }.freeze
 
+      # Carriers with a rural/DAS surcharge test address in Constants::Addresses.
+      # Independent of zone-chart support - a carrier can have a verified zone
+      # chart and no rural chart at all.
+      RURAL_AWARE = %w[USPS UPS].freeze
+
       module_function
 
       # OTHER is only for a malformed entry with no code at all, so a service is
@@ -44,6 +49,10 @@ module RateCard
       def display_order
         DISPLAY_ORDER
       end
+
+      def rural_aware?(carrier)
+        RURAL_AWARE.include?(carrier.to_s)
+      end
     end
   end
 end

data/lib/rate_card/run_spec.rb

@@ -16,7 +16,7 @@ module RateCard
   class RunSpec < Struct.new(
     :token, :customer_name, :customer_id, :carrier, :services, :zones,
     :weight_unit, :weights, :package_type, :rate_keys, :output_base,
-    :show_table, :started_at, :rate_mode, :cubic_tiers,
+    :show_table, :started_at, :rate_mode, :cubic_tiers, :rural,
     keyword_init: true
   )
     # Our rate-key name => the field it arrives as in service_rates. Getting
@@ -44,10 +44,26 @@ module RateCard
       self.class.compact_range(zones)
     end
 
+    def zone_label(zone)
+      zone.is_a?(Symbol) ? zone.to_s.upcase : "Z#{zone}"
+    end
+
+    # true for USPS with rural mode on, or any UPS surcharge type/combination.
+    # nil/false (rural mode off, or a non-rural-aware carrier) is falsy here.
+    def rural?
+      !!rural
+    end
+
     # [1,2,3,5] => "1-3,5". Runs of three or more collapse; a pair stays listed,
     # since "4,5" is no longer than "4-5" and reads as what the user typed.
+    #
+    # UPS rural mode sweeps surcharge-type symbols (:edas, :rdas) instead of
+    # numbered zones - those aren't a range at all, so they're just listed.
     def self.compact_range(numbers)
-      sorted = numbers.to_a.sort.uniq
+      array = numbers.to_a
+      return array.join(',') if array.any? { |n| n.is_a?(Symbol) }
+
+      sorted = array.sort.uniq
       runs = sorted.slice_when { |a, b| b != a + 1 }.to_a
       runs.map { |run| run.length >= 3 ? "#{run.first}-#{run.last}" : run.join(',') }.join(',')
     end
@@ -104,7 +120,14 @@ module RateCard
       end
     end
 
+    # A Symbol zone (:edas, :rdas) only ever comes from UPS rural mode, so it
+    # disambiguates from a real zone number without needing to check carrier
+    # or rural separately. USPS rural mode keeps integer zones, just against
+    # the rural chart instead of the normal one.
     def address_for(zone)
+      return Constants::Addresses::UPS_RURAL[zone] if zone.is_a?(Symbol)
+      return Constants::Addresses::USPS_RURAL_DAS[zone] if carrier == 'USPS' && rural?
+
       Constants::Addresses.for_carrier(carrier)[zone]
     end
 
@@ -136,7 +159,19 @@ module RateCard
     end
 
     def run_dir
-      Pathname.new(output_base).join("#{slug}_#{customer_id}_#{timestamp}")
+      Pathname.new(output_base).join("#{slug}_#{customer_id}_#{timestamp}#{rural_suffix}")
+    end
+
+    # UPS rural mode runs one pass per selected surcharge type (see
+    # TUI::App#build_specs), so a single spec's zones is exactly one symbol -
+    # the suffix names it, so two same-second passes don't collide on
+    # run_dir. USPS rural mode sweeps real zones as usual, so it just gets
+    # the generic suffix.
+    def rural_suffix
+      return '' unless rural?
+
+      surcharge = zones.find { |zone| zone.is_a?(Symbol) }
+      surcharge ? "_#{surcharge}" : '_rural'
     end
 
     def validate!

data/lib/rate_card/table_renderer.rb

@@ -47,7 +47,7 @@ module RateCard
     end
 
     def render(service, rate_key)
-      header = [spec.weight_label, *spec.zones.map { |zone| "Z#{zone}" }]
+      header = [spec.weight_label, *spec.zones.map { |zone| spec.zone_label(zone) }]
       body = rows(service, rate_key)
 
       Lipgloss::Table.new

data/lib/rate_card/tui/app.rb

@@ -24,11 +24,14 @@ module RateCard
 
       # No :token stage — see TokenPrompt for why it cannot live in the loop.
       STAGES = %i[
-        loading rate_mode carrier services zones unit weights package_type
-        rate_keys confirm fetching
+        loading rate_mode carrier rural rural_surcharges services zones unit weights
+        package_type rate_keys confirm fetching
       ].freeze
 
-      attr_reader :spec, :grid, :error, :notifier
+      # #spec/#grid hold the most recently finished pass, for every caller that
+      # only ever produced one (every carrier except UPS rural mode with more
+      # than one surcharge type checked). #results holds every pass.
+      attr_reader :spec, :grid, :error, :notifier, :results
 
       # notifier is set by the caller to the Bubbletea::Runner, whose #send is
       # the only way a worker thread can get a message onto the event loop.
@@ -54,6 +57,7 @@ module RateCard
         @failure_sparkline = Ntcharts::Sparkline.new(32, 1)
         @failure_sparkline.style = Lipgloss::Style.new.foreground(Theme::WARNING)
         @log = []
+        @results = []
       end
 
       def cancelled? = @cancelled
@@ -69,7 +73,7 @@ module RateCard
         when ServicesLoaded    then services_loaded(message.services)
         when LoadFailed        then return fail_with(message.error)
         when ProgressAdvanced  then progress_advanced(message)
-        when FetchFinished     then return finish(message.grid)
+        when FetchFinished     then return fetch_finished(message.grid)
         when FetchFailed       then return fail_with(message.error)
         else
           return [self, spinner_or_field(message)]
@@ -175,9 +179,11 @@ module RateCard
 
       def field_for(stage)
         case stage
-        when :rate_mode    then rate_mode_field
-        when :carrier      then carrier_field
-        when :services     then services_field
+        when :rate_mode        then rate_mode_field
+        when :carrier          then carrier_field
+        when :rural            then rural_field
+        when :rural_surcharges then rural_surcharges_field
+        when :services         then services_field
         when :zones        then zones_field
         when :unit         then unit_field
         when :weights      then weights_field
@@ -238,8 +244,40 @@ module RateCard
         )
       end
 
+      # Only USPS and UPS have a rural/DAS chart (Addresses::USPS_RURAL_DAS,
+      # Addresses::UPS_RURAL); every other carrier is decided :normal (nil)
+      # and skips this stage, same as any other single-answer stage. Same
+      # Normal/Rural toggle for both carriers - which surcharge type(s) UPS
+      # means by "rural" is a separate question, :rural_surcharges below.
+      def rural_field
+        return nil unless Constants::Carriers.rural_aware?(carrier)
+
+        choices = [['Normal', false], ['Rural (DAS)', true]]
+        Fields::Select.new(label: 'Rural / DAS', choices: choices,
+                           selected: choices.index { |_, v| v == @answers[:rural] } || 0)
+      end
+
+      # UPS has no per-zone rural chart - each surcharge type is one fixed
+      # address, not a zone sweep - so this replaces the zones question for
+      # UPS rural mode. Checking both produces two separate rate cards (see
+      # #build_specs), one per surcharge type, rather than one card that
+      # conflates two different addresses under one "zone" axis.
+      def rural_surcharges_field
+        return nil unless ups_rural?
+
+        choices = [['EDAS', :edas], ['RDAS', :rdas]]
+        answered = @answers[:rural_surcharges]
+        Fields::MultiSelect.new(
+          label: 'Surcharge types',
+          choices: choices,
+          checked: answered ? checked_indexes(choices.map(&:last), answered) : (0...choices.length)
+        )
+      end
+
       def zones_field
-        available = Constants::Addresses.available_zones(carrier)
+        return nil if ups_rural?
+
+        available = usps_rural? ? Constants::Addresses::USPS_RURAL_DAS.keys.sort : Constants::Addresses.available_zones(carrier)
         full = "#{available.first}-#{available.last}"
         answered = @answers[:zones]
 
@@ -255,6 +293,14 @@ module RateCard
         )
       end
 
+      def usps_rural?
+        carrier == 'USPS' && @answers[:rural] == true
+      end
+
+      def ups_rural?
+        carrier == 'UPS' && @answers[:rural] == true
+      end
+
       # Weight is fixed per cubic tier, so asking for a display unit is
       # meaningless in cubic mode — decided as :oz (unused) and skipped.
       def unit_field
@@ -373,18 +419,39 @@ module RateCard
 
       # ---------------------------------------------------------------- fetch
 
+      # UPS rural mode with more than one surcharge type checked runs as
+      # several independent passes (see #build_specs) - each one calls
+      # Grid.build, feeds the same progress bar, and lands its own {spec:,
+      # grid:} in #results before the next pass starts. Every other carrier
+      # and mode has exactly one pass, same as before this existed.
       def start_fetch
-        @spec = build_spec
+        @pending_specs = build_specs
         # Before the first call, so a bad path is not discovered after 128 of them.
         begin
-          CsvWriter.ensure_writable!(@spec.output_base)
+          @pending_specs.each { |spec| CsvWriter.ensure_writable!(spec.output_base) }
         rescue OutputNotWritable => e
           return fail_with(e).last
         end
 
+        @results = []
+        @total_passes = @pending_specs.length
+        @pass_index = 0
+        next_pass
+      end
+
+      def next_pass
+        @spec = @pending_specs.shift
+        return Bubbletea.quit if @spec.nil?
+
+        @pass_index += 1
+        @completed = 0
+        @failed = 0
+        fetch_command(@spec)
+      end
+
+      def fetch_command(spec)
         client = @client_factory.call(@token)
         notifier = @notifier
-        spec = @spec
         provider = @provider
 
         lambda do
@@ -408,9 +475,10 @@ module RateCard
         @failure_sparkline.push(message.failed)
       end
 
-      def finish(grid)
+      def fetch_finished(grid)
         @grid = grid
-        [self, Bubbletea.quit]
+        @results << { spec: @spec, grid: grid }
+        [self, next_pass]
       end
 
       def fail_with(error)
@@ -418,7 +486,23 @@ module RateCard
         [self, Bubbletea.quit]
       end
 
+      # One RunSpec per pass. UPS rural mode runs one pass per checked
+      # surcharge type (each is a fixed single address, not a zone sweep -
+      # see Addresses::UPS_RURAL) rather than folding both into one card's
+      # zone axis. Every other carrier/mode is the single pass it always was.
+      def build_specs
+        if ups_rural?
+          (@answers[:rural_surcharges] || []).map { |surcharge| run_spec(zones: [surcharge]) }
+        else
+          [run_spec(zones: @answers[:zones])]
+        end
+      end
+
       def build_spec
+        build_specs.first
+      end
+
+      def run_spec(zones:)
         cubic = @answers[:rate_mode] == :cubic
         RunSpec.new(
           token: @token,
@@ -426,11 +510,12 @@ module RateCard
           customer_id: identity[:customer_id],
           carrier: carrier,
           services: @answers[:services],
-          zones: @answers[:zones],
+          zones: zones,
           weight_unit: @answers[:unit] || :oz,
           weights: cubic ? [] : @answers[:weights],
           cubic_tiers: cubic ? @answers[:weights] : [],
           rate_mode: @answers[:rate_mode] || :weight,
+          rural: @answers[:rural],
           package_type: @answers[:package_type],
           rate_keys: @answers[:rate_keys],
           output_base: @output_base,
@@ -457,15 +542,28 @@ module RateCard
       # Everything the run will do, gathered in one block. The answers are also
       # in the transcript above, but they arrived one at a time over eight
       # screens; this is the only place they can be read against each other.
+      #
+      # Built from real RunSpecs (build_specs) rather than raw @answers, so a
+      # UPS rural run with both surcharge types checked recaps as the two
+      # separate cards it will actually produce, one line each.
       def recap_view
+        specs = build_specs
+        carrier_line = "  #{Theme.bold(carrier)}#{rural_recap} · #{@answers[:services].map(&:name).join(', ')}"
         [
-          "  #{Theme.bold(carrier)} · #{@answers[:services].map(&:name).join(', ')}",
-          "  zones #{RunSpec.compact_range(@answers[:zones])} · #{rows_recap} · #{@answers[:package_type]}",
+          carrier_line,
+          *specs.map { |spec| "  zones #{spec.zone_summary} · #{rows_recap} · #{@answers[:package_type]}" },
           "  columns: #{@answers[:rate_keys].map { |k| RunSpec::RATE_KEY_LABELS.fetch(k) }.join(', ')}",
-          "  #{Theme.bold(call_count.to_s)} rate calls against #{Theme.danger('production')}"
+          "  #{Theme.bold(specs.sum(&:call_count).to_s)} rate calls against #{Theme.danger('production')}" \
+            "#{specs.length > 1 ? " (#{specs.length} separate cards)" : ''}"
         ].join("\n")
       end
 
+      def rural_recap
+        return '' unless @answers[:rural]
+
+        " (#{rural_label(@answers[:rural])})"
+      end
+
       def rows_recap
         if @answers[:rate_mode] == :cubic
           "cubic tiers #{RunSpec.compact_range(@answers[:weights])}"
@@ -474,16 +572,13 @@ module RateCard
         end
       end
 
-      def call_count
-        @answers[:weights].length * @answers[:zones].length
-      end
-
       def fetch_view
         total = @spec.call_count
         percent = total.zero? ? 0.0 : @completed.to_f / total
+        title = @total_passes > 1 ? "fetching rates (pass #{@pass_index}/#{@total_passes})" : 'fetching rates'
         line = "  #{@progress.view_as(percent)}  #{@completed}/#{total}"
         line += "  #{Theme.warning("#{Theme::ALERT} #{@failed} failed")}" if @failed.positive?
-        view = "#{Theme.bold('  fetching rates')}\n#{line}"
+        view = "#{Theme.bold("  #{title}")}\n#{line}"
         view += "\n#{failure_sparkline_view}" if @failed.positive?
         view
       end
@@ -500,7 +595,8 @@ module RateCard
       # transcript of the run stays on screen — the recap is then a summary of
       # what is already visible rather than the first chance to check it.
       def answered_line(stage, value)
-        label = { rate_mode: 'rate by', carrier: 'carrier', services: 'services', zones: 'zones',
+        label = { rate_mode: 'rate by', carrier: 'carrier', rural: 'rural / DAS',
+                  rural_surcharges: 'surcharge types', services: 'services', zones: 'zones',
                   unit: 'unit', weights: 'weights', package_type: 'package',
                   rate_keys: 'columns' }[stage]
         label = 'cubic tiers' if stage == :weights && @answers[:rate_mode] == :cubic
@@ -511,13 +607,19 @@ module RateCard
 
       def describe(stage, value)
         case stage
-        when :services  then value.map(&:name).join(', ')
-        when :zones     then RunSpec.compact_range(value)
-        when :weights   then RunSpec.compact_range(value)
-        when :rate_keys then value.map { |k| RunSpec::RATE_KEY_LABELS.fetch(k) }.join(', ')
+        when :services          then value.map(&:name).join(', ')
+        when :zones             then RunSpec.compact_range(value)
+        when :weights           then RunSpec.compact_range(value)
+        when :rural             then rural_label(value)
+        when :rural_surcharges  then value.map { |v| v.to_s.upcase }.join(', ')
+        when :rate_keys         then value.map { |k| RunSpec::RATE_KEY_LABELS.fetch(k) }.join(', ')
         else value.to_s
         end
       end
+
+      def rural_label(value)
+        value ? 'rural (DAS)' : 'normal'
+      end
     end
   end
 end

data/lib/rate_card/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RateCard
-  VERSION = '0.1.2'
+  VERSION = '0.1.4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rate-card
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - eHub