waves-stable 0.7.7

data/lib/renderers/erubis.rb

@@ -0,0 +1,63 @@
+require 'erubis'
+
+module Erubis # :nodoc:
+
+  # This is added to the Erubis Content class to allow the same helper methods
+  # to be used with both Markaby and Erubis.
+  class Context
+    include Waves::Helpers::UrlHelper
+    include Waves::Helpers::TagHelper
+    include Waves::Helpers::AssetHelper
+    include Waves::Helpers::NumberHelper
+    
+    def <<(s) 
+      eval("_buf", @binding).concat s # add to rendered output
+    end
+    
+    def capture
+      eval("_context.push(_buf); _buf = ''", @binding) #ignore output from that eval, will be added via "<<"
+      result = Erubis::Eruby.new(yield).result @binding
+      eval("_buf = _context.pop", @binding)
+      result
+    end
+    
+    def render(eruby)
+      unless @binding
+        @binding = binding
+        eval("_buf = ''; _context = []", @binding)
+      end
+      eruby.result @binding
+    end
+
+  end
+
+end
+
+module Waves
+
+  module Renderers
+
+    class Erubis
+
+      include Renderers::Mixin
+
+      extension :erb
+
+      def self.render( path, assigns )
+        eruby = ::Erubis::Eruby.new( template( path ) )
+        helper = helper( path )
+        context = ::Erubis::Context.new
+        context.meta_eval { include( helper ) ; }
+        context.instance_eval do
+          assigns.each do |key,val|
+            instance_variable_set("@#{key}",val)
+          end
+        end
+        context.render(eruby)
+      end
+
+    end
+
+  end
+
+end

data/lib/renderers/haml.rb

@@ -0,0 +1,45 @@
+require 'haml'
+
+module Waves
+
+  module Renderers
+
+    class Scope
+      include Waves::Helpers::Common
+      include Waves::Helpers::Model
+      include Waves::Helpers::TagHelper
+      include Waves::Helpers::UrlHelper
+      include Waves::Helpers::View
+
+      def <<(s)
+        eval("@haml_buffer", @binding).push_text s # add to rendered output
+      end
+
+      def capture(&block)
+        capture_haml(nil, &block)
+      end
+
+    end
+
+    class Haml
+
+      include Renderers::Mixin
+
+      extension :haml
+
+      def self.render( path, assigns )
+        engine = ::Haml::Engine.new( template( path ) )
+        scope = Scope.new
+        helper = helper( path )
+        scope.meta_eval { include( helper ) }
+        scope.instance_eval do
+          assigns.each { |key,val| instance_variable_set("@#{key}",val) unless key == :request }
+        end
+        engine.render(scope, assigns)
+      end
+
+    end
+
+  end
+
+end

data/lib/renderers/markaby.rb

@@ -0,0 +1,33 @@
+require 'markaby'
+
+::Markaby::Builder.set( :indent, 2 )
+
+module Waves
+
+  module Renderers
+
+    class Markaby
+
+      include Renderers::Mixin
+
+      extension :mab
+
+      # capture needed here for content fragments, otherwise
+      # you'll just get the last tag's output ...
+      # def self.capture( template )
+      #  "capture { #{template} }"
+      # end
+
+      def self.render( path, assigns )
+        builder = ::Markaby::Builder.new( assigns )
+        helper = helper( path )
+        builder.meta_eval { include( helper ) }
+        builder.instance_eval( template( path ) )
+        builder.to_s
+      end
+
+    end
+
+  end
+
+end

data/lib/renderers/mixin.rb

@@ -0,0 +1,50 @@
+module Waves
+
+  module Renderers # :nodoc:
+
+    # The renderers mixin provides a number of methods to simplify writing new renderers.
+    # Just include this in your Renderer class and write your render method.
+    module Mixin
+
+      # Adds the following methods to the target class:
+      #
+      # - extension: allows you to set or get the extension used by this renderer.
+      #
+      #     Renderers::Markaby.extension 'foo' # tell Waves to use .foo as Markaby extension
+      #
+      # - filename: generate a filename for the template based on a logical path.
+      # - template: read the template from the file corresponding to the given logical path.
+      # - helper: return a helper module that corresponds to the given logical path.
+      #
+      def self.included(target)
+        class << target
+
+          def extension(*args)
+            return @extension if args.length == 0
+            @extension = args.first
+          end
+
+          def filename(path)
+            :templates / "#{path}.#{self.extension}"
+          end
+
+          def render(path,args=nil)
+          end
+
+          def template( path )
+            File.read( filename( path ) )
+          end
+
+          def helper( path )
+            Waves.application.helpers[
+              File.basename( File.dirname( path ) ).camel_case ]
+          end
+        end
+      end
+
+
+    end
+
+  end
+
+end

data/lib/runtime/application.rb

