Mercurial > hg > sonic-visualiser
changeset 1712:fb3bce15f480 vext
Merge from default branch
| author | Chris Cannam |
|---|---|
| date | Thu, 08 Jun 2017 16:49:35 +0100 |
| parents | 10952e402220 (diff) aabab3358644 (current diff) |
| children | 994560e84965 e64981b88943 |
| files | |
| diffstat | 11 files changed, 2045 insertions(+), 26 deletions(-) [+] |
line wrap: on
line diff
--- a/.hgignore Thu May 25 15:43:32 2017 +0100 +++ b/.hgignore Thu Jun 08 16:49:35 2017 +0100 @@ -26,3 +26,20 @@ .DS_Store *.stash cov-int/* +*.deb +vamp-plugin-sdk +svcore +svgui +svapp +checker +piper-cpp +dataquay +bqvec +bqfft +bqresample +bqaudioio +sv-dependency-builds +icons/scalable +vamp-plugin-load-checker +piper-vamp-simple-server +piper-convert
--- a/.hgsub Thu May 25 15:43:32 2017 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,13 +0,0 @@ -vamp-plugin-sdk = https://code.soundsoftware.ac.uk/hg/vamp-plugin-sdk -svcore = https://code.soundsoftware.ac.uk/hg/svcore -svgui = https://code.soundsoftware.ac.uk/hg/svgui -svapp = https://code.soundsoftware.ac.uk/hg/svapp -dataquay = https://bitbucket.org/breakfastquay/dataquay -bqvec = https://bitbucket.org/breakfastquay/bqvec -bqfft = https://bitbucket.org/breakfastquay/bqfft -bqresample = https://bitbucket.org/breakfastquay/bqresample -bqaudioio = https://bitbucket.org/breakfastquay/bqaudioio -sv-dependency-builds = https://code.soundsoftware.ac.uk/hg/sv-dependency-builds -icons/scalable = https://code.soundsoftware.ac.uk/hg/sv-iconset -checker = https://code.soundsoftware.ac.uk/hg/vamp-plugin-load-checker -piper-cpp = https://code.soundsoftware.ac.uk/hg/piper-cpp
--- a/.hgsubstate Thu May 25 15:43:32 2017 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,13 +0,0 @@ -692c02f29c999fa355a60220089499924ca94e02 bqaudioio -fb508f7cdcdc245add2de6811acda46745516716 bqfft -a867fff0963dd91df0fd99c81d690c1155e73645 bqresample -ddbf6d836efb6fc320b652e1a4dff4edeaae9b53 bqvec -cf18645ff411a2b292946153109d499fbf69de9f checker -3768bdde6fdf866aa63fff5bde8d9fa64a8979ef dataquay -3d2cde3b1ab3d39c7f9e542250c288a9da0f6850 icons/scalable -db929669e7d3564ec09cf41bf7ee347fa11233de piper-cpp -eccd51b72864a07c9744d88d0b3c22f557ba43c1 sv-dependency-builds -72b4870f0e6b0d3bc279b77cfb550a0c3f846f52 svapp -e7e626a87a1ef03ba474c25a3c5ae886738c134e svcore -cdaeff1858af72b24f40b5799d8d11c495dc14f0 svgui -946d850c940c1aa46e0db3dae1625182d2f7ca9e vamp-plugin-sdk
--- a/configure Thu May 25 15:43:32 2017 +0100 +++ b/configure Thu Jun 08 16:49:35 2017 +0100 @@ -8521,6 +8521,28 @@ fi +if test -x vext ; then + if test -d .hg -o -d .git ; then + if ! ./vext install; then + as_fn_error $? "Vext failed; please fix any reported errors and try again" "$LINENO" 5 + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: Vext executable found but not in an Hg or Git working-copy: not running it" >&5 +$as_echo "$as_me: Vext executable found but not in an Hg or Git working-copy: not running it" >&6;} + if ! test -d vamp-plugin-sdk ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No vamp-plugin-sdk directory present, so external libraries might not have been updated" >&5 +$as_echo "$as_me: WARNING: No vamp-plugin-sdk directory present, so external libraries might not have been updated" >&2;} + fi + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: No Vext executable found: assuming external libraries are already here" >&5 +$as_echo "$as_me: No Vext executable found: assuming external libraries are already here" >&6;} + if ! test -d vamp-plugin-sdk ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No vamp-plugin-sdk directory present, so external libraries might not have been updated" >&5 +$as_echo "$as_me: WARNING: No vamp-plugin-sdk directory present, so external libraries might not have been updated" >&2;} + fi +fi + if ! $QMAKE -r sonic-visualiser.pro; then as_fn_error $? "qmake failed: Command was \"$QMAKE -r\"" "$LINENO" 5 fi
--- a/configure.ac Thu May 25 15:43:32 2017 +0100 +++ b/configure.ac Thu Jun 08 16:49:35 2017 +0100 @@ -139,6 +139,24 @@ AC_OUTPUT +if test -x vext ; then + if test -d .hg -o -d .git ; then + if ! ./vext install; then + AC_MSG_ERROR([Vext failed; please fix any reported errors and try again]) + fi + else + AC_MSG_NOTICE([Vext executable found but not in an Hg or Git working-copy: not running it]) + if ! test -d vamp-plugin-sdk ; then + AC_MSG_WARN([No vamp-plugin-sdk directory present, so external libraries might not have been updated]) + fi + fi +else + AC_MSG_NOTICE([No Vext executable found: assuming external libraries are already here]) + if ! test -d vamp-plugin-sdk ; then + AC_MSG_WARN([No vamp-plugin-sdk directory present, so external libraries might not have been updated]) + fi +fi + if ! $QMAKE -r sonic-visualiser.pro; then AC_MSG_ERROR([qmake failed: Command was "$QMAKE -r"]) fi
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vext Thu Jun 08 16:49:35 2017 +0100 @@ -0,0 +1,111 @@ +#!/bin/bash + +# Disable shellcheck warnings for useless-use-of-cat. UUOC is good +# practice, not bad: clearer, safer, less error-prone. +# shellcheck disable=SC2002 + +sml="$VEXT_SML" + +set -eu + +mydir=$(dirname "$0") +program="$mydir/vext.sml" + +# We need one of Poly/ML, SML/NJ, or MLton. Since we're running a +# single-file SML program as if it were a script, our order of +# preference is based on startup speed. + +if [ -z "$sml" ]; then + # I think there may be a race condition in the poly interpreter's + # tests for open or closed I/O streams - without the "echo" here, + # or with stderr redirection, this pipeline will sometimes hang + if echo | poly -v 2>/dev/null | grep -q 'Poly/ML'; then + sml="poly" + elif sml -h 2>&1 | grep -q 'Standard ML of New Jersey'; then + sml="smlnj" + elif mlton 2>&1 | grep -q 'MLton'; then + sml="mlton" + else cat 1>&2 <<EOF + +ERROR: No supported SML compiler or interpreter found +EOF + cat <<EOF + + The Vext external source code manager needs a Standard ML (SML) + compiler or interpreter to run. + + Please ensure you have one of the following SML implementations + installed and present in your PATH, and try again. These are listed + approximately in order of preference for this task. + + 1. Poly/ML + - often found in a distribution package called: polyml + - executable name: poly + + 2. Standard ML of New Jersey + - often found in a distribution package called: smlnj + - executable name: sml + + 3. MLton + - often found in a distribution package called: mlton + - executable name: mlton + +EOF + exit 2 + fi +fi + +tmp_sml=$(mktemp /tmp/vext-XXXXXXXX.sml) +tmp_out=$(mktemp /tmp/vext-XXXXXXXX.bin) + +trap 'rm -f $tmp_sml $tmp_out' 0 + +arglist="" +for arg in "$@"; do + if [ -n "$arglist" ]; then arglist="$arglist,"; fi + if echo "$arg" | grep -q '[^a-z]' ; then + arglist="$arglist\"usage\"" + else + arglist="$arglist\"$arg\"" + fi +done + +case "$sml" in + poly) echo 'use "'"$program"'"; vext ['"$arglist"'];' | + poly -q --error-exit ;; + mlton) + cat "$program" > "$tmp_sml" + echo 'val _ = main ()' >> "$tmp_sml" + mlton -output "$tmp_out" "$tmp_sml" + "$tmp_out" "$@" ;; + smlnj) + cat "$program" | ( + cat <<EOF +val smlrun__cp = + let val x = !Control.Print.out in + Control.Print.out := { say = fn _ => (), flush = fn () => () }; + x + end; +val smlrun__prev = ref ""; +Control.Print.out := { + say = fn s => + (if String.isSubstring " Error" s + then (Control.Print.out := smlrun__cp; + (#say smlrun__cp) (!smlrun__prev); + (#say smlrun__cp) s) + else (smlrun__prev := s; ())), + flush = fn s => () +}; +EOF + cat - + cat <<EOF +val _ = vext [$arglist]; +val _ = OS.Process.exit (OS.Process.success); +EOF + ) > "$tmp_sml" + CM_VERBOSE=false sml "$tmp_sml" ;; + *) + echo "Unknown SML implementation name: $sml"; + exit 2 ;; +esac +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vext-lock.json Thu Jun 08 16:49:35 2017 +0100 @@ -0,0 +1,43 @@ +{ + "libs": { + "vamp-plugin-sdk": { + "pin": "5d9af3140f05" + }, + "svcore": { + "pin": "09751743647e" + }, + "svgui": { + "pin": "14dcdc596baf" + }, + "svapp": { + "pin": "72b4870f0e6b" + }, + "checker": { + "pin": "cf18645ff411" + }, + "piper-cpp": { + "pin": "adb1f9a4b8b849e418c12038abc294f92bcd18a7" + }, + "dataquay": { + "pin": "3768bdde6fdf" + }, + "bqvec": { + "pin": "ddbf6d836efb" + }, + "bqfft": { + "pin": "fb508f7cdcdc" + }, + "bqresample": { + "pin": "a867fff0963d" + }, + "bqaudioio": { + "pin": "692c02f29c99" + }, + "sv-dependency-builds": { + "pin": "eccd51b72864" + }, + "icons/scalable": { + "pin": "3d2cde3b1ab3" + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vext-project.json Thu Jun 08 16:49:35 2017 +0100 @@ -0,0 +1,76 @@ +{ + "config": { + "extdir": "." + }, + "providers": { + "soundsoftware": { + "vcs": ["hg", "git"], + "anon": "https://code.soundsoftware.ac.uk/{vcs}/{repo}", + "auth": "https://{account}@code.soundsoftware.ac.uk/{vcs}/{repo}" + } + }, + "libs": { + "vamp-plugin-sdk": { + "vcs": "hg", + "service": "soundsoftware" + }, + "svcore": { + "vcs": "hg", + "service": "soundsoftware" + }, + "svgui": { + "vcs": "hg", + "service": "soundsoftware" + }, + "svapp": { + "vcs": "hg", + "service": "soundsoftware" + }, + "checker": { + "vcs": "hg", + "service": "soundsoftware", + "repository": "vamp-plugin-load-checker" + }, + "piper-cpp": { + "vcs": "git", + "service": "github", + "owner": "piper-audio", + "repository": "piper-vamp-cpp" + }, + "dataquay": { + "vcs": "hg", + "service": "bitbucket", + "owner": "breakfastquay" + }, + "bqvec": { + "vcs": "hg", + "service": "bitbucket", + "owner": "breakfastquay" + }, + "bqfft": { + "vcs": "hg", + "service": "bitbucket", + "owner": "breakfastquay" + }, + "bqresample": { + "vcs": "hg", + "service": "bitbucket", + "owner": "breakfastquay" + }, + "bqaudioio": { + "vcs": "hg", + "service": "bitbucket", + "owner": "breakfastquay" + }, + "sv-dependency-builds": { + "vcs": "hg", + "service": "soundsoftware" + }, + "icons/scalable": { + "vcs": "hg", + "service": "soundsoftware", + "repository": "sv-iconset" + } + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vext.bat Thu Jun 08 16:49:35 2017 +0100 @@ -0,0 +1,3 @@ +@echo off +PowerShell -NoProfile -ExecutionPolicy Bypass -Command "& '%~dpn0.ps1' %*"; +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vext.ps1 Thu Jun 08 16:49:35 2017 +0100 @@ -0,0 +1,101 @@ +<# + +.SYNOPSIS +A simple manager for third-party source code dependencies. +Run "vext help" for more documentation. + +#> + +$sml = $env:VEXT_SML + +$mydir = Split-Path $MyInvocation.MyCommand.Path -Parent +$program = "$mydir/vext.sml" + +# We need either Poly/ML or SML/NJ. No great preference as to which. + +if (!$sml) { + if (Get-Command "polyml" -ErrorAction SilentlyContinue) { + $sml = "poly" + } elseif (Get-Command "sml" -ErrorAction SilentlyContinue) { + $sml = "smlnj" + } else { + echo @" + +ERROR: No supported SML compiler or interpreter found + + The Vext external source code manager needs a Standard ML (SML) + compiler or interpreter to run. + + Please ensure you have one of the following SML implementations + installed and present in your PATH, and try again. + + 1. Poly/ML + - executable name: polyml + + 2. Standard ML of New Jersey + - executable name: sml + +"@ + exit 1 + } +} + +if ($args -match "[^a-z]") { + $arglist = '["usage"]' +} else { + $arglist = '["' + ($args -join '","') + '"]' +} + +if ($sml -eq "poly") { + + $program = $program -replace "\\","\\\\" + echo "use ""$program""; vext $arglist" | polyml -q --error-exit | Out-Host + +} elseif ($sml -eq "smlnj") { + + $lines = @(Get-Content $program) + $lines = $lines -notmatch "val _ = main ()" + + $intro = @" +val smlrun__cp = + let val x = !Control.Print.out in + Control.Print.out := { say = fn _ => (), flush = fn () => () }; + x + end; +val smlrun__prev = ref ""; +Control.Print.out := { + say = fn s => + (if String.isSubstring "Error" s orelse String.isSubstring "Fail" s + then (Control.Print.out := smlrun__cp; + (#say smlrun__cp) (!smlrun__prev); + (#say smlrun__cp) s) + else (smlrun__prev := s; ())), + flush = fn s => () +}; +"@ -split "[\r\n]+" + + $outro = @" +val _ = vext $arglist; +val _ = OS.Process.exit (OS.Process.success); +"@ -split "[\r\n]+" + + $script = @() + $script += $intro + $script += $lines + $script += $outro + + $tmpfile = ([System.IO.Path]::GetTempFileName()) -replace "[.]tmp",".sml" + + $script | Out-File -Encoding "ASCII" $tmpfile + + $env:CM_VERBOSE="false" + + sml $tmpfile $args[1,$args.Length] + + del $tmpfile + +} else { + + "Unknown SML implementation name: $sml" + exit 2 +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vext.sml Thu Jun 08 16:49:35 2017 +0100 @@ -0,0 +1,1654 @@ +(* This file is automatically generated from the individual + source files in the Vext repository. *) + +(* + Vext + + A simple manager for third-party source code dependencies + + Copyright 2017 Chris Cannam. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation + files (the "Software"), to deal in the Software without + restriction, including without limitation the rights to use, copy, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of Chris Cannam and + Particular Programs Ltd shall not be used in advertising or + otherwise to promote the sale, use or other dealings in this + Software without prior written authorization. +*) + +val vext_version = "0.0.1" + + +datatype vcs = + HG | + GIT + +datatype source = + URL of string | + PROVIDER of { + service : string, + owner : string option, + repo : string option + } + +datatype pin = + UNPINNED | + PINNED of string + +datatype libstate = + ABSENT | + CORRECT | + SUPERSEDED | + WRONG + +datatype localstate = + MODIFIED | + UNMODIFIED + +datatype branch = + BRANCH of string | + DEFAULT_BRANCH + +(* If we can recover from an error, for example by reporting failure + for this one thing and going on to the next thing, then the error + should usually be returned through a result type rather than an + exception. *) + +datatype 'a result = + OK of 'a | + ERROR of string + +type libname = string + +type id_or_tag = string + +type libspec = { + libname : libname, + vcs : vcs, + source : source, + branch : branch, + pin : pin +} + +type lock = { + libname : libname, + id_or_tag : id_or_tag +} + +type remote_spec = { + anon : string option, + auth : string option +} + +type provider = { + service : string, + supports : vcs list, + remote_spec : remote_spec +} + +type account = { + service : string, + login : string +} + +type context = { + rootpath : string, + extdir : string, + providers : provider list, + accounts : account list +} + +type userconfig = { + providers : provider list, + accounts : account list +} + +type project = { + context : context, + libs : libspec list +} + +structure VextFilenames = struct + val project_file = "vext-project.json" + val project_lock_file = "vext-lock.json" + val user_config_file = ".vext.json" +end + +signature VCS_CONTROL = sig + + (** Test whether the library is present locally at all *) + val exists : context -> libname -> bool result + + (** Return the id (hash) of the current revision for the library *) + val id_of : context -> libname -> id_or_tag result + + (** Test whether the library is at the given id *) + val is_at : context -> libname * id_or_tag -> bool result + + (** Test whether the library is on the given branch, i.e. is at + the branch tip or an ancestor of it *) + val is_on_branch : context -> libname * branch -> bool result + + (** Test whether the library is at the newest revision for the + given branch. False may indicate that the branch has advanced + or that the library is not on the branch at all. This function + may use the network to check for new revisions *) + val is_newest : context -> libname * branch -> bool result + + (** Test whether the library is at the newest revision available + locally for the given branch. False may indicate that the + branch has advanced or that the library is not on the branch + at all. This function must not use the network *) + val is_newest_locally : context -> libname * branch -> bool result + + (** Test whether the library has been modified in the local + working copy *) + val is_modified_locally : context -> libname -> bool result + + (** Check out, i.e. clone a fresh copy of, the repo for the given + library on the given branch *) + val checkout : context -> libname * source * branch -> unit result + + (** Update the library to the given branch tip *) + val update : context -> libname * branch -> id_or_tag result + + (** Update the library to the given specific id or tag *) + val update_to : context -> libname * id_or_tag -> id_or_tag result +end + +signature LIB_CONTROL = sig + val review : context -> libspec -> (libstate * localstate) result + val status : context -> libspec -> (libstate * localstate) result + val update : context -> libspec -> id_or_tag result +end + +structure FileBits :> sig + val extpath : context -> string + val libpath : context -> libname -> string + val subpath : context -> libname -> string -> string + val command_output : context -> libname -> string list -> string result + val command : context -> libname -> string list -> unit result + val file_contents : string -> string + val mydir : unit -> string + val homedir : unit -> string + val mkpath : string -> unit result + val project_spec_path : string -> string + val project_lock_path : string -> string + val verbose : unit -> bool +end = struct + + fun verbose () = + case OS.Process.getEnv "VEXT_VERBOSE" of + SOME "0" => false + | SOME _ => true + | NONE => false + + fun extpath ({ rootpath, extdir, ... } : context) = + let val { isAbs, vol, arcs } = OS.Path.fromString rootpath + in OS.Path.toString { + isAbs = isAbs, + vol = vol, + arcs = arcs @ [ extdir ] + } + end + + fun subpath ({ rootpath, extdir, ... } : context) libname remainder = + (* NB libname is allowed to be a path fragment, e.g. foo/bar *) + let val { isAbs, vol, arcs } = OS.Path.fromString rootpath + val split = String.fields (fn c => c = #"/") + in OS.Path.toString { + isAbs = isAbs, + vol = vol, + arcs = arcs @ [ extdir ] @ split libname @ split remainder + } + end + + fun libpath context "" = + extpath context + | libpath context libname = + subpath context libname "" + + fun project_file_path rootpath filename = + let val { isAbs, vol, arcs } = OS.Path.fromString rootpath + in OS.Path.toString { + isAbs = isAbs, + vol = vol, + arcs = arcs @ [ filename ] + } + end + + fun project_spec_path rootpath = + project_file_path rootpath (VextFilenames.project_file) + + fun project_lock_path rootpath = + project_file_path rootpath (VextFilenames.project_lock_file) + + fun trim str = + hd (String.fields (fn x => x = #"\n" orelse x = #"\r") str) + + fun file_contents filename = + let val stream = TextIO.openIn filename + fun read_all str acc = + case TextIO.inputLine str of + SOME line => read_all str (trim line :: acc) + | NONE => rev acc + val contents = read_all stream [] + val _ = TextIO.closeIn stream + in + String.concatWith "\n" contents + end + + fun expand_commandline cmdlist = + (* We are quite [too] strict about what we accept here, except + for the first element in cmdlist which is assumed to be a + known command location rather than arbitrary user input. NB + only ASCII accepted at this point. *) + let open Char + fun quote arg = + if List.all + (fn c => isAlphaNum c orelse c = #"-" orelse c = #"_") + (explode arg) + then arg + else "\"" ^ arg ^ "\"" + fun check arg = + let val valid = explode " /#:;?,._-{}@=" + in + app (fn c => + if isAlphaNum c orelse + List.exists (fn v => v = c) valid + then () + else raise Fail ("Invalid character '" ^ + (Char.toString c) ^ + "' in command list")) + (explode arg); + arg + end + in + String.concatWith " " + (map quote + (hd cmdlist :: map check (tl cmdlist))) + end + + val tick_cycle = ref 0 + val tick_chars = Vector.fromList (map String.str (explode "|/-\\")) + + fun tick name = + let val n = Vector.length tick_chars + fun pad_to n str = + if n <= String.size str then str + else pad_to n (str ^ " ") + in + print ("\r " ^ + Vector.sub(tick_chars, !tick_cycle) ^ " " ^ + pad_to 24 name); + tick_cycle := (if !tick_cycle = n - 1 then 0 else 1 + !tick_cycle) + end + + fun run_command context libname cmdlist redirect = + let open OS + val dir = libpath context libname + val cmd = expand_commandline cmdlist + val _ = if verbose () + then print ("Running: " ^ cmd ^ + " (in dir " ^ dir ^ ")...\n") + else tick libname + val _ = FileSys.chDir dir + val status = case redirect of + NONE => Process.system cmd + | SOME file => Process.system (cmd ^ ">" ^ file) + in + if Process.isSuccess status + then OK () + else ERROR ("Command failed: " ^ cmd ^ " (in dir " ^ dir ^ ")") + end + handle ex => ERROR ("Unable to run command: " ^ exnMessage ex) + + fun command context libname cmdlist = + run_command context libname cmdlist NONE + + fun command_output context libname cmdlist = + let open OS + val tmpFile = FileSys.tmpName () + val result = run_command context libname cmdlist (SOME tmpFile) + val contents = file_contents tmpFile + in + FileSys.remove tmpFile handle _ => (); + case result of + OK () => OK contents + | ERROR e => ERROR e + end + + fun mydir () = + let open OS + val { dir, file } = Path.splitDirFile (CommandLine.name ()) + in + FileSys.realPath + (if Path.isAbsolute dir + then dir + else Path.concat (FileSys.getDir (), dir)) + end + + fun homedir () = + (* Failure is not routine, so we use an exception here *) + case (OS.Process.getEnv "HOME", + OS.Process.getEnv "HOMEPATH") of + (SOME home, _) => home + | (NONE, SOME home) => home + | (NONE, NONE) => + raise Fail "Failed to look up home directory from environment" + + fun mkpath path = + if OS.FileSys.isDir path handle _ => false + then OK () + else case OS.Path.fromString path of + { arcs = nil, ... } => OK () + | { isAbs = false, ... } => ERROR "mkpath requires absolute path" + | { isAbs, vol, arcs } => + case mkpath (OS.Path.toString { (* parent *) + isAbs = isAbs, + vol = vol, + arcs = rev (tl (rev arcs)) }) of + ERROR e => ERROR e + | OK () => ((OS.FileSys.mkDir path; OK ()) + handle OS.SysErr (e, _) => + ERROR ("Directory creation failed: " ^ e)) +end + +functor LibControlFn (V: VCS_CONTROL) :> LIB_CONTROL = struct + + (* Valid states for unpinned libraries: + + - CORRECT: We are on the right branch and are up-to-date with + it as far as we can tell. (If not using the network, this + should be reported to user as "Present" rather than "Correct" + as the remote repo may have advanced without us knowing.) + + - SUPERSEDED: We are on the right branch but we can see that + there is a newer revision either locally or on the remote (in + Git terms, we are at an ancestor of the desired branch tip). + + - WRONG: We are on the wrong branch (in Git terms, we are not + at the desired branch tip or any ancestor of it). + + - ABSENT: Repo doesn't exist here at all. + + Valid states for pinned libraries: + + - CORRECT: We are at the pinned revision. + + - WRONG: We are at any revision other than the pinned one. + + - ABSENT: Repo doesn't exist here at all. + *) + + fun check with_network context ({ libname, branch, pin, ... } : libspec) = + let fun check_unpinned () = + let val is_newest = if with_network + then V.is_newest + else V.is_newest_locally + in + case is_newest context (libname, branch) of + ERROR e => ERROR e + | OK true => OK CORRECT + | OK false => + case V.is_on_branch context (libname, branch) of + ERROR e => ERROR e + | OK true => OK SUPERSEDED + | OK false => OK WRONG + end + fun check_pinned target = + case V.is_at context (libname, target) of + ERROR e => ERROR e + | OK true => OK CORRECT + | OK false => OK WRONG + fun check' () = + case pin of + UNPINNED => check_unpinned () + | PINNED target => check_pinned target + in + case V.exists context libname of + ERROR e => ERROR e + | OK false => OK (ABSENT, UNMODIFIED) + | OK true => + case (check' (), V.is_modified_locally context libname) of + (ERROR e, _) => ERROR e + | (_, ERROR e) => ERROR e + | (OK state, OK true) => OK (state, MODIFIED) + | (OK state, OK false) => OK (state, UNMODIFIED) + end + + val review = check true + val status = check false + + fun update context ({ libname, source, branch, pin, ... } : libspec) = + let fun update_unpinned () = + case V.is_newest context (libname, branch) of + ERROR e => ERROR e + | OK true => V.id_of context libname + | OK false => V.update context (libname, branch) + fun update_pinned target = + case V.is_at context (libname, target) of + ERROR e => ERROR e + | OK true => OK target + | OK false => V.update_to context (libname, target) + fun update' () = + case pin of + UNPINNED => update_unpinned () + | PINNED target => update_pinned target + in + case V.exists context libname of + ERROR e => ERROR e + | OK true => update' () + | OK false => + case V.checkout context (libname, source, branch) of + ERROR e => ERROR e + | OK () => update' () + end +end + +(* Simple Standard ML JSON parser + ============================== + + https://bitbucket.org/cannam/sml-simplejson + + An RFC-compliant JSON parser in one SML file with no dependency + on anything outside the Basis library. Also includes a simple + serialiser. + + Tested with MLton, Poly/ML, and SML/NJ compilers. + + Parser notes: + + * Complies with RFC 7159, The JavaScript Object Notation (JSON) + Data Interchange Format + + * Passes all of the JSONTestSuite parser accept/reject tests that + exist at the time of writing, as listed in "Parsing JSON is a + Minefield" (http://seriot.ch/parsing_json.php) + + * Two-pass parser using naive exploded strings, therefore not + particularly fast and not suitable for large input files + + * Only supports UTF-8 input, not UTF-16 or UTF-32. Doesn't check + that JSON strings are valid UTF-8 -- the caller must do that -- + but does handle \u escapes + + * Converts all numbers to type "real". If that is a 64-bit IEEE + float type (common but not guaranteed in SML) then we're pretty + standard for a JSON parser + + Copyright 2017 Chris Cannam. + Parts based on the JSON parser in the Ponyo library by Phil Eaton. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation + files (the "Software"), to deal in the Software without + restriction, including without limitation the rights to use, copy, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of Chris Cannam and + Particular Programs Ltd shall not be used in advertising or + otherwise to promote the sale, use or other dealings in this + Software without prior written authorization. +*) + +signature JSON = sig + + datatype json = OBJECT of (string * json) list + | ARRAY of json list + | NUMBER of real + | STRING of string + | BOOL of bool + | NULL + + datatype 'a result = OK of 'a + | ERROR of string + + val parse : string -> json result + val serialise : json -> string + val serialiseIndented : json -> string + +end + +structure Json :> JSON = struct + + datatype json = OBJECT of (string * json) list + | ARRAY of json list + | NUMBER of real + | STRING of string + | BOOL of bool + | NULL + + datatype 'a result = OK of 'a + | ERROR of string + + structure T = struct + datatype token = NUMBER of char list + | STRING of string + | BOOL of bool + | NULL + | CURLY_L + | CURLY_R + | SQUARE_L + | SQUARE_R + | COLON + | COMMA + + fun toString t = + case t of NUMBER digits => implode digits + | STRING s => s + | BOOL b => Bool.toString b + | NULL => "null" + | CURLY_L => "{" + | CURLY_R => "}" + | SQUARE_L => "[" + | SQUARE_R => "]" + | COLON => ":" + | COMMA => "," + end + + fun bmpToUtf8 cp = (* convert a codepoint in Unicode BMP to utf8 bytes *) + let open Word + infix 6 orb andb >> + in + map (Char.chr o toInt) + (if cp < 0wx80 then + [cp] + else if cp < 0wx800 then + [0wxc0 orb (cp >> 0w6), 0wx80 orb (cp andb 0wx3f)] + else if cp < 0wx10000 then + [0wxe0 orb (cp >> 0w12), + 0wx80 orb ((cp >> 0w6) andb 0wx3f), + 0wx80 orb (cp andb 0wx3f)] + else raise Fail ("Invalid BMP point " ^ (Word.toString cp))) + end + + fun error pos text = ERROR (text ^ " at character position " ^ + Int.toString (pos - 1)) + fun token_error pos = error pos ("Unexpected token") + + fun lexNull pos acc (#"u" :: #"l" :: #"l" :: xs) = + lex (pos + 3) (T.NULL :: acc) xs + | lexNull pos acc _ = token_error pos + + and lexTrue pos acc (#"r" :: #"u" :: #"e" :: xs) = + lex (pos + 3) (T.BOOL true :: acc) xs + | lexTrue pos acc _ = token_error pos + + and lexFalse pos acc (#"a" :: #"l" :: #"s" :: #"e" :: xs) = + lex (pos + 4) (T.BOOL false :: acc) xs + | lexFalse pos acc _ = token_error pos + + and lexChar tok pos acc xs = + lex pos (tok :: acc) xs + + and lexString pos acc cc = + let datatype escaped = ESCAPED | NORMAL + fun lexString' pos text ESCAPED [] = + error pos "End of input during escape sequence" + | lexString' pos text NORMAL [] = + error pos "End of input during string" + | lexString' pos text ESCAPED (x :: xs) = + let fun esc c = lexString' (pos + 1) (c :: text) NORMAL xs + in case x of + #"\"" => esc x + | #"\\" => esc x + | #"/" => esc x + | #"b" => esc #"\b" + | #"f" => esc #"\f" + | #"n" => esc #"\n" + | #"r" => esc #"\r" + | #"t" => esc #"\t" + | _ => error pos ("Invalid escape \\" ^ + Char.toString x) + end + | lexString' pos text NORMAL (#"\\" :: #"u" ::a::b::c::d:: xs) = + if List.all Char.isHexDigit [a,b,c,d] + then case Word.fromString ("0wx" ^ (implode [a,b,c,d])) of + SOME w => (let val utf = rev (bmpToUtf8 w) in + lexString' (pos + 6) (utf @ text) + NORMAL xs + end + handle Fail err => error pos err) + | NONE => error pos "Invalid Unicode BMP escape sequence" + else error pos "Invalid Unicode BMP escape sequence" + | lexString' pos text NORMAL (x :: xs) = + if Char.ord x < 0x20 + then error pos "Invalid unescaped control character" + else + case x of + #"\"" => OK (rev text, xs, pos + 1) + | #"\\" => lexString' (pos + 1) text ESCAPED xs + | _ => lexString' (pos + 1) (x :: text) NORMAL xs + in + case lexString' pos [] NORMAL cc of + OK (text, rest, newpos) => + lex newpos (T.STRING (implode text) :: acc) rest + | ERROR e => ERROR e + end + + and lexNumber firstChar pos acc cc = + let val valid = explode ".+-e" + fun lexNumber' pos digits [] = (rev digits, [], pos) + | lexNumber' pos digits (x :: xs) = + if x = #"E" then lexNumber' (pos + 1) (#"e" :: digits) xs + else if Char.isDigit x orelse List.exists (fn c => x = c) valid + then lexNumber' (pos + 1) (x :: digits) xs + else (rev digits, x :: xs, pos) + val (digits, rest, newpos) = + lexNumber' (pos - 1) [] (firstChar :: cc) + in + case digits of + [] => token_error pos + | _ => lex newpos (T.NUMBER digits :: acc) rest + end + + and lex pos acc [] = OK (rev acc) + | lex pos acc (x::xs) = + (case x of + #" " => lex + | #"\t" => lex + | #"\n" => lex + | #"\r" => lex + | #"{" => lexChar T.CURLY_L + | #"}" => lexChar T.CURLY_R + | #"[" => lexChar T.SQUARE_L + | #"]" => lexChar T.SQUARE_R + | #":" => lexChar T.COLON + | #"," => lexChar T.COMMA + | #"\"" => lexString + | #"t" => lexTrue + | #"f" => lexFalse + | #"n" => lexNull + | x => lexNumber x) (pos + 1) acc xs + + fun show [] = "end of input" + | show (tok :: _) = T.toString tok + + fun parseNumber digits = + (* Note lexNumber already case-insensitised the E for us *) + let open Char + + fun okExpDigits [] = false + | okExpDigits (c :: []) = isDigit c + | okExpDigits (c :: cs) = isDigit c andalso okExpDigits cs + + fun okExponent [] = false + | okExponent (#"+" :: cs) = okExpDigits cs + | okExponent (#"-" :: cs) = okExpDigits cs + | okExponent cc = okExpDigits cc + + fun okFracTrailing [] = true + | okFracTrailing (c :: cs) = + (isDigit c andalso okFracTrailing cs) orelse + (c = #"e" andalso okExponent cs) + + fun okFraction [] = false + | okFraction (c :: cs) = + isDigit c andalso okFracTrailing cs + + fun okPosTrailing [] = true + | okPosTrailing (#"." :: cs) = okFraction cs + | okPosTrailing (#"e" :: cs) = okExponent cs + | okPosTrailing (c :: cs) = + isDigit c andalso okPosTrailing cs + + fun okPositive [] = false + | okPositive (#"0" :: []) = true + | okPositive (#"0" :: #"." :: cs) = okFraction cs + | okPositive (#"0" :: #"e" :: cs) = okExponent cs + | okPositive (#"0" :: cs) = false + | okPositive (c :: cs) = isDigit c andalso okPosTrailing cs + + fun okNumber (#"-" :: cs) = okPositive cs + | okNumber cc = okPositive cc + in + if okNumber digits + then case Real.fromString (implode digits) of + NONE => ERROR "Number out of range" + | SOME r => OK r + else ERROR ("Invalid number \"" ^ (implode digits) ^ "\"") + end + + fun parseObject (T.CURLY_R :: xs) = OK (OBJECT [], xs) + | parseObject tokens = + let fun parsePair (T.STRING key :: T.COLON :: xs) = + (case parseTokens xs of + ERROR e => ERROR e + | OK (j, xs) => OK ((key, j), xs)) + | parsePair other = + ERROR ("Object key/value pair expected around \"" ^ + show other ^ "\"") + fun parseObject' acc [] = ERROR "End of input during object" + | parseObject' acc tokens = + case parsePair tokens of + ERROR e => ERROR e + | OK (pair, T.COMMA :: xs) => + parseObject' (pair :: acc) xs + | OK (pair, T.CURLY_R :: xs) => + OK (OBJECT (rev (pair :: acc)), xs) + | OK (_, _) => ERROR "Expected , or } after object element" + in + parseObject' [] tokens + end + + and parseArray (T.SQUARE_R :: xs) = OK (ARRAY [], xs) + | parseArray tokens = + let fun parseArray' acc [] = ERROR "End of input during array" + | parseArray' acc tokens = + case parseTokens tokens of + ERROR e => ERROR e + | OK (j, T.COMMA :: xs) => parseArray' (j :: acc) xs + | OK (j, T.SQUARE_R :: xs) => OK (ARRAY (rev (j :: acc)), xs) + | OK (_, _) => ERROR "Expected , or ] after array element" + in + parseArray' [] tokens + end + + and parseTokens [] = ERROR "Value expected" + | parseTokens (tok :: xs) = + (case tok of + T.NUMBER d => (case parseNumber d of + OK r => OK (NUMBER r, xs) + | ERROR e => ERROR e) + | T.STRING s => OK (STRING s, xs) + | T.BOOL b => OK (BOOL b, xs) + | T.NULL => OK (NULL, xs) + | T.CURLY_L => parseObject xs + | T.SQUARE_L => parseArray xs + | _ => ERROR ("Unexpected token " ^ T.toString tok ^ + " before " ^ show xs)) + + fun parse str = + case lex 1 [] (explode str) of + ERROR e => ERROR e + | OK tokens => case parseTokens tokens of + OK (value, []) => OK value + | OK (_, _) => ERROR "Extra data after input" + | ERROR e => ERROR e + + fun stringEscape s = + let fun esc x = [x, #"\\"] + fun escape' acc [] = rev acc + | escape' acc (x :: xs) = + escape' (case x of + #"\"" => esc x @ acc + | #"\\" => esc x @ acc + | #"\b" => esc #"b" @ acc + | #"\f" => esc #"f" @ acc + | #"\n" => esc #"n" @ acc + | #"\r" => esc #"r" @ acc + | #"\t" => esc #"t" @ acc + | _ => + let val c = Char.ord x + in + if c < 0x20 + then let val hex = Word.toString (Word.fromInt c) + in (rev o explode) (if c < 0x10 + then ("\\u000" ^ hex) + else ("\\u00" ^ hex)) + end @ acc + else + x :: acc + end) + xs + in + implode (escape' [] (explode s)) + end + + fun serialise json = + case json of + OBJECT pp => "{" ^ String.concatWith + "," (map (fn (key, value) => + serialise (STRING key) ^ ":" ^ + serialise value) pp) ^ + "}" + | ARRAY arr => "[" ^ String.concatWith "," (map serialise arr) ^ "]" + | NUMBER n => implode (map (fn #"~" => #"-" | c => c) + (explode (Real.toString n))) + | STRING s => "\"" ^ stringEscape s ^ "\"" + | BOOL b => Bool.toString b + | NULL => "null" + + fun serialiseIndented json = + let fun indent 0 = "" + | indent i = " " ^ indent (i - 1) + fun serialiseIndented' i json = + let val ser = serialiseIndented' (i + 1) + in + case json of + OBJECT [] => "{}" + | ARRAY [] => "[]" + | OBJECT pp => "{\n" ^ indent (i + 1) ^ + String.concatWith + (",\n" ^ indent (i + 1)) + (map (fn (key, value) => + ser (STRING key) ^ ": " ^ + ser value) pp) ^ + "\n" ^ indent i ^ "}" + | ARRAY arr => "[\n" ^ indent (i + 1) ^ + String.concatWith + (",\n" ^ indent (i + 1)) + (map ser arr) ^ + "\n" ^ indent i ^ "]" + | other => serialise other + end + in + serialiseIndented' 0 json ^ "\n" + end + +end + + +structure JsonBits :> sig + val load_json_from : string -> Json.json (* filename -> json *) + val save_json_to : string -> Json.json -> unit + val lookup_optional : Json.json -> string list -> Json.json option + val lookup_optional_string : Json.json -> string list -> string option + val lookup_mandatory : Json.json -> string list -> Json.json + val lookup_mandatory_string : Json.json -> string list -> string +end = struct + + fun load_json_from filename = + case Json.parse (FileBits.file_contents filename) of + Json.OK json => json + | Json.ERROR e => raise Fail ("Failed to parse file: " ^ e) + + fun save_json_to filename json = + let val jstr = Json.serialiseIndented json + val stream = TextIO.openOut filename + in + TextIO.output (stream, jstr); + TextIO.closeOut stream + end + + fun lookup_optional json kk = + let fun lookup key = + case json of + Json.OBJECT kvs => + (case List.find (fn (k, v) => k = key) kvs of + SOME (k, v) => SOME v + | NONE => NONE) + | _ => raise Fail "Object expected" + in + case kk of + [] => NONE + | key::[] => lookup key + | key::kk => case lookup key of + NONE => NONE + | SOME j => lookup_optional j kk + end + + fun lookup_optional_string json kk = + case lookup_optional json kk of + SOME (Json.STRING s) => SOME s + | SOME _ => raise Fail ("Value (if present) must be string: " ^ + (String.concatWith " -> " kk)) + | NONE => NONE + + fun lookup_mandatory json kk = + case lookup_optional json kk of + SOME v => v + | NONE => raise Fail ("Value is mandatory: " ^ + (String.concatWith " -> " kk) ^ " in json: " ^ + (Json.serialise json)) + + fun lookup_mandatory_string json kk = + case lookup_optional json kk of + SOME (Json.STRING s) => s + | _ => raise Fail ("Value must be string: " ^ + (String.concatWith " -> " kk)) +end + +structure Provider :> sig + val load_providers : Json.json -> provider list + val load_more_providers : provider list -> Json.json -> provider list + val remote_url : context -> vcs -> source -> libname -> string +end = struct + + val known_providers : provider list = + [ { + service = "bitbucket", + supports = [HG, GIT], + remote_spec = { + anon = SOME "https://bitbucket.org/{owner}/{repo}", + auth = SOME "ssh://{vcs}@bitbucket.org/{owner}/{repo}" + } + }, + { + service = "github", + supports = [GIT], + remote_spec = { + anon = SOME "https://github.com/{owner}/{repo}", + auth = SOME "ssh://{vcs}@github.com/{owner}/{repo}" + } + } + ] + + fun vcs_name vcs = + case vcs of GIT => "git" | + HG => "hg" + + fun vcs_from_name name = + case name of "git" => GIT + | "hg" => HG + | other => raise Fail ("Unknown vcs name \"" ^ name ^ "\"") + + fun load_more_providers previously_loaded json = + let open JsonBits + fun load pjson pname : provider = + { + service = pname, + supports = + case lookup_mandatory pjson ["vcs"] of + Json.ARRAY vv => + map (fn (Json.STRING v) => vcs_from_name v + | _ => raise Fail "Strings expected in vcs array") + vv + | _ => raise Fail "Array expected for vcs", + remote_spec = { + anon = lookup_optional_string pjson ["anon"], + auth = lookup_optional_string pjson ["auth"] + } + } + val loaded = + case lookup_optional json ["providers"] of + NONE => [] + | SOME (Json.OBJECT pl) => map (fn (k, v) => load v k) pl + | _ => raise Fail "Object expected for providers in config" + val newly_loaded = + List.filter (fn p => not (List.exists (fn pp => #service p = + #service pp) + previously_loaded)) + loaded + in + previously_loaded @ newly_loaded + end + + fun load_providers json = + load_more_providers known_providers json + + fun expand_spec spec { vcs, service, owner, repo } login = + (* ugly *) + let fun replace str = + case str of + "vcs" => vcs_name vcs + | "service" => service + | "owner" => + (case owner of + SOME ostr => ostr + | NONE => raise Fail ("Owner not specified for service " ^ + service)) + | "repo" => repo + | "account" => + (case login of + SOME acc => acc + | NONE => raise Fail ("Account not given for service " ^ + service)) + | other => raise Fail ("Unknown variable \"" ^ other ^ + "\" in spec for service " ^ service) + fun expand' acc sstr = + case Substring.splitl (fn c => c <> #"{") sstr of + (pfx, sfx) => + if Substring.isEmpty sfx + then rev (pfx :: acc) + else + case Substring.splitl (fn c => c <> #"}") sfx of + (tok, remainder) => + if Substring.isEmpty remainder + then rev (tok :: pfx :: acc) + else let val replacement = + replace + (* tok begins with "{": *) + (Substring.string + (Substring.triml 1 tok)) + in + expand' (Substring.full replacement :: + pfx :: acc) + (* remainder begins with "}": *) + (Substring.triml 1 remainder) + end + in + Substring.concat (expand' [] (Substring.full spec)) + end + + fun provider_url req login providers = + case providers of + [] => raise Fail ("Unknown service \"" ^ (#service req) ^ + "\" for vcs \"" ^ (vcs_name (#vcs req)) ^ "\"") + | ({ service, supports, remote_spec : remote_spec } :: rest) => + if service <> (#service req) orelse + not (List.exists (fn v => v = (#vcs req)) supports) + then provider_url req login rest + else + case (login, #auth remote_spec, #anon remote_spec) of + (SOME _, SOME auth, _) => expand_spec auth req login + | (SOME _, _, SOME anon) => expand_spec anon req NONE + | (NONE, _, SOME anon) => expand_spec anon req NONE + | _ => raise Fail ("No suitable anon/auth URL spec " ^ + "provided for service \"" ^ service ^ "\"") + + fun login_for ({ accounts, ... } : context) service = + case List.find (fn a => service = #service a) accounts of + SOME { login, ... } => SOME login + | NONE => NONE + + fun remote_url (context : context) vcs source libname = + case source of + URL u => u + | PROVIDER { service, owner, repo } => + provider_url { vcs = vcs, + service = service, + owner = owner, + repo = case repo of + SOME r => r + | NONE => libname } + (login_for context service) + (#providers context) +end + +structure HgControl :> VCS_CONTROL = struct + + type vcsstate = { id: string, modified: bool, + branch: string, tags: string list } + + val hg_args = [ "--config", "ui.interactive=true" ] + + fun hg_command context libname args = + FileBits.command context libname ("hg" :: hg_args @ args) + + fun hg_command_output context libname args = + FileBits.command_output context libname ("hg" :: hg_args @ args) + + fun exists context libname = + OK (OS.FileSys.isDir (FileBits.subpath context libname ".hg")) + handle _ => OK false + + fun remote_for context (libname, source) = + Provider.remote_url context HG source libname + + fun current_state context libname : vcsstate result = + let fun is_branch text = text <> "" andalso #"(" = hd (explode text) + and extract_branch b = + if is_branch b (* need to remove enclosing parens *) + then (implode o rev o tl o rev o tl o explode) b + else "default" + and is_modified id = id <> "" andalso #"+" = hd (rev (explode id)) + and extract_id id = + if is_modified id (* need to remove trailing "+" *) + then (implode o rev o tl o rev o explode) id + else id + and split_tags tags = String.tokens (fn c => c = #"/") tags + and state_for (id, branch, tags) = + OK { id = extract_id id, + modified = is_modified id, + branch = extract_branch branch, + tags = split_tags tags } + in + case hg_command_output context libname ["id"] of + ERROR e => ERROR e + | OK out => + case String.tokens (fn x => x = #" ") out of + [id, branch, tags] => state_for (id, branch, tags) + | [id, other] => if is_branch other + then state_for (id, other, "") + else state_for (id, "", other) + | [id] => state_for (id, "", "") + | _ => ERROR ("Unexpected output from hg id: " ^ out) + end + + fun branch_name branch = case branch of + DEFAULT_BRANCH => "default" + | BRANCH "" => "default" + | BRANCH b => b + + fun id_of context libname = + case current_state context libname of + ERROR e => ERROR e + | OK { id, ... } => OK id + + fun is_at context (libname, id_or_tag) = + case current_state context libname of + ERROR e => ERROR e + | OK { id, tags, ... } => + OK (String.isPrefix id_or_tag id orelse + String.isPrefix id id_or_tag orelse + List.exists (fn t => t = id_or_tag) tags) + + fun is_on_branch context (libname, b) = + case current_state context libname of + ERROR e => ERROR e + | OK { branch, ... } => OK (branch = branch_name b) + + fun is_newest_locally context (libname, branch) = + case hg_command_output context libname + ["log", "-l1", + "-b", branch_name branch, + "--template", "{node}"] of + ERROR e => ERROR e + | OK newest_in_repo => is_at context (libname, newest_in_repo) + + fun pull context libname = + hg_command context libname + (if FileBits.verbose () + then ["pull"] + else ["pull", "-q"]) + + fun is_newest context (libname, branch) = + case is_newest_locally context (libname, branch) of + ERROR e => ERROR e + | OK false => OK false + | OK true => + case pull context libname of + ERROR e => ERROR e + | _ => is_newest_locally context (libname, branch) + + fun is_modified_locally context libname = + case current_state context libname of + ERROR e => ERROR e + | OK { modified, ... } => OK modified + + fun checkout context (libname, source, branch) = + let val url = remote_for context (libname, source) + in + case FileBits.mkpath (FileBits.extpath context) of + ERROR e => ERROR e + | _ => hg_command context "" + ["clone", "-u", branch_name branch, + url, libname] + end + + fun update context (libname, branch) = + let val pull_result = pull context libname + in + case hg_command context libname ["update", branch_name branch] of + ERROR e => ERROR e + | _ => + case pull_result of + ERROR e => ERROR e + | _ => id_of context libname + end + + fun update_to context (libname, "") = + ERROR "Non-empty id (tag or revision id) required for update_to" + | update_to context (libname, id) = + case hg_command context libname ["update", "-r" ^ id] of + OK () => id_of context libname + | ERROR _ => + case pull context libname of + ERROR e => ERROR e + | _ => + case hg_command context libname ["update", "-r" ^ id] of + ERROR e => ERROR e + | _ => id_of context libname + +end + +structure GitControl :> VCS_CONTROL = struct + + (* With Git repos we always operate in detached HEAD state. Even + the master branch is checked out using the remote reference, + origin/master. *) + + fun git_command context libname args = + FileBits.command context libname ("git" :: args) + + fun git_command_output context libname args = + FileBits.command_output context libname ("git" :: args) + + fun exists context libname = + OK (OS.FileSys.isDir (FileBits.subpath context libname ".git")) + handle _ => OK false + + fun remote_for context (libname, source) = + Provider.remote_url context GIT source libname + + fun branch_name branch = case branch of + DEFAULT_BRANCH => "master" + | BRANCH "" => "master" + | BRANCH b => b + + fun remote_branch_name branch = "origin/" ^ branch_name branch + + fun checkout context (libname, source, branch) = + let val url = remote_for context (libname, source) + in + case FileBits.mkpath (FileBits.extpath context) of + OK () => git_command context "" + ["clone", "-b", + branch_name branch, + url, libname] + | ERROR e => ERROR e + end + + (* NB git rev-parse HEAD shows revision id of current checkout; + git rev-list -1 <tag> shows revision id of revision with that tag *) + + fun id_of context libname = + git_command_output context libname ["rev-parse", "HEAD"] + + fun is_at context (libname, id_or_tag) = + case id_of context libname of + ERROR e => ERROR e + | OK id => + if String.isPrefix id_or_tag id orelse + String.isPrefix id id_or_tag + then OK true + else + case git_command_output context libname + ["rev-list", "-1", id_or_tag] of + ERROR e => ERROR e + | OK tid => + OK (tid = id andalso + tid <> id_or_tag) (* else id_or_tag was id not tag *) + + fun branch_tip context (libname, branch) = + git_command_output context libname + ["rev-list", "-1", + remote_branch_name branch] + + fun is_newest_locally context (libname, branch) = + case branch_tip context (libname, branch) of + ERROR e => ERROR e + | OK rev => is_at context (libname, rev) + + fun is_on_branch context (libname, branch) = + case branch_tip context (libname, branch) of + ERROR e => ERROR e + | OK rev => + case is_at context (libname, rev) of + ERROR e => ERROR e + | OK true => OK true + | OK false => + case git_command context libname + ["merge-base", "--is-ancestor", + "HEAD", remote_branch_name branch] of + ERROR e => OK false (* cmd returns non-zero for no *) + | _ => OK true + + fun is_newest context (libname, branch) = + case is_newest_locally context (libname, branch) of + ERROR e => ERROR e + | OK false => OK false + | OK true => + case git_command context libname ["fetch"] of + ERROR e => ERROR e + | _ => is_newest_locally context (libname, branch) + + fun is_modified_locally context libname = + case git_command_output context libname ["status", "--porcelain"] of + ERROR e => ERROR e + | OK "" => OK false + | OK _ => OK true + + (* This function updates to the latest revision on a branch rather + than to a specific id or tag. We can't just checkout the given + branch, as that will succeed even if the branch isn't up to + date. We could checkout the branch and then fetch and merge, + but it's perhaps cleaner not to maintain a local branch at all, + but instead checkout the remote branch as a detached head. *) + + fun update context (libname, branch) = + case git_command context libname ["fetch"] of + ERROR e => ERROR e + | _ => + case git_command context libname ["checkout", "--detach", + remote_branch_name branch] of + ERROR e => ERROR e + | _ => id_of context libname + + (* This function is dealing with a specific id or tag, so if we + can successfully check it out (detached) then that's all we need + to do. Otherwise we need to fetch and try again *) + + fun update_to context (libname, "") = + ERROR "Non-empty id (tag or revision id) required for update_to" + | update_to context (libname, id) = + case git_command context libname ["checkout", "--detach", id] of + OK () => id_of context libname + | ERROR _ => + case git_command context libname ["fetch"] of + ERROR e => ERROR e + | _ => + case git_command context libname ["checkout", "--detach", id] of + ERROR e => ERROR e + | _ => id_of context libname +end + +structure AnyLibControl :> LIB_CONTROL = struct + + structure H = LibControlFn(HgControl) + structure G = LibControlFn(GitControl) + + fun review context (spec as { vcs, ... } : libspec) = + (fn HG => H.review | GIT => G.review) vcs context spec + + fun status context (spec as { vcs, ... } : libspec) = + (fn HG => H.status | GIT => G.status) vcs context spec + + fun update context (spec as { vcs, ... } : libspec) = + (fn HG => H.update | GIT => G.update) vcs context spec +end + +fun load_libspec spec_json lock_json libname : libspec = + let open JsonBits + val libobj = lookup_mandatory spec_json ["libs", libname] + val vcs = lookup_mandatory_string libobj ["vcs"] + val retrieve = lookup_optional_string libobj + val service = retrieve ["service"] + val owner = retrieve ["owner"] + val repo = retrieve ["repository"] + val url = retrieve ["url"] + val branch = retrieve ["branch"] + val user_pin = retrieve ["pin"] + val lock_pin = case lookup_optional lock_json ["libs", libname] of + SOME ll => lookup_optional_string ll ["pin"] + | NONE => NONE + in + { + libname = libname, + vcs = case vcs of + "hg" => HG + | "git" => GIT + | other => raise Fail ("Unknown version-control system \"" ^ + other ^ "\""), + source = case (url, service, owner, repo) of + (SOME u, NONE, _, _) => URL u + | (NONE, SOME ss, owner, repo) => + PROVIDER { service = ss, owner = owner, repo = repo } + | _ => raise Fail ("Must have exactly one of service " ^ + "or url string"), + pin = case lock_pin of + SOME p => PINNED p + | NONE => + case user_pin of + SOME p => PINNED p + | NONE => UNPINNED, + branch = case branch of + SOME b => BRANCH b + | NONE => DEFAULT_BRANCH + } + end + +fun load_userconfig () : userconfig = + let val home = FileBits.homedir () + val conf_json = + JsonBits.load_json_from + (OS.Path.joinDirFile { + dir = home, + file = VextFilenames.user_config_file }) + handle IO.Io _ => Json.OBJECT [] + in + { + accounts = case JsonBits.lookup_optional conf_json ["accounts"] of + NONE => [] + | SOME (Json.OBJECT aa) => + map (fn (k, (Json.STRING v)) => + { service = k, login = v } + | _ => raise Fail + "String expected for account name") + aa + | _ => raise Fail "Array expected for accounts", + providers = Provider.load_providers conf_json + } + end + +fun load_project (userconfig : userconfig) rootpath use_locks : project = + let val spec_file = FileBits.project_spec_path rootpath + val lock_file = FileBits.project_lock_path rootpath + val _ = if OS.FileSys.access (spec_file, [OS.FileSys.A_READ]) + handle OS.SysErr _ => false + then () + else raise Fail ("Failed to open project spec file " ^ + (VextFilenames.project_file) ^ " in " ^ + rootpath ^ + ".\nPlease ensure the spec file is in the " ^ + "project root and run this from there.") + val spec_json = JsonBits.load_json_from spec_file + val lock_json = if use_locks + then JsonBits.load_json_from lock_file + handle IO.Io _ => Json.OBJECT [] + else Json.OBJECT [] + val extdir = JsonBits.lookup_mandatory_string spec_json + ["config", "extdir"] + val spec_libs = JsonBits.lookup_optional spec_json ["libs"] + val lock_libs = JsonBits.lookup_optional lock_json ["libs"] + val providers = Provider.load_more_providers + (#providers userconfig) spec_json + val libnames = case spec_libs of + NONE => [] + | SOME (Json.OBJECT ll) => map (fn (k, v) => k) ll + | _ => raise Fail "Object expected for libs" + in + { + context = { + rootpath = rootpath, + extdir = extdir, + providers = providers, + accounts = #accounts userconfig + }, + libs = map (load_libspec spec_json lock_json) libnames + } + end + +fun save_lock_file rootpath locks = + let val lock_file = FileBits.project_lock_path rootpath + open Json + val lock_json = + OBJECT [ + ("libs", OBJECT + (map (fn { libname, id_or_tag } => + (libname, + OBJECT [ ("pin", STRING id_or_tag) ])) + locks)) + ] + in + JsonBits.save_json_to lock_file lock_json + end + +fun pad_to n str = + if n <= String.size str then str + else pad_to n (str ^ " ") + +fun hline_to 0 = "" + | hline_to n = "-" ^ hline_to (n-1) + +val libname_width = 25 +val libstate_width = 11 +val localstate_width = 9 +val notes_width = 5 +val divider = " | " + +fun print_status_header () = + print ("\r" ^ pad_to 80 "" ^ "\n " ^ + pad_to libname_width "Library" ^ divider ^ + pad_to libstate_width "State" ^ divider ^ + pad_to localstate_width "Local" ^ divider ^ + "Notes" ^ "\n " ^ + hline_to libname_width ^ "-+-" ^ + hline_to libstate_width ^ "-+-" ^ + hline_to localstate_width ^ "-+-" ^ + hline_to notes_width ^ "\n") + +fun print_outcome_header () = + print ("\r" ^ pad_to 80 "" ^ "\n " ^ + pad_to libname_width "Library" ^ divider ^ + pad_to libstate_width "Outcome" ^ divider ^ + "Notes" ^ "\n " ^ + hline_to libname_width ^ "-+-" ^ + hline_to libstate_width ^ "-+-" ^ + hline_to notes_width ^ "\n") + +fun print_status with_network (libname, status) = + let val libstate_str = + case status of + OK (ABSENT, _) => "Absent" + | OK (CORRECT, _) => if with_network then "Correct" else "Present" + | OK (SUPERSEDED, _) => "Superseded" + | OK (WRONG, _) => "Wrong" + | ERROR _ => "Error" + val localstate_str = + case status of + OK (_, MODIFIED) => "Modified" + | OK (_, UNMODIFIED) => "Clean" + | _ => "" + val error_str = + case status of + ERROR e => e + | _ => "" + in + print (" " ^ + pad_to libname_width libname ^ divider ^ + pad_to libstate_width libstate_str ^ divider ^ + pad_to localstate_width localstate_str ^ divider ^ + error_str ^ "\n") + end + +fun print_update_outcome (libname, outcome) = + let val outcome_str = + case outcome of + OK id => "Ok" + | ERROR e => "Failed" + val error_str = + case outcome of + ERROR e => e + | _ => "" + in + print (" " ^ + pad_to libname_width libname ^ divider ^ + pad_to libstate_width outcome_str ^ divider ^ + error_str ^ "\n") + end + +fun act_and_print action print_header print_line (libs : libspec list) = + let val lines = map (fn lib => (#libname lib, action lib)) libs + val _ = print_header () + in + app print_line lines; + lines + end + +fun return_code_for outcomes = + foldl (fn ((_, result), acc) => + case result of + ERROR _ => OS.Process.failure + | _ => acc) + OS.Process.success + outcomes + +fun status_of_project ({ context, libs } : project) = + return_code_for (act_and_print (AnyLibControl.status context) + print_status_header (print_status false) + libs) + +fun review_project ({ context, libs } : project) = + return_code_for (act_and_print (AnyLibControl.review context) + print_status_header (print_status true) + libs) + +fun update_project ({ context, libs } : project) = + let val outcomes = act_and_print + (AnyLibControl.update context) + print_outcome_header print_update_outcome libs + val locks = + List.concat + (map (fn (libname, result) => + case result of + ERROR _ => [] + | OK id => [{ libname = libname, id_or_tag = id }]) + outcomes) + val return_code = return_code_for outcomes + in + if OS.Process.isSuccess return_code + then save_lock_file (#rootpath context) locks + else (); + return_code + end + +fun load_local_project use_locks = + let val userconfig = load_userconfig () + val rootpath = OS.FileSys.getDir () + in + load_project userconfig rootpath use_locks + end + +fun with_local_project use_locks f = + let val return_code = f (load_local_project use_locks) + handle e => + (print ("Failed with exception: " ^ + (exnMessage e) ^ "\n"); + OS.Process.failure) + val _ = print "\n"; + in + return_code + end + +fun review () = with_local_project false review_project +fun status () = with_local_project false status_of_project +fun update () = with_local_project false update_project +fun install () = with_local_project true update_project + +fun version () = + (print ("v" ^ vext_version ^ "\n"); + OS.Process.success) + +fun usage () = + (print "\nVext "; + version (); + print ("\nA simple manager for third-party source code dependencies.\n\n" + ^ "Usage:\n\n" + ^ " vext <command>\n\n" + ^ "where <command> is one of:\n\n" + ^ " review check configured libraries against their providers, and report\n" + ^ " status print quick report on local status only, without using network\n" + ^ " install update configured libraries according to project specs and lock file\n" + ^ " update update configured libraries and lock file according to project specs\n" + ^ " version print the Vext version number and exit\n\n"); + OS.Process.failure) + +fun vext args = + let val return_code = + case args of + ["review"] => review () + | ["status"] => status () + | ["install"] => install () + | ["update"] => update () + | ["version"] => version () + | _ => usage () + in + OS.Process.exit return_code; + () + end + +fun main () = + vext (CommandLine.arguments ())