rtml 1.2.2 → 2.0.0.alpha.1

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

@@ -1,91 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,318 +0,0 @@
-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