@@ -0,0 +1,69 @@
+# See the README for an overview.
+module Waves
+
+  class << self
+
+    # Access the principal Waves application.
+    attr_reader :application
+
+    # Register a module as a Waves application.
+    def << ( app )
+      @application = app if Module === app
+    end
+
+    def instance ; Waves::Application.instance ; end
+
+    def method_missing(name,*args,&block)
+      instance.send(name,*args,&block)
+    end
+
+  end
+
+  # An application in Waves is anything that provides access to the Waves
+  # runtime and the registered Waves applications. This includes both
+  # Waves::Server and Waves::Console. Waves::Application is *not* the actual
+  # application module(s) registered as Waves applications. To access the
+  # main Waves application, you can use +Waves+.+application+.
+  class Application
+
+    class << self; attr_accessor :instance; end
+
+    # Accessor for options passed to the application.
+    attr_reader :options
+
+    # Create a new Waves application instance.
+    def initialize( options={} )
+      @options = options
+      Dir.chdir options[:directory] if options[:directory]
+      Application.instance = self
+      Kernel.load( :lib / 'application.rb' ) if Waves.application.nil?
+    end
+
+    def synchronize( &block )
+      ( @mutex ||= Mutex.new ).synchronize( &block )
+    end
+
+    # The 'mode' of the application determines which configuration it will run under.
+    def mode
+      @mode ||= @options[:mode]||:development
+    end
+    
+    # Debug is true if debug is set to true in the current configuration.
+    def debug? ; config.debug ; end
+
+    # Access the current configuration. *Example:* +Waves::Server.config+
+    def config
+      Waves.application.configurations[ mode ]
+    end
+
+    # Access the mappings for the application.
+    def mapping ; Waves.application.configurations[ :mapping ] ; end
+
+    # Reload the modules specified in the current configuration.
+    def reload ; config.reloadable.each { |mod| mod.reload } ; end
+
+    # Returns the cache set for the current configuration
+    def cache ; config.cache ; end
+  end
+
+end

data/lib/runtime/blackboard.rb

@@ -0,0 +1,57 @@
+module Waves
+
+  # Encapsulates the blackboard associated with a given request. The scope of the blackboard is
+  # the same as the request object it gets attached to.
+  #
+  # The Waves blackboard is a very simple shared storaged usable during the request processing.
+  # It is available within:
+  #    - mappings
+  #    - controllers
+  #    - helpers
+  #
+  # Adding a value:
+  #   blackboard.value1 = 1
+  #   blackboard[:value2] = 2
+  #
+  # Retrieving values
+  #   blackboard.value1
+  #   blackboard[:value2]
+  #
+  # see also blackboard_verify.rb  
+  
+  class Blackboard
+
+    # Create a new blackboard object using the given request.
+    def initialize( request )
+      @request = request
+      @data = {}
+    end
+
+    # Access a given data element of the blackboard using the given key.
+    def [](key)
+      @data[key]
+    end
+
+    # Set the given data element of the blackboard using the given key and value.
+    def []=(key,val)
+      @data[key] = val
+    end
+    
+    def each(&block)
+      @data.each(&block)
+    end
+
+    # also allow things like
+    # blackboard.test1 instead of blackboard[:test1]
+    # blackboard.test1 = 2 instead of blackboard[:test1] = 2
+    def method_missing(name,*args)
+      if (name.to_s =~ /=$/)
+        self[name.to_s.gsub('=', '')] = args[0]
+      else
+        self[name.to_s]
+      end
+    end
+
+  end
+  
+end

data/lib/runtime/configuration.rb

