portage-cli 0.8.0 → 0.10.0

data/lib/portage/cli/pick.rb

@@ -0,0 +1,167 @@
+require_relative "history"
+require_relative "human_prompt"
+require_relative "product_page"
+require_relative "offer_choice"
+
+module Portage
+  module Cli
+    # `portage pick` — loop step 3, the person picks the store
+    # (docs/plans/human-pick-and-approve.md Phase 2, Design § 4). The
+    # choices are a saved search's offers (History, `--search LAST` by
+    # default) plus one more, "Compare an offer across stores", which runs
+    # `compare` on the offer the person names and shows the pick again over
+    # its results (the compared offer first, so it can still be chosen).
+    #
+    # On the `tty` surface the person answers on /dev/tty (`by: "person"`).
+    # On the `agent` surface it returns `needs_pick` with `choices[]`; the
+    # agent relays the answer with `--choose REF` (`by: "agent_relayed"`)
+    # or `--compare REF`. `--view REF` only opens that offer's product page.
+    #
+    # Returns a report hash; Cli.run_pick prints it.
+    class Pick
+      COMPARE_REF = "compare".freeze
+      COMPARE_LABEL = "Compare an offer across stores".freeze
+
+      # @param comparer [#call] a saved (string-keyed) offer -> a Compare report.
+      def initialize(prompt:, search: nil, choose: nil, view: nil, compare: nil, history: History.new,
+                     comparer: nil)
+        @prompt = prompt
+        @search_id = search
+        @choose = choose
+        @view = view
+        @compare = compare
+        @history = history
+        @comparer = comparer
+      end
+
+      def call
+        return view_offer if @view
+
+        search = @history.search(@search_id)
+        return search_not_found unless search
+        return compare_from_flag(search) if @compare
+        return relayed(search) if @choose
+        return needs_pick(search) unless @prompt.tty?
+
+        ask(search)
+      rescue HumanPrompt::NoTerminal => e
+        { outcome: "no_terminal", message: e.message }
+      end
+
+      private
+
+      # --- tty ---
+
+      def ask(search)
+        loop do
+          offers = search["offers"]
+          index = @prompt.choose("Pick an offer", choices(search), view: OfferChoice.method(:view_message))
+          return cancelled unless index
+          return picked(search, offers[index], HumanPrompt::BY_PERSON) if index < offers.length
+
+          search = ask_compare(search)
+          return cancelled unless search
+        end
+      end
+
+      # @return [Hash, nil] the search to pick from next (the compare's, or
+      #   the same one when it found nothing), nil when cancelled.
+      def ask_compare(search)
+        offers = search["offers"]
+        index = @prompt.choose("Compare which offer?", offers.map { |o| OfferChoice.for(o) },
+                               view: OfferChoice.method(:view_message))
+        return nil unless index
+
+        compared, message = compared(search, offers[index])
+        @prompt.say(message)
+        compared
+      end
+
+      # --- agent ---
+
+      def needs_pick(search, message: nil)
+        { outcome: "needs_pick", search_id: search["search_id"], query: search["query"], choices: choices(search),
+          message: message || "Show these choices to the person (with each url as a link), then relay their " \
+                              "answer: `portage pick --search #{search['search_id']} --choose REF`, or " \
+                              "`--compare REF` for \"#{COMPARE_LABEL}\"." }
+      end
+
+      def relayed(search)
+        offer = offer_in(search, @choose)
+        return not_in_search(search, @choose) unless offer
+
+        picked(search, offer, HumanPrompt::BY_AGENT)
+      end
+
+      def compare_from_flag(search)
+        offer = offer_in(search, @compare)
+        return not_in_search(search, @compare) unless offer
+
+        compared, message = compared(search, offer)
+        @prompt.tty? ? ask(compared) : needs_pick(compared, message: message)
+      end
+
+      # --- compare ---
+
+      # Saved as a search of its own, so its offers get refs `buy --offer`
+      # and `pick --choose` resolve: the compared offer first (bought by its
+      # own query), then the results (bought by the compared product's
+      # title, which is what compare searched for).
+      # @return [Array(Hash, String)] the search to show next, and a message.
+      def compared(search, offer)
+        report = @comparer.call(offer)
+        return [search, report[:message].to_s] if Array(report[:offers]).empty?
+
+        origin = offer.merge("query" => offer["query"] || search["query"])
+        results = report[:offers].map { |o| o.merge(query: report[:query]) }
+        saved = @history.record_search(query: "compare: #{offer['store']} (product #{offer['product_id']})",
+                                       offer_count: results.length, message: report[:message],
+                                       offers: [origin] + results)
+        [saved, report[:message].to_s]
+      end
+
+      # --- view ---
+
+      def view_offer
+        offer = @history.offer(@view)
+        return unknown_offer(@view) unless offer
+
+        ProductPage.new(url: offer["url"], store: offer["store"]).open.merge(offer_ref: @view)
+      end
+
+      # --- shapes ---
+
+      def choices(search)
+        search["offers"].map { |o| OfferChoice.for(o) } +
+          [{ ref: COMPARE_REF, label: COMPARE_LABEL, url: nil,
+             relay: "portage pick --search #{search['search_id']} --compare REF" }]
+      end
+
+      def offer_in(search, ref) = search["offers"].find { |o| o["offer_ref"] == ref }
+
+      def picked(search, offer, by)
+        { outcome: "picked", search_id: search["search_id"], offer_ref: offer["offer_ref"], store: offer["store"],
+          product_id: offer["product_id"], title: offer["title"], url: offer["url"], by: by,
+          message: "Picked #{offer['title']} from #{offer['store']} — next: " \
+                   "`portage buy --offer #{offer['offer_ref']} --dry-run`." }
+      end
+
+      def cancelled = { outcome: "cancelled", message: "Nothing picked." }
+
+      def search_not_found
+        latest = @search_id.nil? || @search_id.casecmp?("last")
+        what = latest ? "No saved search with offers" : "No search #{@search_id}"
+        { outcome: "search_not_found", search_id: @search_id, message: "#{what} — run `portage find` first." }
+      end
+
+      def not_in_search(search, ref)
+        { outcome: "offer_not_found", search_id: search["search_id"], offer_ref: ref,
+          message: "#{ref} isn't one of search #{search['search_id']}'s offers." }
+      end
+
+      def unknown_offer(ref)
+        { outcome: "offer_not_found", offer_ref: ref, message: "No saved offer #{ref} — run `portage find` again." }
+      end
+    end
+  end
+end

