volt 0.9.6 → 0.9.7.pre2

data/lib/volt/models/array_model.rb

@@ -156,7 +156,7 @@ module Volt
           if can_delete
             super(val)
           else
-           Promise.new.reject("permissions did not allow delete for #{val.inspect}.")
+            Promise.new.reject("permissions did not allow delete for #{val.inspect}.")
           end
         end
       end
@@ -178,12 +178,28 @@ module Volt
 
     # Return the first item in the collection, or create one if one does not
     # exist yet.
-    def first_or_create
+    def first_or_create(attrs={})
       first.then do |item|
         if item
           item
         else
-          create
+          create(attrs)
+        end
+      end
+    end
+
+    # Finds a model maching query and calls .update passing in attrs.  If the
+    # model is not found, it creates the model with attrs merged into query.
+    def update_or_create(query, attrs={})
+      where(query).first.then do |item|
+        if item
+          if attrs.size > 0
+            item.update(attrs)
+          else
+            item
+          end
+        else
+          create(query.merge(attrs))
         end
       end
     end
@@ -241,10 +257,13 @@ module Volt
     def new_model(*args)
       Volt::Model.class_at_path(options[:path]).new(*args)
     end
+
     alias_method :new, :new_model
 
     def new_array_model(*args)
-      Volt::ArrayModel.class_at_path(options[:path]).new(*args)
+      klass = Volt::ArrayModel.class_at_path(options[:path])
+
+      klass.new(*args)
     end
 
     # Convert the model to an array all of the way down
@@ -309,10 +328,15 @@ module Volt
 
     alias_method :reactive_count, :count
     def count(&block)
-      all.reactive_count(&block)
+      if !block && persistor.is_a?(Persistors::ArrayStore)
+        @persistor.resolved_value
+      else
+        all.reactive_count(&block)
+      end
     end
 
     private
+
     # called form <<, append, and create.  If a hash is passed in, it converts
     # it to a model.  Then it takes the model and inserts it into the ArrayModel
     # then persists it.
@@ -328,13 +352,15 @@ module Volt
         model = wrap_values([model]).first
       end
 
-
       if model.is_a?(Model)
         promise = model.can_create?.then do |can_create|
           unless can_create
             fail "permissions did not allow create for #{model.inspect}"
           end
         end.then do
+          if (assoc = options[:associate])
+            parent.associate(assoc, model)
+          end
 
           # Add it to the array and trigger any watches or on events.
           reactive_array_append(model)
@@ -345,6 +371,7 @@ module Volt
             # Validate and save
             model.run_changed
           end.then do
+
             # Mark the model as not new
             model.instance_variable_set('@new', false)
 

data/lib/volt/models/associations.rb

@@ -2,12 +2,12 @@ module Volt
   module Associations
     module ClassMethods
       def belongs_to(method_name, options = {})
-        collection  ||= options.fetch(:collection, method_name).pluralize
-        foreign_key ||= options.fetch(:foreign_key, :id)
-        local_key   ||= options.fetch(:local_key, "#{method_name}_id")
+        collection, foreign_key, local_key = assoc_parts_and_track(
+          method_name, options, :belongs_to
+        )
 
         # Add a field for the association_id
-        field(local_key)
+        field(local_key, String)
 
         # getter
         define_method(method_name) do
@@ -20,43 +20,76 @@ module Volt
           end
         end
 
+        # setter
         define_method(:"#{method_name}=") do |obj|
-          id = obj.is_a?(Fixnum) ? obj : obj.id
+          # Associatie the obj's foreign key
+          obj.set(foreign_key, id)
 
-          # Assign the current model's something_id to the object's id
-          set(local_key, id)
+          # Associate on the method name
+          set(method_name, obj)
         end
       end
 
       def has_many(method_name, options = {})
-        collection  ||= options.fetch(:collection, method_name).pluralize
+        mmethod_name = method_name.to_sym
+        if method_name.singular?
+          raise NameError, "has_many takes a plural association name"
+        end
 
-        # Use the underscored current class name as the something_id.
-        foreign_key ||= options.fetch(:foreign_key, "#{to_s.underscore.singularize}_id")
-        local_key   ||= options.fetch(:local_key, :id)
+        collection, foreign_key, local_key = assoc_parts_and_track(
+          method_name, options, :has_many
+        )
 
         define_method(method_name) do
