@makano/rew 1.0.1

package/bin/rew

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const path = require('path');
+const fs = require('fs');
+const rew_mod = path.resolve(process.cwd(), 'node_modules/rew');
+if(fs.existsSync(rew_mod)){
+  require(rew_mod(path.join(rew_mod, 'lib/rew/cli.js')));
+} else {
+  require('../lib/rew/cli/cli.js');
+}

package/lib/coffeescript/browser.js

@@ -0,0 +1,151 @@
+// Generated by CoffeeScript 2.7.0
+(function() {
+  // This **Browser** compatibility layer extends core CoffeeScript functions
+  // to make things work smoothly when compiling code directly in the browser.
+  // We add support for loading remote Coffee scripts via **XHR**, and
+  // `text/coffeescript` script tags, source maps via data-URLs, and so on.
+  var CoffeeScript, compile,
+    indexOf = [].indexOf;
+
+  CoffeeScript = require('./coffeescript');
+
+  ({compile} = CoffeeScript);
+
+  // Use `window.eval` to evaluate code, rather than just `eval`, to run the
+  // script in a clean global scope rather than inheriting the scope of the
+  // CoffeeScript compiler. (So that `cake test:browser` also works in Node,
+  // use either `window.eval` or `global.eval` as appropriate).
+  CoffeeScript.eval = function(code, options = {}) {
+    var globalRoot;
+    if (options.bare == null) {
+      options.bare = true;
+    }
+    globalRoot = typeof window !== "undefined" && window !== null ? window : global;
+    return globalRoot['eval'](compile(code, options));
+  };
+
+  // Running code does not provide access to this scope.
+  CoffeeScript.run = function(code, options = {}) {
+    options.bare = true;
+    options.shiftLine = true;
+    return Function(compile(code, options))();
+  };
+
+  // Export this more limited `CoffeeScript` than what is exported by
+  // `index.coffee`, which is intended for a Node environment.
+  module.exports = CoffeeScript;
+
+  // If we’re not in a browser environment, we’re finished with the public API.
+  if (typeof window === "undefined" || window === null) {
+    return;
+  }
+
+  // Include source maps where possible. If we’ve got a base64 encoder, a
+  // JSON serializer, and tools for escaping unicode characters, we’re good to go.
+  // Ported from https://developer.mozilla.org/en-US/docs/DOM/window.btoa
+  if ((typeof btoa !== "undefined" && btoa !== null) && (typeof JSON !== "undefined" && JSON !== null)) {
+    compile = function(code, options = {}) {
+      options.inlineMap = true;
+      return CoffeeScript.compile(code, options);
+    };
+  }
+
+  // Load a remote script from the current domain via XHR.
+  CoffeeScript.load = function(url, callback, options = {}, hold = false) {
+    var xhr;
+    options.sourceFiles = [url];
+    xhr = window.ActiveXObject ? new window.ActiveXObject('Microsoft.XMLHTTP') : new window.XMLHttpRequest();
+    xhr.open('GET', url, true);
+    if ('overrideMimeType' in xhr) {
+      xhr.overrideMimeType('text/plain');
+    }
+    xhr.onreadystatechange = function() {
+      var param, ref;
+      if (xhr.readyState === 4) {
+        if ((ref = xhr.status) === 0 || ref === 200) {
+          param = [xhr.responseText, options];
+          if (!hold) {
+            CoffeeScript.run(...param);
+          }
+        } else {
+          throw new Error(`Could not load ${url}`);
+        }
+        if (callback) {
+          return callback(param);
+        }
+      }
+    };
+    return xhr.send(null);
+  };
+
+  // Activate CoffeeScript in the browser by having it compile and evaluate
+  // all script tags with a content-type of `text/coffeescript`.
+  // This happens on page load.
+  CoffeeScript.runScripts = function() {
+    var coffees, coffeetypes, execute, i, index, j, len, s, script, scripts;
+    scripts = window.document.getElementsByTagName('script');
+    coffeetypes = ['text/coffeescript', 'text/literate-coffeescript'];
+    coffees = (function() {
+      var j, len, ref, results;
+      results = [];
+      for (j = 0, len = scripts.length; j < len; j++) {
+        s = scripts[j];
+        if (ref = s.type, indexOf.call(coffeetypes, ref) >= 0) {
+          results.push(s);
+        }
+      }
+      return results;
+    })();
+    index = 0;
+    execute = function() {
+      var param;
+      param = coffees[index];
+      if (param instanceof Array) {
+        CoffeeScript.run(...param);
+        index++;
+        return execute();
+      }
+    };
+    for (i = j = 0, len = coffees.length; j < len; i = ++j) {
+      script = coffees[i];
+      (function(script, i) {
+        var options, source;
+        options = {
+          literate: script.type === coffeetypes[1]
+        };
+        source = script.src || script.getAttribute('data-src');
+        if (source) {
+          options.filename = source;
+          return CoffeeScript.load(source, function(param) {
+            coffees[i] = param;
+            return execute();
+          }, options, true);
+        } else {
+          // `options.filename` defines the filename the source map appears as
+          // in Developer Tools. If a script tag has an `id`, use that as the
+          // filename; otherwise use `coffeescript`, or `coffeescript1` etc.,
+          // leaving the first one unnumbered for the common case that there’s
+          // only one CoffeeScript script block to parse.
+          options.filename = script.id && script.id !== '' ? script.id : `coffeescript${i !== 0 ? i : ''}`;
+          options.sourceFiles = ['embedded'];
+          return coffees[i] = [script.innerHTML, options];
+        }
+      })(script, i);
+    }
+    return execute();
+  };
+
+  // Listen for window load, both in decent browsers and in IE.
+  // Only attach this event handler on startup for the
+  // non-ES module version of the browser compiler, to preserve
+  // backward compatibility while letting the ES module version
+  // be importable without side effects.
+  if (this === window) {
+    if (window.addEventListener) {
+      window.addEventListener('DOMContentLoaded', CoffeeScript.runScripts, false);
+    } else {
+      window.attachEvent('onload', CoffeeScript.runScripts);
+    }
+  }
+
+}).call(this);

