volt 0.7.23 → 0.8.0

data/VERSION

@@ -1 +1 @@
-0.7.23
+0.8.0

data/app/volt/assets/js/setImmediate.js

@@ -0,0 +1,175 @@
+(function (global, undefined) {
+    "use strict";
+
+    if (global.setImmediate) {
+        return;
+    }
+
+    var nextHandle = 1; // Spec says greater than zero
+    var tasksByHandle = {};
+    var currentlyRunningATask = false;
+    var doc = global.document;
+    var setImmediate;
+
+    function addFromSetImmediateArguments(args) {
+        tasksByHandle[nextHandle] = partiallyApplied.apply(undefined, args);
+        return nextHandle++;
+    }
+
+    // This function accepts the same arguments as setImmediate, but
+    // returns a function that requires no arguments.
+    function partiallyApplied(handler) {
+        var args = [].slice.call(arguments, 1);
+        return function() {
+            if (typeof handler === "function") {
+                handler.apply(undefined, args);
+            } else {
+                (new Function("" + handler))();
+            }
+        };
+    }
+
+    function runIfPresent(handle) {
+        // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
+        // So if we're currently running a task, we'll need to delay this invocation.
+        if (currentlyRunningATask) {
+            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
+            // "too much recursion" error.
+            setTimeout(partiallyApplied(runIfPresent, handle), 0);
+        } else {
+            var task = tasksByHandle[handle];
+            if (task) {
+                currentlyRunningATask = true;
+                try {
+                    task();
+                } finally {
+                    clearImmediate(handle);
+                    currentlyRunningATask = false;
+                }
+            }
+        }
+    }
+
+    function clearImmediate(handle) {
+        delete tasksByHandle[handle];
+    }
+
+    function installNextTickImplementation() {
+        setImmediate = function() {
+            var handle = addFromSetImmediateArguments(arguments);
+            process.nextTick(partiallyApplied(runIfPresent, handle));
+            return handle;
+        };
+    }
+
+    function canUsePostMessage() {
+        // The test against `importScripts` prevents this implementation from being installed inside a web worker,
+        // where `global.postMessage` means something completely different and can't be used for this purpose.
+        if (global.postMessage && !global.importScripts) {
+            var postMessageIsAsynchronous = true;
+            var oldOnMessage = global.onmessage;
+            global.onmessage = function() {
+                postMessageIsAsynchronous = false;
+            };
+            global.postMessage("", "*");
+            global.onmessage = oldOnMessage;
+            return postMessageIsAsynchronous;
+        }
+    }
+
+    function installPostMessageImplementation() {
+        // Installs an event handler on `global` for the `message` event: see
+        // * https://developer.mozilla.org/en/DOM/window.postMessage
+        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
+
+        var messagePrefix = "setImmediate$" + Math.random() + "$";
+        var onGlobalMessage = function(event) {
+            if (event.source === global &&
+                typeof event.data === "string" &&
+                event.data.indexOf(messagePrefix) === 0) {
+                runIfPresent(+event.data.slice(messagePrefix.length));
+            }
+        };
+
+        if (global.addEventListener) {
+            global.addEventListener("message", onGlobalMessage, false);
+        } else {
+            global.attachEvent("onmessage", onGlobalMessage);
+        }
+
+        setImmediate = function() {
+            var handle = addFromSetImmediateArguments(arguments);
+            global.postMessage(messagePrefix + handle, "*");
+            return handle;
+        };
+    }
+
+    function installMessageChannelImplementation() {
+        var channel = new MessageChannel();
+        channel.port1.onmessage = function(event) {
+            var handle = event.data;
+            runIfPresent(handle);
+        };
+
+        setImmediate = function() {
+            var handle = addFromSetImmediateArguments(arguments);
+            channel.port2.postMessage(handle);
+            return handle;
+        };
+    }
+
+    function installReadyStateChangeImplementation() {
+        var html = doc.documentElement;
+        setImmediate = function() {
+            var handle = addFromSetImmediateArguments(arguments);
+            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+            var script = doc.createElement("script");
+            script.onreadystatechange = function () {
+                runIfPresent(handle);
+                script.onreadystatechange = null;
+                html.removeChild(script);
+                script = null;
+            };
+            html.appendChild(script);
+            return handle;
+        };
+    }
+
+    function installSetTimeoutImplementation() {
+        setImmediate = function() {
+            var handle = addFromSetImmediateArguments(arguments);
+            setTimeout(partiallyApplied(runIfPresent, handle), 0);
+            return handle;
+        };
+    }
+
+    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
+    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
+    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
+
+    // Don't get fooled by e.g. browserify environments.
+    if ({}.toString.call(global.process) === "[object process]") {
+        // For Node.js before 0.9
+        installNextTickImplementation();
+
+    } else if (canUsePostMessage()) {
+        // For non-IE10 modern browsers
+        installPostMessageImplementation();
+
+    } else if (global.MessageChannel) {
+        // For web workers, where supported
+        installMessageChannelImplementation();
+
+    } else if (doc && "onreadystatechange" in doc.createElement("script")) {
+        // For IE 6–8
+        installReadyStateChangeImplementation();
+
+    } else {
+        // For older browsers
+        installSetTimeoutImplementation();
+    }
+
+    attachTo.setImmediate = setImmediate;
+    attachTo.clearImmediate = clearImmediate;
+}(new Function("return this")()));

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

