rtml 1.2.2

data/app_generators/rtml/templates/rtml/lib/rtml/core/screen.rb

@@ -0,0 +1,91 @@
+module Rtml
+  module Core
+    # Constructs a new TML Screen to be added to a document.
+    class Screen < Element
+      attr_accessor :id
+      include Rtml::Helpers::CoreHelpers::LayoutHelpers
+      include Rtml::Core::Screen::Iterators
+      include Rtml::Core::Screen::VariableMethods
+      include Rtml::Core::Screen::NextScreenMethods
+      
+      # Initializes a new Screen object. An exception is raised if the given ID is longer than 12 characters.
+      def initialize(view = nil, id = nil, parent = nil, &blk)
+        raise "ID '#{id}' is too long by #{(id.to_s.length - 12)} characters" if id.to_s.length > 12
+        @id = id
+        super(view,id,nil,parent)
+        @css_class = nil
+        @content = nil
+        @on_cancel = nil
+        @on_menu = nil
+        @setvars = [ ]
+        @timeout = -1
+        @next = Core::Next.new
+        layout parent.layout if parent
+        protect_all_instance_variables!
+        
+        assert
+        yield_with_optional_param self, &blk if block_given?
+      end
+      
+      # Gets or sets the CSS class to use for this Screen
+      def css_class(*a)
+        with_first_argument(*a) { |arg| @css_class = arg }
+        @css_class
+      end
+      
+      # If the specified conditions are true, sends the user to the target screen.
+      # If all assertions for this screen fail, an assertion error will be raised.
+      # If no target is given, or no conditions are given, the assertion will always fail.
+      def assert(target = nil, *conditions)
+        unless document.screens.screen_defined?(:assert) or self.id == :assert
+          document.screen :assert, :next => ((document.default_screen.blank?) ? url_for(:action => params[:action]) :
+                                              document.default_screen) do |scr|
+            scr.display <<-end_tml
+              <h1>Assertion Failure</h1>
+              on screen "<getvar name='oebr.prev_screen' />"<br/>
+              (Did you define a #next_screen?)
+            end_tml
+          end
+        end
+
+        next_screen((conditions.empty?) ? (target || :assert) : :assert)
+        next_screen target, *conditions unless target.nil? or conditions.length == 0
+      end
+      
+      # Sets the timeout length, in seconds, before the user is forwarded to the Next screen.
+      # If set to -1, there is no timeout.
+      # If there are any links on the current screen, this will have no effect.
+      def timeout(*a)
+        with_first_argument(*a) { |arg| @timeout = arg }
+        @timeout
+      end
+      
+      # Defines what screen to go to next if the user presses the "cancel" button on the terminal.
+      # If no parameter is specified, no change is made and the current value is returned.
+      def on_cancel(*a); on :cancel => a[0]; end
+      
+      # Defines what screen to go to next if the user presses the "menu" button on the terminal.
+      # If no parameter is specified, no change is made and the current value is returned.
+      def on_menu(*a); on :menu => a[0]; end
+            
+      # Constructs the TML representation of this Screen object.
+      def to_tml
+        rtml = render_widget_tml
+        
+        c = properties.to_s
+        c.concat " timeout='#{@timeout}'" unless @timeout == -1
+        c.concat " class='#{@css_class}'" unless @css_class.blank?
+
+        nxt = @next.to_tml
+        nxt += "\n" unless nxt.blank?
+        svars = @setvars.join("\n")
+        svars += "\n" unless svars.blank?
+        content = svars + nxt + rtml
+        
+        "<screen id='#{@id}'#{c}>\n" +
+          content.strip.indent + "\n" +
+        "</screen>"
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/core/screen/iterators.rb

@@ -0,0 +1,63 @@
+module Rtml::Core::Screen::Iterators
+  def each_hyperlink
+    # process hyperlinks
+    base = controller.url_for(:anchor => "", :only_path => true)
+    unless widgets.select { |c| c.kind_of? Rtml::Widgets::DisplayWidget }.empty?
+      rx = /href=["']([^"']*)['"]/
+      rx.each_match(self.to_tml) do |match|
+        # determine whether it's a screen name or an external link
+        s = document.screens.find(match[1])
+        y = (s ? s.id : match[1])
+        yield y
+      end
+    end
+  end
+  
+  # Iterates through and yields each conditional variant associated with this screen.
+  # This does not include hyperlinks or event listeners.
+  def each_condition(&block)
+    self.next.each &block
+  end
+  
+  # Returns a hash of every possible variant. Each value is the condition under which
+  # that path can be chosen, and its key is the ID or URL of the destination.
+  #
+  # If a block is given, it is passed each condition and destination before returning.
+  #
+  # There are two special keys, :hyperlink and :default, representing a destination that
+  # must be manually selected by the user and the default destination (if no other conditions
+  # are met), respectively. These are both Symbols. Any other key will be a String, so it
+  # is trivial to check these:
+  #
+  #  @screen.every_possible_variant do |condition, destination|
+  #    case condition
+  #      when :hyperlink
+  #        puts "found hyperlink: #{destination}"
+  #      when :default
+  #        puts "found default destination: #{destination}"
+  #      else
+  #        puts "When #{condition}, goto #{destination}"
+  #    end
+  #  end
+  #
+  def every_possible_variant
+    ret = ActiveSupport::OrderedHash.new
+    each_hyperlink do |href|
+      ret[href] = :hyperlink
+      yield :hyperlink, href if block_given?
+    end
+    
+    @next.each do |condition, dest|
+      if condition.blank?
+        ret[dest] = :default
+      else
+        ret[dest] = condition
+      end
+      yield ret[dest], dest if block_given?
+    end
+    
+    ret
+  end
+  
+  alias each_possible_variant every_possible_variant  
+end

data/app_generators/rtml/templates/rtml/lib/rtml/core/screen/next_screen_methods.rb

@@ -0,0 +1,70 @@
+module Rtml::Core::Screen::NextScreenMethods
+  # Specifies the next screen for the user to visit. The options can specify conditions
+  # under which the screen will be visited. If next_screen is called twice with exactly
+  # the same options (or options that equate to the same value), an exception will be raised.
+  # Examples:
+  #   screen.next_screen :address                              # Will go to :address if all other conditions fail
+  #   screen.next_screen :zip,   :if => "tmlvar:address != ''" # Will go to :zip if the address variable is not blank
+  #   screen.next_screen :phone, :unless => "tmlvar:phone_required == 1" #Will go to :phone if phone_required != 1
+  #   screen.next_screen :name,  :key => :f1                   # Will go to :name if the user presses F1
+  #
+  # The :if and :unless conditions can be specified as Strings, as in the example above,
+  # or as Arrays of Strings (["tmlvar:address", "!=", ""]). In either case, they must
+  # equate to three parameters -- a left operand, an operator, and a right operand.
+  #
+  # There is an alias for next_screen, "next", which can be used instead. However,
+  # "next" is also a Ruby keyword, so it may not be available depending on your context.
+  # (The "screen.next" format should be allowed, but simply calling "next" will result in an error.)
+  #
+  def next_screen(*args)#scrid, options = {})
+    if args.length > 0
+      scrid = args[0]
+      options = args[1] || {}
+      if scrid.kind_of? Hash
+        if options.empty?
+          options[:if] = scrid.delete :if
+          options[:unless] = scrid.delete :unless
+          options[:key] = scrid.delete :key
+        end
+        scrid = url_for scrid
+      end
+      @next.variant(scrid, options)
+    else
+      @next.for_variant({})
+    end
+    @next
+  end
+ 
+  alias next next_screen
+  alias goto next_screen
+  
+  # Constructs a set of variants (conditional next_screen calls)
+  # Takes a hash of conditions => screen_names.
+  # For example:
+  #
+  #   variants "tmlvar:scrid == 1" => :scr1,
+  #            "tmlvar:scrid == 2" => :scr2
+  #
+  # Produces the same output as:
+  #
+  #   next_screen :scr1, :if => "tmlvar:scrid == 1" 
+  #   next_screen :scr2, :if => "tmlvar:scrid == 2" 
+  #
+  # You can also specify an Array for the conditions, in order
+  # to point more than one condition to the same screen.
+  def variants(hash)
+    hash.each do |cond,scr|
+      cond = [ cond ] unless cond.respond_to? :each
+      cond.each do |c|
+        next_screen scr, :if => c
+      end
+    end
+  end
+  
+  def variants_for(scrid, hash)
+    next_screen scrid
+    variants hash
+  end
+  
+  alias variant_for variants_for
+end

data/app_generators/rtml/templates/rtml/lib/rtml/core/screen/variable_methods.rb

@@ -0,0 +1,73 @@
+module Rtml::Core::Screen::VariableMethods
+  # Returns an array of strings, containing the name of each variable used in this document
+  def variables_used
+    tml = self.to_tml
+    r = []
+    /setvar name=['"]([^'"]+)['"]/.each_match(tml) { |match| r << find_or_register_variable(match[1]).name }
+    /getvar name=['"]([^'"]+)['"]/.each_match(tml) { |match| r << find_or_register_variable(match[1]).name }
+    /input[^<>]*name=['"]([^'"]+)['"]/.each_match(tml) { |match| r << find_or_register_variable(match[1]).name }
+    /[lr]o=['"]tmlvar:([^'"]+)['"]/.each_match(tml) { |match| r << find_or_register_variable(match[1]).name }
+    r
+  end
+  
+  # Returns true if the specified variable or variable name has been used by this screen.
+  def uses_variable?(var_or_name)
+    var = var_or_name
+    var = document.variables.find_by_name(var) if var.kind_of? Symbol or var.kind_of? String
+    tml = self.to_tml
+    
+    return true if tml =~ /name=['"]#{Regexp::escape var.name}['"]/ or
+                   tml =~ /input[^<>]*name=['"]([^'"]+)['"]/ or 
+                   tml =~ /[lr]o=['"]tmlvar:#{Regexp::escape var.name}['"]/
+    false
+  end
+  
+  # Sets the specified variable to a given value. The value can be a single parameter,
+  # or can be a three-part assignment in the form of an Array, Hash or String.
+  # Examples:
+  #   screen.set :i, [ "tmlvar:i", "+", "1" ]
+  #   screen.set :i, "tmlvar:i"
+  #   screen.set :i, :true
+  #   screen.set :i, "tmlvar:i + 1"
+  #   screen.set :i, :to => [ "tmlvar:i", "+", "1" ]
+  #   screen.set :i, :to => "tmlvar:i + 1"
+  #   screen.set :i, :to => true
+  #   screen.set :i, :value => [ "tmlvar:i", "+", "1" ]
+  #   screen.set :i, :value => "tmlvar:i + 1"
+  #   screen.set :i, :value => "tmlvar:i"
+  #   screen.set :name, 'Joe'
+  #   screen.set :name, :to => "Joe"
+  #   screen.set :name, :value => "Joe"
+  #
+  #   screen.set :name => "Joe"
+  #   screen.set :i => "tmlvar:i + 1"
+  #   screen.set :i => [ "tmlvar:i", "+", "1" ]
+  #
+  # set_variable is an alias for the this method.
+  def set(*args)#varn, ops)
+    if args.length == 2
+      varn, ops = args
+      varn.each { |v| set v, ops } and return if varn.kind_of? Array
+      #varn = qualified_variable_name varn
+      var = find_or_register_variable(varn)
+      @setvars << var.setvar(ops)
+    else
+      args[0].each do |key,value|
+        set(key, value)
+      end
+    end
+  end
+  alias set_variable set
+  
+  # Finds and returns the specified variable or variable name, registering it for use with the
+  # document if it is not found and creating it if it is not a Variable object.
+  def find_or_register_variable(var_or_name)
+    var_or_name = var_or_name.name if var_or_name.kind_of? Rtml::Core::Variable
+    var = document.variables.find_by_name(var_or_name)
+    if var.nil?
+      var = Rtml::Core::Variable.new(nil, { :name => var_or_name }, self)
+      document.register_variable var
+    end
+    var
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/core/support/importer.rb

@@ -0,0 +1,55 @@
+class Rtml::Core::Support::Importer
+  # Looks up the specified path, converts it into an instance of ActionController::Base,
+  # and executes the action in the ActionController instance against the specified TML
+  # document. The net result is to "import" the action into this TML document.
+  def initialize(tml_document, path)
+    route = ActionController::Routing::Routes.recognize_path(path)
+    root = ((defined? RAILS_ROOT) ? RAILS_ROOT : File.join(File.dirname(__FILE__), '../../../../../../..'))
+    helpers_path = File.join(root, "app", "helpers", "#{route[:controller]}_tml_helpers")
+    helpers = [ 'common', route[:action] ]
+    
+    for helper in helpers
+      path = File.join helpers_path, helper
+      tml_document.controller.class.tml_helper path
+    end
+    
+    tml_document.controller.send :add_instance_view_paths, route[:action]
+    tml_document.controller.rtml_interface.fire_action route[:action], tml_document.controller
+    
+=begin
+    env = tml_document.controller.request.env.dup
+    %W(rack. action_controller.).each do |i|
+      env.keys.each do |key|
+        env.delete key if key =~ /#{Regexp.escape i}/
+      end
+    end
+    env['PATH_INFO'] = env['REQUEST_URI'] = env['REQUEST_PATH'] = path
+    request = ActionController::Request.new(env)
+    controller_class = "#{route[:controller].camelize}Controller".constantize.new
+    controller_class.process(request, ActionController::Response.new)
+=end
+    #ActionController::Dispatcher.new.call(env)
+    
+
+
+    
+    #raise env.inspect.to_yaml
+    
+    #raise tml_document.controller.request.env.inspect
+    #request = Rack::Request.new(env)
+    #ActionController::Routing::Routes.call(env)
+    #app = ActionController::Routing::Routes.recognize(request)
+    #app.call(env).to_a
+    
+#    controller_class = "#{route[:controller].camelize}Controller".constantize.new
+    #ctrlr.send(:tml_document=, self)
+    
+    #session = ActionController::Integration::Session.new
+    #session.get(path)
+    #session.controller
+    
+    #action = route[:action]
+    #template = controller.send :default_template_name, action, format, ctrlr
+    #render options.merge(:file => template)
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/core/tml_document.rb

@@ -0,0 +1,318 @@
+module Rtml
+  module Core
+    # TMLDocument is the root of all RTML generation.
+    # It is called with an ActionView as a parameter, but this parameter is supplied
+    # via the Rtml::tml_document helper. So instead of embedding TMLDocument.new(. . .) { . . . }
+    # into your application's view, you simply call tml_document { |doc| . . . }
+    # See the README for a complete usage example.
+    class TMLDocument < Element
+      include Rtml::Core::TMLDocument::VariableMethods
+      include Rtml::Core::TMLDocument::ScreenMethods
+      include Rtml::Helpers::CoreHelpers::LayoutHelpers
+      
+      alias variable_declarations vardecs
+      
+      # Initializes a new TML document with the given ActionView.
+      # Requires a block which configures the document and adds content.
+      def initialize(view = nil, &blk)
+        Rtml::Widgets::Widget.load_widgets
+        super(view)
+        
+        reset!
+        
+        def @screens.screen_defined?(a)
+          return true unless self.find(a).nil?
+          false
+        end
+        
+        def @screens.find(id)
+          # FIXME: False positives are possible here, because it doesn't match against the controller or action.
+          if id.kind_of? String
+            if id =~ /#/
+              self.each { |scr| return scr if scr.id.to_s == id[$~.offset(0)[1]..-1] }
+            end
+          end
+          self.each { |scr| return scr if scr.id == id }
+          nil
+        end
+        
+        def @variables.find_by_name(name)
+          name = name.to_s if name.kind_of? Symbol
+#          name = document.qualified_variable_name name
+          self.each { |var| return var if var.name == name }
+          nil
+        end
+
+        protect_all_instance_variables!
+        process_block &blk if block_given?
+      end
+      
+      # Resets this document to an "unmodified" state. This will reverse ALL changes made to the document and
+      # cannot be undone!
+      def reset!
+        @tab_stop = 3
+        (@includes ||= []).clear
+        (@variables ||= []).clear
+        (@vardecs ||= []).clear
+        (@screens ||= []).clear
+        (@defaults ||= {}).clear
+        @layout = nil
+        @default_screen = nil
+        @cache = nil
+        @base = nil
+        widgets.clear
+        
+        # order is important: creating the string "modifies" this document. Processing block is allowed to, though.
+        #self.string action_view.request_forgery_protection_token.to_s, :value => action_view.form_authenticity_token if action_view
+        @modified = false
+      end
+      
+      # Sets the TML document to a "modified" state.
+      def modify!
+        @modified = true
+      end
+      
+      # Returns true if the document has been modified.
+      def modified?
+        @modified
+      end
+      
+      # Returns true if a screen with the specified ID is in this document.
+      def screen_defined?(a)
+        @screens.screen_defined? a
+      end
+      
+      # Duplicates the screen with the first ID. The clone will be given the second ID.
+      def alias_screen(source, target)
+        scr = @screens.find(source).dup
+        scr.id = target
+        @screens << scr
+        scr
+      end
+      
+      # Imports the specified TML document and applies everything in it to this document
+      # Valid options are:
+      #    :super - imports the parent TML document (useful for only overriding a section of the parent document)
+      #    [hash] - imports the TML document found at the path that the specified hash routes to when url_for is
+      #             called
+      #
+      # Examples:
+      #   <%=tml_document do
+      #     import :super
+      #     screen :main_menu, :next => :trans_abrt do
+      #       display :partial => 'custom_menu_content'
+      #     end
+      #   end%>
+      #
+      #   -or-
+      #   
+      #   <%=tml_document do
+      #     import :controller => 'recipes', :action => 'list'
+      #     . . .
+      #   end%>
+      #
+      def import(p)
+        if p.kind_of? Hash then
+          # Hash could be render(options), or render(:file => url_for(options)) -- figure out which
+          # and act accordingly
+          options = { :locals => p.delete(:locals), :layout => p.delete(:layout) }
+          options.delete :locals if options[:locals].nil?
+          options.delete :layout if options[:layout].nil?
+          render_methods = ['file', 'partial', 'inline', 'text']
+          direct_render = (p.keys.select { |i| render_methods.include? i.to_s }).length > 0
+          if direct_render
+            render p.merge(options)
+          else
+            #format = controller.response.template.template_format
+            path = url_for(p.merge(:only_path => true))
+            Rtml::Core::Support::Importer.new(self, path)
+          end
+        else
+          case p
+            when :super then render :super
+            else raise "Import directive not recognized: #{p.inspect}"
+          end
+        end
+      end
+
+      # Generates the actual TML for this document. This is the root generation method
+      # to build all TML for this entire document, including the header, screens, submits,
+      # etc.
+      def to_tml
+        #TODO: We kind of need a before_render type of hook so that this sort of thing can be fired properly.
+        # force assert to the end of the list
+        assert_screen = @screens.find(:assert)
+        if assert_screen
+          @screens.delete assert_screen
+          @screens << assert_screen
+        end
+
+	      rtml = render_widget_tml
+        on :error => url_for(:action => 'error') unless self[:on_error] or ENV['RAILS_ENV'] != 'production'
+        cache = nil
+        cache = 'deny' if @cache == false
+        cache = 'allow' if @cache
+        r = Rtml::Widgets::ElementBuilderWidget.new(self, nil) do |doc|
+          doc.drop_empty_attributes = true
+          doc.tml :xmlns => "http://www.ingenico.co.uk/tml", :cache => cache do |tml|
+            tml.build :head do |head|
+              head.concat includes.to_tml
+              head.build :base, :href => base unless base.blank?
+              build_defaults(head)
+              build_error_screen(head)
+            end
+            tml.concat @vardecs.collect { |i| i.to_s }.join("\n")
+            tml.build :name => :screen, :id => :__default do |scr|
+              scr.build :name => :next, :uri => default_screen.to_screen_ref
+            end unless default_screen.blank?
+            tml.concat @screens.to_tml
+            tml.concat rtml
+          end
+        end
+
+        r = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n#{r.to_s}".gsub(/\t/, ''.ljust(tab_stop))
+        r
+      end
+      
+      def base(*a)
+        with_first_argument(*a) { |arg| @base = arg }
+        @base
+      end
+
+      # Sets or retrieves whether or not this document is allowed to be cached.
+      def cache(*a)
+        with_first_argument(*a) do |arg|
+          case arg
+            when false, 'false', 'deny', :false, :deny then @cache = false #"deny"
+            when '', nil then @cache = nil
+            else @cache = true#'allow'
+          end
+        end
+        @cache
+      end
+      alias allow_cache cache
+      
+      # If a parameter is supplied, the tab stop for this document is set to the given
+      # value (which should be a number). Otherwise, the current value is returned.
+      # This alters the degree of indentation used when to_tml is called.
+      def tab_stop(*a)
+        with_first_argument(*a) { |arg| @tab_stop = arg.to_i }
+        @tab_stop
+      end
+
+      # Specifies a default screen for this document. In TML, the "default" screen is
+      # simply the first screen to be encountered within the file. This method ensures
+      # that no matter what order your screens appear in, the specified screen is where
+      # the user will start. If no parameters are given, the current default screen is
+      # returned and no changes will occur. Note that if this is not set, there will
+      # be no "default" screen, and the first screen added to the document within your
+      # code will be the end user's starting point.
+      def default_screen(*a)
+        with_first_argument(*a) { |arg| @default_screen = arg }
+        @default_screen
+      end
+      
+      # Accepts a hash of options, containing :menu => 'some url' and/or :cancel => 'some url'.
+      # Both values are optional, but no other values may be specified. What this is saying
+      # is, if the user presses the "menu" button on their terminal and the screen they
+      # are viewing is not overriding this default, the user will be redirected to the
+      # :menu URL specified in this method. Similarly, if they press the "cancel" button
+      # on the terminal, they will be forwarded to the :cancel action. If they press the
+      # corresponding button but no action was supplied (you didn't call defaults or you
+      # called it with :cancel and they pressed "enter", or vice versa), then nothing happens.
+      def defaults(options)
+        on options
+#        options.each { |a,b| on a => b }
+      end
+      
+      # As of 05/08/09, this method can be called with just a String for an argument. In this
+      # case, the method will attempt to get the :css or :tml option based on the filename.
+      #
+      # Directs the terminal to include the specified file while loading this application.
+      # The first parameter specifies either :css, :stylesheet, or :tml, which is the format
+      # of the file being included. (:css and :stylesheet are for convenience, and both mean the
+      # same thing.) The properties hash should include a :source URL to the file to be included.
+      # Or, you can call this method with only a single parameter, which must be a Hash.
+      # In this case, you must specify :type => (:css or :stylesheet or :tml).
+      #
+      # Examples:
+      #    tmldoc.includes :css, :source => 'pretty.css'
+      #    tmldoc.includes :source => 'pretty.css', :type => :stylesheet
+      #    tmldoc.includes :tml, :source => 'error_screens.tml'
+      #    tmldoc.includes :rtml, :source => 'error_screens.tml'
+      #
+      # Note that you can, of course, reference Rails actions in this same way:
+      #    tmldoc.includes :tml, :source => 'errors/500'
+      #    tmldoc.includes :rtml, :source => 'errors/500'
+      #    tmldoc.includes :action => :errors, :id => 500
+      #    tmldoc.includes :tml, :source => { :action => :errors, :id => 500 }
+      #
+      # Just be sure that the controller ("errors" in this case) is rendering TML... 
+      #
+      # Also note that in all forms, if type is unspecified, it defaults to :tml.
+      def includes(type = nil, properties = { })
+        # TODO: This should probably be broken into several methods, maybe even its own class.
+        if type.kind_of? Hash
+          if properties.kind_of? Hash
+            properties.merge! type
+          else
+            properties = type
+          end
+          type = nil
+        end
+        
+        properties = { :source => properties } if properties.kind_of? String
+        return @includes if type.nil? and properties.empty?
+        type = properties.delete :type if properties.key? :type and type.nil?
+        type = properties.delete :format if properties.key? :format and type.nil?
+        if properties.kind_of? Hash
+          if type.kind_of? String and not properties.key? :source
+            properties.merge!(:source => type)
+            type = nil
+          end
+        else
+          properties = { :source => properties } unless properties.kind_of? Hash
+        end
+
+        type = :css if type == :stylesheet
+        type = :tml if type == :rtml
+
+        # get source
+        source = ((properties.key? :source) ? properties[:source] : url_for(properties))
+        raise "Could not build source for include directive" if source.nil? or properties.blank?
+
+        # get type
+        if type.nil?
+          # try to infer type from source
+          %W(format=tml .tml type=tml format=rtml .rtml type=rtml /tml/).each { |f| type = :tml if source[f] }
+          %W(format=css .css stylesheets/ css/ type=css).each { |f| type = :css if source[f] }
+          raise "Could not infer type from source, specify :css or :tml in include directive" unless type
+        else
+          raise "Type must be one of [ :css, :stylesheet, :tml, :rtml ]" unless [:css, :tml].include? type
+        end
+        incl = Include.new(action_view, {:source=>source,:type=>type}, self)
+        @includes << incl
+        incl
+      end
+  
+      def proc#:nodoc:
+        super
+      end
+      
+      
+      private
+      def build_defaults(head)
+        c = {}
+        c[:menu] = self[:on_menu] unless self[:on_menu].blank?
+        c[:cancel] = self[:on_cancel] unless self[:on_cancel].blank?
+        head.concat "<defaults #{c.to_s} />" unless c.empty?
+      end
+      
+      def build_error_screen(head)
+        c = { }
+        c[:uri] = self[:on_error] unless self[:on_error].blank?
+        head.concat "<error #{c.to_s} />" unless c.empty?
+      end
+    end
+  end
+end