package/lib/coffeescript/cake.js

@@ -0,0 +1,135 @@
+// Generated by CoffeeScript 2.7.0
+(function() {
+  // `cake` is a simplified version of [Make](http://www.gnu.org/software/make/)
+  // ([Rake](http://rake.rubyforge.org/), [Jake](https://github.com/280north/jake))
+  // for CoffeeScript. You define tasks with names and descriptions in a Cakefile,
+  // and can call them from the command line, or invoke them from other tasks.
+
+  // Running `cake` with no arguments will print out a list of all the tasks in the
+  // current directory's Cakefile.
+
+  // External dependencies.
+  var CoffeeScript, cakefileDirectory, fatalError, fs, helpers, missingTask, oparse, options, optparse, path, printTasks, switches, tasks;
+
+  fs = require('fs');
+
+  path = require('path');
+
+  helpers = require('./helpers');
+
+  optparse = require('./optparse');
+
+  CoffeeScript = require('./');
+
+  // Register .coffee extension
+  CoffeeScript.register();
+
+  // Keep track of the list of defined tasks, the accepted options, and so on.
+  tasks = {};
+
+  options = {};
+
+  switches = [];
+
+  oparse = null;
+
+  // Mixin the top-level Cake functions for Cakefiles to use directly.
+  helpers.extend(global, {
+    // Define a Cake task with a short name, an optional sentence description,
+    // and the function to run as the action itself.
+    task: function(name, description, action) {
+      if (!action) {
+        [action, description] = [description, action];
+      }
+      return tasks[name] = {name, description, action};
+    },
+    // Define an option that the Cakefile accepts. The parsed options hash,
+    // containing all of the command-line options passed, will be made available
+    // as the first argument to the action.
+    option: function(letter, flag, description) {
+      return switches.push([letter, flag, description]);
+    },
+    // Invoke another task in the current Cakefile.
+    invoke: function(name) {
+      if (!tasks[name]) {
+        missingTask(name);
+      }
+      return tasks[name].action(options);
+    }
+  });
+
+  // Run `cake`. Executes all of the tasks you pass, in order. Note that Node's
+  // asynchrony may cause tasks to execute in a different order than you'd expect.
+  // If no tasks are passed, print the help screen. Keep a reference to the
+  // original directory name, when running Cake tasks from subdirectories.
+  exports.run = function() {
+    var arg, args, e, i, len, ref, results;
+    global.__originalDirname = fs.realpathSync('.');
+    process.chdir(cakefileDirectory(__originalDirname));
+    args = process.argv.slice(2);
+    CoffeeScript.run(fs.readFileSync('Cakefile').toString(), {
+      filename: 'Cakefile'
+    });
+    oparse = new optparse.OptionParser(switches);
+    if (!args.length) {
+      return printTasks();
+    }
+    try {
+      options = oparse.parse(args);
+    } catch (error) {
+      e = error;
+      return fatalError(`${e}`);
+    }
+    ref = options.arguments;
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      arg = ref[i];
+      results.push(invoke(arg));
+    }
+    return results;
+  };
+
+  // Display the list of Cake tasks in a format similar to `rake -T`
+  printTasks = function() {
+    var cakefilePath, desc, name, relative, spaces, task;
+    relative = path.relative || path.resolve;
+    cakefilePath = path.join(relative(__originalDirname, process.cwd()), 'Cakefile');
+    console.log(`${cakefilePath} defines the following tasks:\n`);
+    for (name in tasks) {
+      task = tasks[name];
+      spaces = 20 - name.length;
+      spaces = spaces > 0 ? Array(spaces + 1).join(' ') : '';
+      desc = task.description ? `# ${task.description}` : '';
+      console.log(`cake ${name}${spaces} ${desc}`);
+    }
+    if (switches.length) {
+      return console.log(oparse.help());
+    }
+  };
+
+  // Print an error and exit when attempting to use an invalid task/option.
+  fatalError = function(message) {
+    console.error(message + '\n');
+    console.log('To see a list of all tasks/options, run "cake"');
+    return process.exit(1);
+  };
+
+  missingTask = function(task) {
+    return fatalError(`No such task: ${task}`);
+  };
+
+  // When `cake` is invoked, search in the current and all parent directories
+  // to find the relevant Cakefile.
+  cakefileDirectory = function(dir) {
+    var parent;
+    if (fs.existsSync(path.join(dir, 'Cakefile'))) {
+      return dir;
+    }
+    parent = path.normalize(path.join(dir, '..'));
+    if (parent !== dir) {
+      return cakefileDirectory(parent);
+    }
+    throw new Error(`Cakefile not found in ${process.cwd()}`);
+  };
+
+}).call(this);