@@ -7,8 +7,6 @@ class DataStore
   end
 
   def query(collection, query)
-    puts "QUERY: #{collection} - #{query.inspect}"
-
     query = query.dup
     query.keys.each do |key|
       if key =~ /_id$/

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

@@ -23,29 +23,29 @@ class LiveQuery
   end
 
   def notify_removed(ids, skip_channel)
+    # puts "Removed: #{ids.inspect}"
     notify! do |channel|
-      # puts "Removed: #{ids.inspect} to #{channel.inspect}"
       channel.send_message("removed", nil, @collection, @query, ids)
     end
   end
 
   def notify_added(index, data, skip_channel)
+    # puts "Added: #{index} - #{data.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)
+    # puts "Moved: #{id}, #{new_position}"
     notify! do |channel|
-      # 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)
+    # puts "Changed: #{id}, #{data}"
     notify!(skip_channel) do |channel|
-      # puts "Changed: #{id}, #{data} to #{channel.inspect}"
       channel.send_message("changed", nil, @collection, @query, id, data)
     end
   end

data/docs/GETTING_STARTED.md

@@ -1,7 +1,28 @@
 # Getting Started
 
-Volt relies on a few concepts to take make web development faster and easier.  The first of these is reactive programming.  Data on the front and back end is stored in models.  Instead of manually updating a page when the data changes, the page is coded using a handlebars like templating language which automatically updates when the data changes.
+Volt relies on a few concepts to take make web development faster and easier.  The first of these is reactive programming.  Data on the front and back end is stored in models.  Instead of manually updating a page when the data changes, the page is coded using a templating language which automatically updates when the data changes.
 
-## Reactive Values
+## Bindings and Models
 
-The key to making these updates happen is something we call "Reactive Values."  A ReactiveValue wraps another v
+This automaic updating is done via bindings and models.  In Volt app's all data is stored in a model.  From your html, you can bind things like attributes and text to a value in a model.
+
+### Name Example
+
+```html
+<label>Name:</label>
+<input type="text" value="{page._name}" />
+<p>Hello {page._name}</p>
+```
+
+In the example above, our model is called page (more about page later).  Any time a user changes the value of the field, page._name will be updated to the fields value.  When page._name is changed, the fields value changes.  Also when ```page._name``` changes, the page will show the text "Hello ..." where ... is the value of page._name.  These "two-way bindings" help us eliminiate a lot of code by keeping all of our application state in our models.  Data displayed in a view is always computed live from the data in the models.
+
+### Meal Cost Splitter Example
+
+```html
+<label>Cost:</label><input type="text" value="{page._cost}" /><br />
+<label>People:</label><input type="text" value="{page._people}" /><br />
+<p>Cost Per Person: {page._cost.to_f / page._people.to_f}</p>
+```
+In this example, a user can enter a cost and a number of people.  When either changes, the Cost Per Person will update.
+
+###

data/docs/WHY.md

@@ -18,30 +18,9 @@ Data in volt is reactive by default.  Changes to the data is automatically updat
 A lot of modern web development is moving data between the front-end to the back-end.  Volt eliminates all of that work.  Model's on the front-end automatically sync to the back-end, and vice versa.  Validations are run on both sides for security.  Models on the front-end are automatically updated whenever they are changed anywhere else (another browser, a background task, etc..)
 
 
-## Speed
-
-Volt's reactive objects contain extra data about how to propigate events.  Things that don't need to be updated when data changes aren't.  Volt uses an intellegent managed draw cycle to do efficient DOM updates.  Only the changed part of the page is re-rendered.
-
-
-
-
 # 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.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+- 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 core, 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.
 
 
 # Why Ruby

