volt 0.7.1 → 0.7.2

data/app/volt/assets/js/vertxbus.js

@@ -0,0 +1,216 @@
+/*
+ * Copyright 2011-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var vertx = vertx || {};
+
+!function(factory) {
+  if (typeof define === "function" && define.amd) {
+    // Expose as an AMD module with SockJS dependency.
+    // "vertxbus" and "sockjs" names are used because
+    // AMD module names are derived from file names.
+    define("vertxbus", ["sockjs"], factory);
+  } else {
+    // No AMD-compliant loader
+    factory(SockJS);
+  }
+}(function(SockJS) {
+
+  vertx.EventBus = function(url, options) {
+
+    var that = this;
+    var sockJSConn = new SockJS(url, undefined, options);
+    var handlerMap = {};
+    var replyHandlers = {};
+    var state = vertx.EventBus.CONNECTING;
+    var sessionID = null;
+    var pingTimerID = null;
+
+    that.onopen = null;
+    that.onclose = null;
+
+    that.login = function(username, password, replyHandler) {
+      sendOrPub("send", 'vertx.basicauthmanager.login', {username: username, password: password}, function(reply) {
+        if (reply.status === 'ok') {
+          that.sessionID = reply.sessionID;
+        }
+        if (replyHandler) {
+          delete reply.sessionID;
+          replyHandler(reply)
+        }
+      });
+    }
+
+    that.send = function(address, message, replyHandler) {
+      sendOrPub("send", address, message, replyHandler)
+    }
+
+    that.publish = function(address, message, replyHandler) {
+      sendOrPub("publish", address, message, replyHandler)
+    }
+
+    that.registerHandler = function(address, handler) {
+      checkSpecified("address", 'string', address);
+      checkSpecified("handler", 'function', handler);
+      checkOpen();
+      var handlers = handlerMap[address];
+      if (!handlers) {
+        handlers = [handler];
+        handlerMap[address] = handlers;
+        // First handler for this address so we should register the connection
+        var msg = { type : "register",
+                    address: address };
+        sockJSConn.send(JSON.stringify(msg));
+      } else {
+        handlers[handlers.length] = handler;
+      }
+    }
+
+    that.unregisterHandler = function(address, handler) {
+      checkSpecified("address", 'string', address);
+      checkSpecified("handler", 'function', handler);
+      checkOpen();
+      var handlers = handlerMap[address];
+      if (handlers) {
+        var idx = handlers.indexOf(handler);
+        if (idx != -1) handlers.splice(idx, 1);
+        if (handlers.length == 0) {
+          // No more local handlers so we should unregister the connection
+
+          var msg = { type : "unregister",
+                      address: address};
+          sockJSConn.send(JSON.stringify(msg));
+          delete handlerMap[address];
+        }
+      }
+    }
+
+    that.close = function() {
+      checkOpen();
+      if (pingTimerID) clearInterval(pingTimerID);
+      state = vertx.EventBus.CLOSING;
+      sockJSConn.close();
+    }
+
+    that.readyState = function() {
+      return state;
+    }
+
+    sockJSConn.onopen = function() {
+      // Send the first ping then send a ping every 5 seconds
+      sendPing();
+      pingTimerID = setInterval(sendPing, 5000);
+      state = vertx.EventBus.OPEN;
+      if (that.onopen) {
+        that.onopen();
+      }
+    };
+
+    sockJSConn.onclose = function() {
+      state = vertx.EventBus.CLOSED;
+      if (that.onclose) {
+        that.onclose();
+      }
+    };
+
+    sockJSConn.onmessage = function(e) {
+      var msg = e.data;
+      var json = JSON.parse(msg);
+      var body = json.body;
+      var replyAddress = json.replyAddress;
+      var address = json.address;
+      var replyHandler;
+      if (replyAddress) {
+        replyHandler = function(reply, replyHandler) {
+          // Send back reply
+          that.send(replyAddress, reply, replyHandler);
+        };
+      }
+      var handlers = handlerMap[address];
+      if (handlers) {
+        // We make a copy since the handler might get unregistered from within the
+        // handler itself, which would screw up our iteration
+        var copy = handlers.slice(0);
+        for (var i  = 0; i < copy.length; i++) {
+          copy[i](body, replyHandler);
+        }
+      } else {
+        // Might be a reply message
+        var handler = replyHandlers[address];
+        if (handler) {
+          delete replyHandlers[address];
+          handler(body, replyHandler);
+        }
+      }
+    }
+
+    function sendPing() {
+      var msg = {
+        type: "ping"
+      }
+      sockJSConn.send(JSON.stringify(msg));
+    }
+
+    function sendOrPub(sendOrPub, address, message, replyHandler) {
+      checkSpecified("address", 'string', address);
+      checkSpecified("replyHandler", 'function', replyHandler, true);
+      checkOpen();
+      var envelope = { type : sendOrPub,
+                       address: address,
+                       body: message };
+      if (that.sessionID) {
+        envelope.sessionID = that.sessionID;
+      }
+      if (replyHandler) {
+        var replyAddress = makeUUID();
+        envelope.replyAddress = replyAddress;
+        replyHandlers[replyAddress] = replyHandler;
+      }
+      var str = JSON.stringify(envelope);
+      sockJSConn.send(str);
+    }
+
+    function checkOpen() {
+      if (state != vertx.EventBus.OPEN) {
+        throw new Error('INVALID_STATE_ERR');
+      }
+    }
+
+    function checkSpecified(paramName, paramType, param, optional) {
+      if (!optional && !param) {
+        throw new Error("Parameter " + paramName + " must be specified");
+      }
+      if (param && typeof param != paramType) {
+        throw new Error("Parameter " + paramName + " must be of type " + paramType);
+      }
+    }
+
+    function isFunction(obj) {
+      return !!(obj && obj.constructor && obj.call && obj.apply);
+    }
+
+    function makeUUID(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
+        .replace(/[xy]/g,function(a,b){return b=Math.random()*16,(a=="y"?b&3|8:b|0).toString(16)})}
+
+  }
+
+  vertx.EventBus.CONNECTING = 0;
+  vertx.EventBus.OPEN = 1;
+  vertx.EventBus.CLOSING = 2;
+  vertx.EventBus.CLOSED = 3;
+
+  return vertx.EventBus;
+
+});

data/app/volt/tasks/live_query/live_query.rb

@@ -24,28 +24,28 @@ class LiveQuery
 
   def notify_removed(ids, skip_channel)
     notify! do |channel|
-      # puts "Removed: #{ids.inspect} to #{channel.inspect}"
+      puts "Removed: #{ids.inspect} to #{channel.inspect}"
       channel.send_message("removed", nil, @collection, @query, ids)
     end
   end
 
   def notify_added(index, data, skip_channel)
-    notify!(skip_channel) do |channel|
-      # puts "Added: #{index} - #{data.inspect} to #{channel.inspect}"
+    notify! do |channel|
+      puts "Added: #{index} - #{data.inspect} to #{channel.inspect}"
       channel.send_message("added", nil, @collection, @query, index, data)
     end
   end
 
   def notify_moved(id, new_position, skip_channel)
     notify! do |channel|
-      # puts "Moved: #{id}, #{new_position} to #{channel.inspect}"
+      puts "Moved: #{id}, #{new_position} to #{channel.inspect}"
       channel.send_message("moved", nil, @collection, @query, id, new_position)
     end
   end
 
   def notify_changed(id, data, skip_channel)
     notify!(skip_channel) do |channel|
-      # puts "Changed: #{id}, #{data} to #{channel.inspect}"
+      puts "Changed: #{id}, #{data} to #{channel.inspect}"
       channel.send_message("changed", nil, @collection, @query, id, data)
     end
   end

data/app/volt/tasks/live_query/live_query_pool.rb

@@ -15,7 +15,7 @@ class LiveQueryPool < GenericPool
 
   def updated_collection(collection, skip_channel)
     lookup_all(collection).each do |live_query|
-      # puts "RUN ON: #{live_query} with #{live_query.instance_variable_get('@channels').inspect}"
+      puts "RUN ON: #{live_query} with #{live_query.instance_variable_get('@channels').inspect}"
       live_query.run(skip_channel)
     end
   end

data/app/volt/tasks/query_tasks.rb

@@ -19,12 +19,17 @@ class QueryTasks
     live_query = @@live_query_pool.lookup(collection, query)
     track_channel_in_live_query(live_query)
 
+    puts "Load data on #{collection.inspect} - #{query.inspect}"
     live_query.add_channel(@channel)
 
     # Return the initial data
     return live_query.initial_data
   end
 
+  def initial_data
+    return live_query.initial_data
+  end
+
   # Remove a listening channel, the LiveQuery will automatically remove
   # itsself from the pool when there are no channels.
   def remove_listener(collection, query)

data/app/volt/tasks/store_tasks.rb

@@ -1,4 +1,5 @@
 require 'mongo'
+require 'query_tasks'
 
 class StoreTasks
   def initialize(channel=nil, dispatcher=nil)
@@ -13,29 +14,54 @@ class StoreTasks
     @@db
   end
 
-  def save(collection, data)
-    # puts "Insert: #{data.inspect} on #{collection.inspect}"
+  def model_errors(collection, data)
+    model_name = collection[1..-1].singularize.camelize
+
+    # TODO: Security check to make sure we have a valid model
+    begin
+      model_class = Object.send(:const_get, model_name)
+    rescue NameError => e
+      model_class = nil
+    end
+
+    if model_class
+      return model_class.new(data).errors
+    end
+
+    return {}
+  end
 
+  def save(collection, data)
+    puts "Insert: #{data.inspect} on #{collection.inspect}"
     data = data.symbolize_keys
-    id = data[:_id]
 
-    # Try to create
-    # TODO: Seems mongo is dumb and doesn't let you upsert with custom id's
-    begin
-      @@db[collection].insert(data)
-    rescue Mongo::OperationFailure => error
-      # Really mongo client?
-      if error.message[/^11000[:]/]
-        # Update because the id already exists
-        update_data = data.dup
-        update_data.delete(:_id)
-        @@db[collection].update({:_id => id}, update_data)
-      else
-        raise
+    errors = model_errors(collection, data)
+
+    if errors.size == 0
+      id = data[:_id]
+
+      # Try to create
+      # TODO: Seems mongo is dumb and doesn't let you upsert with custom id's
+      begin
+        @@db[collection].insert(data)
+      rescue Mongo::OperationFailure => error
+        # Really mongo client?
+        if error.message[/^11000[:]/]
+          # Update because the id already exists
+          update_data = data.dup
+          update_data.delete(:_id)
+          @@db[collection].update({:_id => id}, update_data)
+        else
+          raise
+        end
       end
-    end
 
-    QueryTasks.live_query_pool.updated_collection(collection, @channel)
+      puts "SAVE: #{@channel.inspect}"
+      QueryTasks.live_query_pool.updated_collection(collection, @channel)
+      return {}
+    else
+      return errors
+    end
   end
 
   def delete(collection, id)

data/docs/WHY.md

@@ -25,6 +25,14 @@ Volt's reactive objects contain extra data about how to propigate events.  Thing
 
 
 
+# Why Volt is Awesome
+
+- only the relevant DOM is updated.  There is no match and patch algorithm to update from strings like other frameworks, all associations are tracked through our reactive values, so we know exactly what needs to be updated without the need to generate any extra HTML.  This has a few advantages, namely that things like input fields are retained, so any properties (focus, tab position, etc...) are also retained.
+
+
+
+
+
 
 
 
@@ -38,6 +46,8 @@ Volt's reactive objects contain extra data about how to propigate events.  Thing
 
 # Why Ruby
 
+Isomorphic type system with javascript
+
 In web development today, JavaScript gets to be the default language by virtue of being in the browser.  JavaScript is a very good language, but it has a lot of warts.  (See http://wtfjs.com/ for some great examples)  Some of these can introduce bugs, others are just difficult to deal with.  JavaScript was rushed to market quickly and standardized very quickly.  Ruby was used by a small community for years while most of the kinks were worked out.  Ruby also has some great concepts such as [uniform access](http://en.wikipedia.org/wiki/Uniform_access_principle), [mixin's](http://en.wikipedia.org/wiki/Mixin), [duck typing](http://en.wikipedia.org/wiki/Duck_typing), and [blocks](http://yehudakatz.com/2012/01/10/javascript-needs-blocks/) to name a few.  While many of these features can be implemented in JavaScript in userland, few are standardardized and the solutions are seldom eloquent.
 
 [5,10,1].sort()

data/lib/volt/cli.rb

@@ -23,7 +23,12 @@ class CLI < Thor
   desc "server", "run the server on the project in the current directory"
   method_option :port, :type => :string, :aliases => '-p', :banner => 'specify which port the server should run on'
   def server
-    require 'thin'
+    if RUBY_PLATFORM == 'java'
+      require 'volt/server'
+    else
+      require 'thin'
+    end
+
     require 'fileutils'
 
     # If we're in a Volt project, clear the temp directory
@@ -36,14 +41,20 @@ class CLI < Thor
       return
     end
 
-    ENV['SERVER'] = 'true'
-    args = ['start', '--threaded', '--max-persistent-conns', '300', "--max-conns", "400"]
+    if RUBY_PLATFORM == 'java'
+      server = Server.new.app
+      Rack::Handler::Jubilee.run(server)
+      Thread.stop
+    else
+      ENV['SERVER'] = 'true'
+      args = ['start', '--threaded', '--max-persistent-conns', '300', "--max-conns", "400"]
 
-    if options[:port]
-      args += ['-p', options[:port].to_s]
-    end
+      if options[:port]
+        args += ['-p', options[:port].to_s]
+      end
 
-    Thin::Runner.new(args).run!
+      Thin::Runner.new(args).run!
+    end
 
     # require 'volt/server'
     #

data/lib/volt/controllers/model_controller.rb

@@ -1,35 +1,57 @@
 class ModelController
   def self.model(val)
-    @@default_model = val
+    @default_model = val
   end
 
   # Sets the current model on this controller
-  def model(val)
+  def model=(val)
+    # Start with a nil reactive value.
+    @model ||= ReactiveValue.new(Proc.new { nil })
+
     if Symbol === val || String === val
-      collections = [:page, :store, :params]
+      collections = [:page, :store, :params, :controller]
       if collections.include?(val.to_sym)
-        @model = self.send(val)
+        @model.cur = self.send(val).cur
       else
         raise "#{val} is not the name of a valid model, choose from: #{collections.join(', ')}"
       end
     elsif val
-      @model = val
+      @model.cur = val.cur
     else
       raise "model can not be #{val.inspect}"
     end
   end
 
+  def model
+    @model
+  end
+
   def self.new(*args, &block)
     inst = self.allocate
-    if @@default_model
-      inst.model(@@default_model || :page)
-    end
+
+    inst.model = (@default_model || :controller)
 
     inst.initialize(*args, &block)
 
     return inst
   end
 
+  def initialize(*args)
+
+
+    # Set the instance variable to match any passed in arguments
+    if args.size > 0
+      args[0].each_pair do |key, value|
+        instance_variable_set(:"@#{key}", value)
+      end
+    end
+  end
+
+  # Change the url params, similar to redirecting to a new url
+  def go(url)
+    self.url.parse(url)
+  end
+
   def page
     $page.page
   end

data/lib/volt/extra_core/inflections.rb

@@ -0,0 +1,63 @@
+require 'volt/extra_core/inflector/inflections'
+
+Inflector.inflections(:en) do |inflect|
+  inflect.plural(/$/, 's')
+  inflect.plural(/s$/i, 's')
+  inflect.plural(/^(ax|test)is$/i, '\1es')
+  inflect.plural(/(octop|vir)us$/i, '\1i')
+  inflect.plural(/(octop|vir)i$/i, '\1i')
+  inflect.plural(/(alias|status)$/i, '\1es')
+  inflect.plural(/(bu)s$/i, '\1ses')
+  inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+  inflect.plural(/([ti])um$/i, '\1a')
+  inflect.plural(/([ti])a$/i, '\1a')
+  inflect.plural(/sis$/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+  inflect.plural(/(hive)$/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+  inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+  inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+  inflect.plural(/^(m|l)ouse$/i, '\1ice')
+  inflect.plural(/^(m|l)ice$/i, '\1ice')
+  inflect.plural(/^(ox)$/i, '\1en')
+  inflect.plural(/^(oxen)$/i, '\1')
+  inflect.plural(/(quiz)$/i, '\1zes')
+
+  inflect.singular(/s$/i, '')
+  inflect.singular(/(ss)$/i, '\1')
+  inflect.singular(/(n)ews$/i, '\1ews')
+  inflect.singular(/([ti])a$/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+  inflect.singular(/(^analy)(sis|ses)$/i, '\1sis')
+  inflect.singular(/([^f])ves$/i, '\1fe')
+  inflect.singular(/(hive)s$/i, '\1')
+  inflect.singular(/(tive)s$/i, '\1')
+  inflect.singular(/([lr])ves$/i, '\1f')
+  inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+  inflect.singular(/(s)eries$/i, '\1eries')
+  inflect.singular(/(m)ovies$/i, '\1ovie')
+  inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+  inflect.singular(/^(m|l)ice$/i, '\1ouse')
+  inflect.singular(/(bus)(es)?$/i, '\1')
+  inflect.singular(/(o)es$/i, '\1')
+  inflect.singular(/(shoe)s$/i, '\1')
+  inflect.singular(/(cris|test)(is|es)$/i, '\1is')
+  inflect.singular(/^(a)x[ie]s$/i, '\1xis')
+  inflect.singular(/(octop|vir)(us|i)$/i, '\1us')
+  inflect.singular(/(alias|status)(es)?$/i, '\1')
+  inflect.singular(/^(ox)en/i, '\1')
+  inflect.singular(/(vert|ind)ices$/i, '\1ex')
+  inflect.singular(/(matr)ices$/i, '\1ix')
+  inflect.singular(/(quiz)zes$/i, '\1')
+  inflect.singular(/(database)s$/i, '\1')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('man', 'men')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+  # inflect.irregular('cow', 'kine')
+  inflect.irregular('zombie', 'zombies')
+
+  inflect.uncountable(%w(equipment information rice money species series fish sheep jeans police))
+end