dyoder-waves 0.7.3

data/lib/mapping/pretty_urls.rb

@@ -0,0 +1,94 @@
+module Waves
+  module Mapping
+
+    # A set of pre-packed mapping rules for dealing with pretty URLs (that use names instead
+    # of numbers to identify resources). There are two modules.
+    # - GetRules, which defines all the GET methods for dealing with named resources
+    # - RestRules, which defines add, update, and delete rules using a REST style interface
+    #
+    module PrettyUrls
+
+      #
+      # GetRules defines the following URL conventions:
+      #
+      #   /resources            # => get a list of all instances of resource
+      #   /resource/name        # => get a specific instance of resource with the given name
+      #   /resource/name/editor # => display an edit page for the given resource
+      #
+      module GetRules
+
+        def self.included(target)
+
+          target.module_eval do
+
+            extend Waves::Mapping
+
+            name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
+
+            # get all resources for the given model
+            path %r{^/#{model}/?$}, :method => :get do | model |
+              resource( model.singular ) { controller { all } | view { |data| list( model => data ) } }
+            end
+
+            # get the given resource for the given model
+            path %r{^/#{model}/#{name}/?$}, :method => :get do | model, name |
+              resource( model ) { controller { find( name ) } | view { |data| show( model => data ) } }
+            end
+
+            # display an editor for the given resource / model
+            path %r{^/#{model}/#{name}/editor/?$}, :method => :get do | model, name |
+              resource( model ) {  controller { find( name ) } | view { |data| editor( model => data ) } }
+            end
+
+          end
+
+        end
+
+      end
+
+      #
+      # RestRules defines the following URL conventions:
+      #
+      #   POST /resources            # => add a new resource
+      #   PUT  /resource/name        # => update the given resource
+      #   DELETE /resource/name      # => delete the given resource
+      #
+      module RestRules
+
+        def self.included(target)
+
+          target.module_eval do
+
+            extend Waves::Mapping
+
+            name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
+
+            # create a new resource for the given model
+            path %r{^/#{model}/?$}, :method => :post do | model |
+              resource( model.singular ) do
+                instance = controller { create }
+                redirect( "/#{model.singular}/#{instance.name}/editor" )
+              end
+            end
+
+            # update the given resource for the given model
+            path %r{^/#{model}/#{name}/?$}, :method => :put do | model, name |
+              resource( model ) { controller { update( name ) }; redirect( url ) }
+            end
+
+            # delete the given resource for the given model
+            path %r{^/#{model}/#{name}/?$}, :method => :delete do | model, name |
+              resource( model ) { controller { delete( name ) } }
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/renderers/erubis.rb

@@ -0,0 +1,61 @@
+require 'erubis'
+
+module Erubis
+
+  # 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
+    
+    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/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,53 @@
+module Waves
+
+  module Renderers
+
+    extend Autocode
+    # autoload :renderers, Class
+
+    # 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,65 @@
+# 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.
+    # Also, initialize the database connection if necessary.
+    def << ( app )
+      @application = app if Module === app
+      app.database if app.respond_to? 'database'
+    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. Valid options include
+    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/configuration.rb

@@ -0,0 +1,180 @@
+module Waves
+
+  # Waves configurations are simply Ruby code, meaning you can use an Ruby expression as
+  # a value for a configuration parameter, extend and inherit your configurations, and
+  # add your own configuration attributes. You can even use it as a configuration repository
+  # for your applications.
+  #
+  # The form for configuration parameters to use the parameter name as a method name. Passing
+  # in a parameter sets the value.
+  #
+  # == 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 parameters:
+  #
+  #   Waves.config.port                        # generic form - gets current config
+  #   Blog.configurations[:development]        # gets a value for a specific config
+  #   Blog::Configurations::Development.port   # Access config constant directly
+  #
+  # You can inherit configurations, as is shown in the example above. Typically, you
+  # can use the application's "default" configuration to set shared configurations,
+  # and then inherit from it for specific variations.
+  #
+  # To define your own attributes, and still make them inheritable, you should use
+  # the +attribute+ class method, like this:
+  #
+  #   class Default < Waves::Configurations::Default
+  #     attribute 'theme' # define a theme attribute
+  #     theme 'ultra'     # give it a default
+  #   end
+  #
+  # There are a number of reserved or built-in attributes. These are:
+  #
+  # - application: configure the application for use with Rack
+  # - database: takes a hash of parameters used to initalize the database; see below
+  # - 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 parameter.
+  #
+  # *Example*
+  #
+  #   # Typical debugging configuration
+  #   application do
+  #     use Rack::ShowExceptions
+  #     run Waves::Dispatchers::Default.new
+  #   end
+  #
+  # == Configuring Database Access
+  #
+  # The database parameter takes a hash with the following elements:
+  #
+  # - host: which host the database is running on
+  # - adapter: which adapter is being used to access the database (mysql, postgres, etc.)
+  # - database: the name of the database the application is connecting to
+  # - user: the user for authentication
+  # - password: password for authentication
+  #
+  # *Example*
+  #
+  #   database :host => 'localhost', :adapter => 'mysql', :database => 'blog',
+  #     :user => 'root', :password => 'guess'
+  #
+  #
+  # == Configuring Code Reloading
+  #
+  # You can specify a list of modules to reload on each request using the +reloadable+
+  # configuration parameter. The Waves server will call +reload+ on each module to trigger
+  # the reloading. Typically, your modules will use the Autocode gem to set parameters for
+  # reloading. This is done for you when you generate an application using the +waves+
+  # command, but you can change the default settings. See the documentation for Autocode
+  # for more information. Typically, you will set this parameter to just include your
+  # main application:
+  #
+  #   reloadable [ Blog ]
+  #
+  # although you could do this with several modules just as easily (say, your primary
+  # application and several helper applications).
+  #
+  # == Configuring Logging
+  #
+  # The +log+ configuration parameter takes the following options (as a hash):
+  # - level: The level to filter logging at. 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.
+      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 provides a good starting point for your applications,
+    # defining a number of attributes that are required by Waves.
+    class Default < Base
+
+      %w( host port ports log reloadable database session debug root ).
+      each { |name| attribute(name) }
+
+      # Set the handler for use with Rack, along with any handler-specific options
+      # that will 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
+
+      # Provide access to the Waves::MimeTypes class via the configuration. You
+      # could potentially point this to your own MIME types repository class.
+      def self.mime_types
+        Waves::MimeTypes
+      end
+
+      # Defines the application for use with Rack.
+      def self.application( &block )
+        if block_given?
+          self['application'] = Rack::Builder.new( &block )
+        else
+          self['application']
+        end
+      end
+
+      debug true
+      session :duration => 30.minutes, :path => '/tmp/sessions'
+      log :level => :info, :output => $stderr
+      reloadable []
+    end
+  end
+end
+
+