volt 0.9.3.pre2 → 0.9.3.pre3

data/lib/volt/server.rb

@@ -10,7 +10,7 @@ require 'sprockets-sass'
 
 require 'volt'
 require 'volt/tasks/dispatcher'
-require 'volt/tasks/task_handler'
+require 'volt/tasks/task'
 require 'volt/server/component_handler'
 require 'volt/server/rack/component_paths'
 require 'volt/server/rack/index_files'
@@ -133,7 +133,7 @@ module Volt
 
       # Serve the main html files from public, also figure out
       # which JS/CSS files to serve.
-      @rack_app.use IndexFiles, @volt_app.component_paths, opal_files
+      @rack_app.use IndexFiles, @volt_app, @volt_app.component_paths, opal_files
 
       @rack_app.use HttpResource, @volt_app, @volt_app.router
 

data/lib/volt/server/component_templates.rb

@@ -1,5 +1,5 @@
 require 'volt/server/html_parser/view_parser'
-require 'volt/tasks/task_handler'
+require 'volt/tasks/task'
 
 # Initialize with the path to a component and returns all the front-end
 # setup code (for controllers, models, views, and routes)
@@ -91,7 +91,7 @@ module Volt
 
         file_contents = File.read(view_path)
 
-        template_calls = []
+        # template_calls = []
 
         # Process template if we have a handler for this file type
         if handler = ComponentTemplates.handler_for_extension(format)
@@ -112,7 +112,7 @@ module Volt
             binding_code = "{#{binding_code.join(', ')}}"
 
             code << "#{page_reference}.add_template(#{name.inspect}, #{template['html'].inspect}, #{binding_code})\n"
-            template_calls << "template(#{name.inspect}, #{template['html'].inspect}, #{binding_code})"
+            # template_calls << "template(#{name.inspect}, #{template['html'].inspect}, #{binding_code})"
           end
         end
 
@@ -200,7 +200,10 @@ module Volt
     end
 
     def generate_initializers_code
-      "\nrequire_tree '#{@component_path}/config/initializers/'\n"
+      code = "\nrequire_tree '#{@component_path}/config/initializers/'\n"
+      code << "require_tree '#{@component_path}/config/initializers/client'\n"
+
+      code
     end
 
   end

data/lib/volt/server/message_bus/message_encoder.rb

@@ -5,8 +5,16 @@ module Volt
     class MessageEncoder
       attr_reader :encrypted
       def initialize
+        # rbnacl is not supported on windows.
+        windows = Gem.win_platform?
+
+        if windows
+          Volt.logger.warn('Currently Message Bus encryption is not supported on windows.')
+        end
+
         # Message bus is encrypted by default
-        @encrypted = (Volt.config.message_bus.try(:disable_encryption) != true)
+        disable = Volt.config.message_bus.try(:disable_encryption)
+        @encrypted = !windows && (disable != true)
 
         if @encrypted
           # Setup a RbNaCl simple box for handling encryption

data/lib/volt/server/rack/component_code.rb

@@ -27,7 +27,14 @@ module Volt
     end
 
     def generate_config_code
-      "\nVolt.setup_client_config(#{Volt.config.public.to_h.inspect})\n"
+      # Setup Volt.config on the client
+      code = "\nVolt.setup_client_config(#{Volt.config.public.to_h.inspect})\n"
+
+      # Include the root initializers
+      code << "require_tree '#{Volt.root}/config/initializers'\n"
+      code << "require_tree '#{Volt.root}/config/initializers/client'\n"
+
+      code
     end
   end
 end

data/lib/volt/server/rack/index_files.rb

@@ -4,12 +4,15 @@ require 'volt/router/routes'
 # Serves the main pages
 module Volt
   class IndexFiles
-    def initialize(app, component_paths, opal_files)
+    def initialize(app, volt_app, component_paths, opal_files)
       @app             = app
+      @volt_app        = volt_app
       @component_paths = component_paths
       @opal_files      = opal_files
 
-      @@router ||= Routes.new.define do
+      @@router = volt_app.router
+
+      @@router.define do
         # Load routes for each component
         component_paths.components.values.flatten.uniq.each do |component_path|
           routes_path = "#{component_path}/config/routes.rb"

data/lib/volt/tasks/{task_handler.rb → task.rb}

@@ -1,3 +1,5 @@
+require 'volt/controllers/collection_helpers'
+
 module Volt
   class Task
     if RUBY_PLATFORM == 'opal'
