Obsah
1. Programovací jazyk Clojure a práce s Gitem (2)
2. Demonstrační příklad git-test7: výpis lokálních větví repositáře
3. Demonstrační příklad git-test8: výpis vzdálených větví repositáře
4. Demonstrační příklad git-test9: přepnutí na vybranou větev (checkout)
5. Demonstrační příklad git-test10: vytvoření nové (lokální) větve
6. Demonstrační příklad git-test11: zjištění vybraných konfiguračních voleb repositáře
7. Repositář s dnešními demonstračními příklady
8. Odkazy na předchozí části seriálu
1. Programovací jazyk Clojure a práce s Gitem (2)
Dnes se již podruhé budeme zabývat popisem knihovny clj-jgit, kterou mohou využít vývojáři používající programovací jazyk Clojure pro tvorbu svých aplikací. Již v předchozím článku jsme si řekli základní informace o této knihovně i o faktu, že se vlastně jedná o z vývojářského hlediska pěkně navržené API ke knihovně JGit, která je využívána v některých projektech naprogramovaných v Javě. Z demonstračních příkladů, které byly minule taktéž prezentovány, je zřejmé, jakým způsobem je možné naklonovat repositář, vypsat si informace o (vzdálených) větvích, přidat do repositáře nové soubory a následně provést commit. Dnes si ukážeme další možnosti, které nám knihovna clj-jgit nabízí. Především si vyzkoušíme přechod na jinou větev, tj. obdobu příkazu git checkout, dále pak zjištění informací o konfiguraci repositáře a v následující části se mj. zmíníme o jedné možnosti využití klíčů (dvojice veřejný klíč+soukromý klíč) pro přístup ke vzdálenému repositáři.
2. Demonstrační příklad git-test7: výpis lokálních větví repositáře
Dnešní první demonstrační příklad je velmi jednoduchý, protože jeho jedinou činností je výpis logovacích informací (což již známe z minula) a následně pak výpis všech lokálních větví repositáře. Pro získání sekvence všech větví, ať již lokálních či vzdálených, se používá funkce nazvaná clj-jgit.porcelain/git-branch-list, které se v nejjednodušším případě předá pouze reference na repositář získaná například s využitím již minule popsané funkce clj-jgit.porcelain/with-repo. Sekvence vrácená funkcí clj-jgit.porcelain/git-branch-list obsahuje javovské objekty typu org.eclipse.jgit.internal.storage.file.RefDirectory. Pokud pouze potřebujeme vypsat jména větví, postačuje nad každým objektem ve vrácené sekvenci zavolat metodu .getName. Část kódu, která se postará o vypsání jmen lokálních větví, může vypadat následovně:
(defn print-local-branches
"Vypis vsech lokalnich vetvi pro vybrany repositar."
[repo]
(println "\nLocal branches")
(doseq [branch (jgit/git-branch-list repo)]
(println (.getName branch))))
Pro vytvoření kostry demonstračního příkladu se použije příkaz, který již dokonale známe z předchozích částí tohoto seriálu:
lein new app git-7
Úprava projektového souboru project.clj spočívá v přidání dvou nových knihoven do sekce :dependencies:
(defproject git-test7 "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.6.0"]
[clj-jgit "0.8.0"]
[clj-rm-rf "1.0.0-SNAPSHOT"]]
:main ^:skip-aot git-test7.core
:target-path "target/%s"
:profiles {:uberjar {:aot :all}})
Zdrojový kód souboru src/git_test7/core.clj:
(ns git-test7.core
(:gen-class))
(require '[clj-jgit.porcelain :as jgit])
(require '[clj-jgit.querying :as jgit-query])
(require '[hozumi.rm-rf :as rm-rf])
(def repository-url
"Adresa GIT repositare vcetne specifikace protokolu."
"https://github.com/tisnik/testrepo.git")
(def directory-name
"Jmeno adresare, do ktereho se GIT repositar naklonuje."
"repo")
(defn clone-repository
"Naklonovani GIT repositare do specifikovaneho adresare."
[url directory]
(jgit/git-clone url directory))
(defn delete-directory
"Smazani adresare vcetne podadresaru a souboru."
[directory]
(rm-rf/rm-r (java.io.File. directory)))
(defn print-customized-log
"Vypis logovacich informaci ve zvolenem formatu."
[repository]
(println "\nLog:")
(doseq [log-entry (jgit/git-log repository)]
(let [info (jgit-query/commit-info repository log-entry)]
(println (:author info) ":" (:message info)))))
(defn print-local-branches
"Vypis vsech lokalnich vetvi pro vybrany repositar."
[repo]
(println "\nLocal branches")
(doseq [branch (jgit/git-branch-list repo)]
(println (.getName branch))))
(defn git-test-7
"Naklonovani repositare, nacteni informaci
z vytvoreneho adresare a vypis podrobnejsiho logu."
[repository-url directory-name]
; naklonovani repositare do specifikovaneho adresare
(clone-repository repository-url directory-name)
; nacteni informaci o repositari z lokalniho adresare
; povsimnete si pouziti "automagicky" vytvorene promenne,
; ktera se jmenuje 'repo'
(try (jgit/with-repo directory-name
(print-customized-log repo)
(print-local-branches repo))
(finally
; vymazani adresare s naklonovanym repositarem
(delete-directory directory-name))))
(defn -main
"Funkce zavolana po zadani prikazu 'lein run'."
[& args]
(git-test-7 repository-url directory-name))
Po spuštění tohoto demonstračního příkladu nad testovacím repositářem by se (pokud se tedy klonování zdařilo) měly na standardní výstup vypsat následující informace:
Log: Pavel Tisnovsky : Added garbage Pavel Tisnovsky : Updated README.md Pavel Tišnovský : Initial commit Local branches refs/heads/master
Vidíme, že ihned po klonování existuje pouze jedna lokální větev, což je v pořádku.
3. Demonstrační příklad git-test8: výpis vzdálených větví repositáře
Ve druhém demonstračním příkladu se jménem git-test8 se kromě lokálních větví vypíšou i větve vzdálené (remote). Mohlo by se zdát, že pro získání vzdálených větví bude nutné použít jinou funkci než pro větve lokální, ve skutečnosti se však pro obě činnosti používá shodná funkce clj-jgit.porcelain/git-branch-list, které se však v případě potřeby předá ještě nepovinný parametr :remote (význam tohoto parametru je zřejmý), popř. je možné použít další nepovinný parametr :all (opět se zřejmým významem). Ostatně se pro zajímavost můžeme podívat na deklaraci funkce clj-jgit.porcelain/git-branch-list, která poměrně elegantním způsobem obaluje mnohem delší javovský kód (viz též http://clj-jgit.github.io/clj-jgit/:
(defn git-branch-list
([^Git repo]
(git-branch-list repo :local))
([^Git repo opt]
(let [opt-val {:all org.eclipse.jgit.api.ListBranchCommand$ListMode/ALL
:remote org.eclipse.jgit.api.ListBranchCommand$ListMode/REMOTE}
branches (if (= opt :local)
(-> repo
(.branchList)
(.call))
(-> repo
(.branchList)
(.setListMode (opt opt-val))
(.call)))]
(seq branches))))
Použití této funkce pro výpis lokálních i vzdálených větví můžeme vypadat následovně:
(defn print-local-branches
"Vypis vsech lokalnich vetvi pro vybrany repositar."
[repo]
(println "\nLocal branches")
(doseq [branch (jgit/git-branch-list repo)]
(println (.getName branch))))
(defn print-remote-branches
"Vypis vsech vzdalenych vetvi pro vybrany repositar."
[repo]
(println "\nRemote branches")
(doseq [branch (jgit/git-branch-list repo :remote)]
(println (.getName branch))))
Vytvoření kostry demonstračního příkladu:
lein new app git-8
Úprava projektového souboru project.clj je stejná, jako tomu bylo v předchozím demonstračním příkladu:
(defproject git-test8 "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.6.0"]
[clj-jgit "0.8.0"]
[clj-rm-rf "1.0.0-SNAPSHOT"]]
:main ^:skip-aot git-test8.core
:target-path "target/%s"
:profiles {:uberjar {:aot :all}})
Zdrojový kód souboru src/git_test8/core.clj:
(ns git-test8.core
(:gen-class))
(require '[clj-jgit.porcelain :as jgit])
(require '[clj-jgit.querying :as jgit-query])
(require '[hozumi.rm-rf :as rm-rf])
(def repository-url
"Adresa GIT repositare vcetne specifikace protokolu."
"https://github.com/tisnik/testrepo.git")
(def directory-name
"Jmeno adresare, do ktereho se GIT repositar naklonuje."
"repo")
(defn clone-repository
"Naklonovani GIT repositare do specifikovaneho adresare."
[url directory]
(jgit/git-clone url directory))
(defn delete-directory
"Smazani adresare vcetne podadresaru a souboru."
[directory]
(rm-rf/rm-r (java.io.File. directory)))
(defn print-customized-log
"Vypis logovacich informaci ve zvolenem formatu."
[repository]
(println "\nLog:")
(doseq [log-entry (jgit/git-log repository)]
(let [info (jgit-query/commit-info repository log-entry)]
(println (:author info) ":" (:message info)))))
(defn print-local-branches
"Vypis vsech lokalnich vetvi pro vybrany repositar."
[repo]
(println "\nLocal branches")
(doseq [branch (jgit/git-branch-list repo)]
(println (.getName branch))))
(defn print-remote-branches
"Vypis vsech vzdalenych vetvi pro vybrany repositar."
[repo]
(println "\nRemote branches")
(doseq [branch (jgit/git-branch-list repo :remote)]
(println (.getName branch))))
(defn git-test-8
"Naklonovani repositare, nacteni informaci
z vytvoreneho adresare a vypis podrobnejsiho logu."
[repository-url directory-name]
; naklonovani repositare do specifikovaneho adresare
(clone-repository repository-url directory-name)
; nacteni informaci o repositari z lokalniho adresare
; povsimnete si pouziti "automagicky" vytvorene promenne,
; ktera se jmenuje 'repo'
(try (jgit/with-repo directory-name
(print-customized-log repo)
(print-local-branches repo)
(print-remote-branches repo))
(finally
; vymazani adresare s naklonovanym repositarem
(delete-directory directory-name))))
(defn -main
"Funkce zavolana po zadani prikazu 'lein run'."
[& args]
(git-test-8 repository-url directory-name))
Po spuštění druhého demonstračního příkladu nad testovacím repositářem by se měly na standardní výstup vypsat následující informace:
Log: Pavel Tisnovsky : Added garbage Pavel Tisnovsky : Updated README.md Pavel Tišnovský : Initial commit Local branches refs/heads/master Remote branches refs/remotes/origin/branch-1 refs/remotes/origin/branch-2 refs/remotes/origin/master
4. Demonstrační příklad git-test9: přepnutí na vybranou větev (checkout)
Získání sekvence lokálních či vzdálených větví je samozřejmě pouze nezbytný začátek pro provádění dalších operací s větvemi. Pro přepnutí větví se v GITu používá příkaz git checkout [jméno větve] a podobně nazvaná funkce – clj-jgit.porcelain/git-checkout – je samozřejmě součástí knihovny clj-jgit. Deklarace této funkce vypadá poněkud složitě, ale to jen z toho důvodu, že mnoho jejích parametrů je nepovinných:
(defn git-checkout
([^Git repo branch-name]
(git-checkout repo branch-name false false nil))
([^Git repo branch-name create-branch?]
(git-checkout repo branch-name create-branch? false nil))
([^Git repo branch-name create-branch? force?]
(git-checkout repo branch-name create-branch? force? nil))
([^Git repo branch-name create-branch? force? ^String start-point]
(if (nil? start-point)
(-> repo
(.checkout)
(.setName branch-name)
(.setCreateBranch create-branch?)
(.setForce force?)
(.call))
(-> repo
(.checkout)
(.setName branch-name)
(.setCreateBranch create-branch?)
(.setForce force?)
(.setStartPoint start-point)
(.call)))))
V našem demonstračním příkladu bude použita první (nejjednodušší) možnost volání této funkce, kdy se jí předá pouze reference na repositář a jméno větve:
(defn checkout
[repo branch-name]
(try
(jgit/git-checkout repo branch-name)
(catch Exception e
(println "Unable to checkout: " e))))
(checkout repo "refs/remotes/origin/branch-1")
Vytvoření kostry demonstračního příkladu:
lein new app git-9
Úprava projektového souboru project.clj se nijak neliší od předchozích příkladů:
(defproject git-test9 "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.6.0"]
[clj-jgit "0.8.0"]
[clj-rm-rf "1.0.0-SNAPSHOT"]]
:main ^:skip-aot git-test9.core
:target-path "target/%s"
:profiles {:uberjar {:aot :all}})
Zdrojový kód souboru src/git_test9/core.clj:
(ns git-test9.core
(:gen-class))
(require '[clj-jgit.porcelain :as jgit])
(require '[clj-jgit.querying :as jgit-query])
(require '[hozumi.rm-rf :as rm-rf])
(def repository-url
"Adresa GIT repositare vcetne specifikace protokolu."
"https://github.com/tisnik/testrepo.git")
(def directory-name
"Jmeno adresare, do ktereho se GIT repositar naklonuje."
"repo")
(defn clone-repository
"Naklonovani GIT repositare do specifikovaneho adresare."
[url directory]
(jgit/git-clone url directory))
(defn delete-directory
"Smazani adresare vcetne podadresaru a souboru."
[directory]
(rm-rf/rm-r (java.io.File. directory)))
(defn print-customized-log
"Vypis logovacich informaci ve zvolenem formatu."
[repository]
(println "\nLog:")
(doseq [log-entry (jgit/git-log repository)]
(let [info (jgit-query/commit-info repository log-entry)]
(println (:author info) ":" (:message info)))))
(defn print-local-branches
"Vypis vsech lokalnich vetvi pro vybrany repositar."
[repo]
(println "\nLocal branches")
(doseq [branch (jgit/git-branch-list repo)]
(println (.getName branch))))
(defn print-remote-branches
"Vypis vsech vzdalenych vetvi pro vybrany repositar."
[repo]
(println "\nRemote branches")
(doseq [branch (jgit/git-branch-list repo :remote)]
(println (.getName branch))))
(defn checkout
[repo branch-name]
(try
(jgit/git-checkout repo branch-name)
(catch Exception e
(println "Unable to checkout: " e))))
(defn git-test-9
"Naklonovani repositare, nacteni informaci
z vytvoreneho adresare a vypis podrobnejsiho logu."
[repository-url directory-name]
; naklonovani repositare do specifikovaneho adresare
(clone-repository repository-url directory-name)
; nacteni informaci o repositari z lokalniho adresare
; povsimnete si pouziti "automagicky" vytvorene promenne,
; ktera se jmenuje 'repo'
(try (jgit/with-repo directory-name
(print-customized-log repo)
(print-local-branches repo)
(print-remote-branches repo)
(checkout repo "refs/remotes/origin/branch-1")
(print-local-branches repo)
(print-remote-branches repo))
(finally
; vymazani adresare s naklonovanym repositarem
(delete-directory directory-name))))
(defn -main
"Funkce zavolana po zadani prikazu 'lein run'."
[& args]
(git-test-9 repository-url directory-name))
Zajímavé informace se vypíšou na standardní výstup po spuštění tohoto příkladu. První část výpisu se vztahuje k lokálním a globálním větvím ve chvíli, než je proveden checkout:
Log: Pavel Tisnovsky : Added garbage Pavel Tisnovsky : Updated README.md Pavel Tišnovský : Initial commit Local branches refs/heads/master Remote branches refs/remotes/origin/branch-1 refs/remotes/origin/branch-2 refs/remotes/origin/master
Po provedení checkoutu dostaneme odlišné sekvence, což ovšem opět odpovídá chování GITu, viz též man git-checkout:
Local branches HEAD refs/heads/master Remote branches HEAD refs/remotes/origin/branch-1 refs/remotes/origin/branch-2 refs/remotes/origin/master
Všechny další operace, tj. zejména minule popsané přidání souboru, ubrání (vymazání) souboru či modifikace souboru, se samozřejmě vztahují k aktuální větvi.
5. Demonstrační příklad git-test10: vytvoření nové (lokální) větve
Podívejme se nyní na další dvě základní operace, které lze provádět s větvemi. Pro vytvoření nové lokální větve slouží funkce clj-jgit.porcelain/git-branch-create, pro smazání pak funkce clj-jgit.porcelain/git-branch-delete. V nejjednodušším případě se těmto funkcím předává reference na repositáž a jméno větve, která se má nově vytvořit či naopak smazat; ovšem obě funkce mají i další nepovinné parametry, což je patrné z výpisu jejich zdrojového kódu (kde mimochodem je opět ukázáno elegantní obalení složitějšího javovského kódu):
(defn git-branch-create
([^Git repo branch-name]
(git-branch-create repo branch-name false nil))
([^Git repo branch-name force?]
(git-branch-create repo branch-name force? nil))
([^Git repo branch-name force? ^String start-point]
(if (nil? start-point)
(-> repo
(.branchCreate)
(.setName branch-name)
(.setForce force?)
(.call))
(-> repo
(.branchCreate)
(.setName branch-name)
(.setForce force?)
(.setStartPoint start-point)
(.call)))))
(defn git-branch-delete
([^Git repo branch-names]
(git-branch-delete repo branch-names false))
([^Git repo branch-names force?]
(-> repo
(.branchDelete)
(.setBranchNames (into-array String branch-names))
(.setForce force?)
(.call))))
Použití funkce clj-jgit.porcelain/git-branch-create je skutečně velmi jednoduché:
(jgit/git-branch-create repo "new-branch")
V dalším demonstračním příkladu bude ukázáno, jak se změní výpis lokálních a vzdálených větví po vytvoření nové větve, přepnutí na jinou větvi atd. Vytvoření kostry demonstračního příkladu:
lein new app git-10
Úprava projektového souboru project.clj (podle předpokladu se zde nedějí žádné podstatné změny):
(defproject git-test10 "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.6.0"]
[clj-jgit "0.8.0"]
[clj-rm-rf "1.0.0-SNAPSHOT"]]
:main ^:skip-aot git-test10.core
:target-path "target/%s"
:profiles {:uberjar {:aot :all}})
Zdrojový kód souboru src/git_test10/core.clj:
(ns git-test10.core
(:gen-class))
(require '[clj-jgit.porcelain :as jgit])
(require '[clj-jgit.querying :as jgit-query])
(require '[hozumi.rm-rf :as rm-rf])
(def repository-url
"Adresa GIT repositare vcetne specifikace protokolu."
"https://github.com/tisnik/testrepo.git")
(def directory-name
"Jmeno adresare, do ktereho se GIT repositar naklonuje."
"repo")
(defn clone-repository
"Naklonovani GIT repositare do specifikovaneho adresare."
[url directory]
(jgit/git-clone url directory))
(defn delete-directory
"Smazani adresare vcetne podadresaru a souboru."
[directory]
(rm-rf/rm-r (java.io.File. directory)))
(defn print-customized-log
"Vypis logovacich informaci ve zvolenem formatu."
[repository]
(println "\nLog:")
(doseq [log-entry (jgit/git-log repository)]
(let [info (jgit-query/commit-info repository log-entry)]
(println (:author info) ":" (:message info)))))
(defn print-local-branches
"Vypis vsech lokalnich vetvi pro vybrany repositar."
[repo]
(println "\nLocal branches")
(doseq [branch (jgit/git-branch-list repo)]
(println (.getName branch))))
(defn print-remote-branches
"Vypis vsech vzdalenych vetvi pro vybrany repositar."
[repo]
(println "\nRemote branches")
(doseq [branch (jgit/git-branch-list repo :remote)]
(println (.getName branch))))
(defn print-branches
[repo]
(print-local-branches repo)
(print-remote-branches repo))
(defn checkout
[repo branch-name]
(try
(jgit/git-checkout repo branch-name)
(catch Exception e
(println "Unable to checkout: " e))))
(defn git-test-10
"Naklonovani repositare, nacteni informaci
z vytvoreneho adresare a vypis podrobnejsiho logu."
[repository-url directory-name]
; naklonovani repositare do specifikovaneho adresare
(clone-repository repository-url directory-name)
; nacteni informaci o repositari z lokalniho adresare
; povsimnete si pouziti "automagicky" vytvorene promenne,
; ktera se jmenuje 'repo'
(try (jgit/with-repo directory-name
(print-customized-log repo)
(print-branches repo)
(println "\nCheckout to branch-1")
(checkout repo "refs/remotes/origin/branch-1")
(print-branches repo)
(println "\nCreating new branch")
(jgit/git-branch-create repo "new-branch")
(print-branches repo)
(println "\nCheckout to new branch")
(checkout repo "new-branch")
(print-branches repo))
(finally
; vymazani adresare s naklonovanym repositarem
(delete-directory directory-name))))
(defn -main
"Funkce zavolana po zadani prikazu 'lein run'."
[& args]
(git-test-10 repository-url directory-name))
Texty vypisované tímto příkladem si rozdělíme na několik částí. Nejdříve se vypíšou nám již známé logovací informace, kde není nic nového:
Log: Pavel Tisnovsky : Added garbage Pavel Tisnovsky : Updated README.md Pavel Tišnovský : Initial commit
Dále se ihned po naklonování vypíšou seznamy lokálních větví (v tomto případě jen jedné větve) a větví vzdálených:
Local branches refs/heads/master Remote branches refs/remotes/origin/branch-1 refs/remotes/origin/branch-2 refs/remotes/origin/master
Následně se provede přepnutí na větev branch-1, takže se seznamy podle očekávání změní:
Checkout to branch-1 Local branches HEAD refs/heads/master Remote branches HEAD refs/remotes/origin/branch-1 refs/remotes/origin/branch-2 refs/remotes/origin/master
Ve třetím kroku se vytvoří nová větev a opět dojde k očekávané změně:
Creating new branch Local branches HEAD refs/heads/master refs/heads/new-branch Remote branches HEAD refs/remotes/origin/branch-1 refs/remotes/origin/branch-2 refs/remotes/origin/master
Je důležité si uvědomit, že vytvoření nové větve ještě neznamená, že se na ni GIT přepne. To se musí provést explicitně:
Checkout to new branch Local branches refs/heads/master refs/heads/new-branch Remote branches refs/remotes/origin/branch-1 refs/remotes/origin/branch-2 refs/remotes/origin/master
6. Demonstrační příklad git-test11: zjištění vybraných konfiguračních voleb repositáře
V dnešním posledním příkladu si ukážeme způsob zjištění (přečtení) vybraných konfiguračních voleb, tj. o přibližnou obdobu příkazu git config –get [jméno]. Zde již situace není úplně jednoduchá, protože je nutné použít složitější postup, který jsem implementoval ve funkci get-config-option:
(defn get-config-option
[repo x y z]
(-> repo
(.getRepository)
(.getConfig)
(.getString x y z)))
Typickým (a možná i nejčastějším) příkladem použití je přečtení URL vzdáleného repositáře. Na příkazové řádce lze použít:
git config --get remote.origin.url git@github.com:tisnik/clojure-examples.git
V Clojure aplikaci namísto toho použijeme:
(get-config-option repo "remote" "origin" "url")
V příkladu se přečtou a zobrazí několik konfiguračních voleb:
(defn print-repo-configuration
[repo]
(println "GIT repo origin URL: " (get-config-option repo "remote" "origin" "url"))
(println "Remote origin fetch: " (get-config-option repo "remote" "origin" "fetch"))
(println "Branch master remote: " (get-config-option repo "branch" "master" "remote")))
Vytvoření kostry demonstračního příkladu:
lein new app git-11
Úprava projektového souboru project.clj:
(defproject git-test11 "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.6.0"]
[clj-jgit "0.8.0"]
[clj-rm-rf "1.0.0-SNAPSHOT"]]
:main ^:skip-aot git-test11.core
:target-path "target/%s"
:profiles {:uberjar {:aot :all}})
Zdrojový kód souboru src/git_test11/core.clj:
(ns git-test11.core
(:gen-class))
(require '[clj-jgit.porcelain :as jgit])
(require '[clj-jgit.querying :as jgit-query])
(require '[hozumi.rm-rf :as rm-rf])
(def repository-url
"Adresa GIT repositare vcetne specifikace protokolu."
"https://github.com/tisnik/testrepo.git")
(def directory-name
"Jmeno adresare, do ktereho se GIT repositar naklonuje."
"repo")
(defn clone-repository
"Naklonovani GIT repositare do specifikovaneho adresare."
[url directory]
(jgit/git-clone url directory))
(defn delete-directory
"Smazani adresare vcetne podadresaru a souboru."
[directory]
(rm-rf/rm-r (java.io.File. directory)))
(defn get-config-option
[repo x y z]
(-> repo
(.getRepository)
(.getConfig)
(.getString x y z)))
(defn print-repo-configuration
[repo]
(println "GIT repo origin URL: " (get-config-option repo "remote" "origin" "url"))
(println "Remote origin fetch: " (get-config-option repo "remote" "origin" "fetch"))
(println "Branch master remote: " (get-config-option repo "branch" "master" "remote")))
(defn git-test-11
"Naklonovani repositare, nacteni informaci
z vytvoreneho adresare a vypis podrobnejsiho logu."
[repository-url directory-name]
; naklonovani repositare do specifikovaneho adresare
(clone-repository repository-url directory-name)
; nacteni informaci o repositari z lokalniho adresare
; povsimnete si pouziti "automagicky" vytvorene promenne,
; ktera se jmenuje 'repo'
(try (jgit/with-repo directory-name
(print-repo-configuration repo))
(finally
; vymazani adresare s naklonovanym repositarem
(delete-directory directory-name))))
(defn -main
"Funkce zavolana po zadani prikazu 'lein run'."
[& args]
(git-test-11 repository-url directory-name))
Po spuštění tohoto demonstračního příkladu by se měly vypsat následující řádky (popř. nějaké chybové hlášení):
GIT repo origin URL: https://github.com/tisnik/testrepo.git Remote origin fetch: +refs/heads/*:refs/remotes/origin/* Branch master remote: origin
7. Repositář s dnešními demonstračními příklady
Všech pět dnes popsaných demonstračních příkladů bylo, podobně jako v předchozích částech tohoto seriálu, uloženo do Git repositáře dostupného na adrese https://github.com/tisnik/clojure-examples. V tabulce zobrazené pod tímto odstavcem naleznete na zdrojové kódy jednotlivých demonstračních příkladů přímé odkazy:
| # | Příklad | Github |
|---|---|---|
| 1 | git-test7 | https://github.com/tisnik/clojure-examples/tree/master/git-test7 |
| 2 | git-test8 | https://github.com/tisnik/clojure-examples/tree/master/git-test8 |
| 3 | git-test9 | https://github.com/tisnik/clojure-examples/tree/master/git-test9 |
| 4 | git-test10 | https://github.com/tisnik/clojure-examples/tree/master/git-test10 |
| 5 | git-test11 | https://github.com/tisnik/clojure-examples/tree/master/git-test11 |
8. Odkazy na předchozí části seriálu
Stalo se již zvykem uvést odkazy na všechny předchozí části tohoto seriálu. Tento zvyk samozřejmě dodržíme i dnes:
- Leiningen: nástroj pro správu projektů napsaných v Clojure
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (2)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-2/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (3)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-3/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (4)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-4/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (5)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-5/ - Leiningen: nástroj pro správu projektů napsaných v Clojure (6)
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-6/ - Programovací jazyk Clojure a databáze (1.část)
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-databaze-1-cast/ - Pluginy pro Leiningen
http://www.root.cz/clanky/leiningen-nastroj-pro-spravu-projektu-napsanych-v-clojure-pluginy-pro-leiningen/ - Programovací jazyk Clojure a knihovny pro práci s vektory a maticemi
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-knihovny-pro-praci-s-vektory-a-maticemi/ - Programovací jazyk Clojure a knihovny pro práci s vektory a maticemi (2)
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-knihovny-pro-praci-s-vektory-a-maticemi-2/ - Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk
http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk/ - Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk (2)
http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk-2/ - Programovací jazyk Clojure: syntéza procedurálních textur s využitím knihovny Clisk (dokončení)
http://www.root.cz/clanky/programovaci-jazyk-clojure-synteza-proceduralnich-textur-s-vyuzitim-knihovny-clisk-dokonceni/ - Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure
http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure/ - Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure (2)
http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure-2/ - Seesaw: knihovna pro snadnou tvorbu GUI v jazyce Clojure (3)
http://www.root.cz/clanky/seesaw-knihovna-pro-snadnou-tvorbu-gui-v-jazyce-clojure-3/ - Programovací jazyk Clojure a práce s Gitem
http://www.root.cz/clanky/programovaci-jazyk-clojure-a-prace-s-gitem/
9. Odkazy na Internetu
- Seriál o Gitu: 1. díl – Git – Historie a principy
http://www.itnetwork.cz/git-tutorial-historie-a-principy - 2. díl – Git – Instalace a vytvoření repositáře
http://www.itnetwork.cz/git-tutorial-instalace-a-stazeni-repositare - 3. díl – Git – Základy
http://www.itnetwork.cz/git-tutorial-zaklady - 4. díl – Git – Zkoumání historie
http://www.itnetwork.cz/git-tutorial-historie - 5. díl – Git – Rozděluj a panuj
http://www.itnetwork.cz/git-tutorial-vetve - 6. díl – Git – práce se vzdáleným repositářem
http://www.itnetwork.cz/git-prace-se-vzdalenym-repositarem - Building User Interfaces with Seesaw (slajdy k přednášce)
http://darevay.com/talks/clojurewest2012/#/title-slide - Seesaw na GitHubu
https://github.com/daveray/seesaw - Seesaw API Documentation
http://daveray.github.io/seesaw/ - Seesaw wiki
https://github.com/daveray/seesaw/wiki - seesaw-repl-tutorial.clj
https://gist.github.com/daveray/1441520 - Témata o Seesaw na Google groups
https://groups.google.com/forum/#!forum/seesaw-clj - Threading macro (dokumentace k jazyku Clojure)
https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/-> - Understanding the Clojure → macro
http://blog.fogus.me/2009/09/04/understanding-the-clojure-macro/ - Clisk
https://github.com/mikera/clisk - clojars: net.mikera/clisk
https://clojars.org/net.mikera/clisk - clojure.inspector
http://clojure.github.io/clojure/clojure.inspector-api.html - Clisk: wiki
https://github.com/mikera/clisk/wiki - Dokumentace vygenerovaná pro knihovnu core.matrix
https://cloojure.github.io/doc/core.matrix/index.html - Size and Dimensionality
https://groups.google.com/forum/#!topic/numerical-clojure/zebBCa68eTw/discussion - Towards core.matrix for Clojure?
https://clojurefun.wordpress.com/2013/01/05/towards-core-matrix-for-clojure/ - The Clojure Toolbox
http://www.clojure-toolbox.com/ - Neanderthal
http://neanderthal.uncomplicate.org/ - Hello world project
https://github.com/uncomplicate/neanderthal/blob/master/examples/hello-world/project.clj - vectorz-clj
https://github.com/mikera/vectorz-clj - vectorz – Examples
https://github.com/mikera/vectorz-clj/wiki/Examples - gloss
https://github.com/ztellman/gloss - HTTP client/server for Clojure
http://www.http-kit.org/ - Array Programming
https://en.wikipedia.org/wiki/Array_programming - Discovering Array Languages
http://archive.vector.org.uk/art10008110 - no stinking loops – Kalothi
http://www.nsl.com/ - Vector (obsahuje odkazy na články, knihy a blogy o programovacích jazycích APL, J a K)
http://www.vector.org.uk/ - APL Interpreters
http://www.vector.org.uk/?area=interpreters - APL_(programming_language
http://en.wikipedia.org/wiki/APL_(programming_language - APL FAQ
http://www.faqs.org/faqs/apl-faq/ - APL FAQ (nejnovější verze)
http://home.earthlink.net/~swsirlin/apl.faq.html - A+
http://www.aplusdev.org/ - APLX
http://www.microapl.co.uk/ - FreeAPL
http://www.pyr.fi/apl/index.htm - J: a modern, high-level, general-purpose, high-performance programming language
http://www.jsoftware.com/ - K, Kdb: an APL derivative for Solaris, Linux, Windows
http://www.kx.com - openAPL (GPL)
http://sourceforge.net/projects/openapl - Parrot APL (GPL)
http://www.parrotcode.org/ - Learning J (Roger Stokes)
http://www.jsoftware.com/help/learning/contents.htm - Rosetta Code
http://rosettacode.org/wiki/Main_Page - Why APL
http://www.acm.org/sigapl/whyapl.htm - java.jdbc API Reference
https://clojure.github.io/java.jdbc/ - Hiccup
https://github.com/weavejester/hiccup - Clojure Ring na GitHubu
https://github.com/ring-clojure/ring - A brief overview of the Clojure web stack
https://brehaut.net/blog/2011/ring_introduction - Getting Started with Ring
http://www.learningclojure.com/2013/01/getting-started-with-ring.html - Getting Started with Ring and Compojure – Clojure Web Programming
http://www.myclojureadventure.com/2011/03/getting-started-with-ring-and-compojure.html - Unit Testing in Clojure
http://nakkaya.com/2009/11/18/unit-testing-in-clojure/ - Testing in Clojure (Part-1: Unit testing)
http://blog.knoldus.com/2014/03/22/testing-in-clojure-part-1-unit-testing/ - API for clojure.test – Clojure v1.6 (stable)
https://clojure.github.io/clojure/clojure.test-api.html - Leiningen: úvodní stránka
http://leiningen.org/ - Leiningen: Git repository
https://github.com/technomancy/leiningen - leiningen-win-installer
http://leiningen-win-installer.djpowell.net/ - Clojure 1: Úvod
http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm/ - Clojure 2: Symboly, kolekce atd.
http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-2-cast/ - Clojure 3: Funkcionální programování
http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-3-cast-funkcionalni-programovani/ - Clojure 4: Kolekce, sekvence a lazy sekvence
http://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-4-cast-kolekce-sekvence-a-lazy-sekvence/ - Clojure 5: Sekvence, lazy sekvence a paralelní programy
http://www.root.cz/clanky/clojure-a-bezpecne-aplikace-pro-jvm-sekvence-lazy-sekvence-a-paralelni-programy/ - Clojure 6: Podpora pro paralelní programování
http://www.root.cz/clanky/programovaci-jazyk-clojure-6-futures-nejsou-jen-financni-derivaty/ - Clojure 7: Další funkce pro paralelní programování
http://www.root.cz/clanky/programovaci-jazyk-clojure-7-dalsi-podpurne-prostredky-pro-paralelni-programovani/ - Clojure 8: Identity, stavy, neměnné hodnoty a reference
http://www.root.cz/clanky/programovaci-jazyk-clojure-8-identity-stavy-nemenne-hodnoty-a-referencni-typy/ - Clojure 9: Validátory, pozorovatelé a kooperace s Javou
http://www.root.cz/clanky/programovaci-jazyk-clojure-9-validatory-pozorovatele-a-kooperace-mezi-clojure-a-javou/ - Clojure 10: Kooperace mezi Clojure a Javou
http://www.root.cz/clanky/programovaci-jazyk-clojure-10-kooperace-mezi-clojure-a-javou-pokracovani/ - Clojure 11: Generátorová notace seznamu/list comprehension
http://www.root.cz/clanky/programovaci-jazyk-clojure-11-generatorova-notace-seznamu-list-comprehension/ - Clojure 12: Překlad programů z Clojure do bajtkódu JVM I:
http://www.root.cz/clanky/programovaci-jazyk-clojure-12-preklad-programu-z-clojure-do-bajtkodu-jvm/ - Clojure 13: Překlad programů z Clojure do bajtkódu JVM II:
http://www.root.cz/clanky/programovaci-jazyk-clojure-13-preklad-programu-z-clojure-do-bajtkodu-jvm-pokracovani/ - Clojure 14: Základy práce se systémem maker
http://www.root.cz/clanky/programovaci-jazyk-clojure-14-zaklady-prace-se-systemem-maker/ - Clojure 15: Tvorba uživatelských maker
http://www.root.cz/clanky/programovaci-jazyk-clojure-15-tvorba-uzivatelskych-maker/ - Clojure 16: Složitější uživatelská makra
http://www.root.cz/clanky/programovaci-jazyk-clojure-16-slozitejsi-uzivatelska-makra/ - Clojure 17: Využití standardních maker v praxi
http://www.root.cz/clanky/programovaci-jazyk-clojure-17-vyuziti-standardnich-maker-v-praxi/ - Clojure 18: Základní techniky optimalizace aplikací
http://www.root.cz/clanky/programovaci-jazyk-clojure-18-zakladni-techniky-optimalizace-aplikaci/ - Clojure 19: Vývojová prostředí pro Clojure
http://www.root.cz/clanky/programovaci-jazyk-clojure-19-vyvojova-prostredi-pro-clojure/ - Clojure 20: Vývojová prostředí pro Clojure (Vimu s REPL)
http://www.root.cz/clanky/programovaci-jazyk-clojure-20-vyvojova-prostredi-pro-clojure-integrace-vimu-s-repl/ - Clojure 21: ClojureScript aneb překlad Clojure do JS
http://www.root.cz/clanky/programovaci-jazyk-clojure-21-clojurescript-aneb-preklad-clojure-do-javascriptu/
