lanes 0.0.1

data/lib/lanes/api/eco.js

@@ -0,0 +1,516 @@
+/**
+ * Eco Compiler v1.1.0-rc-3
+ * http://github.com/sstephenson/eco
+ *
+ * Copyright (c) 2011 Sam Stephenson
+ * Released under the MIT License
+ */
+this.eco = (function(modules) {
+  return function require(name) {
+    var fn, module = {id: name, exports: {}};
+    if (fn = modules[name]) {
+      fn(module, require, module.exports);
+      return module.exports;
+    } else {
+      throw 'Cannot find module \'' + name + '\'';
+    }
+  };
+})({
+  'eco': function(module, require, exports) {
+  // Generated by CoffeeScript 1.6.3
+(function() {
+  var compile, eco, precompile, preprocess, _ref;
+
+  _ref = require("./compiler"), compile = _ref.compile, precompile = _ref.precompile;
+
+  preprocess = require("./preprocessor").preprocess;
+
+  module.exports = eco = function(source) {
+    var _base;
+    if (eco.cache) {
+      return (_base = eco.cache)[source] != null ? (_base = eco.cache)[source] : _base[source] = compile(source);
+    } else {
+      return compile(source);
+    }
+  };
+
+  eco.cache = {};
+
+  eco.preprocess = preprocess;
+
+  eco.precompile = precompile;
+
+  eco.compile = compile;
+
+  eco.render = function(source, data) {
+    return (eco(source))(data);
+  };
+
+  if (require.extensions) {
+    require.extensions[".eco"] = function(module, filename) {
+      var source;
+      source = require("fs").readFileSync(filename, "utf-8");
+      return module._compile("module.exports = " + (precompile(source)), filename);
+    };
+  }
+
+}).call(this);
+
+},
+'./compiler': function(module, require, exports) {
+  // Generated by CoffeeScript 1.6.3
+(function() {
+  var CoffeeScript, indent, precompile, preprocess;
+
+  CoffeeScript = require("coffee-script");
+
+  preprocess = require("./preprocessor").preprocess;
+
+  indent = require("./util").indent;
+
+  exports.precompile = precompile = function(source, functions_ns, helpers) {
+    var script;
+    if (helpers == null) {
+      helpers = "ECO";
+    }
+    script = CoffeeScript.compile(preprocess(source), {
+      noWrap: true
+    });
+    return "function(__obj) {\n  if (!__obj) __obj = {};\n  var __out = [],\n    __capture = " + functions_ns + ".capture(__out),__sanitize = " + functions_ns + ".sanitize,\n    __safe, __objSafe = __obj.safe, __escape = __obj.escape,__safe = __obj.safe = " + functions_ns + ".safe,\n    __escape = __obj.escape = " + functions_ns + ".escape, h = " + helpers + ";\n  (function() {\n    " + (indent(script, 4)) + "\n  }).call(__obj);\n  __obj.safe = __objSafe, __obj.escape = __escape;\n  return __out.join('');\n}";
+  };
+
+  exports.compile = function(source) {
+    return new Function("return " + (precompile(source)))();
+  };
+
+}).call(this);
+
+},
+'./preprocessor': function(module, require, exports) {
+  // Generated by CoffeeScript 1.6.3
+(function() {
+  var Preprocessor, Scanner, util;
+
+  Scanner = require("./scanner");
+
+  util = require("./util");
+
+  module.exports = Preprocessor = (function() {
+    Preprocessor.preprocess = function(source) {
+      var preprocessor;
+      preprocessor = new Preprocessor(source);
+      return preprocessor.preprocess();
+    };
+
+    function Preprocessor(source) {
+      this.scanner = new Scanner(source);
+      this.output = "";
+      this.level = 0;
+      this.options = {};
+      this.captures = [];
+    }
+
+    Preprocessor.prototype.preprocess = function() {
+      var _this = this;
+      while (!this.scanner.done) {
+        this.scanner.scan(function(token) {
+          return _this[token[0]].apply(_this, token.slice(1));
+        });
+      }
+      return this.output;
+    };
+
+    Preprocessor.prototype.record = function(line) {
+      this.output += util.repeat("  ", this.level);
+      return this.output += line + "\n";
+    };
+
+    Preprocessor.prototype.printString = function(string) {
+      if (string.length) {
+        return this.record("__out.push " + (util.inspectString(string)));
+      }
+    };
+
+    Preprocessor.prototype.beginCode = function(options) {
+      return this.options = options;
+    };
+
+    Preprocessor.prototype.recordCode = function(code) {
+      if (code !== "end") {
+        if (this.options.print) {
+          if (this.options.safe) {
+            return this.record("__out.push " + code);
+          } else {
+            return this.record("__out.push __sanitize " + code);
+          }
+        } else {
+          return this.record(code);
+        }
+      }
+    };
+
+    Preprocessor.prototype.indent = function(capture) {
+      this.level++;
+      if (capture) {
+        this.record("__capture " + capture);
+        this.captures.unshift(this.level);
+        return this.indent();
+      }
+    };
+
+    Preprocessor.prototype.dedent = function() {
+      this.level--;
+      if (this.level < 0) {
+        this.fail("unexpected dedent");
+      }
+      if (this.captures[0] === this.level) {
+        this.captures.shift();
+        return this.dedent();
+      }
+    };
+
+    Preprocessor.prototype.fail = function(message) {
+      throw "Parse error on line " + this.scanner.lineNo + ": " + message;
+    };
+
+    return Preprocessor;
+
+  })();
+
+}).call(this);
+
+},
+'./scanner': function(module, require, exports) {
+  // Generated by CoffeeScript 1.6.3
+(function() {
+  var Scanner, StringScanner, trim;
+
+  StringScanner = require("strscan").StringScanner;
+
+  trim = require("./util").trim;
+
+  module.exports = Scanner = (function() {
+    Scanner.modePatterns = {
+      data: /(.*?)(<%%|%%>|<%\s*(\#)|<%(([=-])?)|\n|$)/,
+      code: /(.*?)((((:|(->|=>))\s*))?%>|\n|$)/,
+      comment: /(.*?)(%>|\n|$)/
+    };
+
+    Scanner.dedentablePattern = /^(end|when|else|catch|finally)(?:\W|$)/;
+
+    Scanner.scan = function(source) {
+      var scanner, tokens;
+      tokens = [];
+      scanner = new Scanner(source);
+      while (!scanner.done) {
+        scanner.scan(function(token) {
+          return tokens.push(token);
+        });
+      }
+      return tokens;
+    };
+
+    function Scanner(source) {
+      this.source = source.replace(/\r\n?/g, "\n");
+      this.scanner = new StringScanner(this.source);
+      this.mode = "data";
+      this.buffer = "";
+      this.lineNo = 1;
+      this.done = false;
+    }
+
+    Scanner.prototype.scan = function(callback) {
+      if (this.done) {
+        return callback();
+      } else if (this.scanner.hasTerminated()) {
+        this.done = true;
+        switch (this.mode) {
+          case "data":
+            return callback(["printString", this.flush()]);
+          case "code":
+            return callback(["fail", "unexpected end of template"]);
+        }
+      } else {
+        this.advance();
+        switch (this.mode) {
+          case "data":
+            return this.scanData(callback);
+          case "code":
+            return this.scanCode(callback);
+          case "comment":
+            return this.scanComment(callback);
+        }
+      }
+    };
+
+    Scanner.prototype.advance = function() {
+      this.scanner.scanUntil(Scanner.modePatterns[this.mode]);
+      this.buffer += this.scanner.getCapture(0);
+      this.tail = this.scanner.getCapture(1);
+      this.comment = this.scanner.getCapture(2);
+      this.directive = this.scanner.getCapture(4);
+      return this.arrow = this.scanner.getCapture(5);
+    };
+
+    Scanner.prototype.scanData = function(callback) {
+      if (this.tail === "<%%") {
+        this.buffer += "<%";
+        return this.scan(callback);
+      } else if (this.tail === "%%>") {
+        this.buffer += "%>";
+        return this.scan(callback);
+      } else if (this.tail === "\n") {
+        this.buffer += this.tail;
+        this.lineNo++;
+        return this.scan(callback);
+      } else if (this.tail) {
+        callback(["printString", this.flush()]);
+        if (this.comment) {
+          return this.mode = "comment";
+        } else {
+          this.mode = "code";
+          return callback([
+            "beginCode", {
+              print: this.directive != null,
+              safe: this.directive === "-"
+            }
+          ]);
+        }
+      }
+    };
+
+    Scanner.prototype.scanCode = function(callback) {
+      var code;
+      if (this.tail === "\n") {
+        return callback(["fail", "unexpected newline in code block"]);
+      } else if (this.tail) {
+        this.mode = "data";
+        code = trim(this.flush());
+        if (this.arrow) {
+          code += " " + this.arrow;
+        }
+        if (this.isDedentable(code)) {
+          callback(["dedent"]);
+        }
+        callback(["recordCode", code]);
+        if (this.directive) {
+          return callback(["indent", this.arrow]);
+        }
+      }
+    };
+
+    Scanner.prototype.scanComment = function(callback) {
+      if (this.tail === "\n") {
+        return callback(["fail", "unexpected newline in code block"]);
+      } else if (this.tail) {
+        this.mode = "data";
+        return this.buffer = "";
+      }
+    };
+
+    Scanner.prototype.flush = function() {
+      var buffer;
+      buffer = this.buffer;
+      this.buffer = "";
+      return buffer;
+    };
+
+    Scanner.prototype.isDedentable = function(code) {
+      return code.match(Scanner.dedentablePattern);
+    };
+
+    return Scanner;
+
+  })();
+
+}).call(this);
+
+},
+'./util': function(module, require, exports) {
+  // Generated by CoffeeScript 1.6.3
+(function() {
+  var repeat, specialCharacters;
+
+  exports.repeat = repeat = function(string, count) {
+    return Array(count + 1).join(string);
+  };
+
+  exports.indent = function(string, width) {
+    var line, lines, space;
+    space = repeat(" ", width);
+    lines = (function() {
+      var _i, _len, _ref, _results;
+      _ref = string.split("\n");
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        line = _ref[_i];
+        _results.push(space + line);
+      }
+      return _results;
+    })();
+    return lines.join("\n");
+  };
+
+  exports.trim = function(string) {
+    return string.replace(/^\s+/, "").replace(/\s+$/, "");
+  };
+
+  specialCharacters = {
+    '\\': '\\\\',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t'
+  };
+
+  exports.inspectString = function(string) {
+    var contents;
+    contents = string.replace(/[\x00-\x1f\\]/g, function(character) {
+      var code;
+      if (character in specialCharacters) {
+        return specialCharacters[character];
+      } else {
+        code = character.charCodeAt(0).toString(16);
+        if (code.length === 1) {
+          code = "0" + code;
+        }
+        return "\\u00" + code;
+      }
+    });
+    return "'" + contents.replace(/'/g, '\\\'') + "'";
+  };
+
+}).call(this);
+
+},
+'strscan': function(module, require, exports) {
+  (function() {
+  var StringScanner;
+  ((typeof exports !== "undefined" && exports !== null) ? exports : this).StringScanner = (function() {
+    StringScanner = function(source) {
+      this.source = source.toString();
+      this.reset();
+      return this;
+    };
+    StringScanner.prototype.scan = function(regexp) {
+      var matches;
+      return (matches = regexp.exec(this.getRemainder())) && matches.index === 0 ? this.setState(matches, {
+        head: this.head + matches[0].length,
+        last: this.head
+      }) : this.setState([]);
+    };
+    StringScanner.prototype.scanUntil = function(regexp) {
+      var matches;
+      if (matches = regexp.exec(this.getRemainder())) {
+        this.setState(matches, {
+          head: this.head + matches.index + matches[0].length,
+          last: this.head
+        });
+        return this.source.slice(this.last, this.head);
+      } else {
+        return this.setState([]);
+      }
+    };
+    StringScanner.prototype.scanChar = function() {
+      return this.scan(/[\s\S]/);
+    };
+    StringScanner.prototype.skip = function(regexp) {
+      if (this.scan(regexp)) {
+        return this.match.length;
+      }
+    };
+    StringScanner.prototype.skipUntil = function(regexp) {
+      if (this.scanUntil(regexp)) {
+        return this.head - this.last;
+      }
+    };
+    StringScanner.prototype.check = function(regexp) {
+      var matches;
+      return (matches = regexp.exec(this.getRemainder())) && matches.index === 0 ? this.setState(matches) : this.setState([]);
+    };
+    StringScanner.prototype.checkUntil = function(regexp) {
+      var matches;
+      if (matches = regexp.exec(this.getRemainder())) {
+        this.setState(matches);
+        return this.source.slice(this.head, this.head + matches.index + matches[0].length);
+      } else {
+        return this.setState([]);
+      }
+    };
+    StringScanner.prototype.peek = function(length) {
+      return this.source.substr(this.head, (typeof length !== "undefined" && length !== null) ? length : 1);
+    };
+    StringScanner.prototype.getSource = function() {
+      return this.source;
+    };
+    StringScanner.prototype.getRemainder = function() {
+      return this.source.slice(this.head);
+    };
+    StringScanner.prototype.getPosition = function() {
+      return this.head;
+    };
+    StringScanner.prototype.hasTerminated = function() {
+      return this.head === this.source.length;
+    };
+    StringScanner.prototype.getPreMatch = function() {
+      if (this.match) {
+        return this.source.slice(0, this.head - this.match.length);
+      }
+    };
+    StringScanner.prototype.getMatch = function() {
+      return this.match;
+    };
+    StringScanner.prototype.getPostMatch = function() {
+      if (this.match) {
+        return this.source.slice(this.head);
+      }
+    };
+    StringScanner.prototype.getCapture = function(index) {
+      return this.captures[index];
+    };
+    StringScanner.prototype.reset = function() {
+      return this.setState([], {
+        head: 0,
+        last: 0
+      });
+    };
+    StringScanner.prototype.terminate = function() {
+      return this.setState([], {
+        head: this.source.length,
+        last: this.head
+      });
+    };
+    StringScanner.prototype.concat = function(string) {
+      return this.source += string;
+    };
+    StringScanner.prototype.unscan = function() {
+      if (this.match) {
+        return this.setState([], {
+          head: this.last,
+          last: 0
+        });
+      } else {
+        throw "nothing to unscan";
+      }
+    };
+    StringScanner.prototype.setState = function(matches, values) {
+      var _a, _b;
+      this.head = (typeof (_a = ((typeof values === "undefined" || values === null) ? undefined : values.head)) !== "undefined" && _a !== null) ? _a : this.head;
+      this.last = (typeof (_b = ((typeof values === "undefined" || values === null) ? undefined : values.last)) !== "undefined" && _b !== null) ? _b : this.last;
+      this.captures = matches.slice(1);
+      return (this.match = matches[0]);
+    };
+    return StringScanner;
+  })();
+})();
+
+},
+'coffee-script': function(module, require, exports) {
+  if (typeof CoffeeScript !== 'undefined' && CoffeeScript != null) {
+  module.exports = CoffeeScript;
+} else {
+  throw 'Cannot require \'' + module.id + '\': CoffeeScript not found';
+}
+}
+})('eco');

data/lib/lanes/api/error_formatter.rb

@@ -0,0 +1,37 @@
+module Lanes
+    module API
+        module ErrorFormmater
+            extend self
+
+            def call(message, backtrace=nil, options=nil, env=nil)
+                {
+                 success: false, message: message,
+                 errors: { base: message }
+                }.to_json
+            end
+
+            def handle_exception(message, code, e)
+                Rack::Response.new([self.call(message)],
+                                   code, {"Content-type" => "application/json"}
+                                  ).finish
+                Lanes.logger.error e
+            end
+
+            def handle_fk_exception(e,model)
+                ( target, depends ) = e.message.scan(/on table \"(.*?)\"/).flatten.map do |table|
+                    table.gsub(/^hip_/, '').capitalize.singularize
+                end
+                Lanes::API::ErrorFormmater.handle_exception(
+                  "Unable to delete #{target}, still in use by #{depends}", 400, e
+                )
+            end
+
+            def handle_not_found_exception(e,model)
+                Lanes::API::ErrorFormmater.handle_exception(
+                  model.to_s.demodulize + " (or one of it's dependencies) was not found", 404, e
+                )
+            end
+
+        end
+    end
+end

data/lib/lanes/api/helper_methods.rb

@@ -0,0 +1,32 @@
+module Lanes
+    module API
+
+        module HelperMethods
+
+            def bootstrap_data
+                Oj.dump Extension.bootstrap_data(self)
+            end
+
+            def user_data
+                if (user_id = session[:user_id]) && (user = Lanes::User.where( id: user_id ).first)
+                    Oj.dump(user.workspace_data, mode: :compat)
+                else
+                    {}
+                end
+            end
+
+            def csrf_token
+                Rack::Csrf.csrf_token(env)
+            end
+
+            def lanes_api_url
+                Lanes.config.mounted_at
+            end
+
+            def data
+                @json_data ||= Oj.load( request.body.read )
+            end
+        end
+
+    end
+end

data/lib/lanes/api/javascript_processor.rb

@@ -0,0 +1,116 @@
+require 'execjs'
+require 'coffee-script'
+require 'open3'
+
+module Lanes
+    module API
+
+        TranspileError = Class.new(StandardError)
+
+        class JsAssetCompiler < Tilt::Template
+            class_attribute :registered_extension
+            def prepare
+                # NOOP
+            end
+            def self.register(env)
+                self.descendants.each do | klass |
+                    klass.default_mime_type = 'application/javascript'
+                    env.register_engine( klass.registered_extension, klass )
+                end
+            end
+
+            def wrap_js(js)
+                "(function(Lanes, _, window, undefined) {\n#{js}\n})(window.Lanes, window._, window);"
+            end
+
+        end
+
+        class CoffeeScriptWrapper < JsAssetCompiler
+            self.registered_extension = '.coffee'
+
+            CONSTRUCTOR = /constructor\s*:/
+            EXTENDING_CLASS = /class\s+([\w|\.]+)\s+extends\s+([\w|\.]+)\s*?\n/
+
+            # Coffeescript has two shortcomings with regards to Ampersandjs
+            #
+            # The first is that it's extends format is incompatible with Ampersandjs,
+            # Ampersandjs does quite a bit more via it's own .extend methods.
+            # Accordingly, we substitute our own "extend" call whenever we encounter a coffeescript extends
+            #
+            # The second issue is that if a constructor isn't present, coffeescript with generate it's own
+            # blank implementation that fails to call "super".  We add a constructor that does call super if one's missing.
+
+            def cleaned
+                contents = data.dup
+                data.scan(EXTENDING_CLASS) do |match|
+                    (name,extends) = match
+
+                    contents.gsub!(/class\s+#{name}\s+.*?\n/,"class #{name}\n")
+                    definition = contents[/(class #{name}\n.*?)(\n\w|\Z)/m,1]
+                    # is it missing a constructor?
+                    if definition !~ /constructor:/
+                        # figure out how much to indent, sigh.
+                        indent = definition[/\n(\s+)(\w+):/,1] || '    '
+                        contents.gsub!(/class #{name}\n/,"\\0#{indent}constructor: -> super\n")
+
+                    end
+                    contents.gsub!( /(class #{name}\n.*?)(\n\w|\Z)/m, "\\1\n#{extends}.extend(#{name})\n\\2" )
+
+                    contents
+                    #contents << "#{extends}.extend(#{name})\n"
+                end
+                contents
+            end
+
+            def evaluate(scope, locals, &block)
+                wrap_js ::CoffeeScript.compile(cleaned, bare: true)
+            end
+        end
+
+        class Es6Compiler < JsAssetCompiler
+            self.registered_extension = '.es6'
+            def evaluate(scope, locals, &block)
+                cmd = "#{Lanes.config.es6_transpiler_path} #{Lanes.config.es6_transpiler_options}"
+                stdout, stderr, _status = Open3.capture3(cmd, stdin_data: data)
+                if stderr.empty?
+                    wrap_js stdout
+                else
+                    raise TranspileError, stderr
+                end
+            end
+        end
+
+        class JSWrapper < JsAssetCompiler
+            self.registered_extension = '.lanes'
+            def evaluate(scope, locals, &block)
+                wrap_js data
+            end
+        end
+
+        class SkrTemplates < JsAssetCompiler
+            self.registered_extension = '.html'
+            def evaluate(scope, locals, &block)
+                "Lanes.Templates['#{scope.logical_path}']=" + self.compile(data)
+            end
+
+            def contents
+                @contents ||= Pathname.new(__FILE__).dirname.join('eco.js').read
+            end
+
+            def combined_contents
+                [CoffeeScript::Source.contents, contents].join(";\n")
+            end
+
+            def context
+                @context ||= ExecJS.compile(combined_contents)
+            end
+
+            def compile(template)
+                template = template.read if template.respond_to?(:read)
+                context.call("eco.precompile", template, 'Lanes.TemplateWrapper','Lanes.View.Helpers')
+            end
+
+        end
+
+    end
+end