-          lookup_key = get(local_key)
-          array_model = root.get(collection).where(foreign_key => lookup_key)
-
-          # Since we are coming off of the root collection, we need to setup
-          # the right parent and path.
-          new_path = array_model.options[:path]
-          # Assign path and parent
-          array_model.path = self.path + new_path
-          array_model.parent = self
+          # If the association is already in attributes, return
+          if attributes[method_name]
+            get(method_name)
+          else
 
-          array_model
+            # Get the
+            lookup_key = get(local_key)
+            array_model = root.get(collection).where(foreign_key => lookup_key)
+
+            # Since we are coming off of the root collection, we need to setup
+            # the right parent and path.
+            new_path = array_model.options[:path]
+            # Assign path and parent
+            array_model.path = self.path + new_path
+            array_model.parent = self
+
+            # Store the associated query, don't track changes, since the
+            # association is persisted via _id fields.
+            Volt.run_in_mode(:no_change_tracking) do
+              set(method_name, array_model)
+            end
+            array_model
+          end
         end
+
+        # setter
+        # define_method(:"#{method_name}=") do |val|
+        #   assoc = get(method_name)
+
+        #   # Set the foreign_key on the has_many model to the local_key of the
+        #   # current model.
+        #   assoc.append(val).then do |model|
+        #     model.set(foreign_key, get(local_key))
+        #   end
+        # end
       end
 
       # has_one creates a method on the Volt::Model that returns a promise
       # to get the associated model.
-      def has_one(method_name)
+      def has_one(method_name, options={})
         if method_name.plural?
           raise NameError, "has_one takes a singluar association name"
         end
 
+        collection, foreign_key, local_key = assoc_parts_and_track(
+          method_name, options, :has_one
+        )
+
+
         define_method(method_name) do
           association_with_root_model('has_one') do |root|
             key = self.class.to_s.underscore + '_id'
@@ -64,10 +97,100 @@ module Volt
           end
         end
       end
+
+
+      def assoc_parts(method_name, options, type)
+        collection = options.fetch(:collection, method_name).pluralize
+
+        default_foreign_key = case type
+        when :has_many, :has_one
+          :"#{to_s.underscore.singularize}_id"
+        else
+          :id
+        end
+        foreign_key = options.fetch(:foreign_key, default_foreign_key)
+
+        default_local_key = case type
+        when :belongs_to
+          :"#{method_name}_id"
+        else
+          :id
+        end
+
+        local_key = options.fetch(:local_key, default_local_key)
+
+        return collection, foreign_key, local_key
+      end
+
+      private
+      def check_name_in_use(name)
+        if self.fields[name]
+          type = 'A field'
+        elsif self.associations[name]
+          type = 'An association'
+        else
+          type = nil
+        end
+
+        if type
+          raise "#{type} is already defined for `#{name}` on `#{to_s}`"
+        end
+      end
+
+      # Checks to make sure the association isn't in use, then generates the
+      # collection, foreign_key, and local_key's based on the type and options.
+      # Then tracks the association data on the model class.
+      def assoc_parts_and_track(method_name, options, type)
+        method_name = method_name.to_sym
+        check_name_in_use(method_name)
+
+        collection, foreign_key, local_key = assoc_parts(method_name, options,
+                                                         type)
+
+        # Track the association
+        self.associations[method_name] = {
+          type: type,
+          to_many: type == :has_many,
+          collection: collection,
+          foreign_key: foreign_key,
+          local_key: local_key
+        }
+
+        return collection, foreign_key, local_key
+      end
     end
 
     def self.included(base)
       base.send :extend, ClassMethods
+      base.class_attribute :associations
+      base.associations = {}
+    end
+
+    # Associate takes an association name, and a model and changes the
+    # association field (the foreign_key for has_one, has_many, or the local_key
+    # for belongs_to).  This works for both explicit (has_many, has_one,
+    # belongs_to) associations, and implicit (._items)
+    def associate(method_name, model)
+      assoc_data = self.class.associations[method_name]
+
+      if assoc_data
+        # Extract from association data
+        collection, foreign_key, local_key, type =
+          assoc_data.mfetch(:collection, :foreign_key, :local_key, :type)
+      else
+        # Association is implicit, generate instead
+        type = :has_many
+        collection, foreign_key, local_key =
+          self.class.assoc_parts(method_name, {}, type)
+      end
+
+      case type
+      when :has_many, :has_one
+        model.set(foreign_key, get(local_key))
+      else
+        # belongs_to
+        set(local_key, get(foreign_key))
+      end
     end
 
     private
