volt 0.7.1 → 0.7.2

data/lib/volt/extra_core/inflector/inflections.rb

@@ -0,0 +1,203 @@
+module Inflector
+  # A singleton instance of this class is yielded by Inflector.inflections,
+  # which can then be used to specify additional inflection rules. If passed
+  # an optional locale, rules for other languages can be specified. The
+  # default locale is <tt>:en</tt>. Only rules for English are provided.
+  #
+  #   ActiveSupport::Inflector.inflections(:en) do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable 'equipment'
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular
+  # rule for octopus will now be the first of the pluralization and
+  # singularization rules that is runs. This guarantees that your rules run
+  # before any of the rules that may already have been loaded.
+  class Inflections
+    @__instance__ = {}
+
+    def self.instance(locale = :en)
+      @__instance__[locale] ||= new
+    end
+
+    attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms, :acronym_regex
+
+    def initialize
+      @plurals, @singulars, @uncountables, @humans, @acronyms, @acronym_regex = [], [], [], [], {}, /(?=a)b/
+    end
+
+    # Private, for the test suite.
+    def initialize_dup(orig) # :nodoc:
+      %w(plurals singulars uncountables humans acronyms acronym_regex).each do |scope|
+        instance_variable_set("@#{scope}", orig.send(scope).dup)
+      end
+    end
+
+    # Specifies a new acronym. An acronym must be specified as it will appear
+    # in a camelized string. An underscore string that contains the acronym
+    # will retain the acronym when passed to +camelize+, +humanize+, or
+    # +titleize+. A camelized string that contains the acronym will maintain
+    # the acronym when titleized or humanized, and will convert the acronym
+    # into a non-delimited single lowercase word when passed to +underscore+.
+    #
+    #   acronym 'HTML'
+    #   titleize 'html'     #=> 'HTML'
+    #   camelize 'html'     #=> 'HTML'
+    #   underscore 'MyHTML' #=> 'my_html'
+    #
+    # The acronym, however, must occur as a delimited unit and not be part of
+    # another word for conversions to recognize it:
+    #
+    #   acronym 'HTTP'
+    #   camelize 'my_http_delimited' #=> 'MyHTTPDelimited'
+    #   camelize 'https'             #=> 'Https', not 'HTTPs'
+    #   underscore 'HTTPS'           #=> 'http_s', not 'https'
+    #
+    #   acronym 'HTTPS'
+    #   camelize 'https'   #=> 'HTTPS'
+    #   underscore 'HTTPS' #=> 'https'
+    #
+    # Note: Acronyms that are passed to +pluralize+ will no longer be
+    # recognized, since the acronym will not occur as a delimited unit in the
+    # pluralized result. To work around this, you must specify the pluralized
+    # form as an acronym as well:
+    #
+    #    acronym 'API'
+    #    camelize(pluralize('api')) #=> 'Apis'
+    #
+    #    acronym 'APIs'
+    #    camelize(pluralize('api')) #=> 'APIs'
+    #
+    # +acronym+ may be used to specify any word that contains an acronym or
+    # otherwise needs to maintain a non-standard capitalization. The only
+    # restriction is that the word must begin with a capital letter.
+    #
+    #   acronym 'RESTful'
+    #   underscore 'RESTful'           #=> 'restful'
+    #   underscore 'RESTfulController' #=> 'restful_controller'
+    #   titleize 'RESTfulController'   #=> 'RESTful Controller'
+    #   camelize 'restful'             #=> 'RESTful'
+    #   camelize 'restful_controller'  #=> 'RESTfulController'
+    #
+    #   acronym 'McDonald'
+    #   underscore 'McDonald' #=> 'mcdonald'
+    #   camelize 'mcdonald'   #=> 'McDonald'
+    def acronym(word)
+      @acronyms[word.downcase] = word
+      @acronym_regex = /#{@acronyms.values.join("|")}/
+    end
+
+    # Specifies a new pluralization rule and its replacement. The rule can
+    # either be a string or a regular expression. The replacement should
+    # always be a string that may include references to the matched data from
+    # the rule.
+    def plural(rule, replacement)
+      @uncountables.delete(rule) if rule.is_a?(String)
+      @uncountables.delete(replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new singularization rule and its replacement. The rule can
+    # either be a string or a regular expression. The replacement should
+    # always be a string that may include references to the matched data from
+    # the rule.
+    def singular(rule, replacement)
+      @uncountables.delete(rule) if rule.is_a?(String)
+      @uncountables.delete(replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new irregular that applies to both pluralization and
+    # singularization at the same time. This can only be used for strings, not
+    # regular expressions. You simply pass the irregular in singular and
+    # plural form.
+    #
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def irregular(singular, plural)
+      @uncountables.delete(singular)
+      @uncountables.delete(plural)
+
+      s0 = singular[0]
+      srest = singular[1..-1]
+
+      p0 = plural[0]
+      prest = plural[1..-1]
+
+      if s0.upcase == p0.upcase
+        plural(/(#{s0})#{srest}$/i, '\1' + prest)
+        plural(/(#{p0})#{prest}$/i, '\1' + prest)
+
+        singular(/(#{s0})#{srest}$/i, '\1' + srest)
+        singular(/(#{p0})#{prest}$/i, '\1' + srest)
+      else
+        plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
+        plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
+        plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
+        plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
+
+        singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
+        singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
+        singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
+        singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
+      end
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    #   uncountable 'money'
+    #   uncountable 'money', 'information'
+    #   uncountable %w( money information rice )
+    def uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    # Specifies a humanized form of a string by a regular expression rule or
+    # by a string mapping. When using a regular expression based replacement,
+    # the normal humanize formatting is called after the replacement. When a
+    # string is used, the human form should be specified as desired (example:
+    # 'The name', not 'the_name').
+    #
+    #   human /_cnt$/i, '\1_count'
+    #   human 'legacy_col_person_name', 'Name'
+    def human(rule, replacement)
+      @humans.insert(0, [rule, replacement])
+    end
+
+    # Clears the loaded inflections within a given scope (default is
+    # <tt>:all</tt>). Give the scope as a symbol of the inflection type, the
+    # options are: <tt>:plurals</tt>, <tt>:singulars</tt>, <tt>:uncountables</tt>,
+    # <tt>:humans</tt>.
+    #
+    #   clear :all
+    #   clear :plurals
+    def clear(scope = :all)
+      case scope
+        when :all
+          @plurals, @singulars, @uncountables, @humans = [], [], [], []
+        else
+          instance_variable_set "@#{scope}", []
+      end
+    end
+  end
+
+  # Yields a singleton instance of Inflector::Inflections so you can specify
+  # additional inflector rules. If passed an optional locale, rules for other
+  # languages can be specified. If not specified, defaults to <tt>:en</tt>.
+  # Only rules for English are provided.
+  #
+  #   ActiveSupport::Inflector.inflections(:en) do |inflect|
+  #     inflect.uncountable 'rails'
+  #   end
+  def self.inflections(locale = :en)
+    if block_given?
+      yield Inflections.instance(locale)
+    else
+      Inflections.instance(locale)
+    end
+  end
+end

data/lib/volt/extra_core/inflector/methods.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+# The Inflector transforms words from singular to plural, class names to table
+# names, modularized class names to ones without, and class names to foreign
+# keys. The default inflections for pluralization, singularization, and
+# uncountable words are kept in inflections.rb.
+module Inflector
+  # Returns the plural form of the word in the string.
+  #
+  # If passed an optional +locale+ parameter, the word will be
+  # pluralized using rules defined for that language. By default,
+  # this parameter is set to <tt>:en</tt>.
+  #
+  #   'post'.pluralize             # => "posts"
+  #   'octopus'.pluralize          # => "octopi"
+  #   'sheep'.pluralize            # => "sheep"
+  #   'words'.pluralize            # => "words"
+  #   'CamelOctopus'.pluralize     # => "CamelOctopi"
+  #   'ley'.pluralize(:es)         # => "leyes"
+  def self.pluralize(word, locale = :en)
+    apply_inflections(word, inflections(locale).plurals)
+  end
+
+  # The reverse of +pluralize+, returns the singular form of a word in a
+  # string.
+  #
+  # If passed an optional +locale+ parameter, the word will be
+  # pluralized using rules defined for that language. By default,
+  # this parameter is set to <tt>:en</tt>.
+  #
+  #   'posts'.singularize            # => "post"
+  #   'octopi'.singularize           # => "octopus"
+  #   'sheep'.singularize            # => "sheep"
+  #   'word'.singularize             # => "word"
+  #   'CamelOctopi'.singularize      # => "CamelOctopus"
+  #   'leyes'.singularize(:es)       # => "ley"
+  def self.singularize(word, locale = :en)
+    apply_inflections(word, inflections(locale).singulars)
+  end
+
+
+  private
+
+  # Applies inflection rules for +singularize+ and +pluralize+.
+  #
+  #  apply_inflections('post', inflections.plurals)    # => "posts"
+  #  apply_inflections('posts', inflections.singulars) # => "post"
+  def self.apply_inflections(word, rules)
+    result = word.to_s.dup
+
+    if word.empty? || inflections.uncountables.include?(result.downcase[/\b\w+\Z/])
+      result
+    else
+      rules.each do |(rule, replacement)|
+        if result.match(rule)
+          result = result.sub(rule, replacement)
+          break
+        end
+      end
+      result
+    end
+  end
+end

data/lib/volt/extra_core/inflector.rb

@@ -0,0 +1,4 @@
+# Copied from rails ActiveSupport: https://github.com/rails/rails/blob/feaa6e2048fe86bcf07e967d6e47b865e42e055b/activesupport/lib/active_support/inflector/inflections.rb
+require 'volt/extra_core/inflector/inflections'
+require 'volt/extra_core/inflector/methods'
+require 'volt/extra_core/inflections'

data/lib/volt/extra_core/object.rb

@@ -37,4 +37,13 @@ class Object
   def deep_cur
     self.cur
   end
+
+  def html_inspect
+    inspect.gsub('<', '&lt;').gsub('>', '&gt;')
+  end
+
+  # TODO: Need a real implementation of this
+  def deep_clone
+    Marshal.load(Marshal.dump(self))
+  end
 end

data/lib/volt/extra_core/string.rb

@@ -1,3 +1,5 @@
+require 'volt/extra_core/inflector'
+
 class String
   # TODO: replace with better implementations
   # NOTE: strings are currently immutable in Opal, so no ! methods
@@ -9,31 +11,25 @@ class String
     self.scan(/[A-Z][a-z]*/).join("_").downcase
   end
 
+  def dasherize
+    self.gsub('_', '-')
+  end
+
   def pluralize
-    # TODO: Temp implementation
-    if self[-1] != 's'
-      return self + 's'
-    else
-      return self
-    end
+    Inflector.pluralize(self)
   end
 
   def singularize
-    # TODO: Temp implementation
-    if self[-1] == 's'
-      return self[0..-2]
-    else
-      return self
-    end
+    Inflector.singularize(self)
   end
 
   def plural?
     # TODO: Temp implementation
-    self[-1] == 's'
+    self.pluralize == self
   end
 
   def singular?
     # TODO: Temp implementation
-    self[-1] != 's'
+    self.singularize == self
   end
 end

data/lib/volt/models/array_model.rb

@@ -1,11 +1,28 @@
 require 'volt/models/model_wrapper'
 require 'volt/models/model_helpers'
+require 'volt/models/model_state'
 
 class ArrayModel < ReactiveArray
   include ModelWrapper
   include ModelHelpers
+  include ModelState
 
-  attr_reader :parent, :path, :persistor, :options
+  attr_reader :parent, :path, :persistor, :options, :array
+
+
+  # For many methods, we want to call load data as soon as the model is interacted
+  # with, so we proxy the method, then call super.
+  def self.proxy_with_load_data(*method_names)
+    method_names.each do |method_name|
+      define_method(method_name) do |*args|
+        # puts "CALL #{method_name} - Load Data on #{self.inspect}"
+        load_data
+        super(*args)
+      end
+    end
+  end
+
+  proxy_with_load_data :[], :size, :first, :last
 
   def initialize(array=[], options={})
     @options = options
@@ -20,39 +37,26 @@ class ArrayModel < ReactiveArray
     @persistor.loaded if @persistor
   end
 
-  # For stored items, tell the collection to load the data when it
-  # is requested.
-  def [](index)
-    load_data
-    super
-  end
-
-  def size
-    load_data
-    super
+  tag_method(:find) do
+    destructive!
+    pass_reactive!
   end
-
-  def state
+  def find(*args)
     if @persistor
-      @persistor.state
+      return @persistor.find(*args)
     else
-      :loaded
+      raise "this model's persistance layer does not support find, try using store"
     end
   end
 
-  def loaded?
-    state == :loaded
-  end
-
-  tag_method(:find) do
+  tag_method(:fetch) do
     destructive!
-    pass_reactive!
   end
-  def find(*args)
+  def fetch(*args, &block)
     if @persistor
-      return @persistor.find(*args)
+      return @persistor.fetch(*args, &block)
     else
-      raise "this model's persistance layer does not support find, try using store"
+      raise "this model's persistance layer does not support fetch, try using store"
     end
   end
 
@@ -72,7 +76,10 @@ class ArrayModel < ReactiveArray
     super(model)
 
     @persistor.added(model, @array.size-1) if @persistor
+
+    return model
   end
+  alias_method :append, :<<
 
   # Make sure it gets wrapped
   def inject(*args)
@@ -86,8 +93,8 @@ class ArrayModel < ReactiveArray
     super(*args)
   end
 
-  def new_model(attributes, options)
-    class_at_path(options[:path]).new(attributes, options)
+  def new_model(*args)
+    class_at_path(options[:path]).new(*args)
   end
 
   def new_array_model(*args)
@@ -114,6 +121,18 @@ class ArrayModel < ReactiveArray
     super
   end
 
+  tag_method(:buffer) do
+    destructive!
+  end
+  def buffer
+    model_path = options[:path] + [:[]]
+    model_klass = class_at_path(model_path)
+
+    new_options = options.merge(path: model_path, save_to: self).reject {|k,_| k.to_sym == :persistor }
+    model = model_klass.new({}, new_options)
+
+    return ReactiveValue.new(model)
+  end
 
   private
     # Takes the persistor if there is one and
@@ -130,5 +149,4 @@ class ArrayModel < ReactiveArray
       end
     end
 
-
 end

data/lib/volt/models/cursor.rb

@@ -0,0 +1,6 @@
+require 'volt/models/array_model'
+
+class Cursor < ArrayModel
+  
+
+end

data/lib/volt/models/model.rb

@@ -3,6 +3,9 @@ require 'volt/models/array_model'
 require 'volt/models/model_helpers'
 require 'volt/reactive/object_tracking'
 require 'volt/models/model_hash_behaviour'
+require 'volt/models/validations/validations'
+require 'volt/models/model_state'
+
 
 class NilMethodCall < NoMethodError
   def true?
@@ -20,16 +23,24 @@ class Model
   include ObjectTracking
   include ModelHelpers
   include ModelHashBehaviour
+  include Validations
+  include ModelState
 
   attr_accessor :attributes
   attr_reader :parent, :path, :persistor, :options
 
-  def initialize(attributes={}, options={})
+  def initialize(attributes={}, options={}, initial_state=nil)
     self.options = options
 
-    self.attributes = wrap_values(attributes)
+    self.send(:attributes=, attributes, true)
+
+    @cache = {}
+
+    # Models stat in a loaded state since they are normally setup from an
+    # ArrayModel, which will have the data when they get added.
+    @state = :loaded
 
-    @persistor.loaded if @persistor
+    @persistor.loaded(initial_state) if @persistor
   end
 
   # Update the options
@@ -41,6 +52,18 @@ class Model
     @persistor = setup_persistor(options[:persistor])
   end
 
+  # Assign multiple attributes as a hash, directly.
+  def attributes=(attrs, initial_setup=false)
+    @attributes = wrap_values(attrs)
+
+    unless initial_setup
+      trigger!('changed')
+
+      # Let the persistor know something changed
+      @persistor.changed if @persistor
+    end
+  end
+  alias_method :assign_attributes, :attributes=
 
   # Pass the comparison through
   def ==(val)
@@ -81,6 +104,9 @@ class Model
 
   # Do the assignment to a model and trigger a changed event
   def assign_attribute(method_name, *args, &block)
+    # Free any cached value
+    free(method_name)
+
     self.expand!
     # Assign, without the =
     attribute_name = method_name[0..-2].to_sym
@@ -107,11 +133,25 @@ class Model
       # The method we are calling is on a nil model, return a wrapped
       # exception.
       return return_undefined_method(method_name)
-    elsif attributes && attributes.has_key?(method_name)
-      # Method has the key, look it up directly
-      return attributes[method_name]
     else
-      return read_new_model(method_name)
+      # See if the value is in attributes
+      value = (attributes && attributes[method_name])
+
+      # Also check @cache
+      value ||= (@cache && @cache[method_name])
+
+      if value
+        # key was in attributes or cache
+        return value
+      else
+        # Cache the value, will be removed when expanded or something
+        # is assigned over it.
+        # TODO: implement a timed out cache flusing
+        new_model = read_new_model(method_name)
+        @cache[method_name] = new_model
+
+        return new_model
+      end
     end
   end
 
@@ -142,8 +182,12 @@ class Model
     class_at_path(options[:path]).new(attributes, options)
   end
 
-  def new_array_model(*args)
-    ArrayModel.new(*args)
+  def new_array_model(attributes, options)
+    # Start with an empty query
+    options = options.dup
+    options[:query] = {}
+
+    ArrayModel.new(attributes, options)
   end
 
   def trigger_by_attribute!(event_name, attribute, *passed_args)
@@ -159,15 +203,20 @@ class Model
     end
   end
 
+  # Removes an item from the cache
+  def free(name)
+    @cache.delete(name)
+  end
+
   # If this model is nil, it makes it into a hash model, then
   # sets it up to track from the parent.
   def expand!
     if attributes.nil?
-      self.attributes = {}
+      @attributes = {}
       if @parent
         @parent.expand!
 
-        @parent.attributes[@path.last] = self
+        @parent.send(:"#{@path.last}=", self)
       end
     end
   end
@@ -196,18 +245,84 @@ class Model
     # Add the new item
     result << value
 
+    trigger!('added', nil, 0)
+    trigger!('changed')
+
     return nil
   end
 
   def inspect
-    "<#{self.class.to_s} #{attributes.inspect}>"
+    "<#{self.class.to_s}:#{object_id} #{attributes.inspect}>"
   end
 
   def deep_cur
     attributes
   end
 
+
+  def save!
+    if errors.size == 0
+      puts "SAVING: #{self.errors.inspect} - #{self.inspect} - #{options[:save_to].inspect} on #{self.inspect}"
+      save_to = options[:save_to]
+      if save_to
+        if save_to.is_a?(ArrayModel)
+          # Add to the collection
+          new_model = save_to.append(self.attributes)
+
+          options[:save_to] = new_model
+        else
+          puts "SAVE BUFFERED"
+          # We have a saved model
+          return save_to.assign_attributes(self.attributes)
+        end
+      else
+        raise "Model is not a buffer, can not be saved, modifications should be persisted as they are made."
+      end
+
+      return true
+    else
+      # Some errors, mark all fields
+      self.class.validations.keys.each do |key|
+        mark_field!(key.to_sym)
+      end
+      trigger_for_methods!('changed', :errors, :marked_errors)
+
+      return false
+    end
+  end
+
+
+  # Returns a buffered version of the model
+  tag_method(:buffer) do
+    destructive!
+  end
+  def buffer
+    model_path = options[:path]
+    model_klass = class_at_path(model_path)
+
+    new_options = options.merge(path: model_path, save_to: self).reject {|k,_| k.to_sym == :persistor }
+    model = model_klass.new({}, new_options, :loading)
+
+    if state == :loaded
+      setup_buffer(model)
+    else
+      self.parent.fetch do
+        setup_buffer(model)
+      end
+    end
+
+    # puts "SAVE TO:: #{model.options[:save_to].inspect} for #{model.inspect}"
+
+    return ReactiveValue.new(model)
+  end
+
+
   private
+  def setup_buffer(model)
+    model.attributes = self.attributes
+    model.change_state_to(:loaded)
+  end
+
     # Clear the previous value and assign a new one
     def __assign_element(key, value)
       __clear_element(key)