volt 0.8.14 → 0.8.15

data/lib/volt/server.rb

@@ -50,85 +50,87 @@ module Rack
   end
 end
 
-class Server
-  def initialize(root_path=nil)
-    root_path ||= Dir.pwd
-    Volt.root = root_path
+module Volt
+  class Server
+    def initialize(root_path=nil)
+      root_path ||= Dir.pwd
+      Volt.root = root_path
 
-    @app_path = File.expand_path(File.join(root_path, "app"))
+      @app_path        = File.expand_path(File.join(root_path, "app"))
 
-    # Boot the volt app
-    @component_paths = Volt.boot(root_path)
+      # Boot the volt app
+      @component_paths = Volt.boot(root_path)
 
-    setup_change_listener
+      setup_change_listener
 
-    display_welcome
-  end
+      display_welcome
+    end
 
-  def display_welcome
-    puts File.read(File.join(File.dirname(__FILE__), "server/banner.txt"))
-  end
+    def display_welcome
+      puts File.read(File.join(File.dirname(__FILE__), "server/banner.txt"))
+    end
 
-  def setup_change_listener
-    # Setup the listeners for file changes
-    listener = Listen.to("#{@app_path}/") do |modified, added, removed|
-      puts "file changed, sending reload"
-      SocketConnectionHandler.send_message_all(nil, 'reload')
+    def setup_change_listener
+      # Setup the listeners for file changes
+      listener = Listen.to("#{@app_path}/") do |modified, added, removed|
+        puts "file changed, sending reload"
+        SocketConnectionHandler.send_message_all(nil, 'reload')
+      end
+      listener.start
     end
-    listener.start
-  end
 
-  def app
-    @app = Rack::Builder.new
+    def app
+      @app = Rack::Builder.new
 
-    # Should only be used in production
-    if Volt.config.deflate
-      @app.use Rack::Deflater
-      @app.use Rack::Chunked
-    end
+      # Should only be used in production
+      if Volt.config.deflate
+        @app.use Rack::Deflater
+        @app.use Rack::Chunked
+      end
 
-    @app.use Rack::ContentLength
+      @app.use Rack::ContentLength
 
-    @app.use Rack::KeepAlive
-    @app.use Rack::ConditionalGet
-    @app.use Rack::ETag
+      @app.use Rack::KeepAlive
+      @app.use Rack::ConditionalGet
+      @app.use Rack::ETag
 
-    @app.use Rack::CommonLogger
-    @app.use Rack::ShowExceptions
+      @app.use Rack::CommonLogger
+      @app.use Rack::ShowExceptions
 
-    component_paths = @component_paths
-    @app.map '/components' do
-      run ComponentHandler.new(component_paths)
-    end
+      component_paths = @component_paths
+      @app.map '/components' do
+        run ComponentHandler.new(component_paths)
+      end
 
-    # Serve the opal files
-    opal_files = OpalFiles.new(@app, @app_path, @component_paths)
+      # Serve the opal files
+      opal_files = OpalFiles.new(@app, @app_path, @component_paths)
 
-    # Serve the main html files from public, also figure out
-    # which JS/CSS files to serve.
-    @app.use IndexFiles, @component_paths, opal_files
+      # Serve the main html files from public, also figure out
+      # which JS/CSS files to serve.
+      @app.use IndexFiles, @component_paths, opal_files
 
-    component_paths.require_in_components
+      component_paths.require_in_components
 
-    # Handle socks js connection
-    if RUBY_PLATFORM != 'java'
-      SocketConnectionHandler.dispatcher = Dispatcher.new
+      # Handle socks js connection
+      if RUBY_PLATFORM != 'java'
+        SocketConnectionHandler.dispatcher = Dispatcher.new
 
-      @app.map "/channel" do
-        run Rack::SockJS.new(SocketConnectionHandler)#, :websocket => false
+        @app.map "/channel" do
+          run Rack::SockJS.new(SocketConnectionHandler) #, :websocket => false
+        end
       end
-    end
 
-    @app.use Rack::Static,
-      :urls => ["/"],
-      :root => "public",
-      :index => "",
-      :header_rules => [
-        [:all, {'Cache-Control' => 'public, max-age=86400'}]
-      ]
+      @app.use Rack::Static,
+               :urls         => ["/"],
+               :root         => "public",
+               :index        => "",
+               :header_rules => [
+                   [:all, {'Cache-Control' => 'public, max-age=86400'}]
+               ]
 
