waves 0.7.3 → 0.7.5

data/lib/utilities/integer.rb

@@ -1,14 +1,17 @@
 # Added methods to Integer for commonly used "numeric phrases" like 6.days or 30.megabytes.
 class Integer
-	def seconds ; self ; end
-	def minutes ; self * 60 ; end
-	def hours ; self * 60.minutes ; end
-	def days ; self * 24.hours ; end
-	def weeks ; self * 7.days ; end
-	def bytes ; self ; end
-	def kilobytes ; self * 1024 ; end
-	def megabytes ; self * 1024.kilobytes ; end
-	def gigabytes ; self * 1024.megabytes ; end
-	def terabytes ; self * 1024.gigabytes ; end
-	def petabytes ; self * 1024.gigabytes ; end
-end
+  def seconds ; self ; end
+  def minutes ; self * 60 ; end
+  def hours ; self * 60.minutes ; end
+  def days ; self * 24.hours ; end
+  def weeks ; self * 7.days ; end
+  def bytes ; self ; end
+  def kilobytes ; self * 1024 ; end
+  def megabytes ; self * 1024.kilobytes ; end
+  def gigabytes ; self * 1024.megabytes ; end
+  def terabytes ; self * 1024.gigabytes ; end
+  def petabytes ; self * 1024.terabytes ; end
+  def exabytes ; self * 1024.petabytes ; end
+  def zettabytes ; self * 1024.exabytes ; end
+  def yottabytes ; self * 1024.zettabytes ; end
+end

data/lib/utilities/kernel.rb

@@ -1,34 +1,34 @@
 module Kernel
-	#
-	# From Rails. This comes in handy when you want to return a value that you need to modify. 
-	# So instead of the awkward:
-	#
-	#   foo = Foo.new
-	#   foo.bar = 'bar'
-	#   foo
-	#
-	# You can just say
-	# 
-	#   returning Foo.new { |foo| foo.bar = 'bar' }
-	#
-	def returning( object, &block )
-		yield object; object
-	end
-	
-	#
-	# Inspired by a question on comp.lang.ruby. Sort of like returning, except
-	# you don't need to pass in the returnee as an argument. The drawback is that,
-	# since this relies on instance_eval, you can't access in methods in the local
-	# scope. You can work around this by assigning values to variables, but in that
-	# case, you might be better off using returning.
-	#
-	# Our above example would look like this:
-	#
-	#   with( Foo.new ) { bar = 'bar' }
-	#
-	def with( object, &block )
-	  object.instance_eval(&block); object
-	end
-	
+  #
+  # From Rails. This comes in handy when you want to return a value that you need to modify.
+  # So instead of the awkward:
+  #
+  #   foo = Foo.new
+  #   foo.bar = 'bar'
+  #   foo
+  #
+  # You can just say
+  #
+  #   returning Foo.new { |foo| foo.bar = 'bar' }
+  #
+  def returning( object, &block )
+    yield object; object
+  end
 
-end
+  #
+  # Inspired by a question on comp.lang.ruby. Sort of like returning, except
+  # you don't need to pass in the returnee as an argument. The drawback is that,
+  # since this relies on instance_eval, you can't access in methods in the local
+  # scope. You can work around this by assigning values to variables, but in that
+  # case, you might be better off using returning.
+  #
+  # Our above example would look like this:
+  #
+  #   with( Foo.new ) { bar = 'bar' }
+  #
+  def with( object, &block )
+    object.instance_eval(&block); object
+  end
+
+
+end

data/lib/utilities/module.rb

@@ -1,10 +1,17 @@
 class Module
 
   # This comes in handy when you are trying to do meta-programming with modules / classes
-  # that may be nested within other modules / classes. I think I've seen it defined in 
+  # that may be nested within other modules / classes. I think I've seen it defined in
   # facets, but I'm not relying on facets just for this one method.
-	def basename
-		self.name.split('::').last || ''
-	end
+  def basename
+    self.name.split('::').last || ''
+  end
+
+  # Just a convenience method for accessing a const within a Module
+  def []( cname )
+    const_get( cname.to_s.camel_case )
+  end
+
+
 
 end

data/lib/utilities/object.rb

@@ -1,9 +1,9 @@
 class Object
