jax 0.0.0.1

data/src/jax/prototype/core.js

@@ -0,0 +1,112 @@
+/*
+  Core functions borrowed from Prototype. I don't think these are stepping on anyone's (e.g. jQuery's) toes,
+  but if I find out otherwise I'll have to tweak it. The goal here is to be totally compatible with other libraries
+  wherever possible.
+*/
+
+Jax.$A = function(iterable) {
+  if (!iterable) return [];
+  if ('toArray' in Object(iterable)) return iterable.toArray();
+  var length = iterable.length || 0, results = new Array(length);
+  while (length--) results[length] = iterable[length];
+  return results;
+};
+
+/* TODO find a way to avoid polluting Object. */
+Object.isFunction = function(arg) { return Object.prototype.toString.call(arg) === '[object Function]'; };
+Object.isUndefined = function(object) { return typeof object === "undefined"; };
+Object.isArray = function(object) { return Object.prototype.toString.call(object) === '[object Array]'; };
+Object.extend = function(destination, source) {
+  for (var property in source)
+    destination[property] = source[property];
+  return destination;
+};
+
+Object.extend(Function.prototype, (function() {
+  var slice = Array.prototype.slice;
+
+  function update(array, args) {
+    var arrayLength = array.length, length = args.length;
+    while (length--) array[arrayLength + length] = args[length];
+    return array;
+  }
+
+  function merge(array, args) {
+    array = slice.call(array, 0);
+    return update(array, args);
+  }
+
+  function argumentNames() {
+    var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
+      .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
+      .replace(/\s+/g, '').split(',');
+    return names.length == 1 && !names[0] ? [] : names;
+  }
+
+  function bind(context) {
+    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
+    var __method = this, args = slice.call(arguments, 1);
+    return function() {
+      var a = merge(args, arguments);
+      return __method.apply(context, a);
+    }
+  }
+
+  function bindAsEventListener(context) {
+    var __method = this, args = slice.call(arguments, 1);
+    return function(event) {
+      var a = update([event || window.event], args);
+      return __method.apply(context, a);
+    }
+  }
+
+  function curry() {
+    if (!arguments.length) return this;
+    var __method = this, args = slice.call(arguments, 0);
+    return function() {
+      var a = merge(args, arguments);
+      return __method.apply(this, a);
+    }
+  }
+
+  function delay(timeout) {
+    var __method = this, args = slice.call(arguments, 1);
+    timeout = timeout * 1000;
+    return window.setTimeout(function() {
+      return __method.apply(__method, args);
+    }, timeout);
+  }
+
+  function defer() {
+    var args = update([0.01], arguments);
+    return this.delay.apply(this, args);
+  }
+
+  function wrap(wrapper) {
+    var __method = this;
+    return function() {
+      var a = update([__method.bind(this)], arguments);
+      return wrapper.apply(this, a);
+    }
+  }
+
+  function methodize() {
+    if (this._methodized) return this._methodized;
+    var __method = this;
+    return this._methodized = function() {
+      var a = update([this], arguments);
+      return __method.apply(null, a);
+    };
+  }
+
+  return {
+    argumentNames:       argumentNames,
+    bind:                bind,
+    bindAsEventListener: bindAsEventListener,
+    curry:               curry,
+    delay:               delay,
+    defer:               defer,
+    wrap:                wrap,
+    methodize:           methodize
+  };
+})());

data/src/jax/prototype/extensions.js

