aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/program/aedifex/local.lux
blob: 8761b573af2d6998032d62105a24894175be7af5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
(.module:
  [lux #*
   [abstract
    ["." monad (#+ do)]]
   [control
    ["." io (#+ IO)]
    ["." try (#+ Try)]
    [concurrency
     ["." promise (#+ Promise)]]
    [security
     ["!" capability]]]
   [data
    [binary (#+ Binary)]
    ["." text
     ["%" format (#+ format)]
     ["." encoding]]
    [collection
     ["." list ("#@." monoid)]
     ["." dictionary]]
    [format
     ["." binary]
     ["." tar]
     ["." xml]]]
   [world
    ["." file (#+ Path File Directory)]]]
  [program
   [compositor
    ["." export]]]
  ["." // #_
   ["/" project (#+ Project)]
   ["#." extension]
   ["#." pom]
   ["#." artifact (#+ Artifact)]
   ["#." dependency (#+ Package Resolution Dependency)]
   ["#." hash]])

(def: (local system)
  (All [a] (-> (file.System a) Path))
  (format "~" (:: system separator) ".m2"))

(def: (repository system)
  (All [a] (-> (file.System a) Path))
  (format (..local system) (:: system separator) "repository"))

(def: (guarantee-repository! system artifact)
  (-> (file.System Promise) Artifact (Promise (Try Path)))
  (do {@ (try.with promise.monad)}
    [_ (: (Promise (Try (Directory Promise)))
          (file.get-directory promise.monad system (..local system)))
     #let [root (..repository system)]
     _ (: (Promise (Try (Directory Promise)))
          (file.get-directory promise.monad system root))]
    (monad.fold @
                (function (_ child parent)
                  (do @
                    [#let [path (format parent (:: system separator) child)]
                     _ (: (Promise (Try (Directory Promise)))
                          (file.get-directory promise.monad system path))]
                    (wrap path)))
                root
                (//artifact.local artifact))))

(def: (save! system content file)
  (-> (file.System Promise) Binary Path (Promise (Try Any)))
  (do (try.with promise.monad)
    [file (: (Promise (Try (File Promise)))
             (file.get-file promise.monad system file))]
    (!.use (:: file over-write) [content])))

(def: #export (install system project)
  (-> (file.System Promise) Project (Promise (Try Any)))
  (do (try.with promise.monad)
    [repository (..guarantee-repository! system (get@ #/.identity project))
     #let [identity (get@ #/.identity project)
           artifact-name (format repository (:: system separator) (//artifact.identity identity))]
     package (export.library system (get@ #/.sources project))
     _ (..save! system (binary.run tar.writer package)
                (format artifact-name "." //dependency.lux-library))]
    (..save! system (|> project //pom.project (:: xml.codec encode) encoding.to-utf8)
             (format artifact-name //extension.pom))))

(def: #export (cache system [artifact type] package)
  (-> (file.System Promise) Dependency Package (Promise (Try Any)))
  (do (try.with promise.monad)
    [directory (..guarantee-repository! system artifact)
     #let [prefix (format directory (:: system separator) (//artifact.identity artifact))]
     directory (: (Promise (Try (Directory Promise)))
                  (file.get-directory promise.monad system directory))
     _ (..save! system
                (get@ #//dependency.library package)
                (format prefix "." type))
     _ (..save! system
                (encoding.to-utf8 (get@ #//dependency.sha1 package))
                (format prefix //extension.sha1))
     _ (..save! system
                (encoding.to-utf8 (get@ #//dependency.md5 package))
                (format prefix //extension.md5))
     _ (..save! system
                (|> package (get@ #//dependency.pom) (:: xml.codec encode) encoding.to-utf8)
                (format prefix //extension.pom))]
    (wrap [])))

(def: #export (cache-all system resolution)
  (-> (file.System Promise) Resolution (Promise (Try Any)))
  (do {@ (try.with promise.monad)}
    [_ (monad.map @ (function (_ [dependency package])
                      (..cache system dependency package))
                  (dictionary.entries resolution))]
    (wrap [])))

(def: (read! system path)
  (-> (file.System Promise) Path (Promise (Try Binary)))
  (do (try.with promise.monad)
    [file (: (Promise (Try (File Promise)))
             (!.use (:: system file) path))]
    (!.use (:: file content) [])))

(def: #export (cached system [artifact type])
  (-> (file.System Promise) Dependency (Promise (Try Package)))
  (do (try.with promise.monad)
    [directory (..guarantee-repository! system artifact)
     #let [prefix (format directory (:: system separator) (//artifact.identity artifact))]
     pom (..read! system (format prefix //extension.pom))
     [pom dependencies] (:: promise.monad wrap
                            (do try.monad
                              [pom (encoding.from-utf8 pom)
                               pom (:: xml.codec decode pom)
                               dependencies (//dependency.from-pom pom)]
                              (wrap [pom dependencies])))
     library (..read! system (format prefix "." type))
     sha1 (..read! system (format prefix //extension.sha1))
     md5 (..read! system (format prefix //extension.md5))]
    (wrap {#//dependency.library library
           #//dependency.pom pom
           #//dependency.dependencies dependencies
           #//dependency.sha1 (//hash.representation sha1)
           #//dependency.md5 (//hash.representation md5)})))

(def: #export (all-cached system dependencies resolution)
  (-> (file.System Promise) (List Dependency) Resolution (Promise (Try Resolution)))
  (case dependencies
    #.Nil
    (:: (try.with promise.monad) wrap resolution)
    
    (#.Cons head tail)
    (do promise.monad
      [package (case (dictionary.get head resolution)
                 (#.Some package)
                 (wrap (#try.Success package))

                 #.None
                 (..cached system head))]
      (with-expansions [<next> (as-is (all-cached system tail resolution))]
        (case package
          (#try.Success package)
          (let [resolution (dictionary.put head package resolution)]
            (do (try.with promise.monad)
              [resolution (all-cached system (get@ #//dependency.dependencies package) resolution)]
              <next>))
          
          (#try.Failure error)
          <next>)))))