volt 0.9.6 → 0.9.7.pre2

data/lib/volt/models/model.rb

@@ -13,6 +13,7 @@ require 'volt/models/validators/user_validation'
 require 'volt/models/helpers/dirty'
 require 'volt/models/helpers/listener_tracker'
 require 'volt/models/helpers/change_helpers'
+require 'volt/models/helpers/defaults'
 require 'volt/models/permissions'
 require 'volt/models/associations'
 require 'volt/reactive/class_eventable'
@@ -43,6 +44,7 @@ module Volt
     include FieldHelpers
     include UserValidatorHelpers
     include Models::Helpers::Dirty
+    include Models::Helpers::Defaults
     include ClassEventable
     include Modes
     include Models::Helpers::ListenerTracker
@@ -93,6 +95,8 @@ module Volt
         change_state_to(:loaded_state, initial_state || :loaded, false)
       end
 
+      setup_defaults
+
       # Trigger the new event, pass in :new
       trigger!(:new, :new)
     end
@@ -288,6 +292,10 @@ module Volt
         opts = @options.merge(parent: self, path: path + [method_name])
 
         if method_name.plural?
+          if self.class != Volt::Model
+            opts[:associate] = self.class.collection_name
+          end
+
           return new_array_model([], opts)
         else
           return new_model({}, opts)
@@ -306,12 +314,27 @@ module Volt
       options         = options.dup
       options[:query] = []
 
+      check_require_model_class(options)
+
       Volt::ArrayModel.class_at_path(options[:path]).new(attributes, options)
     end
 
+    # For collections that don't allow on the fly models, we check to see if
+    # a model class has been defined.
+    def check_require_model_class(options)
+      model_klass = Volt::Model.class_at_path(options[:path])
+
+      if model_klass == Volt::Model && @persistor && !@persistor.on_the_fly_collections?
+        raise "The `#{root.repo_name}` repo (at `#{options[:path].join('.')}`) does not allow on the fly collections, create a class for the model before using it."
+      end
+    end
+
     def inspect
       Computation.run_without_tracking do
         str = "#<#{self.class}"
+
+
+        str += ":(buffer)" if buffer?
         # str += ":#{object_id}"
 
         # First, select all of the non-ArrayModel values
@@ -319,7 +342,7 @@ module Volt
 
         # Show the :id first, then sort the rest of the attributes
         id = attrs.delete(:id)
-        id = id[0..3] + '..' + id[-4..-1] if id
+        id = id[0..3] + '..' + id[-4..-1] if id && id.size > 5
 
         attrs = attrs.sort
         attrs.insert(0, [:id, id]) if id
@@ -354,6 +377,20 @@ module Volt
       to_h.to_json
     end
 
+    # return the collection name for this model class
+    def self.collection_name
+      name = @collection_name || self.name
+      if name
+        name.underscore.pluralize.to_sym
+      else
+        raise "Class does not have a name, assign one with collection_name or use a named class."
+      end
+    end
+
+    def self.set_collection_name(collection_name)
+      @collection_name = collection_name.to_s
+    end
+
     # Update tries to update the model and returns
     def update(attrs)
       old_attrs = @attributes.dup

data/lib/volt/models/permissions.rb

@@ -14,7 +14,7 @@ module Volt
             belongs_to key.to_s.gsub(pattern, '')
           else
             raise "You tried to auto associate a model using #{key}, but #{key} "\
-                  "does not end in `_id`"
+              "does not end in `_id`"
           end          # When the model is created, assign it the user_id (if the user is logged in)
           on(:new) do
             # Only assign the user_id if there isn't already one and the user is logged in.
@@ -173,6 +173,13 @@ module Volt
             res.each do |key, value|
               if value.is_a?(Model)
                 value = value.filtered_attributes
+              elsif value.is_a?(ArrayModel)
+                new_val = []
+                value.all.each do |sub_model|
+                  new_val << sub_model.filtered_attributes.sync
+                end
+
+                value = new_val
               end
               keys << key
               values << value

data/lib/volt/models/persistors/array_store.rb

