rate-card 0.1.0

data/lib/rate_card/shipment.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RateCard
+  # Builds the request body for one (weight, zone) rate call.
+  #
+  # The shape follows the documented rate request
+  # (https://docs.ehub.com/rates/rate-request). The customs blocks are sent even
+  # for domestic cards because international services error without them; the
+  # docs mark the parcel-level one as required for international shipments.
+  class Shipment
+    DIMENSION = 2
+    ITEM_VALUE = 18.99
+    HS_TARIFF_CODE = '1704.90.3000'
+
+    def initialize(spec:, weight:, address:)
+      @spec = spec
+      @weight = weight
+      @address = address
+    end
+
+    def payload
+      {
+        shipment: {
+          from_location: Constants::Addresses::ORIGIN,
+          to_location: to_location,
+          parcels: [parcel]
+        }
+      }
+    end
+
+    private
+
+    attr_reader :spec, :weight, :address
+
+    def to_location
+      {
+        company: 'Rate Card Builder',
+        phone: '000-000-0000'
+      }.merge(address)
+    end
+
+    def parcel
+      box = dims
+      {
+        package_type: spec.package_type,
+        length: box[:length],
+        width: box[:width],
+        height: box[:height],
+        weight: spec.weight_in_oz_for(weight),
+        parcel_items: [parcel_item],
+        customs_data: customs_data
+      }
+    end
+
+    def dims
+      spec.dims_for(weight) || { length: DIMENSION, width: DIMENSION, height: DIMENSION }
+    end
+
+    # The parcel as a whole. One item at quantity 1, so this mirrors the item's
+    # declaration; the docs require it for international shipments.
+    def customs_data
+      {
+        content_type: 'merchandise',
+        value: ITEM_VALUE,
+        hs_tariff_code: HS_TARIFF_CODE
+      }
+    end
+
+    def parcel_item
+      {
+        name: 'Candy',
+        quantity: 1,
+        price: ITEM_VALUE,
+        customs_data: customs_data
+      }
+    end
+  end
+end

data/lib/rate_card/table_renderer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'lipgloss'
+require_relative 'tui/theme'
+
+module RateCard
+  # Renders the grid for the terminal: one table per service per rate key, so
+  # stdout maps 1:1 to the CSV files. Returns strings rather than printing, so
+  # UI owns all output and this stays testable.
+  #
+  # Lipgloss draws these rather than TTY::Table, so the card wears the same
+  # rounded border as the TUI banner instead of looking like a different
+  # program's output. Lipgloss also strips colour by itself when stdout is not a
+  # terminal, so the bold header survives being piped to a file as plain text.
+  class TableRenderer
+    MISSING = '—'
+
+    def initialize(grid:, spec:)
+      @grid = grid
+      @spec = spec
+    end
+
+    # Returns Array<[title String, rendered String]>.
+    def tables
+      spec.services.flat_map do |service|
+        spec.rate_keys.map { |rate_key| [title_for(service, rate_key), render(service, rate_key)] }
+      end
+    end
+
+    def rows(service, rate_key)
+      spec.rows.map do |row|
+        cells = spec.zones.map do |zone|
+          format_rate(grid.value(service_id: service.id, rate_key: rate_key,
+                                 weight: row, zone: zone))
+        end
+        [spec.row_label(row), *cells]
+      end
+    end
+
+    private
+
+    attr_reader :grid, :spec
+
+    def title_for(service, rate_key)
+      "#{spec.customer_name} (#{spec.customer_id}) · #{service.name} · " \
+        "#{spec.rate_key_label(rate_key)}"
+    end
+
+    def render(service, rate_key)
+      header = [spec.weight_label, *spec.zones.map { |zone| "Z#{zone}" }]
+      body = rows(service, rate_key)
+
+      Lipgloss::Table.new
+                     .headers(header)
+                     .rows(body)
+                     .border(Lipgloss::ROUNDED_BORDER)
+                     .style_func(rows: body.length, columns: header.length) { |row, _column| cell_style(row) }
+                     .render
+    end
+
+    # Everything is right-aligned: these are all numbers, and a rate is only
+    # comparable to the one above it when the decimal points line up. The
+    # header is the one styled row, which is what makes a wide card scannable
+    # once several tables are printed in a row.
+    def cell_style(row)
+      style = Lipgloss::Style.new.align(Lipgloss::RIGHT).padding(0, 1)
+      return style.bold(true).foreground(TUI::Theme::ACCENT) if row == Lipgloss::Table::HEADER_ROW
+
+      style
+    end
+
+    def format_rate(value)
+      return MISSING if value.nil?
+
+      format('%.2f', value)
+    end
+  end
+end

