dyoder-waves 0.7.3 → 0.7.6

data/lib/foundations/default.rb

@@ -1,6 +1,10 @@
-require 'layers/orm/sequel'
 module Waves
   module Foundations
+# The Default foundation supports the common MVC development pattern, a la Rails and Merb. Models, controllers, views, templates, and helpers live in the corresponding directories. When your code calls for a specific M, V, C, or H, Waves tries to load it from a file matching the snake-case of the constant name.  If the file does not exist, Waves creates the constant from a sensible (and customizable) default.
+#
+# This foundation does not include any ORM configuration.  You can include Waves::Layers::ORM::Sequel or custom configure your model.
+
+    
     module Default
 
       def self.included( app )
@@ -8,14 +12,8 @@ module Waves
         app.instance_eval do
 
           include Waves::Layers::Simple
+          include Waves::Layers::MVC          
           include Waves::Layers::DefaultErrors
-          include Waves::Layers::MVC
-          include Waves::Layers::ORM::Sequel
-
-          # Set autoloading from default.rb files
-          #autoinit :Configurations do
-          #  autoload_class true
-          #end
           
         end
         

data/lib/foundations/simple.rb

@@ -1,8 +1,21 @@
 module Waves
+  
+  # A Waves Foundation provides enough functionality to allow a Waves application
+  # to run.  At the bare minimum, this means creating configuration classes in the Configurations
+  # namespace, as is done in the Simple foundation
+  #
+  # Typically, a Foundation will include several Layers, perform any necessary
+  # configuration, and register the application with the Waves module
   module Foundations
 
+    # The Simple foundation provides the bare minimum needed to run a Waves application.
+    # It is intended for use as the basis of more fully-featured foundations, but you can
+    # use it as a standalone where all the request processing is done directly in a 
+    # mapping lambda.
     module Simple
 
+      # On inclusion in a module, the Simple foundation includes Waves::Layers::Simple and 
+      # registers the module as a Waves application.
       def self.included( app )
 
         app.instance_eval do

data/lib/helpers/asset_helper.rb