-    @app.run lambda{ |env| [ 404, { 'Content-Type'  => 'text/html; charset=utf-8' }, ['404 - page not found'] ] }
+      @app.run lambda { |env| [404, {'Content-Type' => 'text/html; charset=utf-8'}, ['404 - page not found']] }
 
-    return @app
+      @app
+    end
   end
 end

data/lib/volt/spec/setup.rb

@@ -1,4 +1,4 @@
-class Volt
+module Volt
   def self.spec_setup(app_path='.')
     if RUBY_PLATFORM == 'opal'
       require 'volt'
@@ -32,7 +32,7 @@ class Volt
           Capybara.default_driver = :poltergeist
         elsif ENV['BROWSER'] == 'chrome'
           Capybara.register_driver :chrome do |app|
-            Capybara::Selenium::Driver.new(app, :browser => :chrome)
+            Capybara::Selenium::Driver.new(app, browser: :chrome)
           end
 
           Capybara.default_driver = :chrome
@@ -57,4 +57,4 @@ class Volt
       end
     end
   end
-end
+end

data/lib/volt/tasks/dispatcher.rb

@@ -1,29 +1,30 @@
-# The task dispatcher is responsible for taking incoming messages
-# from the socket channel and dispatching them to the proper handler.
-class Dispatcher
+module Volt
+  # The task dispatcher is responsible for taking incoming messages
+  # from the socket channel and dispatching them to the proper handler.
+  class Dispatcher
+    def dispatch(channel, message)
+      callback_id, class_name, method_name, *args = message
 
-  def dispatch(channel, message)
-    callback_id, class_name, method_name, *args = message
+      # Get the class
+      klass = Object.send(:const_get, class_name)
 
-    # Get the class
-    klass = Object.send(:const_get, class_name)
+      if klass.ancestors.include?(TaskHandler)
+        # Init and send the method
+        begin
+          result = klass.new(channel, self).send(method_name, *args)
+          error = nil
+        rescue => e
+          # TODO: Log these errors better
+          puts e.inspect
+          puts e.backtrace
+          result = nil
+          error = e
+        end
 
-    if klass.ancestors.include?(TaskHandler)
-      # Init and send the method
-      begin
-        result = klass.new(channel, self).send(method_name, *args)
-        error = nil
-      rescue => e
-        # TODO: Log these errors better
-        puts e.inspect
-        puts e.backtrace
-        result = nil
-        error = e
-      end
-
-      if callback_id
-        # Callback with result
-        channel.send_message('response', callback_id, result, error)
+        if callback_id
+          # Callback with result
+          channel.send_message('response', callback_id, result, error)
+        end
       end
     end
   end

data/lib/volt/tasks/task_handler.rb

@@ -1,41 +1,43 @@
-class TaskHandler
-  if RUBY_PLATFORM == 'opal'
-    # On the front-end we setup a proxy class to the backend that returns
-    # promises for all calls.
-    def self.method_missing(name, *args, &block)
-      $page.tasks.call(self.name, name, *args, &block)
-    end
-  else
-    def initialize(channel=nil, dispatcher=nil)
-      @channel = channel
-      @dispatcher = dispatcher
-    end
+module Volt
+  class TaskHandler
+    if RUBY_PLATFORM == 'opal'
+      # On the front-end we setup a proxy class to the backend that returns
+      # promises for all calls.
+      def self.method_missing(name, *args, &block)
+        $page.tasks.call(self.name, name, *args, &block)
+      end
+    else
+      def initialize(channel=nil, dispatcher=nil)
+        @channel    = channel
+        @dispatcher = dispatcher
+      end
 
-    def self.inherited(subclass)
-      @subclasses ||= []
-      @subclasses << subclass
-    end
+      def self.inherited(subclass)
+        @subclasses ||= []
+        @subclasses << subclass
+      end
 
-    def self.known_handlers
-      @subclasses ||= []
-    end
+      def self.known_handlers
+        @subclasses ||= []
+      end
 
-    # On the backend, we proxy all class methods like we would
-    # on the front-end.  This returns promises.
-    def self.method_missing(name, *args, &block)
-      promise = Promise.new
+      # On the backend, we proxy all class methods like we would
+      # on the front-end.  This returns promises.
+      def self.method_missing(name, *args, &block)
+        promise = Promise.new
 
-      begin
-        result = self.new(nil, nil).send(name, *args, &block)
+        begin
+          result = self.new(nil, nil).send(name, *args, &block)
 
-        promise.resolve(result)
-      rescue => e
-        puts "Task Error: #{e.inspect}"
-        puts e.backtrace
-        promise.reject(e)
-      end
+          promise.resolve(result)
+        rescue => e
+          puts "Task Error: #{e.inspect}"
+          puts e.backtrace
+          promise.reject(e)
+        end
 
