sproutit-narwhal 0.1.106

data/lib/narwhal/tusk.js

@@ -0,0 +1,170 @@
+
+var system = require("system");
+var fs = require("file");
+var packages = require("packages");
+var util = require("util");
+var json = require("json");
+var http = require("http");
+
+var minCatalogVersion = 1;
+
+var args = require("args");
+var parser = exports.parser = new args.Parser();
+
+parser.help('A Narwhal project package manager.');
+
+// parser.option('sources', exports.sources);
+
+parser.command('list', module.id + '/list')
+
+parser.command('install', module.id + '/install');
+
+parser.command('upgrade', null)
+    .help('downloads the latest version of a package');
+
+parser.command('remove', null)
+    .help('removes the local copy of package');
+
+parser.command('update', module.id + '/update');
+
+parser.command('search', module.id + '/search');
+
+parser.command('init', module.id + '/init');
+
+parser.command('engine', module.id + '/engine');
+
+parser.command('freeze', null)
+    .help('writes a freeze.json file');
+
+parser.command('bundle', null)
+    .help('creates an archive of your project and its package dependencies');
+
+parser.command('reheat', module.id + '/reheat');
+
+parser.command('clone', module.id + '/clone');
+
+parser.command('catalog', module.id + '/catalog');
+
+parser.command('create-catalog', module.id + '/create-catalog');
+
+parser.command('orphans', null)
+    .help('lists packages that are no longer wanted by the user or other packages.')
+
+parser.command('consolidate', module.id + '/consolidate');
+
+parser.helpful();
+
+// utilities
+//
+
+exports.getDirectory = function () {
+    return fs.path(system.prefixes[0]);
+};
+
+exports.getPackagesDirectory = function () {
+    return exports.getDirectory().join('packages');
+};
+
+exports.getTuskDirectory = function () {
+    var tuskDirectory = exports.getDirectory().join('.tusk');
+    tuskDirectory.mkdirs();
+    return tuskDirectory;
+}
+
+exports.getZipsDirectory = function () {
+    return exports.getDirectory().join('zips');
+};
+
+exports.getCatalogPath = function () {
+    return exports.getTuskDirectory().join('catalog.json');
+};
+
+exports.readCatalog = function () {
+    var catalogPath = exports.getCatalogPath();
+    if (!catalogPath.exists())
+        throw new Error(catalogPath + " does not exist.");
+    if (!catalogPath.isFile())
+        throw new Error(catalogPath + " is not a file.");
+    var catalog = json.decode(catalogPath.read({charset: 'utf-8'}));
+    if (catalog.version === undefined || +catalog.version < minCatalogVersion)
+        throw new Error("catalog is out of date.  use tusk update or create-catalog");
+    packages.normalize(catalog.packages);
+    return catalog;
+};
+
+exports.writeCatalog = function (catalog) {
+    var catalogPath = exports.getCatalogPath();
+    print('Writing ' + catalogPath);
+    return catalogPath.write(
+        json.encode(catalog, null, 4),
+        {charset: 'utf-8'}
+    );
+};
+
+exports.update = function (options) {
+    require('./tusk/update').update.call(this, options);
+};
+
+exports.getSourcesPath = function () {
+    var try1 = exports.getTuskDirectory().join('sources.json');
+    var try2 = exports.getDirectory().join('sources.json');
+    if (try1.isFile())
+        return try1;
+    if (try2.isFile())
+        return try2;
+};
+
+exports.readSources = function () {
+    var sources = json.decode(exports.getSourcesPath().read(
+        {charset: 'utf-8'}
+    ));
+    if (
+        sources.version === undefined ||
+        +sources.version < minCatalogVersion
+    )
+        throw new Error(
+            "sources file is out of date.  version " +
+            minCatalogVersion + " is required."
+        );
+    sources.packages = sources.packages || {};
+    return sources;
+};
+
+exports.writeSources = function (sources) {
+    return exports.getSourcesPath().write(
+        json.encode(sources, null, 4),
+        {charset: 'utf-8'}
+    );
+};
+
+exports.getNotesPath = function () {
+    return exports.getTuskDirectory().join('notes.json');
+};
+
+exports.readNotes = function () {
+    var notesPath = exports.getNotesPath();
+    if (!notesPath.isFile())
+        return {};
+    return json.decode(notesPath.read(
+        {charset: 'utf-8'}
+    ));
+};
+
+exports.writeNotes = function (notes) {
+    return exports.getNotesPath().write(
+        json.encode(notes, null, 4),
+        {charset: 'utf-8'}
+    );
+};
+
+// run it
+
+exports.main = function (args) {
+    var options = parser.parse(args);
+    if (!options.acted)
+        parser.printHelp(options);
+};
+
+if (module.id == require.main)
+    exports.main(system.args);
+

