waves 0.7.3 → 0.7.5

data/lib/mapping/pretty_urls.rb

@@ -1,13 +1,13 @@
 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:
       #
@@ -16,78 +16,79 @@ module Waves
       #   /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\-]+)'
-  
+
+            name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
+
             # get all resources for the given model
-            path %r{^/#{model}/?$} do | model |
-              use( model.singular ) | controller { all } | view { |data| list( model => data ) }
+            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}/?$} do | model, name |
-              use(model) | controller { find( name ) } | 
-                view { |data| show( model => data ) }
+            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/?$} do | model, name |
-              use(model) | controller { find( name ) } | 
-                view { |data| editor( model => data ) }       
+            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 using the POST variables
-      #   POST /resource/name        # => update the given resource using the POST variables
+      #   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\-]+)'
-  
+
+            name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
+
             # create a new resource for the given model
             path %r{^/#{model}/?$}, :method => :post do | model |
-              use( model.singular )
-              instance = controller { create }
-              redirect( "/#{model.singular}/#{instance.name}/editor" )
+              resource( model.singular ) do
+                controller do 
+                  instance = create
+                  redirect( "/#{model_name}/#{instance.name}/editor" )
+                end
+              end
             end
 
-            # add / update the given resource for the given model
-            path %r{^/#{model}/#{name}/?$}, :method => :post do | model, name |
-              use(model) | controller { update( name ) }; redirect( url )
+            # 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 |
-              use( model ) | controller { delete( name ) }
+              resource( model ) { controller { delete( name ) } }
             end
-      
+
           end
-          
+
         end
-        
+
       end
-  
+
     end
 
   end

data/lib/renderers/erubis.rb

@@ -1,40 +1,63 @@
 require 'erubis'
 
-module 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
-    def <<(s) ; s ; end
+    # 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
-				eruby.evaluate( context )
-			end
-		
-		end
-
-	end
-	
-end
+  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

@@ -3,31 +3,31 @@ 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
+
+  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

@@ -1,53 +1,50 @@
 module Waves
-	
-	module Renderers
-		
-		extend Autoload
-		autoload :renderers
-	
-	  # 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
+
+  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

@@ -1,53 +1,71 @@
 # 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
-		
-	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
-
-	  # 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]
-		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
+  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.
+    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
 
-end
+end