unfold example

docker_tag_paginate.clj

(ns docker-tag-paginate
  (:require [clj-http.lite.client :as client]
            [cheshire.core :as json]
            [clojure.pprint :refer [print-table]]))

(def base-url "https://registry.hub.docker.com/v2")

;; (progression pos? dec 15)

(defn progression
  [continue? f seed]
  (reify
    clojure.lang.Sequential
    clojure.lang.Seqable
    (seq [_]
      (let [step (fn step-fn [seed]
                   (cons seed (lazy-seq
                                (when (continue? seed)
                                  (step-fn (f seed))))))]
        (step seed)))
    clojure.lang.IReduceInit
    (reduce [_ rf init]
      (loop [ret (rf init seed)
             seed seed]
        (if (reduced? ret)
          @ret
          (if (continue? seed)
            (let [next (f seed)]
              (recur (rf ret next) next))
            ret))))))

(defn read-response
  [response]
  (when (= 200 (:status response))
    (update response :body json/parse-string keyword)))

(defn get-tags
  [image-name]
  (let [base-url (str base-url "/repositories/library/" image-name "/tags/")
        fetch!   (comp read-response client/get)
        next-url (comp :next :body)
        results  (comp :results :body)
        pages    (progression next-url (comp fetch! next-url) (fetch! base-url))]
    (into [] (mapcat results) pages)))

(defn pretty-print-tags
  [tags]
  (->> tags
       (sort-by :last_updated (fn [a b] (compare b a)))
       (print-table [:name :full_size :last_updated])))

(defn -main
  [image-name]
  (-> image-name
      get-tags
      pretty-print-tags))

I have used this, and while I was writing the docstring I thought of coalesce. Maybe unrelated, I thought I might throw it there 😄 Thanks for sharing!

EDIT: for others, here is a more up-to-date, arguably better, approach.