volt 0.4.9 → 0.4.10

data/lib/volt/models/params.rb

@@ -1,72 +0,0 @@
-require 'volt/models/params_array'
-
-# All url related data is stored in params.  This includes the main uri
-# in addition to any query parameters.  The router is responsible for
-# converting any uri sections into params.  Sections in the uri will
-# override any specified parameters.
-#
-# The params value can be updated the same way a model would be, only
-# the updates will trigger an updated url via the browser history api.
-# TODO: Support # for browsers without the history api.
-class Params < Model    
-  def initialize(*args)
-    super(*args)
-  end
-  
-  def deep_clone
-    new_obj = clone
-    
-    new_obj.attributes = new_obj.attributes.dup
-    
-    new_obj
-  end
-
-  tag_method(:delete) do
-    destructive!
-  end
-  def delete(*args)
-    super
-    
-    value_updated
-  end
-
-  def method_missing(method_name, *args, &block)
-    result = super
-    
-    if method_name[0] == '_' && method_name[-1] == '='
-      # Trigger value updated after an assignment
-      self.value_updated
-    end
-    
-    return result
-  end
-  
-  def value_updated
-    # Once the initial url has been parsed and set into the attributes,
-    # start triggering updates on change events.
-    # TODO: This is a temp solution, we need to make it so value_updated
-    # is called after the reactive_value has been updated.
-    if RUBY_PLATFORM == 'opal'
-      %x{
-        if (window.setTimeout && this.$run_update.bind) {
-          if (window.paramsUpdateTimer) {
-            clearTimeout(window.paramsUpdateTimer);
-          }
-          window.paramsUpdateTimer = setTimeout(this.$run_update.bind(this), 0);
-        }
-      }
-    end
-  end
-  
-  def run_update
-    $page.params.trigger!('child_changed') if Volt.client?
-  end
-  
-  def new_model(*args)
-    Params.new(*args)
-  end
-  
-  def new_array_model(*args)
-    ParamsArray.new(*args)
-  end
-end

data/lib/volt/models/params_array.rb

@@ -1,9 +0,0 @@
-class ParamsArray < ArrayModel
-  def new_model(*args)
-    Params.new(*args)
-  end
-  
-  def new_array_model(*args)
-    ParamsArray.new(*args)
-  end
-end

data/lib/volt/models/store.rb

@@ -1,183 +0,0 @@
-require 'volt/models/store_array'
-
-class Store < Model
-  ID_CHARS = [('a'..'z'), ('A'..'Z'), ('0'..'9')].map {|v| v.to_a }.flatten
-  
-  @@identity_map = {}
-  
-  attr_reader :state
-  
-  def initialize(tasks=nil, *args)
-    @tasks = tasks
-    @state = :not_loaded
-
-    super(*args)
-    
-    track_in_identity_map if attributes && attributes[:_id]
-    
-    value_updated
-  end
-  
-  def self.from_id(id)
-    @@identity_map[id]
-  end
-
-  def event_added(event, scope_provider, first)
-    if first && event == :changed
-      # Start listening
-      ensure_id
-      change_channel_connection("add")
-    end
-  end
-  
-  def event_removed(event, no_more_events)
-    if no_more_events && event == :changed
-      # Stop listening
-      change_channel_connection("remove")
-    end
-  end
-  
-  def change_channel_connection(add_or_remove)
-    if attributes && path.size > 1
-      channel_name = "#{path[-2]}##{attributes[:_id]}"
-      puts "Event Added: #{channel_name} -- #{attributes.inspect}"
-      @tasks.call('ChannelTasks', "#{add_or_remove}_listener", channel_name)
-    end    
-  end
-  
-  def self.update(model_id, data)
-    model = @@identity_map[model_id]
-    
-    if model
-      data.each_pair do |key, value|
-        if key != '_id'
-          model.send(:"#{key}=", value)
-        end
-      end
-    end
-  end
-  
-  def generate_id
-    id = []
-    12.times { id << ID_CHARS.sample }
-    
-    return id.join
-  end
-  
-  def method_missing(method_name, *args, &block)
-    if method_name[-1] == ']'
-      # Load the model
-      self.load!
-    end
-
-    result = super
-    
-    if method_name[0] == '_' && method_name[-1] == '='
-      # Trigger value updated after an assignment
-      self.value_updated
-    end
-    
-    return result
-  end
-  
-  def track_in_identity_map
-    @@identity_map[attributes[:_id]] = self
-  end
-  
-  # When called, will setup an id if there is not one
-  def ensure_id
-    # No id yet, lets create one
-    if attributes && !attributes[:_id]
-      self.attributes[:_id] = generate_id
-      track_in_identity_map
-    end
-  end
-  
-  def value_updated
-    path_size = path.size
-    if !(defined?($loading_models) && $loading_models) && @tasks && path_size > 0 && !nil?
-      
-      ensure_id
-      
-      if path_size > 3 && parent && source = parent.parent
-        self.attributes[:"#{path[-4].singularize}_id"] = source._id
-      end
-      
-      # puts "Save: #{collection} - #{attrs.inspect}"
-      @tasks.call('StoreTasks', 'save', collection, self_attributes)
-    end
-  end
-  
-  # Return the attributes that are only for this store, not any sub-associations.
-  def self_attributes
-    # Don't store any sub-stores, those will do their own saving.
-    attrs = attributes.reject {|k,v| v.is_a?(Model) || v.is_a?(ArrayModel) }    
-  end
-  
-  def collection(path=nil)
-    path ||= self.path
-    
-    collection_name = path.last
-    collection_name = path[-2] if collection_name == :[]
-    
-    return collection_name
-  end
-  
-  # On stores, we store the model so we don't have to look it up
-  # every time we do a read.
-  def read_new_model(method_name)
-    # On stores, plural associations are automatically assumed to be
-    # collections.
-    if method_name.plural?
-      model = new_array_model([], self, path + [method_name])
-    else
-      model = new_model(nil, self, path + [method_name])
-    end
-    
-    self.attributes ||= {}
-    attributes[method_name] = model
-    
-    if model.is_a?(StoreArray)# && model.state == :not_loaded
-      model.load!
-    end
-    
-    return model
-  end
-
-  
-  # When called, this model is deleted from its current parent collection
-  # and from the database
-  def delete!
-    if path.size == 0
-      raise "Not in a collection"
-    end
-    
-    # TEMP: Find this model in the parent's collection
-    parent.each_with_index do |child,index|
-      puts "CHECK #{child.inspect} vs #{self.inspect}"
-      if child._id == self._id
-        puts "FOUND AT: #{index}"
-        parent.delete_at(index)
-        break
-      end
-    end
-
-    # Send to the DB that we got deleted
-    unless $loading_models
-      puts "delete #{collection} - #{attributes[:_id]}"
-      @tasks.call('StoreTasks', 'delete', collection, attributes[:_id])
-    end
-  end
-  
-  def inspect
-    "<#{self.class.to_s}-#{@state} #{attributes.inspect}>"
-  end
-  
-  def new_model(attributes={}, parent=nil, path=nil, class_paths=nil)
-    return Store.new(@tasks, attributes, parent, path, class_paths)
-  end
-  
-  def new_array_model(*args)
-    StoreArray.new(@tasks, *args)
-  end
-end

