volt 0.9.2 → 0.9.3.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c57d60611600de9f132243981453e12dd14d7d2b
-  data.tar.gz: e14a1bbead84d93c8cd03bcac1bdaf54d315d2ff
+  metadata.gz: d6e09afcd5fa1abe6f17a9c2912bc79cf4cf74aa
+  data.tar.gz: f0ee7b0085bddf48461122bfccec1b21b06b2e3e
 SHA512:
-  metadata.gz: 4fc5686a5121b45d4186acd8c59e0b46e45ad9796752a1bc0b915234fe864cb90bc8f6ad58954e4f757516a744e07cfe3da20d22e7283b49c12aab7bf59b12f6
-  data.tar.gz: 5b1b6ac243e17387a564b42be1341d378282883766a7e3002f21faa2396bd6c2006b53333ad39936194d5c84ba6ca29fb34c9dd63043f241251d5727481691b7
+  metadata.gz: ed02ac1418ee8f8ed50a67331dfb58eeabf933a55ecb60a2cb05052245164e851331fea5a5de8977a1fbfa31859bedea4dcaf8117b28258559c0954c5ff3f9e3
+  data.tar.gz: 7069f1ac08014813da1501c252fed11031c248b479d7b7323ff49a69b17cdc5dc54e793f48b48b199a6e23fd56178ff6684b47151640ab321af3fd0cfcfe5d71

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## 0.9.3.pre1
+### Added
+- Added validations block for conditional validation runs
+
+### Changed
+- All logic associated with mongo has been moved into the volt-mongo gem.  If you are migrating from a previous version, be sure to add ```gem 'volt-mongo'``` to the Gemfile.
+
 ## 0.9.2
 ### Changed
 - We released 0.9.1 with a bug for destroy (doh!).  Specs added and bug fixed.

data/CONTRIBUTING.md

