volt 0.2.3

data/lib/volt/extra_core/extra_core.rb

@@ -0,0 +1,7 @@
+require 'volt/extra_core/array'
+require 'volt/extra_core/object'
+require 'volt/extra_core/blank'
+require 'volt/extra_core/stringify_keys'
+require 'volt/extra_core/string'
+require 'volt/extra_core/numeric'
+require 'volt/extra_core/true_false'

data/lib/volt/extra_core/numeric.rb

@@ -0,0 +1,9 @@
+class Numeric
+  def in_units_of(unit)
+    if self == 1
+      return "1 #{unit}"
+    else
+      return "#{self} #{unit}s"
+    end
+  end
+end

data/lib/volt/extra_core/object.rb

@@ -0,0 +1,36 @@
+class Object
+  # Setup a default pretty_inspect
+  # alias_method :pretty_inspect, :inspect
+  
+  def instance_values
+    Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
+  end
+  
+  # Provides the same functionality as ||, but since ReactiveValue's only
+  # work with method calls, we provide .or as a convience.
+  def or(other)
+    if self.true?
+      return self
+    else
+      return other
+    end
+  end
+  
+  # Provides the same functionality as &&, but since ReactiveValue's only
+  # work with method calls, we provide .and as a convience
+  def and(other)
+    if self.true?
+      return other
+    else
+      return self
+    end
+  end
+  
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      __send__(*a, &b)
+    end
+  end
+end

data/lib/volt/extra_core/string.rb

@@ -0,0 +1,29 @@
+class String
+  # TODO: replace with better implementations
+  # NOTE: strings are currently immutable in Opal, so no ! methods
+  def camelize
+    self.split("_").map {|s| s.capitalize }.join("")
+  end
+  
+  def underscore
+    self.scan(/[A-Z][a-z]*/).join("_").downcase
+  end
+  
+  def pluralize
+    # TODO: Temp implementation
+    if self[-1] != 's'
+      return self + 's'
+    else
+      return self
+    end
+  end
+  
+  def singularize
+    # TODO: Temp implementation
+    if self[-1] == 's'
+      return self[0..-2]
+    else
+      return self
+    end
+  end
+end

data/lib/volt/extra_core/stringify_keys.rb

@@ -0,0 +1,7 @@
+class Object
+  def stringify_keys
+    self.each_with_object({}) { |(key, value), hash|
+      hash[key.to_s] = value
+    }
+  end
+end

data/lib/volt/extra_core/true_false.rb

@@ -0,0 +1,44 @@
+# The true?/false? predicates are convience methods since if ..reactive_value.. does
+# not correctly evaluate.  The reason for this is that ruby currently does not allow
+# anything besides nil and false to be falsy.
+
+class Object
+  def true?
+    true
+  end
+  
+  def false?
+    false
+  end
+end
+
+class FalseClass
+  def true?
+    false
+  end
+  
+  def false?
+    true
+  end
+end
+
+class NilClass
+  def true?
+    false
+  end
+  
+  def false?
+    true
+  end
+end
+
+# Opal only has a single class for true/false
+class Boolean
+  def true?
+    self
+  end
+  
+  def false?
+    self
+  end  
+end

data/lib/volt/extra_core/try.rb

@@ -0,0 +1,31 @@
+class Object
+  
+  class TryProxy
+    def initialize(original)
+      @original = original
+    end
+    
+    def method_missing(method_name, *args, &block)
+      if @original.respond_to?(method_name)
+        
+      else
+        NilProxy.new
+      end
+    end
+  end
+  
+  class NilProxy
+    def method_missing(method_name, *args, &block)
+      if @original.respond_to?(method_name)
+        
+      else
+        NilProxy.new
+      end
+    end
+  end
+  
+  def try
+    
+  end
+  
+end

data/lib/volt/models.rb

@@ -0,0 +1,5 @@
+require 'volt/extra_core/extra_core'
+require 'volt/reactive/reactive_value'
+require 'volt/models/model'
+require 'volt/models/params'
+

data/lib/volt/models/array_model.rb

@@ -0,0 +1,37 @@
+require 'volt/models/model_wrapper'
+
+class ArrayModel < ReactiveArray
+  include ModelWrapper
+
+  def initialize(array=[], parent=nil, path=nil)
+    @parent = parent
+    @path = path
+    
+    array = wrap_values(array)
+    
+    super(array)
+  end
+  
+  def attributes
+    self
+  end
+  
+  # Make sure it gets wrapped
+  def <<(*args)
+    args = wrap_values(args)
+    
+    super(*args)
+  end
+  
+  # Make sure it gets wrapped
+  def inject(*args)
+    args = wrap_values(args)
+    super(*args)
+  end
+
+  # Make sure it gets wrapped
+  def +(*args)
+    args = wrap_values(args)
+    super(*args)
+  end
+end

data/lib/volt/models/model.rb

