initial commit

.clj-kondo/imports/metosin/malli/config.edn

@@ -0,0 +1,2 @@
+{:lint-as {malli.experimental/defn schema.core/defn}
+ :linters {:unresolved-symbol {:exclude [(malli.core/=>)]}}}

.clj-kondo/imports/potemkin/potemkin/config.edn

@@ -0,0 +1,62 @@
+{:lint-as {potemkin.collections/compile-if      clojure.core/if
+           potemkin.collections/reify-map-type  clojure.core/reify
+           potemkin.collections/def-map-type    clj-kondo.lint-as/def-catch-all
+           potemkin.collections/def-derived-map clj-kondo.lint-as/def-catch-all
+
+           potemkin.types/reify+                clojure.core/reify
+           potemkin.types/defprotocol+          clojure.core/defprotocol
+           potemkin.types/deftype+              clojure.core/deftype
+           potemkin.types/defrecord+            clojure.core/defrecord
+           potemkin.types/definterface+         clojure.core/defprotocol
+           potemkin.types/extend-protocol+      clojure.core/extend-protocol
+           potemkin.types/def-abstract-type     clj-kondo.lint-as/def-catch-all
+
+           potemkin.utils/doit                  clojure.core/doseq
+           potemkin.utils/doary                 clojure.core/doseq
+           potemkin.utils/condp-case            clojure.core/condp
+           potemkin.utils/fast-bound-fn         clojure.core/bound-fn
+
+           potemkin.walk/prewalk                clojure.walk/prewalk
+           potemkin.walk/postwalk               clojure.walk/postwalk
+           potemkin.walk/walk                   clojure.walk/walk
+
+           ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+           ;;;; top-level from import-vars
+           ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+           ;; Have hooks
+           ;;potemkin/import-fn potemkin.namespaces/import-fn
+           ;;potemkin/import-macro potemkin.namespaces/import-macro
+           ;;potemkin/import-def potemkin.namespaces/import-def
+
+           ;; Internal, not transitive
+           ;;potemkin/unify-gensyms               potemkin.macros/unify-gensyms
+           ;;potemkin/normalize-gensyms           potemkin.macros/normalize-gensyms
+           ;;potemkin/equivalent?                 potemkin.macros/equivalent?
+
+           potemkin/condp-case                  clojure.core/condp
+           potemkin/doit                        potemkin.utils/doit
+           potemkin/doary                       potemkin.utils/doary
+
+           potemkin/def-abstract-type           clj-kondo.lint-as/def-catch-all
+           potemkin/reify+                      clojure.core/reify
+           potemkin/defprotocol+                clojure.core/defprotocol
+           potemkin/deftype+                    clojure.core/deftype
+           potemkin/defrecord+                  clojure.core/defrecord
+           potemkin/definterface+               clojure.core/defprotocol
+           potemkin/extend-protocol+            clojure.core/extend-protocol
+
+           potemkin/reify-map-type              clojure.core/reify
+           potemkin/def-derived-map             clj-kondo.lint-as/def-catch-all
+           potemkin/def-map-type                clj-kondo.lint-as/def-catch-all}
+
+ ;; leave import-vars alone, kondo special-cases it
+ :hooks   {:macroexpand {#_#_potemkin.namespaces/import-vars potemkin.namespaces/import-vars
+                         potemkin.namespaces/import-fn    potemkin.namespaces/import-fn
+                         potemkin.namespaces/import-macro potemkin.namespaces/import-macro
+                         potemkin.namespaces/import-def   potemkin.namespaces/import-def
+
+                         #_#_potemkin/import-vars potemkin.namespaces/import-vars
+                         potemkin/import-fn               potemkin.namespaces/import-fn
+                         potemkin/import-macro            potemkin.namespaces/import-macro
+                         potemkin/import-def              potemkin.namespaces/import-def}}}

.clj-kondo/imports/potemkin/potemkin/potemkin/namespaces.clj