data/lib/portage/cli/product_page.rb

@@ -0,0 +1,84 @@
+require "uri"
+require_relative "browser_opener"
+
+module Portage
+  module Cli
+    # Opens the store's page for an offer or quote, so the person can look
+    # before they pick or approve (docs/plans/human-pick-and-approve.md
+    # Phase 2, "View the product page"). Used by `pick --view`, `approve
+    # --view` and the `v`/`v N` answers at a tty prompt. Never gated by the
+    # auto-open setting: the person asked for this page by name.
+    #
+    # The URL came from the store, so it's untrusted: only an http(s) URL on
+    # the offer's own store host is opened, and anything else is refused
+    # with `view_refused` rather than handed to the OS opener.
+    #
+    # Host rule: the URL's host must equal the store's host, compared
+    # case-insensitively with one leading `www.` ignored on either side
+    # (`shop.example` and `www.shop.example` are the same shop). Any other
+    # subdomain (`cdn.shop.example`, `shop.example.evil.test`) is refused —
+    # a store that keeps product pages on another host just can't be
+    # viewed from here. A URL carrying credentials (`user@host`) is refused
+    # too.
+    class ProductPage
+      include BrowserOpener
+
+      # @param url [String, nil] the product page as find/compare returned it.
+      # @param store [String] the offer's store origin (or a bare host).
+      def initialize(url:, store:)
+        @url = url
+        @store = store
+      end
+
+      # @return [Hash] `outcome: "viewed"` (with `opened:`) or
+      #   `outcome: "view_refused"` (with the reason as `message:`).
+      def open
+        reason = refusal
+        return { outcome: "view_refused", url: @url, store: @store, message: reason } if reason
+
+        opened = open_browser(@url)
+        { outcome: "viewed", url: @url, opened: opened,
+          message: opened ? "Opened #{@url}." : "Couldn't open a browser — the page is #{@url}" }
+      end
+
+      # @return [String, nil] why the page can't be opened, nil when it can.
+      def refusal
+        return "No product page on record for this offer." if @url.to_s.strip.empty?
+
+        uri = web_uri(@url)
+        return "Not an http(s) URL: #{@url}" unless uri
+        return "Refusing a URL with credentials in it: #{@url}" if uri.userinfo
+        return nil if self.class.same_shop?(uri.host, store_host)
+
+        "#{uri.host} isn't the offer's store (#{store_host || @store}) — not opening #{@url}"
+      end
+
+      def self.same_shop?(host, store_host)
+        return false unless host && store_host
+
+        host_key(host) == host_key(store_host)
+      end
+
+      def self.host_key(host) = host.downcase.delete_prefix("www.")
+      private_class_method :host_key
+
+      private
+
+      def store_host
+        raw = @store.to_s.strip
+        parse(raw.match?(%r{\Ahttps?://}i) ? raw : "https://#{raw}")&.host
+      end
+
+      def web_uri(url)
+        uri = parse(url)
+        uri if uri&.host && %w[http https].include?(uri.scheme&.downcase)
+      end
+
+      def parse(url)
+        URI.parse(url.to_s.strip)
+      rescue URI::InvalidURIError
+        nil
+      end
+    end
+  end
+end

data/lib/portage/cli/quotes.rb

@@ -0,0 +1,82 @@
+require "json"
+require "fileutils"
+require "securerandom"
+
+module Portage
+  module Cli
+    # Local record of the priced checkouts `portage buy --dry-run` has shown,
+    # one JSON file per quote under ~/.portage/quotes/. A quote is what
+    # `buy --quote QUOTE_ID --yes` later buys: it pins the store, product,
+    # quantity and the total that was shown, so the run that charges can
+    # refuse if the price has moved since (see Cli.buy_from_quote).
+    #
+    # Quotes never expire. Each is single use: #consume stamps `used_at`
+    # rather than deleting the file, so a spent quote is still told apart
+    # from one that never existed.
+    class Quotes
+      DIR = File.join(Dir.home, ".portage", "quotes").freeze
+      ID_FORMAT = /\Aqt_[0-9a-f]{12}\z/
+
+      def initialize(dir: DIR, now: Time.now)
+        @dir = dir
+        @now = now.to_i
+      end
+
+      # @param total [Integer, nil] minor units of `currency`.
+      # @param title [String, nil] what the checkout holds, for `portage
+      #   approve`'s summary.
+      # @param url [String, nil] the offer's product page, for `approve --view`.
+      # @return [Hash, nil] the saved quote (string keys, `quote_id` set), or
+      #   nil when it couldn't be written — a quote that can't be saved just
+      #   isn't offered, never a failed dry run.
+      def create(store:, product_id:, qty:, total:, currency:, query: nil, offer_ref: nil, title: nil, url: nil)
+        quote = { "quote_id" => "qt_#{SecureRandom.hex(6)}", "offer_ref" => offer_ref, "store" => store,
+                  "product_id" => product_id, "query" => query, "qty" => qty, "total" => total,
+                  "currency" => currency, "title" => title, "url" => url, "created_at" => @now,
+                  "approved" => false }
+        write(quote)
+      end
+
+      # @return [Hash, nil] nil for an unknown (or malformed) id.
+      def find(quote_id)
+        return nil unless quote_id.to_s.match?(ID_FORMAT)
+
+        parsed = JSON.parse(File.read(path(quote_id)))
+        parsed if parsed.is_a?(Hash)
+      rescue StandardError
+        nil
+      end
+
+      # Records the person's yes to this quote's total
+      # (docs/plans/human-pick-and-approve.md Phase 2): `by` is "person" for
+      # a yes typed at the tty, "agent_relayed" for one an agent passed on.
+      # A relayed yes never downgrades a quote the person already approved.
+      # @return [Hash, nil] the updated quote, nil when unknown or unwritable.
+      def approve(quote_id, by:)
+        quote = find(quote_id)
+        return nil unless quote
+        return quote if quote["approved_by"] == "person"
+
+        write(quote.merge("approved" => true, "approved_by" => by, "approved_at" => @now))
+      end
+
+      # Marks the quote spent. Best-effort, like every other local record.
+      def consume(quote_id)
+        quote = find(quote_id)
+        write(quote.merge("used_at" => @now)) if quote
+      end
+
+      private
+
+      def path(quote_id) = File.join(@dir, "#{quote_id}.json")
+
+      def write(quote)
+        FileUtils.mkdir_p(@dir)
+        File.write(path(quote["quote_id"]), JSON.generate(quote))
+        quote
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/portage/cli/version.rb

@@ -1,5 +1,5 @@
 module Portage
   module Cli
-    VERSION = "0.8.0".freeze
+    VERSION = "0.10.0".freeze
   end
 end