volt 0.8.14 → 0.8.15

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

@@ -1,40 +1,40 @@
 require 'volt/models/persistors/base'
 require 'volt/models/persistors/model_identity_map'
 
-module Persistors
-  class Store < Base
+module Volt
+  module Persistors
+    class Store < Base
 
-    @@identity_map = ModelIdentityMap.new
+      @@identity_map = ModelIdentityMap.new
 
-    def initialize(model, tasks=nil)
-      @tasks = tasks
-      @model = model
+      def initialize(model, tasks=nil)
+        @tasks = tasks
+        @model = model
 
-      @saved = false
-    end
-
-    def saved?
-      @saved
-    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.
-      options = @model.options.merge(parent: @model, path: @model.path + [method_name])
-      if method_name.plural?
-        model = @model.new_array_model([], options)
-      else
-        model = @model.new_model(nil, options)
-
-        # TODO: Might not need to assign this
-        @model.attributes ||= {}
-        @model.attributes[method_name] = model
+        @saved = false
       end
 
+      def saved?
+        @saved
+      end
 
-      return model
+      # 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.
+        options = @model.options.merge(parent: @model, path: @model.path + [method_name])
+        if method_name.plural?
+          model = @model.new_array_model([], options)
+        else
+          model                          = @model.new_model(nil, options)
+
+          # TODO: Might not need to assign this
+          @model.attributes              ||= {}
+          @model.attributes[method_name] = model
+        end
+        model
+      end
     end
   end
 end

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

@@ -1,14 +1,16 @@
-module Persistors
-  class StoreFactory
-    def initialize(tasks)
-      @tasks = tasks
-    end
+module Volt
+  module Persistors
+    class StoreFactory
+      def initialize(tasks)
+        @tasks = tasks
+      end
 
-    def new(model)
-      if model.is_a?(ArrayModel)
-        ArrayStore.new(model, @tasks)
-      else
-        ModelStore.new(model, @tasks)
+      def new(model)
+        if model.is_a?(ArrayModel)
+          ArrayStore.new(model, @tasks)
+        else
+          ModelStore.new(model, @tasks)
+        end
       end
     end
   end

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

@@ -1,37 +1,39 @@
-# StoreState provides method for a store to track its loading state.
-module StoreState
-
-  # Called when a collection loads
-  def loaded(initial_state=nil)
-    change_state_to(initial_state || :not_loaded)
-  end
-
-  def state
-    @state_dep ||= Dependency.new
-    @state_dep.depend
-
-    return @state
-  end
-
-  # Called from the QueryListener when the data is loaded
-  def change_state_to(new_state, skip_trigger=false)
-    old_state = @state
-    @state = new_state
-
-    # Trigger changed on the 'state' method
-    unless skip_trigger
-      if old_state != @state
-        @state_dep.changed! if @state_dep
+module Volt
+  module Persistors
+    # StoreState provides method for a store to track its loading state.
+    module StoreState
+
+      # Called when a collection loads
+      def loaded(initial_state=nil)
+        change_state_to(initial_state || :not_loaded)
       end
-    end
 
-    if @state == :loaded && @fetch_promises
-      # Trigger each waiting fetch
-      @fetch_promises.compact.each {|fp| fp.resolve(@model) }
-      @fetch_promises = nil
+      def state
+        @state_dep ||= Dependency.new
+        @state_dep.depend
+        @state
+      end
 
-      stop_listening
+      # Called from the QueryListener when the data is loaded
+      def change_state_to(new_state, skip_trigger=false)
+        old_state = @state
+        @state    = new_state
+
+        # Trigger changed on the 'state' method
+        unless skip_trigger
+          if old_state != @state
+            @state_dep.changed! if @state_dep
+          end
+        end
+
+        if @state == :loaded && @fetch_promises
+          # Trigger each waiting fetch
+          @fetch_promises.compact.each { |fp| fp.resolve(@model) }
+          @fetch_promises = nil
+
+          stop_listening
+        end
+      end
     end
   end
-
 end

data/lib/volt/models/url.rb

@@ -1,124 +1,117 @@
 # The url class handles parsing and updating the url
 require 'volt/reactive/reactive_accessors'
+module Volt
+  class URL
+    include ReactiveAccessors
 
-class URL
-  include ReactiveAccessors
+    # TODO: we need to make it so change events only trigger on changes
+    reactive_accessor :scheme, :host, :port, :path, :query, :params, :fragment
+    attr_accessor :router
 