@@ -79,7 +202,7 @@ module Volt
 
       # Check if we are on the store collection
       if persistor.is_a?(Volt::Persistors::ModelStore) ||
-         persistor.is_a?(Volt::Persistors::Page)
+          persistor.is_a?(Volt::Persistors::Page)
         # Get the root node
         root = persistor.try(:root_model)
 

data/lib/volt/models/buffer.rb

@@ -10,60 +10,57 @@ module Volt
       # TODO: this shouldn't need to be run, but if no attributes are assigned, then
       # if needs to be run.  Maybe there's a better way to handle it.
       validate!.then do
-        # Get errors from validate
-        errors = self.errors.to_h
-
         result = nil
 
-        if errors.size == 0
-          # cache save_to in a local
-          save_to = self.save_to
-          if save_to
-            if save_to.is_a?(ArrayModel)
-              # Add to the collection
-              promise = save_to.create(attributes)
-            else
-              # We have a saved model
-              promise = save_to.assign_attributes(attributes)
-            end
-
-            result = promise.then do |new_model|
-              # The main model saved, so mark the buffer as not new
-              @new = false
+        # cache save_to in a local
+        save_to = self.save_to
+        if save_to
+          if save_to.is_a?(ArrayModel)
+            # Add to the collection
+            promise = save_to.create(attributes)
+          else
+            # We have a saved model
+            promise = save_to.assign_attributes(attributes, false, true)
+          end
 
-              if new_model
-                # Mark the model as loaded
-                new_model.change_state_to(:loaded_state, :loaded)
+          result = promise.then do |new_model|
+            # The main model saved, so mark the buffer as not new
+            @new = false
 
-                # Set the buffer's id to track the main model's id
-                self.save_to = new_model
-              end
+            if new_model
+              # Mark the model as loaded
+              new_model.change_state_to(:loaded_state, :loaded)
 
-              # Copy attributes back from save_to model
-              @attributes = new_model.attributes
+              # Set the buffer's id to track the main model's id
+              self.save_to = new_model
+            end
 
-              # Remove tracked changes
-              clear_tracked_changes!
+            # Copy attributes back from save_to model
+            @attributes = new_model.attributes
 
-              new_model
-            end.fail do |errors|
-              if errors.is_a?(Hash)
-                server_errors.replace(errors)
+            # Remove tracked changes
+            clear_tracked_changes!
 
-                # Merge the server errors into the main errors
-                self.errors.merge!(server_errors.to_h)
-              end
+            new_model
+          end.fail do |errors|
+            if errors.is_a?(Hash)
+              server_errors.replace(errors)
 
-              promise_for_errors(errors)
+              # Merge the server errors into the main errors
+              self.errors.merge!(server_errors.to_h)
             end
-          else
-            fail 'Model is not a buffer, can not be saved, modifications should be persisted as they are made.'
+
+            promise_for_errors(errors)
           end
+
+          result
         else
-          # Some errors, mark all fields
-          result = promise_for_errors(errors)
+          fail 'Model is not a buffer, can not be saved, modifications should be persisted as they are made.'
         end
-
+      end.fail do |errors|
+        # Some errors, mark all fields
+        promise_for_errors(errors)
+      end.then do |result|
         # If passed a block, call then on it with the block.
         result = result.then(&block) if block
 

data/lib/volt/models/cursor.rb

@@ -2,5 +2,20 @@ require 'volt/models/array_model'
 
 module Volt
   class Cursor < ArrayModel
+    # Some cursors return a value instead of an ArrayModel, in this case, we
+    # store the array in the ArrayModel (so we can reuse ArrayModel's path)
+    # TODO: should abstract this into a base class.
+    def value=(val)
+      @array = val
+      @has_value = true
+    end
+
+    def value
+      @array
+    end
+
+    def has_value?
+      @has_value
+    end
   end
 end

data/lib/volt/models/errors.rb

@@ -28,5 +28,16 @@ module Volt
 
       str.join(', ')
     end
+
+    # message returns a human readable string for the errors
+    def message
+      str = []
+
+      each_pair do |field, error|
+        str << "#{field} #{error}"
+      end
+
+      str.to_sentence
+    end
   end
 end