@@ -0,0 +1,124 @@
+/* My own custom extensions to Prototype */
+
+//= require "class"
+
+(function() {
+  /*
+    Delegator is instantiated by the class method #delegate with _this_ and _arguments_ as arguments.
+    It is effectively responsible for copying a set of methods into the destination object.
+    
+    @see Jax.Class.Methods#delegate
+   */
+  var Delegator = Jax.Class.create({
+    initialize: function(target, methods) {
+      this.methods = methods;
+      this.target = target;
+    },
+    
+    into: function(destination, dest_klass) {
+      /*
+        yes, we're using eval in here. But as this method is only called during setup, it's probably OK for the most
+        part. Note the caveat that if dest_klass is omitted and the dev is using regular expressions to match method
+        names, we have no choice but to put an eval into the alias chain for this.target#initialize. Not ideal but I
+        couldn't think of a better way to make it work.
+       */
+      var methods = {};
+      var method_name;
+      var alias_chain_regexps = [];
+      
+      for (var i = 0; i < this.methods.length; i++) {
+        if (typeof(this.methods[i]) == "string") {
+          /* it's not a regexp so this case is pretty straightforward */
+          method_name = this.methods[i];
+          methods[method_name] =
+            eval("(function() { return this."+destination+"."+method_name+".apply(this."+destination+", arguments); })");
+        } else if (this.methods[i].test) {
+          var method_regexp = this.methods[i];
+          /*
+            regexp -- this is harder because we don't know what klass _destination_ points to.
+            we have two choices: require an explicit klass argument, or assume the dev is prepared
+            to pay the overhead price of testing regexps and calling #eval within #initialize.
+            
+            let's do both: if explicit klass was given, use it. Else, set up an alias chain for #initialize.
+           */
+          
+          if (dest_klass) {
+            for (method_name in dest_klass.prototype) {
+              if (method_regexp.test(method_name)) {
+                methods[method_name] =
+                        eval("(function() { return this."+destination+"."+method_name+".apply(this."+destination+", arguments); })");
+              }
+            }
+          } else {
+            alias_chain_regexps.push(method_regexp);
+          }
+        }
+      }
+
+      /* add known methods */
+      this.target.addMethods(methods);
+      
+      if (alias_chain_regexps.length > 0) {
+        if (!this.target.alias_chain_regexps)
+        {
+          /* alias chain doesn't yet exist -- create it */
+          this.target.alias_chain_regexps = {};
+          var original_initialize_method = this.target.prototype.initialize;
+          var fn = "(function(){" +
+                     "if (original_initialize_method) original_initialize_method.apply(this, arguments);" +
+                     "var i, j, method_name, destination, method_regexp, self = this;" +
+                  
+                     "destination = this."+destination+";" +
+                     "for (i = 0; i < this.klass.alias_chain_regexps['"+destination+"'].length; i++) {" +
+                       "method_regexp = this.klass.alias_chain_regexps['"+destination+"'][i];" +
+                       "for (j in destination) {" +
+                         "method_name = j;" +
+                         "if (method_regexp.test(method_name)) " +
+                           "this[method_name] = eval('(function(){return self."+destination+".'+method_name+" +
+                                                    "'.apply(self."+destination+", arguments);})');" +
+                       "}" +
+                     "}" +
+                  "})";
+          
+          this.target.prototype.initialize = eval(fn);
+        }
+        /* else, alias chain exists; we only have to add method regexps */
+        
+        this.target.alias_chain_regexps[destination] = this.target.alias_chain_regexps[destination] || [];
+        for (i = 0; i < alias_chain_regexps.length; i++) {
+          this.target.alias_chain_regexps[destination].push(alias_chain_regexps[i]);
+        }
+      }
+    }
+  });
+    
+  /*
+    Prototype doesn't seem to have a way to add instance methods to all classes (a generic base object would have
+    been nice) so we have to hack it in by aliasing ::create and then replacing it.
+  */
+  Jax.Class.InstanceMethods = {
+    isKindOf: function(klass) {
+      return(this instanceof klass);
+    }
+  };
+
+  var original_create = Jax.Class.create;
+  Jax.Class.create = function() {
+    var klass = original_create.apply(Jax.Class, arguments);
+    klass.prototype.klass = klass;
+    klass.addMethods(Jax.Class.InstanceMethods);
+    Jax.Util.addRequestedHelpers(klass);
+
+    return klass;
+  };
+  
+  /*
+    class method #delegate
+    usages:
+      klass.delegate(/^(get|load|mult)(.*)Matrix$/).into("matrix_stack");
+      klass.delegate("getProjectionMatrix", "loadModelMatrix").into("matrix_stack");
+   */
+  Jax.Class.Methods.delegate = function() {
+    return new Delegator(this, arguments);
+  };
+})();

data/src/jax/route_set.js