-      return promise
+        return promise
+      end
     end
   end
-end
+end

data/lib/volt/utils/ejson.rb

@@ -1,9 +1,11 @@
-class EJson
-  def self.dump_as(obj)
-    obj
-  end
+module Volt
+  class EJson
+    def self.dump_as(obj)
+      obj
+    end
 
-  def self.dump(obj)
-    JSON.dump(dump_as(obj))
+    def self.dump(obj)
+      JSON.dump(dump_as(obj))
+    end
   end
 end

data/lib/volt/utils/generic_counting_pool.rb

@@ -1,44 +1,46 @@
 require 'volt/utils/generic_pool'
 
-# A counting pool behaves like a normal GenericPool, except for
-# each time lookup is called, remove should be called when complete.
-# The item will be completely removed from the GenericCountingPool
-# only when it has been removed an equal number of times it has been
-# looked up.
-class GenericCountingPool < GenericPool
-  # return a created item with a count
-  def generate_new(*args)
-    [0, create(*args)]
-  end
+module Volt
+  # A counting pool behaves like a normal GenericPool, except for
+  # each time lookup is called, remove should be called when complete.
+  # The item will be completely removed from the GenericCountingPool
+  # only when it has been removed an equal number of times it has been
+  # looked up.
+  class GenericCountingPool < GenericPool
+    # return a created item with a count
+    def generate_new(*args)
+      [0, create(*args)]
+    end
 
-  # Finds an item and tracks that it was checked out.  Use
-  # #remove when the item is no longer needed.
-  def find(*args, &block)
-    item = __lookup(*args, &block)
+    # Finds an item and tracks that it was checked out.  Use
+    # #remove when the item is no longer needed.
+    def find(*args, &block)
+      item = __lookup(*args, &block)
 
-    item[0] += 1
+      item[0] += 1
 
-    return item[1]
-  end
+      return item[1]
+    end
 
-  # Lookups an item
-  def lookup(*args, &block)
-    item = super(*args, &block)
+    # Lookups an item
+    def lookup(*args, &block)
+      item = super(*args, &block)
 
-    return item[1]
-  end
+      return item[1]
+    end
 
-  def transform_item(item)
-    [0, item]
-  end
+    def transform_item(item)
+      [0, item]
+    end
 
-  def remove(*args)
-    item = __lookup(*args)
-    item[0] -= 1
+    def remove(*args)
+      item    = __lookup(*args)
+      item[0] -= 1
 
-    if item[0] == 0
-      # Last one using this item has removed it.
-      super(*args)
+      if item[0] == 0
+        # Last one using this item has removed it.
+        super(*args)
+      end
     end
   end
 end

data/lib/volt/utils/generic_pool.rb

@@ -1,93 +1,96 @@
-# GenericPool is a base class you can inherit from to cache items
-# based on a lookup.
-#
-# GenericPool assumes either a block is passed to lookup, or a
-# #create method, that takes the path arguments and reutrns a new instance.
-#
-# GenericPool can handle as deep of paths as needed.  You can also lookup
-# all of the items at a sub-path with #lookup_all
-#
-# TODO: make the lookup/create threadsafe
-class GenericPool
-  attr_reader :pool
-  def initialize
-    @pool = {}
-  end
+module Volt
+  # GenericPool is a base class you can inherit from to cache items
+  # based on a lookup.
+  #
+  # GenericPool assumes either a block is passed to lookup, or a
+  # #create method, that takes the path arguments and reutrns a new instance.
+  #
+  # GenericPool can handle as deep of paths as needed.  You can also lookup
+  # all of the items at a sub-path with #lookup_all
+  #
+  # TODO: make the lookup/create threadsafe
+  class GenericPool
+    attr_reader :pool
+
+    def initialize
+      @pool = {}
+    end
 
-  def lookup(*args, &block)
-    section = @pool
+    def lookup(*args, &block)
+      section = @pool
 
-    # TODO: This is to work around opal issue #500
-    if RUBY_PLATFORM == 'opal'
-      args.pop if args.last == nil
-    end
+      # TODO: This is to work around opal issue #500
+      if RUBY_PLATFORM == 'opal'
+        args.pop if args.last == nil
+      end
 
 
-    args.each_with_index do |arg, index|
-      last = (args.size-1) == index
+      args.each_with_index do |arg, index|
+        last = (args.size-1) == index
 