-  # TODO: we need to make it so change events only trigger on changes
-  reactive_accessor :scheme, :host, :port, :path, :query, :params, :fragment
-  attr_accessor :router
-
-  def initialize(router=nil)
-    @router = router
-    @params = Model.new({}, persistor: Persistors::Params)
-  end
+    def initialize(router = nil)
+      @router = router
+      @params = Model.new({}, persistor: Persistors::Params)
+    end
 
-  # Parse takes in a url and extracts each sections.
-  # It also assigns and changes to the params.
-  def parse(url)
-    if url[0] == '#'
-      # url only updates fragment
-      self.fragment = url[1..-1]
-      update!
-    else
-      host = `document.location.host`
-      protocol = `document.location.protocol`
-
-      if url !~ /[:]\/\//
-        # Add the host for local urls
-        url = protocol + "//#{host}" + url
+    # Parse takes in a url and extracts each sections.
+    # It also assigns and changes to the params.
+    def parse(url)
+      if url[0] == '#'
+        # url only updates fragment
+        self.fragment = url[1..-1]
+        update!
       else
-        # Make sure its on the same protocol and host, otherwise its external.
-        if url !~ /#{protocol}\/\/#{host}/
-          # Different host, don't process
-          return false
+        host     = `document.location.host`
+        protocol = `document.location.protocol`
+
+        if url !~ /[:]\/\//
+          # Add the host for local urls
+          url = protocol + "//#{host}" + url
+        else
+          # Make sure its on the same protocol and host, otherwise its external.
+          if url !~ /#{protocol}\/\/#{host}/
+            # Different host, don't process
+            return false
+          end
         end
-      end
 