-	# This is an extremely powerful little function that will be built-in to Ruby 1.9.
-	# This version is from Mauricio Fernandez via ruby-talk. Works like instance_eval
-	# except that you can pass parameters to the block. This means you can define a block
-	# intended for use with instance_eval, pass it to another method, which can then
-	# invoke with parameters. This is used quite a bit by the Waves::Mapping code.
+  # This is an extremely powerful little function that will be built-in to Ruby 1.9.
+  # This version is from Mauricio Fernandez via ruby-talk. Works like instance_eval
+  # except that you can pass parameters to the block. This means you can define a block
+  # intended for use with instance_eval, pass it to another method, which can then
+  # invoke with parameters. This is used quite a bit by the Waves::Mapping code.
   def instance_exec(*args, &block)
     mname = "__instance_exec_#{Thread.current.object_id.abs}"
     class << self; self end.class_eval{ define_method(mname, &block) }

data/lib/utilities/proc.rb

@@ -0,0 +1,10 @@
+class Proc
+
+  # calls the given lambda with the receiver as its argument
+  def |(lambda)
+    lambda do
+      lambda.call( self.call )
+    end
+  end
+
+end

data/lib/utilities/string.rb

@@ -1,41 +1,47 @@
 # Waves extends String with a variety of methods for changing from singular to plural and back, and switching to different types of case and word separators. These methods are similar to those found in Rails and other frameworks, but some (all?) of the names are different. The names here were chosen for increased clarity and are hopefully easy to adjust to ...
-#
-# Notably, the inflector code here is not as comprehensive as the Rails code. This will be fixed in a future version of Waves.
 
 class String
-	
-	# Does a File.join on the two arguments joined by the /. Very handy
-	# for doing platform-safe paths without having to use File.join.
-	#
-	# I unfortunately don't recall where i first saw this ... see
-	# Symbol extension as well, allowing for :files / 'afilename.txt'
-	
-	def / ( string )
-		File.join(self,string.to_s)
-	end
-	
-	def singular
-		gsub(/ies$/,'y').gsub(/es$/,'').gsub(/s$/,'')
-	end
-
-	def plural
-		gsub(/(s|sh|ch)$/,'\1es').gsub(/(i|y)$/,'ies').gsub(/([^s])$/,'\1s')
-	end
-
-	def camel_case
-		gsub(/(_)(\w)/) { $2.upcase }.gsub(/^([a-z])/) { $1.upcase }
-	end		
-	
-	def snake_case
-    gsub(/([a-z\d])([A-Z])/){ "#{$1}_#{$2}"}.tr("-", "_").downcase
-	end
-	
-	def title_case
-		gsub(/(^|\s)\s*([a-z])/) { $1 + $2.upcase }
-	end
-	
-	def text
-		gsub(/[\_\-\.\:]/,' ')
-	end
-	
-end
+
+  # Does a File.join on the two arguments joined by the /. Very handy
+  # for doing platform-safe paths without having to use File.join.
+  #
+  # I unfortunately don't recall where i first saw this ... see
+  # Symbol extension as well, allowing for :files / 'afilename.txt'
+
+  def / ( string )
+    File.join(self,string.to_s)
+  end
+
+  def singular
+    Inflect::English.singular(self)
+  end
+
+  alias_method(:singularize, :singular)
+
+  def plural
+    Inflect::English.plural(self)
+  end
+
+  alias_method(:pluralize, :plural)
+
+  def lower_camel_case
+    gsub(/(_)(\w)/) { $2.upcase }
+  end
+
+  def camel_case
+    lower_camel_case.gsub(/^([a-z])/) { $1.upcase }
+  end
+
+  def snake_case
+    gsub(/\s+/,'').gsub(/([a-z\d])([A-Z])/){ "#{$1}_#{$2}"}.tr("-", "_").downcase
+  end
+
+  def title_case
+    gsub(/(^|\s)\s*([a-z])/) { $1 + $2.upcase }
+  end
+
+  def text
+    gsub(/[\_\-\.\:]/,' ')
+  end
+
+end

data/lib/utilities/symbol.rb

@@ -1,7 +1,7 @@
 class Symbol
   # Does File.join on self and string, converting self to string before invocation.
   # See String#/ for more.
-	def / ( string )
-		self.to_s / string
-	end
-end
+  def / ( string )
+    self.to_s / string
+  end
+end

data/lib/views/base.rb

@@ -0,0 +1,9 @@
+module Waves
+  module Views
+    class Base
+      
+      include Waves::Views::Mixin
+      
+    end
+  end  
+end

data/lib/views/mixin.rb

@@ -1,44 +1,44 @@
 module Waves