data/lib/narwhal/tusk/bin.js

@@ -0,0 +1,13 @@
+
+var util = require('util');
+var tusk = require('../tusk');
+var args = require('args');
+
+var parser = exports.parser = new args.Parser();
+
+parser.help('lists all packaged executables');
+
+parser.action(function (options) {
+});
+
+

data/lib/narwhal/tusk/catalog.js

@@ -0,0 +1,22 @@
+
+var tusk = require("../tusk");
+var util = require("util");
+var args = require("args");
+
+var parser = exports.parser = new args.Parser();
+
+parser.help('lists all packages in the catalog');
+
+parser.action(function (options) {
+    var self = this;
+    if (!tusk.getCatalogPath().isFile())
+        require('./update').update.call(this, options);
+    util.forEachApply(tusk.readCatalog().packages, function (name, info) {
+        name = info.name || name;
+        self.print(
+            "\0green(" + name + "\0)" + 
+            (info.description ? ": " + info.description : "")
+        );
+    });
+});
+

data/lib/narwhal/tusk/clone.js

@@ -0,0 +1,66 @@
+
+var tusk = require("../tusk");
+var os = require("os");
+var util = require("util");
+var args = require("args");
+
+var parser = exports.parser = new args.Parser();
+
+parser.help('clones a package from its version control system.')
+
+parser.args('package');
+
+parser.option('-o', '--owner', 'owner')
+    .help("clone from the owner's repository")
+    .bool()
+    .inverse();
+
+parser.option('-u', '--user', 'user')
+    .help('overrides the user name from which to clone the package')
+    .set();
+
+parser.action(function (options) {
+    var self = this;
+    if (!util.len(options.args))
+        throw new Error("Package name required");
+    var packagesDirectory = tusk.getPackagesDirectory();
+    var sources = tusk.readSources().packages;
+    var catalog = tusk.readCatalog().packages;
+    var owner = options.owner;
+    options.args.forEach(function (name) {
+        if (!util.has(sources, name))
+            throw new Error("Package does not exist: " + name);
+        var source = util.get(sources, name);
+        if (source.type !== "github")
+            throw new Error("Package " + util.enquote(name) + " is not a Github package.");
+    });
+    options.args.forEach(function (name) {
+        var source = util.get(sources, name);
+        var githubName = util.get(source, 'name', name);
+        var user = options.user || source.user;
+        var command = [
+            'git',
+            'clone',
+            owner ?
+            (
+                'git@github.com:' + user +
+                '/' + githubName + '.git'
+            ):
+            (
+                'git://github.com/' +
+                user + '/' + githubName + '.git'
+            ),
+            packagesDirectory.join(name)
+        ];
+        self.print('\0cyan(' + command.map(function (term) {
+            var enquoted = os.enquote(term);
+            if (enquoted != "'" + term + "'")
+                return enquoted;
+            return term;
+        }).join(' ') + '\0)');
+        os.system(command);
+    });
+});
+
+parser.helpful();
+

data/lib/narwhal/tusk/consolidate.js

@@ -0,0 +1,25 @@
+
+var tusk = require("../tusk");
+var util = require("util");
+var args = require("args");
+var fs = require("file");
+var packages = require("packages");
+
+var parser = exports.parser = new args.Parser();
+
+parser.help('consolidates all installed packages into the current sea.');
+
+parser.action(function (options) {
+    var self = this;
+    var packagesDirectory = tusk.getPackagesDirectory();
+    util.forEachApply(util.items(packages.catalog), function (name, info) {
+        var target = packagesDirectory.join(name);
+        if (!target.exists()) {
+            fs.symlink(info.directory, target);
+            self.print(target + ' -> ' + info.directory);
+        }
+    });
+});
+
+parser.helpful();
+

data/lib/narwhal/tusk/create-catalog.js

