volt 0.8.27.beta3 → 0.8.27.beta4

data/lib/volt/router/routes.rb

@@ -76,7 +76,7 @@ module Volt
     def params_to_url(test_params)
       # Add in underscores
       test_params = test_params.each_with_object({}) do |(k, v), obj|
-        obj[:"_#{k}"] = v
+        obj[k.to_sym] = v
       end
 
       @param_matches.each do |param_matcher|
@@ -160,6 +160,7 @@ module Volt
 
       parts.each_with_index do |part, index|
         if has_binding?(part)
+          # Strip off {{ and }}
           params[part[2...-2].strip.to_sym] = index
 
           # Set the part to be '*' (anything matcher)

data/lib/volt/server/component_templates.rb

@@ -76,8 +76,6 @@ module Volt
         code << File.read(model_path) + "\n\n"
 
         model_name = model_path.match(/([^\/]+)[.]rb$/)[1]
-
-        code << "#{page_reference}.add_model(#{model_name.inspect})\n\n"
       end
 
       code

data/lib/volt/server/html_parser/component_view_scope.rb

@@ -0,0 +1,59 @@
+module Volt
+  class ComponentViewScope < ViewScope
+    # The path passed in is the path used to lookup view's.  The path from the tag is passed in
+    # as tag_name
+    def initialize(handler, path, tag_name, attributes, unary)
+      super(handler, path)
+
+      @binding_in_path = path
+
+      component_name = tag_name[1..-1].tr(':', '/')
+
+      data_hash = []
+      attributes.each_pair do |name, value|
+        name = name.tr('-', '_')
+        parts, binding_count = binding_parts_and_count(value)
+
+        # if this attribute has bindings
+        if binding_count > 0
+          if binding_count > 1
+            # Multiple bindings
+          elsif parts.size == 1 && binding_count == 1
+            # A single binding
+            getter = value[2...-2].strip
+            data_hash << "#{name.inspect} => Proc.new { #{getter} }"
+
+            setter = getter_to_setter(getter)
+            data_hash << "#{(name + '=').inspect} => Proc.new { |val| #{setter} }"
+
+            # Add an _parent fetcher.  Useful for things like volt-fields to get the parent model.
+            parent = parent_fetcher(getter)
+
+            # TODO: This adds some overhead, perhaps there is a way to compute this dynamically on the
+            # front-end.
+            data_hash << "#{(name + '_parent').inspect} => Proc.new { #{parent} }"
+
+            # Add a _last_method property.  This is useful
+            data_hash << "#{(name + '_last_method').inspect} => #{last_method_name(getter).inspect}"
+          end
+        else
+          # String
+          data_hash << "#{name.inspect} => #{value.inspect}"
+        end
+      end
+
+      @arguments = "#{component_name.inspect}, { #{data_hash.join(',')} }"
+    end
+
+    def close_scope
+      binding_number                    = @handler.scope[-2].binding_number
+      @handler.scope[-2].binding_number += 1
+      @path                             += "/__template/#{binding_number}"
+
+      super
+
+      @handler.html << "<!-- $#{binding_number} --><!-- $/#{binding_number} -->"
+      @handler.scope.last.save_binding(binding_number, "lambda { |__p, __t, __c, __id| Volt::ComponentBinding.new(__p, __t, __c, __id, #{@binding_in_path.inspect}, Proc.new { [#{@arguments}] }, #{@path.inspect}) }")
+    end
+  end
+end

data/lib/volt/server/html_parser/view_handler.rb

@@ -56,6 +56,9 @@ module Volt
       if @in_textarea && tag_name == 'textarea'
         last.close_scope
         @in_textarea = nil
+      elsif tag_name[0] == ':'
+        # Closing a volt tag
+        last.close_scope
       else
         last << "</#{tag_name}>"
       end

data/lib/volt/server/html_parser/view_parser.rb

@@ -1,6 +1,7 @@
 require 'volt/server/html_parser/sandlebars_parser'
 require 'volt/server/html_parser/view_scope'
 require 'volt/server/html_parser/if_view_scope'
+require 'volt/server/html_parser/component_view_scope'
 require 'volt/server/html_parser/view_handler'
 require 'volt/server/html_parser/each_scope'
 require 'volt/server/html_parser/textarea_scope'