@@ -41,6 +41,10 @@ If not installed, you can install from the source or use Homebrew:
 brew upgrade && brew install phantomjs
 ```
 
+#### Caveat
+
+You need 2.0 for MutationObserver API support, so until this issue https://github.com/teampoltergeist/poltergeist/issues/574 is resolved that poltergeist will support phantomjs 2.0, the test for attribute binding has to be in a real browser.
+
 #### Bundle Install and Test
 
 Ensure that you can build the project and run tests.

data/Gemfile

@@ -2,6 +2,9 @@ source 'http://rubygems.org'
 
 gemspec
 
+# volt-mongo gem for testing
+gem 'volt-mongo'
+
 group :development do
   # For testing the kitchen sink app
   # Twitter bootstrap

data/app/volt/assets/js/volt_js_polyfills.js

@@ -10,7 +10,6 @@ if (!Function.prototype.bind) {
   };
 }
 
-
 // setImmediate
 (function (global, undefined) {
     "use strict";

data/app/volt/assets/js/volt_watch.js

@@ -0,0 +1,217 @@
+/*
+ * Watch Event Listener
+ *
+ * @author Darcy Clarke
+ * Modified by Penn Su
+ *
+ * Copyright (c) 2014 Darcy Clarke
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ * Usage:
+ * watch(element, 'width height', function(){
+ *   console.log(this.style.width, this.style.height);
+ * });
+ */
+
+(function (window) {
+
+  var toArray;
+  var eqlArrays;
+
+  // http://jsfiddle.net/moagrius/YxzfV/
+  Array.prototype.multisplice = function(){
+    var args = Array.apply(null, arguments);
+    args.sort(function(a,b){
+     return a - b;
+    });
+    for(var i = 0; i < args.length; i++){
+      var index = args[i] - i;
+      this.splice(index, 1);
+    }
+  }
+
+  // Object to Array
+  toArray = function (obj) {
+
+    var arr = [];
+
+    for (var i = obj.length >>> 0; i--;) {
+      arr[i] = obj[i];
+    }
+
+    return arr;
+
+  };
+
+  eqlArrays = function (a, b) {
+    a.length == b.length && a.every(function (e, i) { e === b[i] });
+  }
+
+  var _watch = function (elements, props, options, callback){
+
+    // Setup
+    var self = this;
+    var check;
+
+    // Check if we should fire callback
+    check = function (e) {
+
+      var self = this;
+
+      for (var i = 0; i < self.watching.length; i++) {
+
+        var data = self.watching[i];
+        var changed = true;
+        var temp;
+
+        // Iterate through properties
+        for (var j = 0; j < data.props.length; j++) {
+          temp = self.attributes[data.props[j]] || self.style[data.props[j]];
+          if (data.vals[j] != temp) {
+            data.vals[j] = temp;
+            data.changed[j] = true;
+          }
+        }
+
+        // Check changed attributes
+        for (var k = 0; k < data.props.length; k++) {
+          if (!data.changed[k]) {
+            changed = false;
+            break;
+          }
+        }
+
+        // Run callback if property has changed
+        if (changed && data.callback) {
+          data.callback.apply(self, e);
+        }
+
+      };
+
+    };
+
+    // Elements from node list to array
+    elements = toArray(elements);
+
+    // Type check options
+    if (typeof(options) == 'function') {
+      callback = options;
+      options = {};
+    }
+
+    // Type check callback
+    if (typeof(callback) != 'function') {
+      callback = function(){};
+    }
+
+    // Set throttle
+    options.throttle = options.throttle || 10;
+
+    // Iterate over elements
+    for (var i = 0; i < elements.length; i++) {
+
+      var element = elements[i];
+      var data = {
+        props: props.split(' '),
+        vals: [],
+        changed: [],
+        callback: callback
+      };
+
+      // Grab each property's initial value
+      for (var j = 0; j < data.props.length; j++) {
+        data.vals[j] = element.attributes[data.props[j]] || element.style[data.props[j]];
+        data.changed[j] = false;
+      }
+
+      // Set watch array
+      if (!element.watching) {
+        element.watching = [];
+      }
+
+      // Store data in watch array
+      element.watching.push(data);
+
+      // Create new Mutation Observer
+      var observer = new MutationObserver(function (mutations) {
+        console.log(mutations);
+        for (var k = 0; k < mutations.length; k++) {
+          check.call(mutations[k].target, mutations[k]);
+        }
+      });
+
+      // Set observer array
+      if (!element.observers) {
+        element.observers = [];
+      }
+
+      // Store element observer
+      element.observers.push(observer);
+
+      // Start observing
+      observer.observe(element, { subtree: false, attributes: true });
+
+    }
+
+    // Return elements to enable chaining
+    return self;
+
+  };
+
+  var _unwatch = function (elements, props){
+
+    // Setup
+    var self = this;
+
+    // Elements from node list to array
+    elements = toArray(elements);
+
+    // Iterate over elements
+    for (var i = 0; i < elements.length; i++) {
+
+      var element = elements[i];
+      var indexes = []
+
+      if (element.watching) {
+        for (var j = 0; j < element.watching.length; j++) {
+
+          var data = element.watching[j];
+          if (eqlArrays(data.props, props.split(' '))) {
+            indexes.push(j);
+          }
+
+        }
+
+        element.watching.multisplice.apply(element.watching, indexes);
+      }
+
+    }
+
+    // Return elements to enable chaining
+    return self;
+
+  };
+
+  // Expose watch to window
+  window.watch = function () {
+    return _watch.apply(arguments[0], arguments);
+  };
+
+  window.unwatch = function () {
+    return _unwatch.apply(arguments[0], arguments);
+  };
+
+  // Expose watch to jQuery
+  (function ($) {
+    $.fn.watch = function () {
+      Array.prototype.unshift.call(arguments, this);
+      return _watch.apply(this, arguments);
+    };
+
+    $.fn.unwatch = function () {
+      Array.prototype.unshift.call(arguments, this);
+      return _unwatch.apply(this, arguments);
+    };
+  })(jQuery);
+
+})(window);

data/app/volt/models/user.rb

@@ -23,8 +23,13 @@ module Volt
     end
 
     if RUBY_PLATFORM == 'opal'
-      # Don't validate on the server
-      validate :password, length: 8
+      validations do
+        # Only validate password when it has changed
+        if changed?(:password)
+          # Don't validate on the server
+          validate :password, length: 8
+        end
+      end
     end
 
     def password=(val)

data/app/volt/tasks/query_tasks.rb

@@ -16,6 +16,12 @@ class QueryTasks < Volt::Task
     self.class.live_query_pool
   end
 
+  def self.reset!
+    @@channel_live_queries = {}
+    @@live_query_pool = nil
+    live_query_pool
+  end
+
   def add_listener(collection, query)
     live_query = @@live_query_pool.lookup(collection, query)
     track_channel_in_live_query(live_query)

data/lib/volt/boot.rb

@@ -2,7 +2,7 @@ unless RUBY_PLATFORM == 'opal'
   # An option to skip requiring.
   unless ENV['SKIP_BUNDLER_REQUIRE']
     # Require in gems
-    Bundler.require((ENV['VOLT_ENV'] || ENV['RACK_ENV'] || :development).to_sym)
+    Bundler.require(:default, (ENV['VOLT_ENV'] || ENV['RACK_ENV'] || :development).to_sym)
   end
 end
 

data/lib/volt/cli/generate.rb

@@ -74,7 +74,7 @@ class Generate < Thor
   method_option :name, type: :string, banner: 'The name of the task.'
   method_option :component, type: :string, default: 'main', banner: 'The component the task should be created in.', required: false
   def task(name, component = 'main')
-    name = name.underscore.gsub(/_tasks$/, '').singularize + '_tasks'
+    name = name.underscore.gsub(/_tasks$/, '').singularize + '_task'
     output_file = Dir.pwd + "/app/#{component}/tasks/#{name}.rb"
     spec_file = Dir.pwd + "/spec/app/#{component}/tasks/#{name}_spec.rb"
     template('task/task.rb.tt', output_file, task_name: name.camelize.singularize)

data/lib/volt/config.rb

@@ -1,5 +1,7 @@
 # Config lets a user set global config options for Volt.
-# The hash is setup on the server, then passed to the client on initial page render.
+# The hash is setup on the server, then the settings under .public are passed
+# to the client on initial page render.  Volt.configure can be called multiple
+# times and settings will be added to the existing configuration.
 if RUBY_PLATFORM == 'opal'
   require 'ostruct'
 
@@ -82,8 +84,16 @@ else
       alias_method :config, :configuration
     end
 
+    inst = self
     configuration_defaults do |c|
-      c.from_h(Volt.defaults)
+      current_config = inst.instance_variable_get(:@configuration)
+      if current_config
+        # Default to the existing config, so we can extend
+        c.from_h(current_config.to_h)
+      else
+        # First call
+        c.from_h(Volt.defaults)
+      end
     end
   end
 end

data/lib/volt/controllers/model_controller.rb

@@ -190,7 +190,7 @@ module Volt
     def require_login(message = 'You must login to access this area.')
       unless Volt.current_user_id
         flash._notices << message
-        go '/login'
+        redirect_to '/login'
 
         stop_chain
       end

data/lib/volt/data_stores/base_adaptor_client.rb

@@ -0,0 +1,34 @@
+module Volt
+  class DataStore
+    class BaseAdaptorClient
+      # normalize_query should take all parts of the query and return a
+      # "normalized" version, so that two queries that are eseitnally the same
+      # except for things like order are the same.
+      #
+      # Typically this means sorting parts of the query so that two queries
+      # which do the same things are the same, so they can be uniquely
+      # identified.
+      #
+      # The default implementation does no normalizing.  This works, but results
+      # in more queries being sent to the backend.
+      def self.normalize_query(query)
+        query
+      end
+
+      # A class method that takes an array of method names we want to provide
+      # on the ArrayModel class.  (These are typically query/sort/order/etc...
+      # methods).  This adds a proxy method to the store persistor for all
+      # passed in method names, and then sets up a default tracking method
+      # on the ArrayStore persistor.
+      def self.data_store_methods(*method_names)
+        Volt::ArrayModel.proxy_to_persistor(*method_names)
+
+        method_names.each do |method_name|
+          Volt::Persistors::ArrayStore.send(:define_method, method_name) do |*args|
+            add_query_part(method_name, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/volt/data_stores/{base.rb → base_adaptor_server.rb}

@@ -1,6 +1,6 @@
 module Volt
   class DataStore
-    class Base
+    class BaseAdaptorServer
     end
   end
 end

data/lib/volt/data_stores/data_store.rb

@@ -1,20 +1,36 @@
-require 'volt/data_stores/mongo_driver'
+require 'volt/data_stores/base_adaptor_server'
 
 module Volt
   class DataStore
     def self.fetch
       # Cache the driver
-      return @driver if @driver
+      return @adaptor if @adaptor
 
       database_name = Volt.config.db_driver
-      driver_name = database_name.camelize + 'Driver'
+      adaptor_name = database_name.camelize + 'AdaptorServer'
 
-      begin
-        driver = const_get(driver_name)
-        @driver = MongoDriver.new
-      rescue NameError => e
+      root = Volt::DataStore
+      if root.const_defined?(adaptor_name)
+        adaptor_name = root.const_get(adaptor_name)
+        @adaptor = adaptor_name.new
+      else
         raise "#{database_name} is not a supported database"
       end
+
+      @adaptor
+    end
+
+    def self.adaptor_client
+      # Load the client adaptor
+      @adaptor_client ||= begin
+        ds_name = Volt.config.public.datastore_name
+        unless ds_name
+          raise "No data store configured, please include volt-mongo or " +
+                "another similar gem."
+        end
+        adaptor_class_name = ds_name.capitalize + "AdaptorClient"
+        Volt::DataStore.const_get(adaptor_class_name)
+      end
     end
   end
 end