-      if last
-        # return, creating if needed
-        return(section[arg] ||= create_new_item(*args, &block))
-      else
-        next_section = section[arg]
-        next_section ||= (section[arg] = {})
-        section = next_section
+        if last
+          # return, creating if needed
+          return(section[arg] ||= create_new_item(*args, &block))
+        else
+          next_section = section[arg]
+          next_section ||= (section[arg] = {})
+          section      = next_section
+        end
       end
     end
-  end
 
-  # Does the actual creating, if a block is not passed in, it calls
-  # #create on the class.
-  def create_new_item(*args)
-    if block_given?
-      new_item = yield(*args)
-    else
-      new_item = create(*args)
-    end
+    # Does the actual creating, if a block is not passed in, it calls
+    # #create on the class.
+    def create_new_item(*args)
+      if block_given?
+        new_item = yield(*args)
+      else
+        new_item = create(*args)
+      end
 
-    return transform_item(new_item)
-  end
+      return transform_item(new_item)
+    end
 
-  # Allow other pools to override how the created item gets stored.
-  def transform_item(item)
-    item
-  end
+    # Allow other pools to override how the created item gets stored.
+    def transform_item(item)
+      item
+    end
 
-  # Make sure we call the pool one from lookup_all and not
-  # an overridden one.
-  alias_method :__lookup, :lookup
+    # Make sure we call the pool one from lookup_all and not
+    # an overridden one.
+    alias_method :__lookup, :lookup
 
-  def lookup_all(*args)
-    result = __lookup(*args) { nil }
+    def lookup_all(*args)
+      result = __lookup(*args) { nil }
 
-    if result
-      return result.values
-    else
-      return []
+      if result
+        return result.values
+      else
+        return []
+      end
     end
-  end
 
-  def remove(*args)
-    stack = []
-    section = @pool
+    def remove(*args)
+      stack   = []
+      section = @pool
 
-    args.each_with_index do |arg, index|
-      stack << section
+      args.each_with_index do |arg, index|
+        stack << section
 
-      if args.size-1 == index
-        section.delete(arg)
-      else
-        section = section[arg]
+        if args.size-1 == index
+          section.delete(arg)
+        else
+          section = section[arg]
+        end
       end
-    end
 
-    (stack.size-1).downto(1) do |index|
-      node = stack[index]
-      parent = stack[index-1]
+      (stack.size-1).downto(1) do |index|
+        node   = stack[index]
+        parent = stack[index-1]
 
-      if node.size == 0
-        parent.delete(args[index-1])
+        if node.size == 0
+          parent.delete(args[index-1])
+        end
       end
     end
   end

data/lib/volt/utils/local_storage.rb

@@ -1,49 +1,53 @@
 if RUBY_PLATFORM == 'opal'
-  module LocalStorage
-    def self.[](key)
-      %x{
-        var val = localStorage.getItem(key);
-        return val === null ? nil : val;
-      }
-    end
-
-    def self.[]=(key, value)
-      `localStorage.setItem(key, value)`
-    end
-
-    def self.clear
-      `localStorage.clear()`
-      self
-    end
-
-    def self.delete(key)
-      %x{
-        var val = localStorage.getItem(key);
-        localStorage.removeItem(key);
-        return val === null ? nil : val;
-      }
+  module Volt
+    module LocalStorage
+      def self.[](key)
+        %x{
+          var val = localStorage.getItem(key);
+          return val === null ? nil : val;
+        }
+      end
+
+      def self.[]=(key, value)
+        `localStorage.setItem(key, value)`
+      end
+
+      def self.clear
+        `localStorage.clear()`
+        self
+      end
+
+      def self.delete(key)
+        %x{
+          var val = localStorage.getItem(key);
+          localStorage.removeItem(key);
+          return val === null ? nil : val;
+        }
+      end
     end
   end
 else
-  module LocalStorage
-    @@store = {}
-    def self.[](key)
-      @@store[key]
-    end
+  module Volt
+    module LocalStorage
+      @@store = {}
 
-    def self.[]=(key, value)
-      @@store[key] = value
-    end
+      def self.[](key)
+        @@store[key]
+      end
 
-    def self.clear
-      @@store = {}
+      def self.[]=(key, value)
+        @@store[key] = value
+      end
 
-      self
-    end
+      def self.clear
+        @@store = {}
+
+        self
+      end
 
-    def self.delete(key)
-      @@store.delete(key)
+      def self.delete(key)
+        @@store.delete(key)
+      end
     end
   end
 end
-

data/lib/volt/volt/environment.rb

@@ -1,4 +1,4 @@
-class Volt
+module Volt
   class Environment
     def initialize
       @env = ENV['VOLT_ENV']