data/lib/volt/server/html_parser/view_scope.rb

@@ -40,6 +40,8 @@ module Volt
             end
           when 'template'
             add_template(args)
+          when 'yield'
+            add_yield(args)
           else
             if content =~ /.each\s+do\s+\|/
               add_each(content, false)
@@ -56,6 +58,8 @@ module Volt
             close_scope
           when 'else'
             add_else(nil)
+          when 'yield'
+            add_yield
           else
             add_content_binding(content)
         end
@@ -92,6 +96,17 @@ module Volt
       @binding_number += 1
     end
 
+    def add_yield(content=nil)
+      # Strip ( and ) from the outsides
+      content ||= ''
+      content = content.strip.gsub(/^\(/, '').gsub(/\)$/, '')
+
+      @handler.html << "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
+      save_binding(@binding_number, "lambda { |__p, __t, __c, __id| Volt::YieldBinding.new(__p, __t, __c, __id, Proc.new { [#{content}] }) }")
+
+      @binding_number += 1
+    end
+
     # Returns ruby code to fetch the parent. (by removing the last fetch)
     # TODO: Probably want to do this with AST transforms with the parser/unparser gems
     def parent_fetcher(getter)
@@ -109,48 +124,9 @@ module Volt
     end
 
     def add_component(tag_name, attributes, unary)
-      component_name = tag_name[1..-1].tr(':', '/')
+      @handler.scope << ComponentViewScope.new(@handler, @path + "/__component#{@binding_number}", tag_name, attributes, unary)
 
-      @handler.html << "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
-
-      data_hash = []
-      attributes.each_pair do |name, value|
-        name = name.tr('-', '_')
-        parts, binding_count = binding_parts_and_count(value)
-
-        # if this attribute has bindings
-        if binding_count > 0
-          if binding_count > 1
-            # Multiple bindings
-          elsif parts.size == 1 && binding_count == 1
-            # A single binding
-            getter = value[2...-2].strip
-            data_hash << "#{name.inspect} => Proc.new { #{getter} }"
-
-            setter = getter_to_setter(getter)
-            data_hash << "#{(name + '=').inspect} => Proc.new { |val| #{setter} }"
-
-            # Add an _parent fetcher.  Useful for things like volt-fields to get the parent model.
-            parent = parent_fetcher(getter)
-
-            # TODO: This adds some overhead, perhaps there is a way to compute this dynamically on the
-            # front-end.
-            data_hash << "#{(name + '_parent').inspect} => Proc.new { #{parent} }"
-
-            # Add a _last_method property.  This is useful
-            data_hash << "#{(name + '_last_method').inspect} => #{last_method_name(getter).inspect}"
-          end
-        else
-          # String
-          data_hash << "#{name.inspect} => #{value.inspect}"
-        end
-      end
-
-      arguments = "#{component_name.inspect}, { #{data_hash.join(',')} }"
-
-      save_binding(@binding_number, "lambda { |__p, __t, __c, __id| Volt::ComponentBinding.new(__p, __t, __c, __id, #{@path.inspect}, Proc.new { [#{arguments}] }) }")
-
-      @binding_number += 1
+      @handler.last.close_scope if unary
     end
 
     def add_textarea(tag_name, attributes, unary)

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

@@ -16,7 +16,7 @@ module Volt
 
         # Gem folders with volt in them
         # TODO: we should probably qualify this a bit more
-        app_folders += Gem.loaded_specs.values.map(&:full_gem_path).reject { |g| g !~ /volt/ }.map { |f| f + '/app' }
+        app_folders += Gem.loaded_specs.values.reduce([]) { |paths, gem| paths << "#{gem.full_gem_path}/app" if gem.name =~ /volt/; paths }
 
         app_folders.uniq
       end