@@ -0,0 +1,56 @@
+(ns potemkin.namespaces
+  (:require [clj-kondo.hooks-api :as api]))
+
+(defn import-macro*
+  ([sym]
+   `(def ~(-> sym name symbol) ~sym))
+  ([sym name]
+   `(def ~name ~sym)))
+
+(defmacro import-fn
+  ([sym]
+   (import-macro* sym))
+  ([sym name]
+   (import-macro* sym name)))
+
+(defmacro import-macro
+  ([sym]
+   (import-macro* sym))
+  ([sym name]
+   (import-macro* sym name)))
+
+(defmacro import-def
+  ([sym]
+   (import-macro* sym))
+  ([sym name]
+   (import-macro* sym name)))
+
+#_
+(defmacro import-vars
+  "Imports a list of vars from other namespaces."
+  [& syms]
+  (let [unravel (fn unravel [x]
+                  (if (sequential? x)
+                    (->> x
+                         rest
+                         (mapcat unravel)
+                         (map
+                           #(symbol
+                              (str (first x)
+                                   (when-let [n (namespace %)]
+                                     (str "." n)))
+                              (name %))))
+                    [x]))
+        syms (mapcat unravel syms)
+        result `(do
+                  ~@(map
+                      (fn [sym]
+                        (let [vr (resolve sym)
+                              m (meta vr)]
+                          (cond
+                            (nil? vr) `(throw (ex-info (format "`%s` does not exist" '~sym) {}))
+                            (:macro m) `(def ~(-> sym name symbol) ~sym)
+                            (:arglists m) `(def ~(-> sym name symbol) ~sym)
+                            :else `(def ~(-> sym name symbol) ~sym))))
+                      syms))]
+    result))

.env

@@ -0,0 +1,2 @@
+TMDB_API_KEY=7bf53a92bd6de63cd714d296880bb84b
+TMDB_READ_ACCESS_TOKEN=eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOiI3YmY1M2E5MmJkNmRlNjNjZDcxNGQyOTY4ODBiYjg0YiIsIm5iZiI6MTc2NTY1Mzg4NC40MzI5OTk4LCJzdWIiOiI2OTNkYmQ3YzRhMzQ4ZDMxZmE1ZGZkNDEiLCJzY29wZXMiOlsiYXBpX3JlYWQiXSwidmVyc2lvbiI6MX0._2HIbv-IYk83jgTcgh0H_EtMYfcuFizLEcsKQphUFEI

.gitignore

@@ -0,0 +1,30 @@
+.calva/output-window/
+.calva/repl.calva-repl
+.classpath
+.clj-kondo/.cache
+.cpcache
+.DS_Store
+.eastwood
+.factorypath
+.hg/
+.hgignore
+.java-version
+.lein-*
+.lsp/.cache
+.lsp/sqlite.db
+.nrepl-history
+.nrepl-port
+.portal
+.project
+.rebel_readline_history
+.settings
+.socket-repl-port
+.sw*
+.vscode
+*.class
+*.jar
+*.swp
+*~
+/checkouts
+/classes
+/target

CHANGELOG.md

@@ -0,0 +1,24 @@
+# Change Log
+All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/).
+
+## [Unreleased]
+### Changed
+- Add a new arity to `make-widget-async` to provide a different widget shape.
+
+## [0.1.1] - 2026-02-10
+### Changed
+- Documentation on how to make the widgets.
+
+### Removed
+- `make-widget-sync` - we're all async, all the time.
+
+### Fixed
+- Fixed widget maker to keep working when daylight savings switches over.
+
+## 0.1.0 - 2026-02-10
+### Added
+- Files from the new template.
+- Widget maker public API - `make-widget-sync`.
+
+[Unreleased]: https://github.com/xulfer/tmdb/compare/0.1.1...HEAD
+[0.1.1]: https://github.com/xulfer/tmdb/compare/0.1.0...0.1.1

LICENSE

@@ -0,0 +1,214 @@
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
+LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
+CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and
+documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are
+distributed by that particular Contributor. A Contribution 'originates' from
+a Contributor if it was added to the Program by such Contributor itself or
+anyone acting on such Contributor's behalf. Contributions do not include
+additions to the Program which: (i) are separate modules of software
+distributed in conjunction with the Program under their own license
+agreement, and (ii) are not derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which are
+necessarily infringed by the use or sale of its Contribution alone or when
+combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement,
+including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free copyright license to
+reproduce, prepare derivative works of, publicly display, publicly perform,
+distribute and sublicense the Contribution of such Contributor, if any, and
+such derivative works, in source code and object code form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free patent license under
+Licensed Patents to make, use, sell, offer to sell, import and otherwise
+transfer the Contribution of such Contributor, if any, in source code and
+object code form.  This patent license shall apply to the combination of the
+Contribution and the Program if, at the time the Contribution is added by the
+Contributor, such addition of the Contribution causes such combination to be
+covered by the Licensed Patents. The patent license shall not apply to any
+other combinations which include the Contribution. No hardware per se is
+licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses
+to its Contributions set forth herein, no assurances are provided by any
+Contributor that the Program does not infringe the patent or other
+intellectual property rights of any other entity. Each Contributor disclaims
+any liability to Recipient for claims brought by any other entity based on
+infringement of intellectual property rights or otherwise. As a condition to
+exercising the rights and licenses granted hereunder, each Recipient hereby
+assumes sole responsibility to secure any other intellectual property rights
+needed, if any. For example, if a third party patent license is required to
+allow Recipient to distribute the Program, it is Recipient's responsibility
+to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient
+copyright rights in its Contribution, if any, to grant the copyright license
+set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under
+its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and
+conditions, express and implied, including warranties or conditions of title
+and non-infringement, and implied warranties or conditions of merchantability
+and fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for
+damages, including direct, indirect, special, incidental and consequential
+damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered
+by that Contributor alone and not by any other party; and
+
+iv) states that source code for the Program is available from such
+Contributor, and informs licensees how to obtain it in a reasonable manner on
+or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within
+the Program.
+
+Each Contributor must identify itself as the originator of its Contribution,
+if any, in a manner that reasonably allows subsequent Recipients to identify
+the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with
+respect to end users, business partners and the like. While this license is
+intended to facilitate the commercial use of the Program, the Contributor who
+includes the Program in a commercial product offering should do so in a
+manner which does not create potential liability for other Contributors.
+Therefore, if a Contributor includes the Program in a commercial product
+offering, such Contributor ("Commercial Contributor") hereby agrees to defend
+and indemnify every other Contributor ("Indemnified Contributor") against any
+losses, damages and costs (collectively "Losses") arising from claims,
+lawsuits and other legal actions brought by a third party against the
+Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in
+a commercial product offering.  The obligations in this section do not apply
+to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must:
+a) promptly notify the Commercial Contributor in writing of such claim, and
+b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement
+negotiations. The Indemnified Contributor may participate in any such claim
+at its own expense.
+
+For example, a Contributor might include the Program in a commercial product
+offering, Product X. That Contributor is then a Commercial Contributor. If
+that Commercial Contributor then makes performance claims, or offers
+warranties related to Product X, those performance claims and warranties are
+such Commercial Contributor's responsibility alone. Under this section, the
+Commercial Contributor would have to defend claims against the other
+Contributors related to those performance claims and warranties, and if a
+court requires any other Contributor to pay any damages as a result, the
+Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON
+AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER
+EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR
+CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A
+PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all risks
+associated with its exercise of rights under this Agreement , including but
+not limited to the risks and costs of program errors, compliance with
+applicable laws, damage to or loss of data, programs or equipment, and
+unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
+CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
+LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of the
+remainder of the terms of this Agreement, and without further action by the
+parties hereto, such provision shall be reformed to the minimum extent
+necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+(excluding combinations of the Program with other software or hardware)
+infringes such Recipient's patent(s), then such Recipient's rights granted
+under Section 2(b) shall terminate as of the date such litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to
+comply with any of the material terms or conditions of this Agreement and
+does not cure such failure in a reasonable period of time after becoming
+aware of such noncompliance. If all Recipient's rights under this Agreement
+terminate, Recipient agrees to cease use and distribution of the Program as
+soon as reasonably practicable. However, Recipient's obligations under this
+Agreement and any licenses granted by Recipient relating to the Program shall
+continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in
+order to avoid inconsistency the Agreement is copyrighted and may only be
+modified in the following manner. The Agreement Steward reserves the right to
+publish new versions (including revisions) of this Agreement from time to
+time. No one other than the Agreement Steward has the right to modify this
+Agreement. The Eclipse Foundation is the initial Agreement Steward. The
+Eclipse Foundation may assign the responsibility to serve as the Agreement
+Steward to a suitable separate entity. Each new version of the Agreement will
+be given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program
+(including its Contributions) under the new version. Except as expressly
+stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
+licenses to the intellectual property of any Contributor under this
+Agreement, whether expressly, by implication, estoppel or otherwise. All
+rights in the Program not expressly granted under this Agreement are
+reserved.
+
+This Agreement is governed by the laws of the State of New York and the
+intellectual property laws of the United States of America. No party to this
+Agreement will bring a legal action under this Agreement more than one year
+after the cause of action arose. Each party waives its rights to a jury trial
+in any resulting litigation.

README.md

@@ -0,0 +1,70 @@
+# tmdb
+
+FIXME: my new application.
+
+## Installation
+
+Download from https://github.com/xulfer/tmdb
+
+## Usage
+
+FIXME: explanation
+
+Run the project directly, via `:exec-fn`:
+
+    $ clojure -X:run-x
+    Hello, Clojure!
+
+Run the project, overriding the name to be greeted:
+
+    $ clojure -X:run-x :name '"Someone"'
+    Hello, Someone!
+
+Run the project directly, via `:main-opts` (`-m tmdb.main`):
+
+    $ clojure -M:run-m
+    Hello, World!
+
+Run the project, overriding the name to be greeted:
+
+    $ clojure -M:run-m Via-Main
+    Hello, Via-Main!
+
+Run the project's tests (they'll fail until you edit them):
+
+    $ clojure -T:build test
+
+Run the project's CI pipeline and build an uberjar (this will fail until you edit the tests to pass):
+
+    $ clojure -T:build ci
+
+Run that uberjar:
+
+    $ java -jar target/tmdb-0.1.0-SNAPSHOT.jar
+
+## Options
+
+FIXME: listing of options this app accepts.
+
+## Examples
+
+...
+
+### Bugs
+
+...
+
+### Any Other Sections
+### That You Think
+### Might be Useful
+
+## License
+
+Copyright © 2026 Michealsmith
+
+_EPLv1.0 is just the default for projects generated by `clj-new`: you are not_
+_required to open source this project, nor are you required to use EPLv1.0!_
+_Feel free to remove or change the `LICENSE` file and remove or update this_
+_section of the `README.md` file!_
+
+Distributed under the Eclipse Public License version 1.0.

build.clj

@@ -0,0 +1,43 @@
+(ns build
+  (:refer-clojure :exclude [test])
+  (:require [clojure.tools.deps :as t]
+            [clojure.tools.build.api :as b]))
+
+(def lib 'net.clojars.tmdb/tmdb)
+(def version "0.1.0-SNAPSHOT")
+(def main 'tmdb.main)
+(def class-dir "target/classes")
+
+(defn test "Run all the tests." [opts]
+  (println "\nRunning tests...")
+  (let [basis    (b/create-basis {:aliases [:test]})
+        combined (t/combine-aliases basis [:test])
+        cmds     (b/java-command
+                  {:basis basis
+                   :java-opts (:jvm-opts combined)
+                   :main      'clojure.main
+                   :main-args ["-m" "cognitect.test-runner"]})
+        {:keys [exit]} (b/process cmds)]
+    (when-not (zero? exit) (throw (ex-info "Tests failed" {}))))
+  opts)
+
+(defn- uber-opts [opts]
+  (assoc opts
+         :lib lib :main main
+         :uber-file (format "target/%s-%s.jar" lib version)
+         :basis (b/create-basis {})
+         :class-dir class-dir
+         :src-dirs ["src"]
+         :ns-compile [main]))
+
+(defn ci "Run the CI pipeline of tests (and build the uberjar)." [opts]
+  (test opts)
+  (b/delete {:path "target"})
+  (let [opts (uber-opts opts)]
+    (println "\nCopying source...")
+    (b/copy-dir {:src-dirs ["resources" "src"] :target-dir class-dir})
+    (println (str "\nCompiling " main "..."))
+    (b/compile-clj opts)
+    (println "\nBuilding JAR...")
+    (b/uber opts))
+  opts)

deps.edn

@@ -0,0 +1,27 @@
+{:paths ["src" "resources"]
+ :deps {org.clojure/clojure {:mvn/version "1.12.0"}
+        org.clojure/tools.cli {:mvn/version "1.3.250"}
+        metosin/malli {:mvn/version "0.20.0"}
+        hato/hato {:mvn/version "1.0.0"}
+        clj-http/clj-http {:mvn/version "3.13.1"}
+        cheshire/cheshire {:mvn/version "6.1.0"}
+        envvar/envvar {:mvn/version "1.1.2"}}
+
+ :aliases
+ {:dev {:extra-paths ["dev"]
+        :extra-deps {org.clojure/tools.namespace {:mvn/version "1.4.4"}}}
+  :run-m {:main-opts ["-m" "tmdb.main"]}
+  :run-x {:ns-default tmdb.main
+          :exec-fn greet
+          :exec-args {:name "Clojure"}}
+
+  :build {:deps {io.github.clojure/tools.build {:mvn/version "0.10.5"}}
+          :ns-default build}
+  :test {:extra-paths ["test"]
+         :extra-deps {org.clojure/test.check {:mvn/version "1.1.1"}
+                      io.github.cognitect-labs/test-runner
+                      {:git/tag "v0.5.1" :git/sha "dfb30dd"}}}
+  :marginalia
+  {:extra-deps {marginalia/marginalia {:mvn/version "0.9.2"}}
+   :main-opts  ["-m" "marginalia.main" "-n" "YourProjectName"
+                "src" "test"]}}}

dev/user.clj

@@ -0,0 +1,33 @@
+(ns user
+  (:require [clojure.tools.namespace.repl :refer [refresh refresh-all]]
+            [tmdb.client :as client]
+            [tmdb.request :as req]
+            [tmdb.movie :as movie]
+            [tmdb.util :as util]))
+
+;; Load env variables if available (e.g., from .env file)
+;; You can use a library like environ or just System/getenv.
+;; For now, let's assume TMDB_TOKEN is in the environment.
+
+(def token (System/getenv "TMDB_TOKEN"))
+
+(def tmdb_client
+  (when token
+    (client/make-client token)))
+
+(defn help []
+  (println "Welcome to TMDB Development REPL!")
+  (println "Available vars:")
+  (println "  token: Your TMDB API Token (from env)")
+  (println "  tmdb_client: Initialized client (if token is present)")
+  (println "Available commands:")
+  (println "  (refresh) - Reload changed namespaces")
+  (println "  (reset)   - Reload all namespaces"))
+
+(defn reset []
+  (refresh))
+
+(println "Loaded dev/user.clj")
+(if token
+  (println "Token found! tmdb_client is ready.")
+  (println "WARNING: TMDB_TOKEN not found in environment."))

doc/intro.md

@@ -0,0 +1,3 @@
+# Introduction to tmdb
+
+TODO: write [great documentation](http://jacobian.org/writing/what-to-write/)

src/tmdb/client.clj

@@ -0,0 +1,52 @@
+(ns tmdb.client
+  (:require [hato.client :as hc]
+            [tmdb.request :as req]))
+
+(def tmdb_key "eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOiI3YmY1M2E5MmJkNmRlNjNjZDcxNGQyOTY4ODBiYjg0YiIsIm5iZiI6MTc2NTY1Mzg4NC40MzI5OTk4LCJzdWIiOiI2OTNkYmQ3YzRhMzQ4ZDMxZmE1ZGZkNDEiLCJzY29wZXMiOlsiYXBpX3JlYWQiXSwidmVyc2lvbiI6MX0._2HIbv-IYk83jgTcgh0H_EtMYfcuFizLEcsKQphUFEI")
+
+(declare http-get-pages)
+
+(defprotocol TMDB
+  "Set of functions for interacting with The Movie Database"
+  (search [this term] "Search for a movie."))
+
+(defrecord Context [client token]
+  TMDB
+  (search [this term]
+    (-> (req/make-request this "https://api.themoviedb.org/3/search/movie")
+        (req/with-query term)
+        (req/with-page 1)
+        (http-get-pages))))
+
+;; Creates a new client.
+(defn make-client
+  "Creates a new client for consuming the TMDB API."
+  [api-token]
+  (->Context (hc/build-http-client {}) api-token))
+
+(defn- http-get
+  "Send a GET request."
+  [request]
+  (hc/get (first request) (second request)))
+
+(defn- http-get-pages
+  "Send a get request, and return pages from the API in a sequence."
+  [request]
+  (sequence
+   (comp (map :results)
+         cat)
+
+   (iteration
+    (fn [p]
+      (let [p (or p 1)]
+        (-> request
+            (req/with-page p)
+            http-get
+            :body)))
+    :init-k 1
+    :kf (fn [resp]
+          (let [page (:page resp)
+                total (:total_pages resp)]
+            (when-not (>= page total)
+              (inc page)))))))
+

src/tmdb/main.clj

@@ -0,0 +1,59 @@
+(ns tmdb.main
+  (:require [clojure.string :as string]
+            [clojure.tools.cli :as cli]
+            [tmdb.movie]
+            [tmdb.util :refer [make-error-msg]]
+            [envvar.core :as envvar :refer [env with-env]])
+  (:gen-class))
+
+(def cli-options [["-t" "--token TOKEN" :desc "Access token from TMDB."]])
+
+(defn- usage [summary]
+  (->> ["TMDB client"
+        ""
+        "Usage: tmdb [options] action"
+        ""
+        "Options:"
+        summary
+        ""
+        "Actions:"
+        "  search  Search for a movie title."
+        ""
+        "Please refer to the manual page for further information."]
+       (string/join \newline)))
+
+(defn- process-args "" [args]
+  (let [{:keys [options arguments errors summary]} (cli/parse-opts args cli-options)]
+    (cond
+      (:help options)
+      {:exit-message (usage summary) :ok? true}
+
+      errors
+      {:exit-message (make-error-msg "Error parsing options:\n\n"
+                                     errors) :ok? false}
+
+      (and (= 1 (count arguments))
+           (= "search" (string/lower-case (first arguments))))
+      {:action (first arguments) :options options}
+
+      :else
+      {:exit-message (usage summary)})))
+
+(defn exit [status msg]
+  (println msg)
+  (System/exit status))
+
+(defn -main
+  "I don't do a whole lot ... yet."
+  [& args]
+  (let [{:keys [action options exit-message ok?]} (process-args args)]
+    (if exit-message
+      (exit (if ok? 0 1) exit-message)
+      (case action
+        "search" (tmdb.movie/search options)))))
+
+;;(envvar/load-file-variables! ".env")
+  ;;(fetch example_url)
+  ;;(movie->details 343611)
+
+

src/tmdb/movie.clj

@@ -0,0 +1,45 @@
+(ns tmdb.movie
+  (:require [hato.client :as hc]
+            [clojure.tools.cli :as cli]
+            [clojure.string :as str]
+            [tmdb.util :refer [make-error-msg]]))
+
+(def search-options [["-y" "--year YEAR" :desc "Specify the year of the movie"]])
+
+(defn usage
+  "Prints usage information."
+  [summary]
+  (->> [""
+        "Search for a movie"
+        ""
+        summary]
+       (str/join \newline)))
+
+;; TODO: Return a proper map...
+(defn- perform-search [term opts]
+  [term opts])
+
+(defn- process-args
+  ""
+  [args]
+  (let [{:keys [options args errors summary]} (cli/parse-opts args search-options)]
+    (cond
+      (:help options)
+      {:exit-message (usage summary) :ok? true}
+
+      errors
+      {:exit-message (make-error-msg "Error parsing options\n\n" errors)
+       :ok? false}
+
+      (= 1 (count args))
+      (perform-search (first args) options)
+
+      :else
+      {:exit-message "Unknown error." :ok? false})
+
+    (println (str "Args" args))))
+
+(defn search
+  "Handles the search option."
+  [opts]
+  (process-args opts))

src/tmdb/request.clj

@@ -0,0 +1,46 @@
+(ns tmdb.request
+  (:require [tmdb.util :refer [deep-merge]]))
+
+(def RequestTuple
+  [:tuple
+   [:string {:min 1}]
+   [:map {:closed false}]])
+
+(defn make-request
+  "Makes a simple request for a given url."
+  [{:keys [client token]} url]
+  [url {:oauth-token token
+        :http-client client
+        :as :json
+        :query-params {:page 1}}])
+
+(defn- update-query-params
+  [[url request] query]
+  [url (deep-merge request {:query-params query})])
+
+(defn get-url
+  "Retrieves the URL from the request."
+  [request]
+  (first request))
+
+(defn get-page
+  [request]
+  (get-in request [1 :query-params :page]))
+
+(defn with-page
+  "Sets a the page property for a request."
+  [request page_no]
+  (update-query-params request {:page page_no}))
+
+(defn get-query
+  "Returns the search query from the request tuple."
+  [request]
+  (get-in request [1 :query-params :query]))
+
+(defn with-query
+  "Returns a new request with the search query updated."
+  [request search]
+  (update-query-params request {:query search}))
+
+
+

src/tmdb/util.clj

@@ -0,0 +1,15 @@
+(ns tmdb.util
+  (:require [clojure.string :as str]))
+
+(defn deep-merge [a b]
+  (if (and (map? a) (map? b))
+    (merge-with deep-merge a b)
+    b))
+
+(defn make-error-msg
+  "Makes an error message whether it's just a string, or a
+  string and a list."
+  ([err-str]
+   err-str)
+  ([err-str [& rest]]
+   (str/join \newline (cons err-str rest))))

test/tmdb/main_test.clj

@@ -0,0 +1,7 @@
+(ns tmdb.main-test
+  (:require [clojure.test :refer :all]
+            [tmdb.main :refer :all]))
+
+(deftest a-test
+  (testing "FIXME, I fail."
+    (is (= 0 1))))