@@ -0,0 +1,80 @@
+
+var tusk = require("../tusk");
+var util = require("util");
+var args = require("args");
+var http = require("http");
+var json = require("json");
+
+var parser = exports.parser = new args.Parser();
+
+parser.help('creates a catalog of packages from sources.json');
+
+parser.action(function (options) {
+    var self = this;
+    var sources = tusk.readSources();
+    var catalog = {};
+    catalog['!'] = "This file is generated by 'tusk create-catalog', copied from '.tusk', and committed only so that it may be downloaded from Github with 'tusk update'.";
+    catalog.version = util.copy(sources.version);
+    var packages = catalog.packages = {};
+    util.forEachApply(
+        util.items(sources.packages || {}),
+        function (name, source) {
+            var info;
+
+            if (source['package.json'])
+                info = util.copy(source['package.json']);
+
+            if (source.type == "inline") {
+                if (!info) {
+                    self.print(
+                        "\0red(dropped:\0) " + name + 
+                        " \0blue(because it did not provide a " +
+                        "package.json inline.\0)"
+                    );
+                    return;
+                }
+
+            } else if (source.type == "github") {
+
+                var githubName = source.name || name,
+                    githubRef = source.ref || "master";
+                if (!source.user)
+                    throw new Error("package source " + util.enquote(name) + " did not have a github user name");
+                var project = source.user + '/' + githubName;
+                var url = "http://github.com/" + project + "/raw/" + githubRef + "/package.json";
+
+                // download package.json if not already provided
+                if (!info) {
+                    try {
+                        var text = http.read(url).toString('utf-8');
+                    } catch (exception) {
+                        self.print("\0red(dropped:\0) " + name + " \0blue(because of an HTTP error\0)");
+                        return;
+                    }
+                    try {
+                        info = json.decode(text);
+                    } catch (exception) {
+                        self.print("\0red(dropped:\0) " + name + " \0blue(because of a JSON error\0)");
+                        return;
+                    }
+                }
+
+                info.githubName = githubName;
+                info.type = "zip";
+                info.location = 'http://github.com/' + source.user + '/' + githubName + '/zipball/' + githubRef;
+
+            } else {
+                throw new Error(
+                    "Project " + util.enquote(name) +
+                    " has an urecognized type: " +
+                    util.enquote(source.type)
+                );
+            }
+
+            self.print('\0green(' + name + '\0)');
+            packages[name] = info;
+        }
+    );
+    tusk.writeCatalog(catalog);
+});
+

data/lib/narwhal/tusk/engine.js

@@ -0,0 +1,42 @@
+
+var system = require('system');
+var os = require('os');
+var fs = require('file');
+var util = require('util');
+var tusk = require('../tusk');
+var args = require('args');
+
+var parser = exports.parser = new args.Parser();
+
+parser.help('selects a engine for the current "sea"');
+
+parser.arg('engine').optional();
+
+parser.action(function (options) {
+    var packages = require("packages");
+    
+    var self = this;
+    var directory = tusk.getDirectory();
+    var enginesDirectory = directory.join('engines');
+    if (options.args.length == 0) {
+        enginesDirectory.list().forEach(function (engineName) {
+            self.print(engineName);
+        });
+    } else {
+        var engine = options.args.shift();
+        if (!util.has(packages.engines, engine))
+            throw new Error("No such engine " + util.enquote(engine));
+        var narwhalConf = directory.join('narwhal.conf');
+        narwhalConf.write(
+            'NARWHAL_ENGINE=' +
+            os.enquote(engine) + "\n" + 
+            'NARWHAL_ENGINE_HOME=' +
+            os.enquote(
+                packages.engines[engine].directory.from(
+                    fs.path(system.prefix).join('')
+                )
+            ) + "\n"
+        );
+    }
+});
+

data/lib/narwhal/tusk/init.js

@@ -0,0 +1,56 @@
+
+var system = require("system");
+var fs = require("file");
+var json = require("json");
+var util = require("util");
+var args = require("args");
+var parser = exports.parser = new args.Parser();
+
+parser.help('initializes a Narwhal package/project directory');
+
+parser.option('--name', 'name').def("").set();
+parser.option('--author', 'author').def("").set();
+parser.option('--dependency', 'dependencies').push();
+parser.option('--contributor', 'contributors').push();
+
+parser.action(function (options, parentOptions) {
+    parentOptions.acted = true;
+    var packageInfo = {};
+    var path;
+    if (options.args.length && !/^-/.test(options.args[0]))
+        path = options.args.shift();
+    else
+        path = fs.cwd();
+    util.update(packageInfo, options);
+    delete packageInfo.args;
+    delete packageInfo.command;
+    path = fs.path(path).absolute();
+    print(path);
+    path.join('.tusk').mkdirs();
+    path.join('bin').mkdirs();
+    path.join('lib').mkdirs();
+
+    var sea = path.join('bin', 'sea');
+    fs.path(system.prefix).join('bin', 'sea').copy(sea);
+    sea.chmod(0755);
+
+    var activate = path.join('bin', 'activate.bash');
+    fs.path(system.prefix).join('bin', 'activate.bash')
+        .copy(activate);
+    activate.relative().symlink(activate.resolve('activate'));
+
+    path.join('README').touch();
+    path.join('narwhal.conf')
+        .write('NARWHAL_DEFAULT_ENGINE=' + system.engine);
+    var packagePath = path.join('package.json');
+    if (packagePath.isFile())
+        util.complete(
+            packageInfo, 
+            json.decode(packagePath.read({charset:'utf-8'}))
+        );
+    packagePath.write(
+        json.encode(packageInfo, null, 4),
+        {charset:'utf-8'}
+    );
+});
+