data/lib/volt.rb

@@ -1,8 +1,15 @@
 require 'volt/volt/environment'
 require 'volt/extra_core/extra_core'
-require 'volt/reactive/reactive_value'
+require 'volt/reactive/computation'
+require 'volt/reactive/dependency'
 
 class Volt
+  if RUBY_PLATFORM == 'opal'
+    @@in_browser = `!!document && !window.OPAL_SPEC_PHANTOM`
+  else
+    @@in_browser = false
+  end
+
   def self.root
     @root ||= File.expand_path(Dir.pwd)
   end
@@ -26,4 +33,16 @@ class Volt
   def self.env
     @env ||= Volt::Environment.new
   end
+
+  def self.logger
+    @logger ||= Logger.new
+  end
+
+  def self.logger=(val)
+    @logger = val
+  end
+
+  def self.in_browser?
+    @@in_browser
+  end
 end

data/lib/volt/console.rb

@@ -1,3 +1,23 @@
+require 'pry'
+
+class Pry
+  # To make the console more useful, we make it so we flush the event registry
+  # after each line.  This makes it so events are triggered after each line.
+  # To accomplish this we monkey-patch pry.
+  def rep(target=TOPLEVEL_BINDING)
+    target = Pry.binding_for(target)
+    result = re(target)
+
+    Pry.critical_section do
+      show_result(result)
+    end
+
+    # Automatically flush after each line
+    Computation.flush!
+  end
+end
+
+
 class Console
   def self.start
     require 'pry'

data/lib/volt/controllers/model_controller.rb

@@ -1,8 +1,10 @@
-require 'volt/controllers/reactive_accessors'
+require 'volt/reactive/reactive_accessors'
 
 class ModelController
   include ReactiveAccessors
 
+  reactive_accessor :current_model
+
   def self.model(val)
     @default_model = val
   end
@@ -10,24 +12,31 @@ class ModelController
   # Sets the current model on this controller
   def model=(val)
     # Start with a nil reactive value.
-    @model ||= ReactiveValue.new(Proc.new { nil })
+    self.current_model ||= Model.new
 
     if Symbol === val || String === val
       collections = [:page, :store, :params, :controller]
       if collections.include?(val.to_sym)
-        @model.cur = self.send(val).cur
+        self.current_model = self.send(val)
       else
         raise "#{val} is not the name of a valid model, choose from: #{collections.join(', ')}"
       end
     elsif val
-      @model.cur = val.cur
+      self.current_model = val
     else
       raise "model can not be #{val.inspect}"
     end
   end
 
   def model
-    @model
+    model = self.current_model
+
+    # If the model is a proc, call it now
+    if model.is_a?(Proc)
+      model = model.call
+    end
+
+    return model
   end
 
   def self.new(*args, &block)
@@ -40,11 +49,16 @@ class ModelController
     return inst
   end
 
+  attr_accessor :attrs
+
   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)
+    if args[0]
+      # Assign the first passed in argument to attrs
+      self.attrs = args[0]
+
+      # If a model attribute is passed in, we assign it directly
+      if attrs.respond_to?(:model)
+        self.model = attrs.locals[:model]
       end
     end
   end
@@ -87,10 +101,10 @@ class ModelController
   end
 
   def controller
-    @controller ||= ReactiveValue.new(Model.new)
+    @controller ||= Model.new
   end
 
   def method_missing(method_name, *args, &block)
-    return @model.send(method_name, *args, &block)
+    return model.send(method_name, *args, &block)
   end
 end

data/lib/volt/extra_core/object.rb

@@ -9,7 +9,7 @@ class Object
   # Provides the same functionality as ||, but since ReactiveValue's only
   # work with method calls, we provide .or as a convience.
   def or(other)
-    if self.true?
+    if self && !self.nil?
       return self
     else
       return other
@@ -19,25 +19,13 @@ class Object
   # Provides the same functionality as &&, but since ReactiveValue's only
   # work with method calls, we provide .and as a convience
   def and(other)
-    if self.true?
+    if self && !self.nil?
       return other
     else
       return self
     end
   end
 
-  def try(*a, &b)
-    if a.empty? && block_given?
-      yield self
-    else
-      __send__(*a, &b)
-    end
-  end
-
-  def deep_cur
-    self.cur
-  end
-
   def html_inspect
     inspect.gsub('<', '&lt;').gsub('>', '&gt;')
   end