@@ -1,13 +1,14 @@
 require 'volt/models/persistors/store'
 require 'volt/models/persistors/store_state'
 require 'volt/models/persistors/query/query_listener_pool'
+require 'volt/models/persistors/query/query_identifier'
 require 'volt/utils/timers'
 
 module Volt
   module Persistors
     class ArrayStore < Store
       include StoreState
-
+      include ReactiveAccessors
 
       @@query_pool = QueryListenerPool.new
 
@@ -72,6 +73,7 @@ module Volt
 
       # Called by child models to track their listeners
       def listener_removed
+        # puts "LIST REMOVE:  #{inspect}"
         @listener_event_counter.remove
       end
 
@@ -137,7 +139,7 @@ module Volt
           if parent && !@model.is_a?(Cursor) && (attrs = parent.attributes) && attrs[:id]
             query = query.dup
 
-            query << [:find, { :"#{@model.path[-3].singularize}_id" => attrs[:id] }]
+            query << [:where, { :"#{@model.path[-3].singularize}_id" => attrs[:id] }]
           end
         end
 
@@ -157,16 +159,89 @@ module Volt
       # This will then be passed to the backend to run the query.
       #
       # @return [Cursor] a new cursor
-      def add_query_part(*args)
+      def add_query_part(*args, &block)
         opts = @model.options
         query = opts[:query] ? opts[:query].deep_clone : []
-        query << args
+
+        if args[0] == :where && block
+          # Change the query name to show that we were passed a block
+          args[0] = :where_with_block
+          # Block was passed to where query, pass in the QueryIdentifier
+          result = block.call(QueryIdentifier.new)
+
+          query << [*args, result.to_query]
+        else
+          query << args
+        end
 
         # Make a new opts hash with changed query
         opts = opts.merge(query: query)
         Cursor.new([], opts)
       end
 
+      # When doing things like .count, we get back a value, not an Array of
+      # Models.  To handle this, the updates from the server just resolve the
+      # value directly.
+      def resolve_value(val)
+        if @resolve_promises
+          # Resolve all waiting promises
+          resolve_promises.each do |promise|
+            promise.resolve(val)
+          end
+        else
+          # Only invalidate to generate a new promise if the previous one is
+          #  already realized.
+          resolve_dep.changed!
+          @resolve_dep = nil
+        end
+
+        # @root_dep.changed!
+
+        @model.value = val
+        @resolve_promises = nil
+      end
+
+      def value
+        # proc do |comp|
+        @root_dep.depend
+        resolve_dep.depend
+        #   comp.stop
+        # end.watch!
+        unless Computation.current
+          # Load the data now manually not running inside of a computation.
+          load_data
+        end
+
+        if @value.respond_to?(:has_value?) && @model.has_value? && (resval = self.resolved_value)
+          # Value is already there, return a resolved promise
+          return Promise.new.resolve(resval)
+        else
+          # Otherwise generate a new promise and queue it for resolving
+          promise = Promise.new
+          resolve_promises << promise
+
+          return promise
+        end
+      end
+
+      # Return a promise for resolving a value from something like .count
+      def resolve_promises
+        @resolve_promises ||= []
+      end
+
+
+      def resolve_dep
+        @resolve_dep ||= Dependency.new
+      end
+
+      def resolved_value
+        if @value.respond_to?(:has_value?) && @model.has_value?
+          @model.value
+        else
+          nil
+        end
+      end
+
       # Call a method on the model once the model is loaded.  Return a promise
       # that will resolve when the model is loaded
       def run_once_loaded
@@ -191,6 +266,12 @@ module Volt
       # passed block will be passed to the promises then.  Then will be passed the model.
       def fetch(&block)
         Volt.logger.warn('Deprication warning: in 0.9.3.pre4, all query methods on store now return Promises, so you can juse use .all or .first instead of .fetch')
+        begin
+          raise
+        rescue => e
+          puts e.inspect
+          puts e.backtrace.join("\n")
+        end
         promise = Promise.new
 
         # Run the block after resolve if a block is passed in
@@ -211,10 +292,6 @@ module Volt
         promise
       end
 