@@ -0,0 +1,185 @@
+module Waves
+
+  # Waves configurations are Ruby code.  This means you can use a Ruby expression as
+  # the value of a configuration attribute, extend and inherit your configurations, and
+  # add your own attributes. You can even use it as a repository
+  # for your application configuration.
+  #
+  # You can access configuration attributes using the attribute name as a method, with the value as the argument.
+  #
+  # == Example
+  #
+  #    module Blog
+  #      module Configurations
+  #        class Development < Default
+  #          host '127.0.0.1'
+  #          port 2000
+  #          reloadable [ Blog ]
+  #          log :level => :debug
+  #          application do
+  #            use Rack::ShowExceptions
+  #            run Waves::Dispatchers::Default.new
+  #          end
+  #        end
+  #      end
+  #    end
+  #
+  # There are three forms for accessing attributes:
+  #
+  #   Waves.config.port                        # generic form - gets the value for current config
+  #   Blog.configurations[:development].port   # gets the value for a specified config
+  #   Blog::Configurations::Development.port   # Access a specific config constant directly
+  #
+  # Configuration data is inheritable, as shown in the example above. Typically, you
+  # would set data common to all configurations in the Default class, from which
+  # your variations inherit.
+  #
+  # You may define your own heritable attributes using the +attribute+ class method:
+  #
+  #   class Default < Waves::Configurations::Default
+  #     attribute 'theme' # define an attribute named "theme"
+  #     theme 'ultra'     # set an inheritable default
+  #   end
+  #
+  # Certain attributes are reserved for internal use by Waves:
+  #
+  # - application: configure the application for use with Rack
+  # - database: initialization parameters needed by the ORM layer
+  # - reloadable: an array of module names to reload; see below for more
+  # - log: takes a hash of parameters; see below for more
+  # - host: the host to bind the server to (string)
+  # - port: the port for the server to listen on (number)
+  # - ports: used by the cluster:start task for clustering servers (array of numbers)
+  # - debug: true if running in "debug" mode, which automatically reloads code
+  #
+  # == Configuring The Rack Application
+  #
+  # One of the really nice features of Rack is the ability to install "middleware"
+  # components to optimize the way you handle requests. Waves exposes this ability
+  # directly to the application developer via the +application+ configuration method.
+  #
+  # *Example*
+  #
+  #   # Typical debugging configuration
+  #   application do
+  #     use Rack::ShowExceptions
+  #     run Waves::Dispatchers::Default.new
+  #   end
+  #
+  # == Configuring Database Access
+  #
+  # The ORM layers provided with Waves use the +database+ attribute for connection initialization.
+  # Most ORMs take a hash for this purpose, with keys that may vary depending on the ORM and backend.
+  #
+  #   # Sequel with a MySQL db
+  #   database :host => 'localhost', :adapter => 'mysql', :database => 'blog',
+  #     :user => 'root', :password => 'guess'
+  #
+  #   # Sequel with an SQLite db
+  #   database :adapter => 'sqlite', :database => 'blog'
+  #
+  # See the documentation for each ORM layer for details.
+  #
+  # == Configuring Code Reloading
+  #
+  # The +reloadable+ attribute takes an array of modules. Before every request, the default Waves 
+  # dispatcher calls +reload+ on each listed module.  The module should remove any reloadable constants
+  # currently defined in its namespace.  
+  #
+  # In a Waves application built on the Default foundation, +reload+ functionality is provided
+  # by AutoCode for the Configurations, Controllers, Helpers, Models, and Views modules.
+  # 
+  # Listing only your application module will work in most cases:  
+  #
+  #   reloadable [ Blog ]
+  #
+  # As an alternative, you could reload only some of the modules within your application:
+  #
+  #   reloadable [ Blog::Models, Blog::Controllers ]
+  #
+  # == Configuring Logging
+  #
+  # The +log+ configuration attribute takes hash with these keys:
+  # - :level - The log filter level. Uses Ruby's built in Logger class.
+  # - :output - A filename or IO object. Should be a filename if running as a daemon.
+  #
+  # *Examples*
+  #
+  #  log :level => :info, :output => $stderr
+  #  log :level => :error, :output => 'log/blog.log'
+  #
+
+  module Configurations
+
+    class Base
+      # Set the given attribute with the given value. Typically, you wouldn't
+      # use this directly.
+      def self.[]=( name, val )
+        meta_def("_#{name}") { val }
+      end
+
+      # Get the value of the given attribute. Typically, you wouldn't
+      # use this directly.
+      def self.[]( name ) ; send "_#{name}" ; end
+
+      # Define a new attribute. After calling this, you can get and set the value
+      # using the attribute name as the method
+      def self.attribute( name )
+        meta_def(name) do |*args|
+          raise ArgumentError.new('Too many arguments.') if args.length > 1
+          args.length == 1 ? self[ name ] = args.first : self[ name ]
+        end
+        self[ name ] = nil
+      end
+
+    end
+
+    # The Default configuration defines sensible defaults for attributes required by Waves.
+    #   debug true
+    #   synchronize? true
+    #   session :duration => 30.minutes, :path => '/tmp/sessions'
+    #   log :level => :info, :output => $stderr
+    #   reloadable []
+    class Default < Base
+
+      %w( host port ports log reloadable database session debug root synchronize? ).
+      each { |name| attribute(name) }
+
+      # Set the Rack handler, along with any specific options
+      # that need to be passed to the handler's #run method. 
+      #
+      # When accessing the value
+      # (calling with no arguments), returns an array of the handler and options.
+      def self.handler(*args)
+        if args.length > 0
+          @rack_handler, @rack_handler_options = args
+        else
+          [ @rack_handler, @rack_handler_options ]
+        end
+      end
+
+      # Provides access to the Waves::MimeTypes class via the configuration. You
+      # can override #mime_types to return your own MIME types repository class.
+      def self.mime_types
+        Waves::MimeTypes
+      end
+
+      # Defines the application for use with Rack.  Treat this method like an
+      # instance of Rack::Builder
+      def self.application( &block )
+        if block_given?
+          self['application'] = Rack::Builder.new( &block )
+        else
+          self['application']
+        end
+      end
+
+      debug true ; synchronize? true
+      session :duration => 30.minutes, :path => '/tmp/sessions'
+      log :level => :info, :output => $stderr
+      reloadable []
+    end
+  end
+end
+
+