-	
-	# Views in Waves are ultimately responsible for generating the response body. Views mirror controllers - both have full access to the request and response, and both may modify the response and even short-circuit the request processing and return a result by calling redirect or calling Response#finish.
-	#
-	# Views, like controllers, are classes with methods that are invoked by a mapping block (see Waves::Mapping). View instance methods take an assigns hash that are typically converted into instance variables accesible from within a template. 
-	#
-	# Like controllers, a default implementation is provided by the +waves+ command when you first create your application. This default can be overridden to change the behaviors for all views, or you can explicitly define a View class to provide specific behavior for one view. 
-	#
-	# The default implementation simply determines which template to render and renders it, returning the result as a string. This machinery is provided by the View mixin, so it is easy to create your own View implementations.
-	#
-	# = Templates
-	#
-	# Although you won't typically need to modify or define View classes, you will often create and modify templates. Templates can be evaluated using any registered Renderer. Two are presently packaged with Waves: Markaby and Erubis. Templates have access to the assigns hash passed to the view method as instance variables. These can be explicitly defined by the mapping file or whomever is invoking the view.
-	#
-	# *Example*
-	#
-	#   # Find the story named 'home' and pass it into the view template as @story
-	#   use( :story ) | controller { find( 'home' ) } | view { |x| show( :story => x ) }
-	#
-	# = Helpers
-	#
-	# Helper methods can be defined for any view template by simply defining them within the default Helper module in <tt>helpers/default.rb</tt> of the generated application. Helpers specific to a particular View class can be explicitly defined by creating a helper module that corresponds to the View class. For examples, for the +User+ View class, you would define a helper module in <tt>user.rb</tt> named +User+.
-	#
-	# The default helper class initially includes a wide-variety of helpers, including helpers for layouts, Textile formatting, rendering forms, and nested views, as well as helpers for accessing the request and response objects. More helpers will be added in future releases, but in many cases, there is no need to include all of them in your application.
-	#
-	# = Layouts
-	#
-	# Layouts are defined using the +Layout+ view class, and layout templates are placed in the +layout+ directory of the +templates+ directory. Layouts are explicitly set within a template using the +layout+ method.
-	#
-	# *Example*
-	#
-	#   layout :default, :title => @story.title do
-	#     h1 @story.title
-	#     textile @story.content
-	#   end
-	#
-	#
-	# The layout method takes a name and an assigns hash that will be available within the layout template as instance variables. In this example, <tt>@title</tt> will be defined as <tt>@story.title</tt> within the layout template named 'default.' 
-	#
-	# Any number of layouts may be included within a single view, and layouts may even be nested within layouts. This makes it possible to create large numbers of highly structured views that can be easily changed with minimal effort. For example, you might a specific layout associated with form elements. By incorporating this into your views as a +layout+ template, you can make changes across all your forms by changing this single template.
-	#
+
+  # Views in Waves are ultimately responsible for generating the response body. Views mirror controllers - both have full access to the request and response, and both may modify the response and even short-circuit the request processing and return a result by calling redirect or calling Response#finish.
+  #
+  # Views, like controllers, are classes with methods that are invoked by a mapping block (see Waves::Mapping). View instance methods take an assigns hash that are typically converted into instance variables accesible from within a template.
+  #
+  # Like controllers, a default implementation is provided by the +waves+ command when you first create your application. This default can be overridden to change the behaviors for all views, or you can explicitly define a View class to provide specific behavior for one view.
+  #
+  # The default implementation simply determines which template to render and renders it, returning the result as a string. This machinery is provided by the View mixin, so it is easy to create your own View implementations.
+  #
+  # = Templates
+  #
+  # Although you won't typically need to modify or define View classes, you will often create and modify templates. Templates can be evaluated using any registered Renderer. Two are presently packaged with Waves: Markaby and Erubis. Templates have access to the assigns hash passed to the view method as instance variables. These can be explicitly defined by the mapping file or whomever is invoking the view.
+  #
+  # *Example*
+  #
+  #   # Find the story named 'home' and pass it as @story into the "story/show" template
+  #   use( :story ) | controller { find( 'home' ) } | view { |x| show( :story => x ) }
+  #
+  # = Helpers
+  #
+  # Helper methods can be defined for any view template by simply defining them within the default Helper module in <tt>helpers/default.rb</tt> of the generated application. Helpers specific to a particular View class can be explicitly defined by creating a helper module that corresponds to the View class. For examples, for the +User+ View class, you would define a helper module in <tt>user.rb</tt> named +User+.
+  #
+  # The default helper class initially includes a wide-variety of helpers, including helpers for layouts, Textile formatting, rendering forms, and nested views, as well as helpers for accessing the request and response objects. More helpers will be added in future releases, but in many cases, there is no need to include all of them in your application.
+  #
+  # = Layouts
+  #
+  # Layouts are defined using the +Layout+ view class, and layout templates are placed in the +layout+ directory of the +templates+ directory. Layouts are explicitly set within a template using the +layout+ method.
+  #
+  # *Example*
+  #
+  #   layout :default, :title => @story.title do
+  #     h1 @story.title
+  #     textile @story.content
+  #   end
+  #
+  #
+  # The layout method takes a name and an assigns hash that will be available within the layout template as instance variables. In this example, <tt>@title</tt> will be defined as <tt>@story.title</tt> within the layout template named 'default.'
+  #
+  # Any number of layouts may be included within a single view, and layouts may even be nested within layouts. This makes it possible to create large numbers of highly structured views that can be easily changed with minimal effort. For example, you might specify a layout associated with form elements. By incorporating this into your views as a +layout+ template, you can make changes across all your forms by changing this single template.
+  #
   # = Nested Views
   #
   # It is easy to include one view inside another. A common use for this is to define one set of templates for reusable content 'fragments' (somewhat akin to partials in Rails) and another set that incorporate these fragments into specific layouts. Including a view from within another view is done, logically enough, using the +view+ method.