data/lib/volt/models/store_array.rb

@@ -1,82 +0,0 @@
-class StoreArray < ArrayModel
-  attr_reader :state
-  
-  def initialize(tasks=nil, array=[], parent=nil, path=nil)
-    @tasks = tasks
-    @state = :not_loaded
-
-    super(array, parent, path)
-    
-    # TEMP: TODO: Setup the listeners right away
-    change_channel_connection('add', 'added')
-    change_channel_connection('add', 'removed')
-  end
-  
-  # def event_added(event, scope_provider, first) 
-  #   puts "New event1: #{event.inspect} - #{first}"   
-  #   if first && [:added, :removed].include?(event)
-  #     # Start listening for added items on the collection
-  #     
-  #     change_channel_connection('add', event)
-  #   end
-  # end
-  # 
-  # def event_removed(event, no_more_events)
-  #   if no_more_events && [:added, :removed].include?(event)
-  #     # Stop listening
-  #     change_channel_connection("remove", event)
-  #   end
-  # end
-  
-  
-  def load!
-    if @state == :not_loaded
-      @state = :loading
-    
-      if @tasks && path.last.plural?
-        # Check to see the parents scope so we can only lookup associated
-        # models.
-        scope = {}
-      
-        # Scope to the parent
-        if path.size > 1 && attributes && attributes[:_id].true?
-          scope[:"#{path[-2].singularize}_id"] = _id
-        end
-        
-        puts "Load At Scope: #{scope.inspect}"
-        
-        load_child_models(scope)
-      end
-    end
-    
-    return self
-  end
-  
-  def load_child_models(scope)
-    # puts "FIND: #{collection(path).inspect} at #{scope.inspect}"
-    @tasks.call('StoreTasks', 'find', path.last, scope) do |results|
-      # TODO: Globals evil, replace
-      $loading_models = true
-      results.each do |result|
-        self << Store.new(@tasks, result, self, path + [:[]], @class_paths)
-      end
-      $loading_models = false
-    end
-  end
-  
-  def change_channel_connection(add_or_remove, event)
-    if @tasks && parent.attributes && path.size != 0
-      channel_name = "#{path[-1]}-#{event}"
-      puts "Listen on #{channel_name} - #{add_or_remove}"
-      @tasks.call('ChannelTasks', "#{add_or_remove}_listener", channel_name)
-    end    
-  end
-  
-  def new_model(*args)
-    Store.new(@tasks, *args)
-  end
-  
-  def new_array_model(*args)
-    StoreArray.new(@tasks, *args)
-  end
-end

data/spec/models/params_spec.rb

@@ -1,16 +0,0 @@
-require 'volt/models'
-
-describe Params do
-  it "should stay as params classes when used" do
-    a = Params.new
-    expect(a._test.class).to eq(Params)
-    
-    expect(a._test._cool.class).to eq(Params)
-    
-    a._items << {_name: 'Test'}
-    
-    expect(a._items.class).to eq(ParamsArray)
-    expect(a._items[0].class).to eq(Params)
-    expect(a._items[0]._name.class).to eq(String)
-  end
-end