-      # Alias then for now
-      # TODO: Deprecate
-      alias_method :then, :fetch
-
       # Called from backend when an item is added
       def add(index, data)
         $loading_models = true
@@ -293,6 +370,8 @@ module Volt
       def async?
         true
       end
+
+      private
     end
   end
 end

data/lib/volt/models/persistors/base.rb

@@ -46,6 +46,25 @@ module Volt
         false
       end
 
+      # Stores can allow or not allow "on the fly collections", this means a
+      # collection will be created when saved to, even if the collection did
+      # not exist previously and was not created with a class.
+      #
+      # If we allow on the fly collections, we could do the following:
+      #    store._somethings
+      # ^ where no Something model class had been created
+      def on_the_fly_collections?
+        true
+      end
+
+      # Count gets passed down to the persistor, since different persistors
+      # may implement it different ways.  #reactive_count just aliases normal
+      # count for now.
+      def count(*args, &block)
+        @model.reactive_count(*args, &block)
+      end
+
+
       # Find the root for this model
       def root_model
         node = @model

data/lib/volt/models/persistors/model_store.rb

@@ -159,7 +159,7 @@ module Volt
 
       if RUBY_PLATFORM != 'opal'
         def db
-          @@db ||= Volt::DataStore.fetch
+          @@db ||= Volt::DataStore.fetch(Volt.current_app)
         end
 
         # Do the actual writing of data to the database, only runs on the backend.

data/lib/volt/models/persistors/page.rb

@@ -8,7 +8,7 @@ module Volt
       end
 
       def where(query)
-        @model.select do |model|
+        result = @model.select do |model|
           # Run through each key in the query and make sure the value matches.
           # We use .all? because once one fails to match, we can return false,
           # because it wouldn't match as a whole.
@@ -16,6 +16,9 @@ module Volt
             model.get(key) == value
           end
         end
+
+        options = @model.options.merge(parent: @model, path: @model.path)
+        @model.new_array_model(result, options)
       end
     end
   end

data/lib/volt/models/persistors/query/query_identifier.rb

@@ -0,0 +1,102 @@
+# Volt allows you to pass blocks to .where queries.  The block will receive a
+# single argument, which sumulates the row in the database.  On the row, you
+# can call comparitors and use logical and/or (| and &) to build up queries.
+#
+# The QueryIdentifier class stores all methods called on it, and uses the
+# QueryOp class to store logical operations.  You can call .to_query on the
+# result to get an array representing the query.  This can then be normalized
+# and called on the backend to answer the query.
+
+module Volt
+  class QueryIdentifier
+    def initialize(from='ident')
+      @from = from
+    end
+
+    def method_missing(method_name, *args)
+      method_name = method_name.to_s
+      # c for call
+
+      args.map do |arg|
+        if arg.is_a?(Array)
+          # Escape the array
+          arg.unshift('a')
+        end
+      end
+
+      QueryIdentifier.new(['c', @from, method_name, *args])
+    end
+
+    def ==(val)
+      method_missing(:==, val)
+    end
+
+    # def !
+    #   method_missing(:!)
+    # end
+
+    # Special methods in ruby don't respond to method_missing, so setup methods
+    # for them.
+    # We need < and > until https://github.com/opal/opal/issues/1137 is fixed.
+    ['=~', '!~', '&', '|', '<', '>', '<=', '>='].each do |op|
+      define_method(op) do |val|
+        __op(op, val)
+      end
+    end
+
+    # And for unary ops
+    def ~
+      __op('~')
+    end
+
+    def +(val)
+      method_missing(:+, val)
+    end
+
+    def __op(*args)
+      QueryOp.new(['c', self, *args])
+    end
+
+    def coerce(other)
+      unless other.is_a?(Volt::QueryIdentifier)
+        other = Volt::QueryIdentifier.new(other)
+      end
+
+      [other, self]
+    end
+
+    def inspect
+      "(#{@from.join(' ')})"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def to_query
+      if @from.is_a?(Array)
+        @from.map do |val|
+          if val.is_a?(QueryIdentifier)
+            val.to_query
+          else
+            val
+          end
+        end
+      else
+        @from
+      end
+    end
+  end
+
+  class QueryOp < QueryIdentifier
+
+  end
+end
+
+# def where
+#   ident = Volt::QueryIdentifier.new
+#   yield(ident)
+# end
+
+# a = where {|v| ((v.name < 10) | (v.name > 5)) & ~(v.name == 'Ryan') }
+# b = where {|v| 1 < v.name }