@@ -52,57 +52,59 @@ module Waves
   #
   # As always, the request and response objects, and a wide-variety of short-cut methods, are available within view templates via the Waves::ResponseMixin.
   #
-  	
-	module Views
 
-		class NoTemplateError < Exception ; end
-	
-	  # A class method that returns the known Renderers, which is any module that is defined within Waves::Renderers and includes the Renderers::Mixin. You can define new Renderers simply be reopening Waves::Renderers and defining a module that mixes in Renderers::Mixin.
-		def Views.renderers
-			return [] if Renderers.constants.nil?
-			Renderers.constants.inject([]) do |rx,cname|
-				( Module === (c=Renderers.const_get(cname)) &&
-					c < Renderers::Mixin ) ? ( rx << c ) : rx
-			end
-		end
+  module Views
+
+    class NoTemplateError < Exception ; end
+
+    # A class method that returns the known Renderers, which is any module that is defined within Waves::Renderers and includes the Renderers::Mixin. You can define new Renderers simply be reopening Waves::Renderers and defining a module that mixes in Renderers::Mixin.
+    def Views.renderers
+      return [] if Renderers.constants.nil?
+      Renderers.constants.sort.inject([]) do |rx,cname|
+        ( Module === (c=Renderers.const_get(cname)) &&
+          c < Renderers::Mixin ) ? ( rx << c ) : rx
+      end
+    end
+
+    # The View mixin simply sets up the machinery for invoking a template, along with methods for accessing the request context and the standard interface for invoking a view method.
+    module Mixin
+
+      attr_reader :request
+
+      include Waves::ResponseMixin
+
+      def self.included( c )
+        def c.process( request, *args, &block )
+          self.new( request ).instance_exec( *args, &block )
+        end
+      end
+
+      def initialize( request )
+        @request = request
+        @layout = :default
+      end
+
+      # Return the first renderer for which a template file can be found.
+      # Uses Renderers::Mixin.filename to construct the filename for each renderer.
+      def renderer(path)
+        Views.renderers.find do |renderer|
+          File.exists?( renderer.filename( path ) )
+        end
+      end
+
+      def render( path, context = {} )
+        context.merge!( :request => request )
+        template = renderer( path ) || renderer( :generic / File.basename(path) )
+        raise NoTemplateError.new( path ) if template.nil?
+        template.render( path, context )
+      end
+
+      def method_missing(name,*args)
+        render( "/#{self.class.basename.snake_case}/#{name}", *args )
+      end
 
-	  # The View mixin simply sets up the machinery for invoking a template, along with methods for accessing the request context and the standard interface for invoking a view method.
-		module Mixin
-				
-			attr_reader :request
-			
-			include Waves::ResponseMixin
-			
-			def self.included( c )
-				def c.process( request, *args, &block )
-					self.new( request ).instance_exec( *args, &block )
-				end
-			end
-			
-			def initialize( request )
-				@request = request
-				@layout = :default
-			end
-			
-			def renderer(path)
-				Views.renderers.find do |renderer| 
-					File.exists?( renderer.filename( path ) )
-				end
-			end
-			
-			def render( path, context = {} )
-				context.merge!( :request => request ) 
-				template = renderer( path ) || renderer( :generic / File.basename(path) )
-				raise NoTemplateError.new( path ) if template.nil?
-				template.render( path, context )
-			end
-			
-			def method_missing(name,*args)
-				render( "/#{self.class.basename.snake_case}/#{name}", *args )
-			end
-			
-		end
+    end
 
-	end
+  end
 
 end