@@ -14,8 +16,11 @@ module Volt
         $page.tasks.call(self.name, name, meta_data, *args, &block)
       end
     else
+      include CollectionHelpers
+
       def initialize(volt_app, channel = nil, dispatcher = nil)
-        @volt_app = volt_app
+        @volt_app   = volt_app
+        @page       = volt_app.page
         @channel    = channel
         @dispatcher = dispatcher
       end
@@ -39,11 +44,6 @@ module Volt
           new(Volt.current_app, nil, nil).send(name, *args, &block)
         end.resolve(nil)
       end
-
-      # Provide access to the store collection
-      def store
-        $page.store
-      end
     end
   end
 end

data/lib/volt/utils/promise.rb

@@ -0,0 +1,429 @@
+# A copy of the opal 0.8 promise library.  The one in 0.7.x has some bugs.
+
+# {Promise} is used to help structure asynchronous code.
+#
+# It is available in the Opal standard library, and can be required in any Opal
+# application:
+#
+#     require 'promise'
+#
+# ## Basic Usage
+#
+# Promises are created and returned as objects with the assumption that they
+# will eventually be resolved or rejected, but never both. A {Promise} has
+# a {#then} and {#fail} method (or one of their aliases) that can be used to
+# register a block that gets called once resolved or rejected.
+#
+#     promise = Promise.new
+#
+#     promise.then {
+#       puts "resolved!"
+#     }.fail {
+#       puts "rejected!"
+#     }
+#
+#     # some time later
+#     promise.resolve
+#
+#     # => "resolved!"
+#
+# It is important to remember that a promise can only be resolved or rejected
+# once, so the block will only ever be called once (or not at all).
+#
+# ## Resolving Promises
+#
+# To resolve a promise, means to inform the {Promise} that it has succeeded
+# or evaluated to a useful value. {#resolve} can be passed a value which is
+# then passed into the block handler:
+#
+#     def get_json
+#       promise = Promise.new
+#
+#       HTTP.get("some_url") do |req|
+#         promise.resolve req.json
+#       end
+#
+#       promise
+#     end
+#
+#     get_json.then do |json|
+#       puts "got some JSON from server"
+#     end
+#
+# ## Rejecting Promises
+#
+# Promises are also designed to handle error cases, or situations where an
+# outcome is not as expected. Taking the previous example, we can also pass
+# a value to a {#reject} call, which passes that object to the registered
+# {#fail} handler:
+#
+#     def get_json
+#       promise = Promise.new
+#
+#       HTTP.get("some_url") do |req|
+#         if req.ok?
+#           promise.resolve req.json
+#         else
+#           promise.reject req
+#         end
+#
+#       promise
+#     end
+#
+#     get_json.then {
+#       # ...
+#     }.fail { |req|
+#       puts "it went wrong: #{req.message}"
+#     }
+#
+# ## Chaining Promises
+#
+# Promises become even more useful when chained together. Each {#then} or
+# {#fail} call returns a new {Promise} which can be used to chain more and more
+# handlers together.
+#
+#     promise.then { wait_for_something }.then { do_something_else }
+#
+# Rejections are propagated through the entire chain, so a "catch all" handler
+# can be attached at the end of the tail:
+#
+#     promise.then { ... }.then { ... }.fail { ... }
+#
+# ## Composing Promises
+#
+# {Promise.when} can be used to wait for more than one promise to resolve (or
+# reject). Using the previous example, we could request two different json
+# requests and wait for both to finish:
+#
+#     Promise.when(get_json, get_json2).then |first, second|
+#       puts "got two json payloads: #{first}, #{second}"
+#     end
+#
+class Promise
+  def self.value(value)
+    new.resolve(value)
+  end
+
+  def self.error(value)
+    new.reject(value)
+  end
+
+  def self.when(*promises)
+    When.new(promises)
+  end
+
+  attr_reader :error, :prev, :next
+
+  def initialize(action = {})
+    @action = action
+
+    @realized  = false
+    @exception = false
+    @value     = nil
+    @error     = nil
+    @delayed   = false
+
+    @prev = nil
+    @next = nil
+  end
+
+  def value
+    if Promise === @value
+      @value.value
+    else
+      @value
+    end
+  end
+
+  def act?
+    @action.has_key?(:success) || @action.has_key?(:always)
+  end
+
+  def action
+    @action.keys
+  end
+
+  def exception?
+    @exception
+  end
+
+  def realized?
+    !!@realized
+  end
+
+  def resolved?
+    @realized == :resolve
+  end
+
+  def rejected?
+    @realized == :reject
+  end
+
+  def ^(promise)
+    promise << self
+    self    >> promise
+
+    promise
+  end
+
+  def <<(promise)
+    @prev = promise
+
+    self
+  end
+
+  def >>(promise)
+    @next = promise
+
+    if exception?
+      promise.reject(@delayed[0])
+    elsif resolved?
+      promise.resolve(@delayed ? @delayed[0] : value)
+    elsif rejected?
+      if !@action.has_key?(:failure) || Promise === (@delayed ? @delayed[0] : @error)
+        promise.reject(@delayed ? @delayed[0] : error)
+      elsif promise.action.include?(:always)
+        promise.reject(@delayed ? @delayed[0] : error)
+      end
+    end
+
+    self
+  end
+
+  def resolve(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      return (value << @prev) ^ self
+    end
+
+    begin
+      if block = @action[:success] || @action[:always]
+        value = block.call(value)
+      end
+
+      resolve!(value)
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def resolve!(value)
+    @realized = :resolve
+    @value    = value
+
+    if @next
+      @next.resolve(value)
+    else
+      @delayed = [value]
+    end
+  end
+
+  def reject(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      return (value << @prev) ^ self
+    end
+
+    begin
+      if block = @action[:failure] || @action[:always]
+        value = block.call(value)
+      end
+
+      if @action.has_key?(:always)
+        resolve!(value)
+      else
+        reject!(value)
+      end
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def reject!(value)
+    @realized = :reject
+    @error    = value
+
+    if @next
+      @next.reject(value)
+    else
+      @delayed = [value]
+    end
+  end
+
+  def exception!(error)
+    @exception = true
+
+    reject!(error)
+  end
+
+  def then(&block)
+    if @next
+      raise ArgumentError, 'a promise has already been chained'
+    end
+
+    self ^ Promise.new(success: block)
+  end
+
+  alias do then
+
+  def fail(&block)
+    if @next
+      raise ArgumentError, 'a promise has already been chained'
+    end
+
+    self ^ Promise.new(failure: block)
+  end
+
+  alias rescue fail
+  alias catch fail
+
+  def always(&block)
+    if @next
+      raise ArgumentError, 'a promise has already been chained'
+    end
+
+    self ^ Promise.new(always: block)
+  end
+
+  alias finally always
+  alias ensure always
+
+  def trace(depth = nil, &block)
+    if @next
+      raise ArgumentError, 'a promise has already been chained'
+    end
+
+    self ^ Trace.new(depth, block)
+  end
+
+  def inspect
+    result = "#<#{self.class}(#{object_id})"
+
+    if @next
+      result += " >> #{@next.inspect}"
+    end
+
+    if realized?
+      result += ": #{(@value || @error).inspect}>"
+    else
+      result += ">"
+    end
+
+    result
+  end
+
+  class Trace < self
+    def self.it(promise)
+      current = []
+
+      if promise.act? || promise.prev.nil?
+        current.push(promise.value)
+      end
+
+      if prev = promise.prev
+        current.concat(it(prev))
+      else
+        current
+      end
+    end
+
+    def initialize(depth, block)
+      @depth = depth
+
+      super success: -> {
+        trace = Trace.it(self).reverse
+        trace.pop
+
+        if depth && depth <= trace.length
+          trace.shift(trace.length - depth)
+        end
+
+        block.call(*trace)
+      }
+    end
+  end
+
+  class When < self
+    def initialize(promises = [])
+      super()
+
+      @wait = []
+
+      promises.each {|promise|
+        wait promise
+      }
+    end
+
+    def each(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        values.each(&block)
+      }
+    end
+
+    def collect(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        When.new(values.map(&block))
+      }
+    end
+
+    def inject(*args, &block)
+      self.then {|values|
+        values.reduce(*args, &block)
+      }
+    end
+
+    alias map collect
+
+    alias reduce inject
+
+    def wait(promise)
+      unless Promise === promise
+        promise = Promise.value(promise)
+      end
+
+      if promise.act?
+        promise = promise.then
+      end
+
+      @wait << promise
+
+      promise.always {
+        try if @next
+      }
+
+      self
+    end
+
+    alias and wait
+
+    def >>(*)
+      super.tap {
+        try
+      }
+    end
+
+    def try
+      if @wait.all?(&:realized?)
+        if promise = @wait.find(&:rejected?)
+          reject(promise.error)
+        else
+          resolve(@wait.map(&:value))
+        end
+      end
+    end
+  end
+end