data/lib/volt/models/persistors/query/query_listener.rb

@@ -1,5 +1,5 @@
 module Volt
-  # The query listener is what gets notified on the backend when the results from
+  # The query listener is what gets notified from the backend when the results from
   # a query have changed.  It then will make the necessary changes to any ArrayStore's
   # to get them to display the new data.
   class QueryListener
@@ -12,6 +12,7 @@ module Volt
 
       @collection = collection
       @query      = query
+      @data       = []
 
       @listening = false
     end
@@ -23,6 +24,9 @@ module Volt
       QueryTasks.add_listener(@collection, @query).then do |ret|
         results, errors = ret
 
+        # Store the data
+        @data = results
+
         # When the initial data comes back, add it into the stores.
         @stores.dup.each do |store|
           # Clear if there are existing items
@@ -30,11 +34,15 @@ module Volt
             store.model.clear if store.model.size > 0
           end
 
-          results.each do |index, data|
-            store.add(index, data)
-          end
+          if results.is_a?(Array)
+            results.each_with_index do |data, index|
+              store.add(index, data)
+            end
 
-          store.model.change_state_to(:loaded_state, :loaded)
+            store.model.change_state_to(:loaded_state, :loaded)
+          else
+            store.resolve_value(results)
+          end
 
           # if Volt.server?
           #   store.model.change_state_to(:loaded_state, :dirty)
@@ -42,7 +50,7 @@ module Volt
         end
       end.fail do |err|
         # TODO: need to make it so we can re-raise out of this promise
-        msg = "Error adding listener: #{err.inspect}"
+        msg = "Database Query Error: #{err.inspect}"
         msg += "\n#{err.backtrace.join("\n")}" if err.respond_to?(:backtrace)
         Volt.logger.error(msg)
 
@@ -64,13 +72,20 @@ module Volt
         # copy the data from the existing model.
         store.model.clear
 
-        # Get an existing store to copy data from
-        first_store_model = @stores.first.model
-        first_store_model.each_with_index do |item, index|
-          store.add(index, item.to_h)
+        first_store = @stores.first
+
+        if (resolved_value = first_store.resolved_value)
+          store.resolve_value(resolved_value)
+        else
+          # Get an existing store to copy data from
+          first_store_model = first_store.model
+          first_store_model.each_with_index do |item, index|
+            store.add(index, item.to_h)
+          end
+
+          store.model.change_state_to(:loaded_state, first_store_model.loaded_state)
         end
 
-        store.model.change_state_to(:loaded_state, first_store_model.loaded_state)
       else
         # First time we've added a store, setup the listener and get
         # the initial data.
@@ -94,7 +109,30 @@ module Volt
       end
     end
 
-    def added(index, data)
+    def updated(diff)
+      diff.each do |op|
+        operation, arg1, arg2 = op
+
+        case operation
+        when 'i'
+          # insert
+          inserted(arg1, arg2)
+        when 'r'
+          # remove
+          removed([arg1])
+        when 'c'
+          # changed
+          changed(arg1, arg2)
+        when 'm'
+          # move
+        when 'u'
+          # single value, update it
+          update(arg1)
+        end
+      end
+    end
+
+    def inserted(index, data)
       @stores.each do |store|
         store.add(index, data)
       end
@@ -106,7 +144,14 @@ module Volt
       end
     end
 
+    def update(data)
+      @stores.each do |store|
+        store.resolve_value(data)
+      end
+    end
+
     def changed(model_id, data)
+      puts "CH: #{model_id.inspect} - #{data.inspect}"
       $loading_models = true
       Persistors::ModelStore.changed(model_id, data)
       $loading_models = false