-      matcher = url.match(/^(#{protocol[0..-2]})[:]\/\/([^\/]+)(.*)$/)
-      self.scheme = matcher[1]
-      host, port = matcher[2].split(':')
+        matcher         = url.match(/^(#{protocol[0..-2]})[:]\/\/([^\/]+)(.*)$/)
+        self.scheme     = matcher[1]
+        self.host, port = matcher[2].split(':')
 
-      self.host = host
-      self.port = (port || 80).to_i
+        self.port = (port || 80).to_i
 
-      path = matcher[3]
-      path, fragment = path.split('#', 2)
-      path, query = path.split('?', 2)
+        path           = matcher[3]
+        path, fragment = path.split('#', 2)
+        path, query    = path.split('?', 2)
 
-      self.path = path
-      self.fragment = fragment
-      self.query = query
+        self.path     = path
+        self.fragment = fragment
+        self.query    = query
 
-      assign_query_hash_to_params
-    end
+        assign_query_hash_to_params
+      end
 
-    scroll
+      scroll
 
-    return true
-  end
+      return true
+    end
 
-  # Full url rebuilds the url from it's constituent parts
-  def full_url
-    if port && port != 80
-      host_with_port = "#{host}:#{port}"
-    else
+    # Full url rebuilds the url from it's constituent parts
+    def full_url
       host_with_port = host
-    end
+      host_with_port += ":#{port}" if port && port != 80
 
-    path, params = @router.params_to_url(@params.to_h)
+      self.path, params = @router.params_to_url(@params.to_h)
 
-    self.path = path if path
+      new_url    = "#{scheme}://#{host_with_port}#{path.chomp('/')}"
 
-    new_url = "#{scheme}://#{host_with_port}#{(path || self.path).chomp('/')}"
+      # Add query params
+      params_str = ''
+      unless params.empty?
+        query_parts = []
+        nested_params_hash(params).each_pair do |key, value|
+          # remove the _ from the front
+          value = `encodeURI(value)`
+          query_parts << "#{key[1..-1]}=#{value}"
+        end
 
-    params_str = ''
-    unless params.empty?
-      query_parts = []
-      nested_params_hash(params).each_pair do |key,value|
-        # remove the _ from the front
-        value = `encodeURI(value)`
-        query_parts << "#{key[1..-1]}=#{value}"
+        if query_parts.size > 0
+          self.query = query_parts.join('&')
+          new_url    += '?' + self.query
+        end
       end
 
-      if query_parts.size > 0
-        self.query = query_parts.join('&')
-        new_url += '?' + self.query
-      end
-    end
+      # Add fragment
+      frag    = self.fragment
+      new_url += '#' + frag if frag.present?
 
-    frag = self.fragment
-    if frag.present?
-      self.fragment = frag
-      new_url += '#' + frag
+      return new_url
     end
 
-    return new_url
-  end
-
-  # Called when the state has changed and the url in the
-  # browser should be updated
-  # Called when an attribute changes to update the url
-  def update!
-    if Volt.client?
-      new_url = full_url()
+    # Called when the state has changed and the url in the
+    # browser should be updated
+    # Called when an attribute changes to update the url
+    def update!
+      if Volt.client?
+        new_url = full_url()
 
-      # Push the new url if pushState is supported
-      # TODO: add fragment fallback
-      %x{
+        # Push the new url if pushState is supported
+        # TODO: add fragment fallback
+        %x{
         if (document.location.href != new_url && history && history.pushState) {
           history.pushState(null, null, new_url);
         }
       }
+      end
     end
-  end
 
-  def scroll
-    if Volt.client?
-      frag = self.fragment
-      if frag
-        # Scroll to anchor via http://www.w3.org/html/wg/drafts/html/master/browsers.html#scroll-to-fragid
-        %x{
+    def scroll
+      if Volt.client?
+        frag = self.fragment
+        if frag
+          # Scroll to anchor via http://www.w3.org/html/wg/drafts/html/master/browsers.html#scroll-to-fragid
+          %x{
           var anchor = $('#' + frag);
           if (anchor.length == 0) {
             anchor = $('*[name="' + frag + '"]:first');
@@ -128,14 +121,14 @@ class URL
             $(document.body).scrollTop(anchor.offset().top);
           }
         }
-      else
-        # Scroll to the top by default
-        `$(document.body).scrollTop(0);`
+        else
+          # Scroll to the top by default
+          `$(document.body).scrollTop(0);`
+        end
       end
     end
-  end
 
-  private
+    private
     # Assigning the params is tricky since we don't want to trigger changed on
     # any values that have not changed.  So we first loop through all current
     # url params, removing any not present in the params, while also removing
@@ -165,7 +158,7 @@ class URL
     def assign_from_old(params, new_params)
       queued_deletes = []
 
-      params.attributes.each_pair do |name,old_val|
+      params.attributes.each_pair do |name, old_val|
         # If there is a new value, see if it has [name]
         new_val = new_params ? new_params[name] : nil
 
@@ -183,7 +176,7 @@ class URL
         end
       end
 
-      queued_deletes.each {|name| params.delete(name) }
+      queued_deletes.each { |name| params.delete(name) }
     end
 
     # Assign any new params, which weren't in the old params.
@@ -200,10 +193,10 @@ class URL
 
     def query_hash
       query_hash = {}
-      qury = self.query
+      qury       = self.query
       if qury
-        qury.split('&').reject {|v| v == '' }.each do |part|
-          parts = part.split('=').reject {|v| v == '' }
+        qury.split('&').reject { |v| v == '' }.each do |part|
+          parts    = part.split('=').reject { |v| v == '' }
 
           # Decode string
           # parts[0] = `decodeURI(parts[0])`
@@ -212,7 +205,7 @@ class URL
           sections = query_key_sections(parts[0])
 
           hash_part = query_hash
-          sections.each_with_index do |section,index|
+          sections.each_with_index do |section, index|
             if index == sections.size-1
               # Last part, assign the value
               hash_part[section] = parts[1]
@@ -231,14 +224,13 @@ class URL
     # Example:
     # user[name]=Ryan would parse as [:_user, :_name]
     def query_key_sections(key)
-      key.split(/\[([^\]]+)\]/).reject(&:empty?).map {|v| :"_#{v}"}
+      key.split(/\[([^\]]+)\]/).reject(&:empty?).map { |v| :"_#{v}" }
     end
 
     # Generate the key for a nested param attribute
     def query_key(path)
       i = 0
       path.map do |v|
-        # v = v[1..-1]
         i += 1
         if i != 1
           "[#{v}]"
@@ -251,7 +243,7 @@ class URL
     def nested_params_hash(params, path=[])
       results = {}
 
-      params.each_pair do |key,value|
+      params.each_pair do |key, value|
         unless value.nil?
           if value.respond_to?(:persistor) && value.persistor && value.persistor.is_a?(Persistors::Params)
             # TODO: Should be a param
@@ -264,5 +256,5 @@ class URL
 
       return results
     end
-
+  end
 end

data/lib/volt/models/validations.rb

@@ -2,77 +2,78 @@
 require 'volt/models/validators/length_validator'
 require 'volt/models/validators/presence_validator'
 
-# Include in any class to get validation logic
-module Validations
-  module ClassMethods
-    def validate(field_name, options)
-      @validations ||= {}
-      @validations[field_name] = options
-    end
+module Volt
+  # Include in any class to get validation logic
+  module Validations
+    module ClassMethods
+      def validate(field_name, options)
+        @validations             ||= {}
+        @validations[field_name] = options
+      end
 
-    def validations
-      @validations
+      def validations
+        @validations
+      end
     end
-  end
 
-  def self.included(base)
-    base.send :extend, ClassMethods
-  end
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
 
-  # Once a field is ready, we can use include_in_errors! to start
-  # showing its errors.
-  def mark_field!(field_name, trigger_changed=true)
-    marked_fields[field_name] = true
-  end
+    # Once a field is ready, we can use include_in_errors! to start
+    # showing its errors.
+    def mark_field!(field_name, trigger_changed=true)
+      marked_fields[field_name] = true
+    end
 
-  def marked_fields
-    @marked_fields ||= ReactiveHash.new
-  end
+    def marked_fields
+      @marked_fields ||= ReactiveHash.new
+    end
 
-  def marked_errors
-    errors(true)
-  end
+    def marked_errors
+      errors(true)
+    end
 
-  # TODO: Errors is being called for any validation change.  We should have errors return a
-  # hash like object that only calls the validation for each one.
-  def errors(marked_only=false)
-    errors = {}
+    # TODO: Errors is being called for any validation change.  We should have errors return a
+    # hash like object that only calls the validation for each one.
+    def errors(marked_only=false)
+      errors = {}
 
-    validations = self.class.validations
+      validations = self.class.validations
 
-    if validations
-      # Merge into errors, combining any error arrays
-      merge = Proc.new do |new_errors|
-        errors.merge!(new_errors) do |key, new_val, old_val|
-          new_val + old_val
+      if validations
+        # Merge into errors, combining any error arrays
+        merge = Proc.new do |new_errors|
+          errors.merge!(new_errors) do |key, new_val, old_val|
+            new_val + old_val
+          end
         end
-      end
 
-      # Run through each validation
-      validations.each_pair do |field_name, options|
-        if marked_only
-          # When marked only, skip any validations on non-marked fields
-          next unless marked_fields[field_name]
-        end
+        # Run through each validation
+        validations.each_pair do |field_name, options|
+          if marked_only
+            # When marked only, skip any validations on non-marked fields
+            next unless marked_fields[field_name]
+          end
 
-        options.each_pair do |validation, args|
-          # Call the specific validator, then merge the results back
-          # into one large errors hash.
-          klass = validation_class(validation, args)
+          options.each_pair do |validation, args|
+            # Call the specific validator, then merge the results back
+            # into one large errors hash.
+            klass = validation_class(validation, args)
 
-          if klass
-            validate_with(merge, klass, field_name, args)
-          else
-            raise "validation type #{validation} is not specified."
+            if klass
+              validate_with(merge, klass, field_name, args)
+            else
+              raise "validation type #{validation} is not specified."
+            end
           end
         end
       end
-    end
 
-    return errors
-  end
+      return errors
+    end
 
-  private
+    private
     # calls the validate method on the class, passing the right arguments.
     def validate_with(merge, klass, field_name, args)
       return merge.call(klass.validate(self, field_name, args))
@@ -80,9 +81,10 @@ module Validations
 
     def validation_class(validation, args)
       begin
-        Object.const_get(:"#{validation.camelize}Validator")
+        Volt.const_get(:"#{validation.camelize}Validator")
       rescue NameError => e
         puts "Unable to find #{validation} validator"
       end
     end
+  end
 end

data/lib/volt/models/validators/length_validator.rb

@@ -1,28 +1,30 @@
-class LengthValidator
-  def self.validate(model, field_name, args)
-    errors = {}
-    value = model.send(field_name)
+module Volt
+  class LengthValidator
+    def self.validate(model, field_name, args)
+      errors = {}
+      value  = model.send(field_name)
 
-    if args.is_a?(Fixnum)
-      min = args
-      max = nil
-      message = nil
-    elsif args.is_a?(Hash)
-      min = args[:length] || args[:minimum]
-      max = args[:maximum]
-      raise "length or minimum must be specified" unless min.is_a?(Fixnum)
+      if args.is_a?(Fixnum)
+        min     = args
+        max     = nil
+        message = nil
+      elsif args.is_a?(Hash)
+        min = args[:length] || args[:minimum]
+        max = args[:maximum]
+        raise "length or minimum must be specified" unless min.is_a?(Fixnum)
 
-      message = args[:message]
-    else
-      raise "The arguments to length must be a number or a hash"
-    end
+        message = args[:message]
+      else
+        raise "The arguments to length must be a number or a hash"
+      end
 
-    if !value || value.size < min
-      errors[field_name] = [message || "must be at least #{args} characters"]
-    elsif max && value.size > max
-      errors[field_name] = [message || "must be less than #{args} characters"]
-    end
+      if !value || value.size < min
+        errors[field_name] = [message || "must be at least #{args} characters"]
+      elsif max && value.size > max
+        errors[field_name] = [message || "must be less than #{args} characters"]
+      end
 
-    return errors
+      return errors
+    end
   end
 end