@@ -0,0 +1,67 @@
+module Waves
+  module Helpers
+    module AssetHelper
+      # Returns an html image tag for the +source+. The +source+ can be a full
+      # path or a file that exists in your public images directory. Note that 
+      # specifying a filename without the extension is now deprecated in Rails.
+      # You can add html attributes using the +options+. The +options+ supports
+      # two additional keys for convienence and conformance:
+      #
+      # * <tt>:alt</tt>  - If no alt text is given, the file name part of the 
+      #   +source+ is used (capitalized and without the extension)
+      # * <tt>:size</tt> - Supplied as "{Width}x{Height}", so "30x45" becomes 
+      #   width="30" and height="45". <tt>:size</tt> will be ignored if the
+      #   value is not in the correct format.
+      #
+      #  image_tag("icon.png")  # =>
+      #    <img src="/images/icon.png" alt="Icon" />
+      #  image_tag("icon.png", :size => "16x10", :alt => "Edit Entry")  # =>
+      #    <img src="/images/icon.png" width="16" height="10" alt="Edit Entry" />
+      #  image_tag("/icons/icon.gif", :size => "16x16")  # =>
+      #    <img src="/icons/icon.gif" width="16" height="16" alt="Icon" />
+      def image_tag(source, options = {})
+        options.symbolize_keys!
+          
+        options[:src] = image_path(source)
+        options[:alt] ||= File.basename(options[:src], '.*').split('.').first.capitalize
+  
+        if options[:size]
+          options[:width], options[:height] = options[:size].split("x") if options[:size] =~ %r{^\d+x\d+$}
+          options.delete(:size)
+        end
+
+        tag("img", options)
+      end
+
+      # Computes the path to an image asset in the public images directory.
+      # Full paths from the document root will be passed through.
+      # Used internally by image_tag to build the image path. Passing
+      # a filename without an extension is deprecated.
+      #
+      #   image_path("edit.png")  # => /images/edit.png
+      #   image_path("icons/edit.png")  # => /images/icons/edit.png
+      #   image_path("/icons/edit.png")  # => /icons/edit.png
+      def image_path(source)
+        compute_public_path(source, 'images', 'png')
+      end
+
+      private
+        def compute_public_path(source, dir, ext)
+          source = source.dup
+          source << ".#{ext}" if File.extname(source).blank?
+          unless source =~ %r{^[-a-z]+://}
+            source = "/#{dir}/#{source}" unless source[0] == ?/
+            asset_id = rails_asset_id(source)
+            source << '?' + asset_id if defined?(RAILS_ROOT) && !asset_id.blank?
+            # source = "#{ActionController::Base.asset_host}#{@controller.request.relative_url_root}#{source}"
+          end
+          source
+        end
+        
+        def rails_asset_id(source)
+          ENV["WAVES_ASSET_ID"] || File.mtime("public/#{source}").to_i.to_s rescue ""
+        end
+
+    end
+  end
+end

data/lib/helpers/common.rb

@@ -1,4 +1,8 @@
 module Waves
+  
+  # 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.
   module Helpers
 
     # Common helpers are helpers that are needed for just about any Web page. For example,

data/lib/helpers/default.rb

@@ -0,0 +1,13 @@
+module Waves
+  module Helpers
+    module Default
+      attr_reader :request, :content
+      include Waves::ResponseMixin
+      include Waves::Helpers::Common
+      include Waves::Helpers::Formatting
+      include Waves::Helpers::Model
+      include Waves::Helpers::View
+      include Waves::Helpers::Form
+    end
+  end
+end

data/lib/helpers/form.rb

@@ -15,6 +15,7 @@ module Waves
     # will invoke the +text+ form view (the template in +templates/form/text.mab+),
     # passing in the name ('blog.title') and the value (@blog.title) as instance variables.
     #
+    # These helpers are Markaby only.
     module Form
 
       # This method really is a place-holder for common wrappers around groups of

data/lib/helpers/number_helper.rb

@@ -0,0 +1,25 @@
+module Waves
+  module Helpers
+    module NumberHelper
+
+      # Formats a +number+ with grouped thousands using +delimiter+. You
+      # can customize the format in the +options+ hash.
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter, defaults to ","
+      # * <tt>:separator</tt>  - Sets the separator between the units, defaults to "."
+      #
+      #  number_with_delimiter(12345678)      => 12,345,678
+      #  number_with_delimiter(12345678.05)   => 12,345,678.05
+      #  number_with_delimiter(12345678, :delimiter => ".")   => 12.345.678
+      def number_with_delimiter(number, delimiter=",", separator=".")
+        begin
+          parts = number.to_s.split(separator)
+          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+          parts.join separator
+        rescue
+          number
+        end
+      end
+
+    end
+  end
+end

data/lib/helpers/tag_helper.rb

@@ -0,0 +1,58 @@
+module Waves
+  module Helpers
+    module TagHelper
+      
+      ESCAPE_TABLE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
+      def h(value)
+        value.to_s.gsub(/[&<>"]/) { |s| ESCAPE_TABLE[s] }
+      end
+      
+      # Returns an empty HTML tag of type +name+ which by default is XHTML 
+      # compliant. Setting +open+ to true will create an open tag compatible 
+      # with HTML 4.0 and below. Add HTML attributes by passing an attributes 
+      # hash to +options+. For attributes with no value like (disabled and 
+      # readonly), give it a value of true in the +options+ hash. You can use
+      # symbols or strings for the attribute names.
+      #
+      #   tag("br")
+      #    # => <br />
+      #   tag("br", nil, true)
+      #    # => <br>
+      #   tag("input", { :type => 'text', :disabled => true }) 
+      #    # => <input type="text" disabled="disabled" />
+      def tag(name, options = nil, open = false)
+        "<#{name}#{tag_options(options) if options}" + (open ? ">" : " />")
+      end
+      
+      # Returns the escaped +html+ without affecting existing escaped entities.
+      #
+      #   escape_once("1 > 2 &amp; 3")
+      #    # => "1 &lt; 2 &amp; 3"
+      def escape_once(html)
+        fix_double_escape(h(html.to_s))
+      end
+      
+      private
+        
+        def tag_options(options)
+          cleaned_options = convert_booleans(options.stringify_keys.reject {|key, value| value.nil?})
+          ' ' + cleaned_options.map {|key, value| %(#{key}="#{escape_once(value)}")}.sort * ' ' unless cleaned_options.empty?
+        end
+        
+        def convert_booleans(options)
+          %w( disabled readonly multiple ).each { |a| boolean_attribute(options, a) }
+          options
+        end
+        
+        def boolean_attribute(options, attribute)
+          options[attribute] ? options[attribute] = attribute : options.delete(attribute)
+        end
+        
+        # Fix double-escaped entities, such as &amp;amp;, &amp;#123;, etc.
+        def fix_double_escape(escaped)
+          escaped.gsub(/&amp;([a-z]+|(#\d+));/i) { "&#{$1};" }
+        end
+        
+    end
+  end
+end

data/lib/helpers/url_helper.rb

@@ -0,0 +1,77 @@
+module Waves
+  module Helpers
+    module UrlHelper
+
+      # Returns the URL for the set of +options+ provided. This takes the 
+      # same options as url_for in action controller. For a list, see the 
+      # documentation for ActionController::Base#url_for. Note that it'll 
+      # set :only_path => true so you'll get the relative /controller/action 
+      # instead of the fully qualified http://example.com/controller/action.
+      #  
+      # When called from a view, url_for returns an HTML escaped url. If you 
+      # need an unescaped url, pass :escape => false in the +options+.
+      def url_for(options = {}, *parameters_for_method_reference)
+        if options.kind_of? Hash
+          options = { :only_path => true }.update(options.symbolize_keys)
+          escape = options.key?(:escape) ? options.delete(:escape) : true
+        else
+          escape = true
+        end
+
+        url = options[:url] #@controller.send(:url_for, options, *parameters_for_method_reference)
+        escape ? html_escape(url) : url
+      end
+
+
+      # Creates a link tag of the given +name+ using a URL created by the set 
+      # of +options+. See the valid options in the documentation for 
+      # ActionController::Base#url_for. It's also possible to pass a string instead 
+      # of an options hash to get a link tag that uses the value of the string as the 
+      # href for the link. If nil is passed as a name, the link itself will become 
+      # the name.
+      #
+      # The +html_options+ will accept a hash of html attributes for the link tag.
+      # It also accepts 3 modifiers that specialize the link behavior. 
+      #
+      # * <tt>:confirm => 'question?'</tt>: This will add a JavaScript confirm 
+      #   prompt with the question specified. If the user accepts, the link is 
+      #   processed normally, otherwise no action is taken.
+      # * <tt>:popup => true || array of window options</tt>: This will force the 
+      #   link to open in a popup window. By passing true, a default browser window 
+      #   will be opened with the URL. You can also specify an array of options 
+      #   that are passed-thru to JavaScripts window.open method.
+      # * <tt>:method => symbol of HTTP verb</tt>: This modifier will dynamically
+      #   create an HTML form and immediately submit the form for processing using 
+      #   the HTTP verb specified. Useful for having links perform a POST operation
+      #   in dangerous actions like deleting a record (which search bots can follow
+      #   while spidering your site). Supported verbs are :post, :delete and :put.
+      #   Note that if the user has JavaScript disabled, the request will fall back 
+      #   to using GET. If you are relying on the POST behavior, your should check
+      #   for it in your controllers action by using the request objects methods
+      #   for post?, delete? or put?.
+      #
+      # You can mix and match the +html_options+ with the exception of
+      # :popup and :method which will raise an ActionView::ActionViewError
+      # exception.
+      #
+      #   link_to "Visit Other Site", "http://www.rubyonrails.org/", :confirm => "Are you sure?"
+      #   link_to "Help", { :action => "help" }, :popup => true
+      #   link_to "View Image", { :action => "view" }, :popup => ['new_window_name', 'height=300,width=600']
+      #   link_to "Delete Image", { :action => "delete", :id => @image.id }, :confirm => "Are you sure?", :method => :delete
+      def link_to(name, options = {}, html_options = nil, *parameters_for_method_reference)
+        if html_options
+          html_options = html_options.stringify_keys
+          # convert_options_to_javascript!(html_options)
+          tag_options = tag_options(html_options)
+        else
+          tag_options = nil
+        end
+
+        url = options.is_a?(String) ? options : self.url_for(options, *parameters_for_method_reference)
+        "<a href=\"#{url}\"#{tag_options}>#{name || url}</a>"
+      end
+
+      
+    end
+  end
+end

data/lib/layers/default_errors.rb

@@ -1,23 +1,25 @@
 module Waves
   module Layers
+    
+    # Configures Waves to use the templates in app/templates/errors for exception handling
     module DefaultErrors
 
       def self.included( app )
 
-        app.instance_eval do
-
-          autoinit 'Configurations::Mapping' do
+        app.auto_eval :Configurations do
+          auto_eval :Mapping do
+            extend Waves::Mapping
             handle(Waves::Dispatchers::NotFoundError) do
               html = Waves.application.views[:errors].process( request ) do
                 not_found_404( :error => Waves::Dispatchers::NotFoundError )
               end
               response.status = '404'
               response.content_type = 'text/html'
-              response.write( html )
+              response.body = html
             end
           end
-
         end
+        
       end
     end
   end

data/lib/layers/mvc.rb

@@ -0,0 +1,54 @@
+module Waves
+  module Layers
+    # The MVC layer establishes the Models, Views, Controllers, and Helpers namespaces inside 
+    # a Waves application.  In each namespace, undefined constants are handled by AutoCode, which
+    # loads the constant from the correct file in the appropriate directory if it exists, or creates
+    # from default otherwise.
+    module MVC
+
+      def self.included( app )
+        
+        def app.models ; self::Models ; end
+        def app.views ; self::Views ; end
+        def app.controllers ; self::Controllers ; end
+        def app.helpers ; self::Helpers ; end
+        
+        app.auto_create_module( :Models ) do
+          include AutoCode
+          auto_create_class :Default
+          auto_load :Default, :directories => [:models]
+        end
+        
+        app.auto_eval( :Models ) do
+          auto_create_class true, app::Models::Default
+          auto_load true, :directories => [ :models ]
+        end
+
+        app.auto_create_module( :Views ) { include AutoCode }
+        
+        app.auto_eval( :Views ) do
+          auto_create_class :Default, Waves::Views::Base
+          auto_load :Default, :directories => [:views]
+          auto_create_class true, app::Views::Default
+          auto_load true, :directories => [ :views ]
+        end
+
+        app.auto_create_module( :Controllers ) { include AutoCode }
+        
+        app.auto_eval( :Controllers ) do
+          auto_create_class :Default, Waves::Controllers::Base
+          auto_load :Default, :directories => [:controllers]
+          auto_create_class true, app::Controllers::Default
+          auto_load true, :directories => [ :controllers ]          
+        end
+
+        app.auto_create_module( :Helpers ) do
+          include AutoCode
+          auto_create_module { include Waves::Helpers::Default }
+          auto_load true, :directories => [ :helpers ]
+        end          
+
+      end
+    end
+  end
+end

data/lib/layers/orm/active_record.rb

@@ -0,0 +1,93 @@
+class Symbol
+  # Protect ActiveRecord from itself by undefining the to_proc method.
+  # Don't worry, AR will redefine it.
+  alias :extensions_to_proc :to_proc
+  remove_method :to_proc
+end
+require 'active_record'
+require "#{File.dirname(__FILE__)}/active_record/tasks/schema"    if defined?(Rake)
+require "#{File.dirname(__FILE__)}/active_record/tasks/generate"  if defined?(Rake)
+
+
+module Waves
+  module Layers
+    module ORM
+
+      # Sets up the ActiveRecord connection and configures AutoCode on Models, so that constants in that
+      # namespace get loaded from file or created as subclasses of Models::Default
+      module ActiveRecord
+        
+        # On inclusion, this module:
+        # - creates on the application module a database method that establishes and returns the ActiveRecord connection
+        # - arranges for autoloading/autocreation of missing constants in the Models namespace
+        # - defines ActiveRecord-specific helper methods on Waves::Controllers::Base
+        # 
+        # The controller helper methdods are:
+        # - all
+        # - find(name)
+        # - create
+        # - delete(name)
+        # - update(name)
+        
+        def self.included(app)
+          
+          def app.database
+            unless @database
+              ::ActiveRecord::Base.establish_connection(config.database)
+              @database = ::ActiveRecord::Base.connection
+            end
+            @database
+          end
+                      
+          app.auto_create_module( :Models ) do
+            include AutoCode
+            auto_create_class :Default, ::ActiveRecord::Base
+            auto_load :Default, :directories => [ :models ]
+          end
+          
+          app.auto_eval :Models do
+            auto_create_class true, app::Models::Default
+            auto_load true, :directories => [ :models ]
+
+            auto_eval true do
+              app.database
+              set_table_name basename.snake_case.pluralize.intern
+            end
+          end
+          
+          Waves::Controllers::Base.instance_eval do
+            include Waves::Layers::ORM::ActiveRecord::ControllerMethods
+          end
+          
+        end
+        
+        # Mixed into Waves::Controllers::Base.  Provides ORM-specific helper methods for model access.
+        module ControllerMethods
+          def all
+            model.find(:all)
+          end
+          
+          def find( id )
+            model.find(id) or not_found
+          end
+          
+          def create
+            model.create( attributes )
+          end
+          
+          def delete( id )
+            find( id ).destroy
+          end
+          
+          def update( id )
+            instance = find( id )
+            instance.update_attributes( attributes )
+            instance
+          end
+        end
+        
+      end
+    end
+  end
+end
+