data/lib/rate_card/token.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+
+module RateCard
+  # Reads claims out of an eHub JWT so we can show the user which customer a
+  # pasted token belongs to. We decode so the user can confirm they are pointed at
+  # the intended production account before a run starts. Deliberately does NOT
+  # verify the signature: these claims are displayed, never trusted for
+  # authorization. The API's 401 is the only real check.
+  module Token
+    class DecodeError < Error; end
+
+    module_function
+
+    def decode(raw)
+      payload = payload_from(raw)
+      user = payload.dig('data', 'user') || {}
+
+      customer_id = user['customer_id'] if user['customer_id'].is_a?(Integer)
+      email = presence(user['email'])
+      # FIXME - I don't even think we need a name field here tbh
+      name = email || (customer_id ? "customer #{customer_id}" : 'unknown customer')
+
+      { name: name, customer_id: customer_id, email: email }
+    end
+
+    def presence(value)
+      string = value.to_s.strip
+      string.empty? ? nil : string
+    end
+
+    def payload_from(raw)
+      segments = raw.to_s.split('.')
+      raise DecodeError, 'token is not a JWT (expected three segments)' unless segments.length == 3
+
+      # urlsafe_decode64 restores missing '=' padding itself, which matters
+      # because real JWT segments are always unpadded.
+      parsed = JSON.parse(Base64.urlsafe_decode64(segments[1]))
+      raise DecodeError, 'token payload is not a JSON object' unless parsed.is_a?(Hash)
+
+      parsed
+    rescue ArgumentError, JSON::ParserError
+      raise DecodeError, 'this does not look like an eHub API token — please try again'
+    end
+  end
+end

data/lib/rate_card/token_prompt.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module RateCard
+  # Reads the API token before the TUI takes the terminal.
+  #
+  # This is deliberately NOT a TUI field. bubbletea-ruby's input reader returns
+  # one key per poll and discards the rest of the buffered bytes, so a pasted
+  # 200-character JWT arrives as a single character and the other 199 are lost
+  # — verified against 0.1.4, and bracketed_paste does not help. Typing is
+  # unaffected at any speed, so every other answer is safe inside the loop; the
+  # token is the one field that is always pasted.
+  #
+  # Reading it here also means the terminal's own line editing handles the
+  # paste, which is what makes it work.
+  module TokenPrompt
+    module_function
+
+    # Returns the raw token, or nil if the user gave up (EOF / ctrl-d).
+    def read(ui:, io: $stdin)
+      loop do
+        ui.prompt('eHub API token: ')
+        raw = read_masked(io)
+        return nil if raw.nil?
+
+        raw = raw.strip
+        # Never a silent `next`: that reprinted the prompt with no explanation,
+        # and a pasted token whose clipboard content carries a leading newline
+        # then reads as a doubled prompt or a hang. Not phrased as a bad token —
+        # the user has not pasted one yet.
+        if raw.empty?
+          ui.error('no token on that line — paste the token')
+          next
+        end
+
+        begin
+          Token.decode(raw)
+          return raw
+        rescue Token::DecodeError => e
+          ui.error("#{e.message} — paste the token again")
+        end
+      end
+    end
+
+    # noecho keeps the JWT off the screen; #gets keeps the terminal's line
+    # discipline, which is what makes a paste arrive intact.
+    def read_masked(io)
+      if io.respond_to?(:noecho) && io.tty?
+        value = io.noecho(&:gets)
+        puts
+        value
+      else
+        io.gets
+      end
+    end
+  end
+end