← Back to branch summary

~ubuntu-branches/ubuntu/wily/julia/wily

« back to all changes in this revision

Viewing changes to base/pkg/metadata.jl

  • Committer: Package Import Robot
  • Author(s): Sébastien Villemot
  • Date: 2013-02-06 17:54:29 UTC
  • mfrom: (1.1.3)
  • Revision ID: package-import@ubuntu.com-20130206175429-13br5kqpkfjqdmre
Tags: 0.0.0+20130206.git32ff5759-1
* New upstream snapshot.
* debian/copyright: reflect upstream changes
* debian/rules: update get-orig-source to reflect upstream changes
   + Don't ship nginx
   + Adapt for new configure-random target in deps/Makefile
* Enable build of Tk wrapper.
   + debian/control: add build dependency on tk-dev
   + debian/rules: add tk rule to build-arch
* debian/julia.install: install VERSION and COMMIT files
* no-webrepl.patch: new patch
* Refresh other patches
* Add source override for config.status file under deps/random/

Show diffs side-by-side

added added

removed removed

Lines of Context:
base/pkg/metadata.jl
 
1
module Metadata
 
2
 
 
3
import Git
 
4
import Base.isequal, Base.isless, Base.contains, Base.hash
 
5
 
 
6
export parse_requires, Version, VersionSet
 
7
 
 
8
function gen_versions(pkg::String)
 
9
    for (ver,sha1) in Git.each_tagged_version(pkg)
 
10
        dir = "METADATA/$pkg/versions/$ver"
 
11
        run(`mkdir -p $dir`)
 
12
        open("$dir/sha1","w") do io
 
13
            println(io,sha1)
 
14
        end
 
15
        if isfile("$pkg/REQUIRE")
 
16
            run(`cp $pkg/REQUIRE $dir/requires`)
 
17
        end
 
18
    end
 
19
end
 
20
gen_versions() = for pkg in each_package() gen_versions(pkg) end
 
21
 
 
22
function gen_hashes(pkg::String)
 
23
    for (ver,dir) in each_tagged_version(pkg)
 
24
        sha1 = readchomp("$dir/sha1")
 
25
        run(`mkdir -p METADATA/$pkg/hashes`)
 
26
        open("METADATA/$pkg/hashes/$sha1","w") do io
 
27
            println(io,ver)
 
28
        end
 
29
    end
 
30
end
 
31
gen_hashes() = for pkg in each_package() gen_hashes(pkg) end
 
32
 
 
33
function pkg_url(pkg::String)
 
34
    path = "METADATA/$pkg/url"
 
35
    isfile(path) ? readchomp(path) : nothing
 
36
end
 
37
 
 
38
function version(pkg::String, sha1::String)
 
39
    path = "METADATA/$pkg/hashes/$sha1"
 
40
    isfile(path) || Metadata.gen_hashes(pkg)
 
41
    isfile(path) ? convert(VersionNumber,readchomp(path)) : sha1
 
42
end
 
43
 
 
44
each_package() = @task begin
 
45
    for line in each_line(`ls -1 METADATA`)
 
46
        line = chomp(line)
 
47
        # stat() chokes if we try to check if the subdirectory of a non-directory exists
 
48
        if isdir(joinpath("METADATA", line)) && isdir(joinpath("METADATA", line, "versions"))
 
49
            produce(line)
 
50
        end
 
51
    end
 
52
end
 
53
 
 
54
each_tagged_version(pkg::String) = @task begin
 
55
    for line in each_line(`ls -1 $(joinpath("METADATA", pkg, "versions"))`)
 
56
        line = chomp(line)
 
57
        if isdir(joinpath("METADATA", pkg, "versions", line)) && ismatch(Base.VERSION_REGEX, line)
 
58
            ver = convert(VersionNumber,line)
 
59
            dir = "METADATA/$pkg/versions/$(line)"
 
60
            if isfile("$dir/sha1")
 
61
                produce((ver,dir))
 