@@ -0,0 +1,125 @@
+/**
+ * class Jax.RouteSet
+ * 
+ * Manages routing for Jax. All routes are mapped through the route set, and
+ * the route set is responsible for recognizing routes and dispatching them
+ * to the appropriate destination.
+ * 
+ * A route is generally represented as a string of the form
+ * "controller_name/action_name", where controller_name is the short name of
+ * the controller and the action name is the action to be triggered. For
+ * example, a route matching the #index action of the WelcomeController
+ * would look like:
+ * 
+ *     "welcome/index"
+ *   
+ * A special case is the root route, which is always mapped to "/". This is
+ * used to give Jax applications a default starting point. If omitted, it
+ * will be necessary to invoke the appropriate controller manually. You
+ * can do this by calling Jax.RouteSet#dispatch.
+ **/
+Jax.RouteSet = (function() {
+  function set_route(self, path, route_descriptor) {
+    return self._map[path] = route_descriptor;
+  }
+  
+  function find_route(self, path) {
+    return self._map[path] || null;
+  }
+  
+  return Jax.Class.create({
+    initialize: function() {
+      this.clear();
+    },
+    
+    clear: function() {
+      this._map = {};
+    },
+
+    /**
+     * Jax.RouteSet#root(controller, actionName) -> undefined
+     * - controller (Jax.Controller): the controller that will be routed to
+     * - actionName (String): the name of the action to be invoked by this route
+     * 
+     * Note that the controller is expected to be a subclass of Jax.Controller.
+     * 
+     * Example:
+     * 
+     *     Jax.routes.root(WelcomeController, "index");
+     * 
+     **/
+    root: function() {
+      var args = [];
+      for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);
+      set_route(this, "/", this.getRouteDescriptor.apply(this, args));
+    },
+    
+    /**
+     * Jax.RouteSet#map(path, controller, actionName) -> undefined
+     **/
+    map: function(path) {
+      var args = [];
+      for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+      set_route(this, path, this.getRouteDescriptor.apply(this, args));
+    },
+    
+    getRouteDescriptor: function() {
+      var route_descriptor;
+      switch(arguments.length) {
+        case 1:
+          if (typeof(arguments[0]) == "object")
+          {
+            route_descriptor = arguments[0];
+            if (!route_descriptor.action) route_descriptor.action = "index";
+            return arguments[0];
+          }
+          else return { controller: arguments[0], action: "index" };
+        case 2: return { controller: arguments[0], action: arguments[1] };
+        case 3:
+          route_descriptor = arguments[3];
+          route_descriptor.controller = arguments[0];
+          route_descriptor.action = arguments[1];
+          return route_descriptor;
+        default: throw new Error("Invalid arguments");
+      };
+    },
+    
+    /**
+     * Jax.RouteSet#recognize_route(path) -> Object
+     * - path (String): the route path to be recognized
+     * 
+     * Recognizes the specified path, returning an object with properties
+     * 'controller' and 'action'. If the route cannot be recognized, an
+     * error is thrown.
+     **/
+    recognize_route: function(path) {
+      var route = find_route(this, path) || find_route(this, path+"/index");
+      if (!route) throw new Error("Route not recognized: '"+path+"'");
+      return route;
+    },
+
+    /**
+     * Jax.RouteSet#isRouted(path) -> Boolean
+     * - path (String): the route path to be recognized
+     * 
+     * Returns true if the specified path can be routed, false otherwise.
+     **/
+    isRouted: function(path) {
+      return !!find_route(this, path);
+    },
+
+    /**
+     * Jax.RouteSet#dispatch(path) -> Jax.Controller
+     * - path (String): the route path to be recognized
+     * 
+     * Recognizes the given path as a route and invokes its controller and action.
+     * After the controller has been invoked, the controller instance itself is
+     * returned.
+     **/
+    dispatch: function(path, context) {
+      var route = this.recognize_route(path);
+      
+      return route.controller.invoke(route.action, context);
+    }
+  });
+})();

data/src/jax/vendor/ejs.js

@@ -0,0 +1,4 @@
+{
+  //= require "../../../vendor/ejs/src/ejs"
+  //= require "../../../vendor/ejs/src/view"
+};

data/src/jax/vendor/glMatrix.js

@@ -0,0 +1,3 @@
+{
+  //= require "../../../vendor/glmatrix/glMatrix"
+};

data/src/jax/view.js

@@ -0,0 +1,37 @@
+/**
+ * class Jax.View
+ * 
+ * Provides a container class around which View functions can be stored.
+ * 
+ * This is useful because other parts of Jax will set up helper methods and
+ * delegation methods for a View to make use of.
+ * 
+ * For example, one of the most common tasks for a View is to clear the
+ * rendering canvas:
+ * 
+ *     this.glClear(GL_COLOR_BIT | GL_DEPTH_BUFFER_BIT);
+ *     
+ * The _glClear_ method is delegated into the Jax.Context associated with
+ * this view.
+ * 
+ * By default, in addition to all WebGL methods, the following delegates and
+ * properties are created by Jax:
+ * 
+ *   * *world*   - the instance of Jax.World that houses all of the objects in
+ *                 the scene
+ *   * *player*  - the instance of Jax.Player for this context containing information
+ *                 about the human user.
+ *   * *context* - the instance of Jax.Context that this view is associated with.
+ * 
+ **/
+Jax.View = (function() {
+  return Jax.Class.create({
+    initialize: function(view_func) {
+      this.view_func = view_func;
+    },
+    
+    render: function() {
+      this.view_func();
+    }
+  });
+})();

data/src/jax/view_manager.js

@@ -0,0 +1,46 @@
+/**
+ * class Jax.ViewManager
+ * 
+ **/
+Jax.ViewManager = (function() {
+  return Jax.Class.create({
+    initialize: function() {
+      this.views = {};
+    },
+
+    /**
+     * Jax.ViewManager#push(path, view) -> undefined
+     * - path (String): the view path to be stored
+     * - view (Function): a function to be called when rendering the view
+     * 
+     * If the path is already stored, the current one will be replaced.
+     **/
+    push: function(path, view) {
+      this.views[path] = view;
+    },
+    
+    /**
+     * Jax.ViewManager#get(path) -> Object
+     * - path (String): the view path to be returned.
+     * 
+     * Note that every call to this method produces a new instance of Jax.View,
+     * so be aware that this can cause efficiency problems and memory leaks
+     * if not handled appropriately.
+     **/
+    get: function(path) {
+      if (this.views[path])
+        return new Jax.View(this.views[path]);
+      else throw new Error("Could not find view at '"+path+"'!");
+    },
+
+    /** alias of: Jax.ViewManager#get
+     * Jax.ViewManager#find(path) -> Object
+     * - path (String): the view path to be returned.
+     * 
+     * Note that every call to this method produces a new instance of Jax.View,
+     * so be aware that this can cause efficiency problems and memory leaks
+     * if not handled appropriately.
+     **/
+    find: function(path) { return this.get(path); }
+  });
+})();