@@ -66,15 +66,6 @@ module Volt
             path = ruby_file.gsub(/^#{app_folder}\//, '')[0..-4]
             require(path)
           end
-
-          if Volt.server?
-            # Add models to page
-            Dir["#{app_folder}/*/models/*.rb"].each do |ruby_file|
-              class_name = File.basename(ruby_file).gsub(/[.]rb$/, '')
-
-              $page.add_model(class_name)
-            end
-          end
         end
 
         load_views_and_routes

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

@@ -10,10 +10,15 @@ module Volt
       @opal_files      = opal_files
 
       @@router ||= Routes.new.define do
-        # Find the route file
-        home_path  = component_paths.component_paths('main').first
-        route_file = File.read("#{home_path}/config/routes.rb")
-        eval(route_file)
+        # Load routes for each component
+        component_paths.components.values.flatten.uniq.each do |component_path|
+          routes_path = "#{component_path}/config/routes.rb"
+
+          if File.exists?(routes_path)
+            route_file = File.read(routes_path)
+            instance_eval(route_file, routes_path, 0)
+          end
+        end
       end
     end
 

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

@@ -11,13 +11,17 @@ module Volt
 
     def initialize(builder, app_path, component_paths)
       Opal::Processor.source_map_enabled = Volt.source_maps?
+      Opal::Processor.const_missing_enabled = true
 
       # Don't run arity checks in production
       # Opal::Processor.arity_check_enabled = !Volt.env.production?
       # Opal::Processor.dynamic_require_severity = :raise
 
+      server = Opal::Server.new(prefix: '/')
+
       @component_paths                   = component_paths
-      @environment                       = Opal::Environment.new
+      # @environment                       = Opal::Environment.new
+      @environment                       = server.sprockets
 
       # Since the scope changes in builder blocks, we need to capture
       # environment in closure
@@ -31,33 +35,37 @@ module Volt
         environment.css_compressor = Sprockets::YUICompressor
       end
 
-      environment.append_path(app_path)
+      server.append_path(app_path)
 
       volt_gem_lib_path = File.expand_path(File.join(File.dirname(__FILE__), '../../..'))
-      environment.append_path(volt_gem_lib_path)
+      server.append_path(volt_gem_lib_path)
 
-      add_asset_folders(environment)
+      add_asset_folders(server)
 
       # Add the opal load paths
       Opal.paths.each do |path|
-        environment.append_path(path)
+        server.append_path(path)
       end
 
       # opal-jquery gem
       spec = Gem::Specification.find_by_name('opal-jquery')
-      environment.append_path(spec.gem_dir + '/opal')
+      server.append_path(spec.gem_dir + '/lib')
 
       builder.map '/assets' do
-        run environment
+        run server
       end
 
-      if Volt.source_maps?
-        source_maps = SourceMapServer.new(environment)
-
-        builder.map(source_maps.prefix) do
-          run source_maps
-        end
-      end
+      # map server.source_maps.prefix do
+      #   run server.source_maps
+      # end
+
+      # if Volt.source_maps?
+      #   source_maps = SourceMapServer.new(environment)
+      #
+      #   builder.map(source_maps.prefix) do
+      #     run source_maps
+      #   end
+      # end
     end
 
     def add_asset_folders(environment)

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

@@ -25,7 +25,7 @@ class QuietCommonLogger < Rack::CommonLogger
 
     # Because of web sockets, the initial request doesn't finish, so we
     # can just trigger it now.
-    if !ext && !path.start_with?('/channel')
+    unless ext || path.start_with?('/channel')
       log(env, status, header, began_at)
     end
 

data/lib/volt/server/socket_connection_handler.rb

@@ -6,6 +6,10 @@ module Volt
   class SocketConnectionHandler < SockJS::Session
     # Create one instance of the dispatcher
 
+    # We track the connected user_id with the channel for use with permissions.
+    # This may be changed as new listeners connect, which is fine.
+    attr_accessor :user_id
+
     def self.dispatcher=(val)
       @@dispatcher = val
     end

data/lib/volt/spec/setup.rb

@@ -16,6 +16,32 @@ module Volt
 
         setup_capybara(app_path)
       end
+
+
+      # Setup the spec collection accessors
+      # RSpec.shared_context "volt collections", {} do
+      RSpec.shared_examples_for 'volt collections', {} do
+        # Page conflicts with capybara's page method
+        # let(:page) { Model.new }
+        let(:store) do
+          @__store_accessed = true
+          $page ||= Page.new
+          $page.store
+        end
+
+        after do
+          if @__store_accessed
+            # Clear the database after each spec where we use store
+            # @@db ||= Volt::DataStore.fetch
+            # puts "DB CLASS: #{@@db.inspect}"
+            # @@db.drop_database
+            ::DataStore.new.drop_database
+
+            $page.instance_variable_set('@store', nil)
+          end
+        end
+      end
+
     end
   end
 end

data/lib/volt/tasks/dispatcher.rb

@@ -1,3 +1,5 @@
+# require 'ruby-prof'
+
 module Volt
   # The task dispatcher is responsible for taking incoming messages
   # from the socket channel and dispatching them to the proper handler.
@@ -25,8 +27,17 @@ module Volt
         promise = promise.then do
           Thread.current['meta'] = meta_data
 
+          # # Profile the code
+          # RubyProf.start
+
           result = klass.new(channel, self).send(method_name, *args)
 
+          # res = RubyProf.stop
+          #
+          # # Print a flat profile to text
+          # printer = RubyProf::FlatPrinter.new(res)
+          # printer.print(STDOUT)
+
           Thread.current['meta'] = nil
 
           result

data/lib/volt/utils/event_counter.rb

@@ -0,0 +1,29 @@
+module Volt
+  # EventCounter has an #add and #remove method, and when the first one is added
+  # will call the #start proc (passed to new), and when the last is removed will
+  # call #stop.
+  class EventCounter
+    attr_reader :count
+
+    def initialize(start, stop)
+      @start = start
+      @stop = stop
+
+      @count = 0
+    end
+
+    def add
+      @count += 1
+
+      @start.call if @count == 1
+    end
+
+    def remove
+      @count -= 1
+
+      raise "count below 0" if @count < 0
+
+      @stop.call if @count == 0
+    end
+  end
+end

data/lib/volt/utils/generic_pool.rb

@@ -96,5 +96,17 @@ module Volt
         end
       end
     end
+
+    def print
+      puts '--- Running Queries ---'
+
+      @pool.each_pair do |table, query_hash|
+        query_hash.each_key do |query|
+          puts "#{table.inspect}: #{query.inspect}"
+        end
+      end
+
+      puts '---------------------'
+    end
   end
 end

data/lib/volt/utils/modes.rb

@@ -0,0 +1,40 @@
+require 'thread'
+
+if RUBY_PLATFORM == 'opal'
+  # Stub thread class
+  class Thread
+    def self.current
+      @current ||= {}
+    end
+  end
+end
+
+module Volt
+  # Modes provide a way to effect the state inside of a block that
+  # can be checked from elsewhere.  This is very useful if you have
+  # some flag you may want to change without needing to pass all
+  # of the way through some other code.
+  module Modes
+    module ClassMethods
+      # Takes a block that when run, changes to mode inside of it
+      def run_in_mode(mode_name)
+        previous = Thread.current[mode_name]
+        Thread.current[mode_name] = true
+        begin
+          yield
+        ensure
+          Thread.current[mode_name] = previous
+        end
+      end
+
+      # Check to see if we are in the specified mode
+      def in_mode?(mode_name)
+        return defined?(Thread) && Thread.current[mode_name]
+      end
+    end
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+  end
+end

data/lib/volt/utils/promise_patch.rb

@@ -0,0 +1,66 @@
+# A temp patch for promises until https://github.com/opal/opal/pull/725 is released.
+class Promise
+  def initialize(success = nil, failure = nil)
+    @success = success
+    @failure = failure
+
+    @realized  = nil
+    @exception = false
+    @value     = nil
+    @error     = nil
+    @delayed   = false
+
+    @prev = nil
+    @next = nil
+  end
+
+
+  def >>(promise)
+    @next = promise
+
+    if exception?
+      promise.reject(@delayed[0])
+    elsif resolved?
+      promise.resolve(@delayed ? @delayed[0] : value)
+    elsif rejected? && (!@failure || Promise === (@delayed ? @delayed[0] : @error))
+      promise.reject(@delayed ? @delayed[0] : error)
+    end
+
+    self
+  end
+
+  def resolve!(value)
+    if @next
+      @next.resolve(value)
+    else
+      @delayed = [value]
+    end
+  end
+
+  def reject!(value)
+    if @next
+      @next.reject(value)
+    else
+      @delayed = [value]
+    end
+  end
+
+  # Waits for the promise to resolve (assuming it is blocking on
+  # the server) and returns the result.
+  def sync
+    result = nil
+    error = nil
+
+    self.then do |val|
+      result = val
+    end.fail do |err|
+      error = err
+    end
+
+    if error
+      raise error
+    else
+      return result
+    end
+  end
+end

data/lib/volt/utils/timers.rb

@@ -0,0 +1,33 @@
+module Volt
+
+  # The timers class provides useful methods for working in an asynchronus environment.
+  class Timers
+    # next tick (same as setImmediate) calls the block of code after any currently
+    # running code is finished.
+    def self.next_tick(&block)
+      if Volt.in_browser?
+        `setImmediate(function() {`
+          yield
+        `})`
+      else
+        tick_timers = (Thread.current['tick_timers'] ||= [])
+        tick_timers << block
+      end
+    end
+
+    # On the server, we need to manually flush next tick timers.
+    # This is done automatically in the console after each enter.
+    def self.flush_next_tick_timers!
+      tick_timers = Thread.current['tick_timers']
+
+      if tick_timers
+        # clear
+        Thread.current['tick_timers'] = nil
+        tick_timers.each do |timer|
+          # Run the timer
+          timer.call
+        end
+      end
+    end
+  end
+end

data/lib/volt/volt/users.rb

@@ -1,7 +1,14 @@
+require 'thread'
+
 module Volt
   class << self
     # Get the user_id from the cookie
     def user_id
+      # Check for a user_id from with_user
+      if (user_id = Thread.current['with_user_id'])
+        return user_id
+      end
+
       user_id_signature = self.user_id_signature
 
       if user_id_signature.nil?
@@ -14,7 +21,8 @@ module Volt
           hash = user_id_signature[(index + 1)..-1]
 
           # Make sure the user hash matches
-          if BCrypt::Password.new(hash) != "#{Volt.config.app_secret}::#{user_id}"
+          # TODO: We could cache the digest generation for even faster comparisons
+          if hash != Digest::SHA256.hexdigest("#{Volt.config.app_secret}::#{user_id}")
             # user id has been tampered with, reject
             fail 'user id or hash has been tampered with'
           end
@@ -25,6 +33,24 @@ module Volt
       end
     end
 
+    # as_user lets you run a block as another user
+    #
+    # @param user_id [Integer]
+    def as_user(user_id)
+      previous_id = Thread.current['with_user_id']
+      Thread.current['with_user_id'] = user_id
+
+      yield
+
+      Thread.current['with_user_id'] = previous_id
+    end
+
+    def skip_permissions
+      Volt.run_in_mode(:skip_permissions) do
+        yield
+      end
+    end
+
     # True if the user is logged in and the user is loaded
     def user?
       !!user
@@ -32,11 +58,17 @@ module Volt
 
     # Return the current user.
     def user
-      user_id = self.user_id
-      if user_id
-        $page.store._users.find_one(_id: user_id)
+      # Run first on the query, or return nil
+      user_query.try(:first)
+    end
+
+    def fetch_user
+      u_query = user_query
+      if u_query
+        u_query.fetch_first
       else
-        nil
+        # No user, resolve nil
+        Promise.new.resolve(nil)
       end
     end
 
@@ -72,5 +104,16 @@ module Volt
 
       user_id_signature
     end
+
+    private
+    # Returns a query for the current user_id or nil if there is no user_id
+    def user_query
+      user_id = self.user_id
+      if user_id
+        $page.store._users.where(_id: user_id)
+      else
+        nil
+      end
+    end
   end
 end

data/lib/volt.rb

@@ -2,6 +2,8 @@ require 'volt/volt/environment'
 require 'volt/extra_core/extra_core'
 require 'volt/reactive/computation'
 require 'volt/reactive/dependency'
+require 'volt/utils/modes'
+
 require 'volt/config'
 unless RUBY_PLATFORM == 'opal'
   require 'volt/data_stores/data_store'
@@ -15,6 +17,8 @@ module Volt
                   false
                 end
 
+  include Modes
+
   class << self
     def root
       @root ||= File.expand_path(Dir.pwd)