62
            end
 
63
        end
 
64
    end
 
65
end
 
66
 
 
67
function packages()
 
68
    pkgs = String[]
 
69
    for pkg in each_package()
 
70
        push!(pkgs,pkg)
 
71
    end
 
72
    sort!(pkgs)
 
73
end
 
74
 
 
75
type Version
 
76
    package::ByteString
 
77
    version::VersionNumber
 
78
end
 
79
 
 
80
isequal(a::Version, b::Version) =
 
81
    a.package == b.package && a.version == b.version
 
82
function isless(a::Version, b::Version)
 
83
    (a.package < b.package) && return true
 
84
    (a.package > b.package) && return false
 
85
    return a.version < b.version
 
86
end
 
87
 
 
88
function versions(pkgs)
 
89
    vers = Version[]
 
90
    for pkg in pkgs
 
91
        for (ver,dir) in each_tagged_version(pkg)
 
92
            push!(vers,Version(pkg,ver))
 
93
        end
 
94
    end
 
95
    sort!(vers)
 
96
end
 
97
versions() = versions(packages())
 
98
 
 
99
hash(v::Version) = hash([v.(n) for n in Version.names])
 
100
 
 
101
type VersionSet
 
102
    package::ByteString
 
103
    versions::Vector{VersionNumber}
 
104
 
 
105
    function VersionSet(pkg::ByteString, vers::Vector{VersionNumber})
 
106
        if !issorted(vers)
 
107
            error("version numbers must be sorted")
 
108
        end
 
109
        new(pkg,vers)
 
110
    end
 
111
end
 
112
VersionSet(pkg::ByteString) = VersionSet(pkg, VersionNumber[])
 
113
 
 
114
isequal(a::VersionSet, b::VersionSet) =
 
115
    a.package == b.package && a.versions == b.versions
 
116
isless(a::VersionSet, b::VersionSet) = a.package < b.package
 
117
 
 
118
function contains(s::VersionSet, v::Version)
 
119
    (s.package != v.package) && return false
 
120
    for i in length(s.versions):-1:1
 
121
        (v.version >= s.versions[i]) && return isodd(i)
 
122
    end
 
123
    return isempty(s.versions)
 
124
end
 
125
 
 
126
hash(s::VersionSet) = hash([s.(n) for n in VersionSet.names])
 
127
 
 
128
function parse_requires(file::String)
 
129
    reqs = VersionSet[]
 
130
    open(file) do io
 
131
        for line in each_line(io)
 
132
            if ismatch(r"^\s*(?:#|$)", line) continue end
 
133
            line = replace(line, r"#.*$", "")
 
134
            fields = split(line)
 
135
            pkg = shift!(fields)
 
136
            vers = [ convert(VersionNumber,x) for x=fields ]
 
137
            if !issorted(vers)
 
138
                error("invalid requires entry for $pkg in $file: $vers")
 
139
            end
 
140
            # TODO: merge version sets instead of appending?
 
141
            push!(reqs,VersionSet(pkg,vers))
 
142
        end
 
143
    end
 
144
    sort!(reqs)
 
145
end
 
146
 
 
147
function dependencies(pkgs,vers)
 
148
    deps = Array((Version,VersionSet),0)
 
149
    for pkg in each_package()
 
150
        for (ver,dir) in each_tagged_version(pkg)
 
151
            v = Version(pkg,ver)
 
152
            file = "$dir/requires"
 
153
            if isfile(file)
 
154
                for d in parse_requires("$dir/requires")
 
155
                    if !contains(pkgs,d.package)
 
156
                        error("Unknown dependency for $pkg: $(d.package)")
 
157
                    end
 
158
                    push!(deps,(v,d))
 
159
                end
 
160
            end
 
161
        end
 
162
    end
 
163
    sort!(deps)
 
164
end
 
165
 
 
166
older(a::Version, b::Version) = a.package == b.package && a.version < b.version
 
167
 
 
168
end # module