@@ -0,0 +1,210 @@
+require 'volt/models/model_wrapper'
+require 'volt/models/array_model'
+require 'volt/reactive/object_tracking'
+
+class NilMethodCall < NoMethodError
+  def true?
+    false
+  end
+  
+  def false?
+    true
+  end
+end
+
+class Model
+  include ReactiveTags
+  include ModelWrapper
+  include ObjectTracking
+  
+  attr_accessor :attributes
+  attr_reader :parent, :path
+  
+  def nil?
+    attributes.nil?
+  end
+  
+  def false?
+    attributes.false?
+  end
+  
+  def true?
+    attributes.true?
+  end
+  
+  def initialize(attributes={}, parent=nil, path=nil, class_paths=nil)
+    self.attributes = wrap_values(attributes)
+    @parent = parent
+    @path = path
+  end
+  
+  # Pass the comparison through
+  def ==(val)
+    attributes == val
+  end
+  
+  # Pass through needed
+  def !
+    !attributes
+  end
+  
+  tag_method(:delete) do
+    destructive!
+  end
+  def delete(*args)
+    __clear_element(args[0])
+    attributes.delete(*args)
+    trigger_by_attribute!('changed', args[0])
+  end
+  
+  tag_all_methods do
+    destructive! do |method_name|
+      method_name[0] == '_' && method_name[-1] == '='
+    end
+    pass_reactive! do |method_name|
+      method_name[0] == '_' && method_name[-1] == '='
+    end
+  end
+  def method_missing(method_name, *args, &block)
+    if method_name[0] == '_'
+      if method_name[-1] == '='
+        # Assigning an attribute with =
+        assign_attribute(method_name, *args, &block)
+      else
+        read_attribute(method_name)
+      end
+    else
+      # Call method directly on attributes.  (since they are
+      # not using _ )
+      attributes.send(method_name, *args, &block)
+    end
+  end
+  
+  # Do the assignment to a model and trigger a changed event
+  def assign_attribute(method_name, *args, &block)
+    self.expand!
+    # Assign, without the =
+    attribute_name = method_name[0..-2].to_sym
+    
+    value = args[0]
+    __assign_element(attribute_name, value)
+    
+    attributes[attribute_name] = wrap_value(value)
+    trigger_by_attribute!('changed', attribute_name)
+  end
+  
+  # When reading an attribute, we need to handle reading on:
+  # 1) a nil model, which returns a wrapped error
+  # 2) reading directly from attributes
+  # 3) trying to read a key that doesn't exist.
+  def read_attribute(method_name)
+    # Reading an attribute, we may get back a nil model.
+    method_name = method_name.to_sym
+    
+    if attributes == nil
+      # 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 new_model(nil, self, method_name)
+    end
+  end
+  
+  def return_undefined_method(method_name)
+    # Methods called on nil capture an error so the user can know where
+    # their nil calls are.  This error can be re-raised at a later point.
+    begin
+      raise NilMethodCall.new("undefined method `#{method_name}' for #{self.to_s}")
+    rescue => e
+      result = e
+
+      # Cleanup backtrace around ReactiveValue's
+      # TODO: this could be better
+      result.backtrace.reject! {|line| line['lib/models/model.rb'] || line['lib/models/live_value.rb'] }
+    end
+  end
+  
+  def new_model(*args)
+    Model.new(*args)
+  end
+  
+  def trigger_by_attribute!(event_name, attribute, *passed_args)
+    trigger_by_scope!(event_name, *passed_args) do |scope|
+      method_name, *args, block = scope
+      
+      # TODO: Opal bug
+      args ||= []
+      
+      # Any methods without _ are not directly related to one attribute, so
+      # they should all trigger
+      !method_name || method_name[0] != '_' || (method_name == attribute.to_sym && args.size == 0)
+    end
+  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 = {}
+      if @parent
+        @parent.expand!
+      
+        @parent.attributes[@path] = self
+      end
+    end
+  end
+  
+  tag_method(:<<) do
+    destructive!
+    pass_reactive!
+  end
+  # Initialize an empty array and append to it
+  def <<(value)
+    @parent.expand!
+    result = @parent.send(@path)
+    
+    if result.nil?
+      # If this isn't a model yet, instantiate it
+      @parent.send(:"#{@path}=", ArrayModel.new([], @parent, @path))
+      result = @parent.send(@path)
+      
+      # Add the new item
+      result << value
+    end
+    
+    return result
+  end
+  
+  def inspect
+    "<#{self.class.to_s}:#{@path} #{attributes.inspect}>"
+  end
+  
+  
+  private
+    # Clear the previous value and assign a new one
+    def __assign_element(key, value)
+      __clear_element(key)
+      __track_element(key, value)
+    end
+    
+    # TODO: Somewhat duplicated from ReactiveArray
+    def __clear_element(key)
+      # Cleanup any tracking on an index
+      # TODO: is this send a security risk?
+      # puts "TRY TO CLEAR: #{key} - #{@reactive_element_listeners && @reactive_element_listeners.keys.inspect}"
+      if @reactive_element_listeners && @reactive_element_listeners[key]        
+        @reactive_element_listeners[key].remove
+        @reactive_element_listeners.delete(key)
+      end
+    end
+  
+    def __track_element(key, value)
+      puts "TRACK: #{key} - #{value.inspect}"
+      __setup_tracking(key, value) do |event, key, args|
+        trigger_by_attribute!(event, key, *args)
+      end
+    end
+end

data/lib/volt/models/model_wrapper.rb

@@ -0,0 +1,23 @@
+module ModelWrapper
+  # For cretain values, we wrap them to make the behave as a
+  # model.
+  def wrap_value(value)
+    if value.cur.is_a?(Array)
+      value = ArrayModel.new(value, self, nil)
+    elsif value.cur.is_a?(Hash)
+      value = Model.new(value)
+    end
+    
+    return value
+  end
+  
+  def wrap_values(values)
+    if values.cur.is_a?(Array)
+      values = values.map {|v| wrap_value(v) }
+    elsif values.cur.is_a?(Hash)
+      values = Hash[values.map {|k,v| [k, wrap_value(v)] }]
+    end
+    
+    return values
+  end
+end