rtml 1.2.2 → 2.0.0.alpha.1

data/app_generators/rtml/templates/rtml/app/controllers/rtml/rtml_app_controller.rb

@@ -1,252 +0,0 @@
-class Rtml::RtmlAppController < Rtml::TmlAppController
-  include Rtml::Helpers::ControllerHelpers::MenuHelpers
-  
-  prepend_before_filter :force_rtml, :only => :uml
-  before_render :render_tml
-  around_filter :process_action_with_view_paths
-  hide_action :rtml_interface, :tml_document, :rtml_document, :tml_document=, :rtml_document=
-  
-  # For creating UML diagrams of TML screens for the given action. Must be in this same controller.
-  def uml
-    helper = response.template
-    
-    include_view_paths_for params[:id]
-    self.rtml_interface.fire_action(params[:id], self)
-    @screens = tml_document.screens
-    url = []
-    @screens.each do |scr|
-      map = {}
-      left = nil
-      scr.every_possible_variant do |cond, dest|
-        left = helper.uml_for_screen(scr)
-        right = helper.uml_for_screen(@screens.find(dest) || helper.format_for_uml(dest))
-        if cond == :default and not map[right] then cond = ""
-        else
-          cond = unless cond =~ /key=/ then cond.to_s.gsub(/(^|\s)..=['"]([^'"]*)['"]/, '\1\2')
-          else cond.to_s.gsub(/['"]/, '').gsub(/key=/, 'on key ')
-          end
-        end
-        if map[right] then map[right] << " | #{cond}"
-        else map[right] = cond
-        end
-      end
-      # we use the map to merge multiple conditions in order to point to a destination only once
-      map.each { |right, cond| url << "[#{left}]-#{cond}>[#{right}]" }
-    end
-    tml_document.reset!
-    
-    data = helper.get_uml_image_data(url)
-    send_data data, :disposition => 'inline', :type => 'image/png', :file_name => "#{params[:id]}.png"
-  end
-  
-  def self.inherited(base) #:nodoc:
-    super
-    # TODO: It may be important to leave base.controller_path in the view paths in order to
-    # handle overriding the tml_app views. Need to figure out if this is necessary or not.
-    # base.append_view_path(File.join("vendor", "plugins", "rtml", "app/views", base.controller_path))
-    base.send :include, "#{base.controller_path}_tml_helpers".camelize.constantize rescue nil
-  end
-  
-  def self.rtml_interface #:nodoc:
-    if self.superclass.respond_to? :rtml_interface
-      @rtml_interface ||= Class.new(self.superclass.rtml_interface.class).new
-    else
-      @rtml_interface ||= Class.new(Rtml::Proxying::RtmlInterface).new
-    end
-    @rtml_interface
-  end
-  
-  def self.add_rtml_actions(*actions) #:nodoc:
-    actions.flatten.each do |action|
-      raise ArgumentError.new("Action must be Symbol or String") unless action.kind_of? Symbol or action.kind_of? String
-      line = __LINE__ + 1
-      eval %Q`
-        def #{action}
-          set_rtml unless template_exists?(default_template_name)
-          if request.format == :rtml
-            self.rtml_interface.fire_action(#{action.inspect}, self)
-          end
-        end
-      `, binding, __FILE__, line
-    end
-  end
-  
-  def rtml_interface #:nodoc:
-    self.class.rtml_interface
-  end
-  
-  # Returns the TML document that is being constructed for this request.
-  def tml_document
-    @tml_document ||= Rtml::Core::TMLDocument.new(response.template)
-  end
-  
-  # Overwrites the TML document, if any, with the specified target.
-  # The specified target document becomes the "active" target, and will
-  # be rendered in place of this one.
-  def tml_document=(target)
-    @tml_document = target
-  end
-  
-  alias rtml_document= tml_document=
-  alias rtml_document tml_document
-  
-  protected
-  include Rtml
-  include Rtml::Core
-  extend Rtml::TmlAppHelper
-  extend Rtml::Helpers::ControllerHelpers
-  
-  # Adds the specified action's view paths to this action's view paths,
-  # which would allow you to render views and partials from the specified
-  # action. Note that if two actions specify the same view, the view path
-  # that is encountered first takes precedence. (This should be the current
-  # action, which is ideal, BUT it's Rails core functionality that I'm not
-  # going to vouch for. Basically, keep the names unique or use at your own
-  # risk.)
-  def include_view_paths_for(action)
-    add_instance_view_paths(action)
-  end
-  
-  # Used for modifying the template files to be found in
-  # controller/action/screen_name.erb (instead of the Rails default
-  # controller/action.erb).
-  def default_template_name(action_name = self.action_name,
-                            ext         = response.template.template_format,
-                            klass       = self.class) #:nodoc:
-    s = super
-    return s if s
-    if action_name =~ /\//
-      return s
-    else
-      return super("#{params[:action]}/#{action_name}", ext, klass)
-    end
-  end
-  
-  # We need the default rescue_action functionality, but we first
-  # need to reset the TML document that's being generated, or else
-  # we'll end up with a TML document that half represents what the
-  # user was constructing, half represents the error being reported,
-  # and is completely invalid TML!
-  def rescue_action(*a)
-    tml_document.reset!
-    super
-  end
-
-  
-  private
-  # Adds default action-specific view paths to this controller, then
-  # calls the action, and finally removes the view paths.
-  def process_action_with_view_paths
-    include_view_paths_for params[:action]
-    yield
-    remove_instance_view_paths
-  end
-  
-  # Adds all registered view paths for the specified action to the
-  # controller for this action. This is called by the around_filter
-  # before the action is called.
-  def add_instance_view_paths(action)
-    controller = self
-    @paths_to_delete = []
-    (controller.class.view_paths_for_actions.select do |a|
-      a[0].to_s.length == 0 || a[0].to_s == action.to_s
-    end).each do |a|
-      path = a[1]
-      add_instance_view_path path
-    end
-  end
-  
-  # Adds the specified view path to the controller's view paths
-  # and also adds it to the list of paths to be deleted at the end
-  # of this action (so that they are not permanent in production).
-  def add_instance_view_path(path)
-    unless controller.class.view_paths.include? path
-      @paths_to_delete << path
-      controller.prepend_view_path path
-    end
-  end
-  
-  # Removes all view paths that were not a part of the action-unspecific
-  # (global) array for this controller. This is called by the around_filter
-  # after content has been rendered.
-  def remove_instance_view_paths
-    controller = self
-    @paths_to_delete.each do |path|
-      controller.view_paths.delete path
-    end
-  end
-
-  def render_tml
-    headers_filter
-    return unless tml_document.modified? and not performed? and response.redirected_to.nil? 
-
-    # The reason I don't check against request.format here is because I want to handle things like respond_to,
-    # which might look something like
-    #  respond_to do |format|
-    #    format.rtml
-    #    format.html
-    #    format.json { render :json => obj.to_json }
-    #    format.xml  { render :xml => obj.to_xml }
-    #  end
-    #
-    # respond_to does not set request.format; it sets response.template.template_format. So that's what I need
-    # to check. Note that pretty much everywhere else, request.format should be checked, because pretty much
-    # everywhere else we want to know what the client is ASKING for.
-    #
-    if response.template.template_format == :rtml
-      tml = tml_document.to_tml
-      ### HACK!
-      # Having problems with the browser restarting the app when the visiting the full link with an anchor.
-      # Strange, it only happens once. But this should work around it.
-      tml.gsub!(/(["'])#{Regexp::escape url_for(:action => params[:action], :only_path => true)}\#/, '\1#')
-      logger.debug tml if self.class.rtml_debug_config[:dump_tml]
-      render_without_before_render_filter :text => tml
-    end
-  end
-    
-  # Another method for forcing the user into an RTML format. See Rtml::TmlAppController#force_format
-  # and use with care. What this does, essentially, is check to see whether there are any RTML
-  # templates available, and if so, forces the user into RTML format. Only used in very rare
-  # circumstances, obviously, because this will ignore things like what browser is actually
-  # requesting the document. If you call this method, and the user is using Firefox or IE,
-  # tough luck: an RTML template exists, you've told RTML to use it unconditionally.
-  # No effect if no RTML ERB template exists. So for instance, if you are building a TML document
-  # via the tml_helpers, none of the above will happen.
-  def set_rtml
-    if self.class.action_methods.include? params[:action]
-      unless template_exists? default_template_name(params[:action]) and not tml_document.screen_defined? params[:action]
-        force_format :rtml
-      end
-    end
-  end
-  
-  def force_rtml #:nodoc:
-    force_format :rtml
-  end
-  
-  # Declare the specified action to require the specified path. This is used
-  # in the around_filter when constructing the default view paths for an action.
-  #
-  # If action is nil, this path will be added to all actions. (This may be useful
-  # if you want to add a view path to all instances of this controller without
-  # affecting the view paths of any other controllers.)
-  def self.append_view_path_for_action(action, path)
-    view_paths_for_actions << [ action.to_s, path ]
-  end
-  
-  # Return the array of default paths. First argument is action name; second 
-  # argument is the path itself.
-  def self.view_paths_for_actions
-    if @view_paths_for_actions.nil?
-      if self.superclass.respond_to? :view_paths_for_actions
-        @view_paths_for_actions = self.superclass.view_paths_for_actions.collect { |arr| arr.dup }
-      else
-        @view_paths_for_actions = []
-      end
-    end
-    @view_paths_for_actions
-  end
-  
-  public
-  tml_helper :all
-end

data/app_generators/rtml/templates/rtml/app/controllers/rtml/tml_app_controller.rb

@@ -1,418 +0,0 @@
-module Rtml
-  class TmlAppController < ApplicationController
-    include Rtml::Helpers::RenderHelper
-    include Rtml::Helpers::TerminalHelpers
-
-    #It's sad, but we have to skip the authenticity token, because OEGW doesn't support cookies
-    # and therefore has no clue what a Session object is. The Session is used to make sure
-    # authenticity tokens are valid and to generate new ones -- so what happens is, since
-    # the terminal doesn't maintain a session cookie, every request is considered a new "session"
-    # and the previous "session" token is invalidated. So POST data can't be processed because
-    # Rails thinks it's all fake! Until OpenEstate supports session cookies, it has to be disabled.
-    # FIXME: When session cookies are supported, re-enable authenticity verification. Or override
-    # Rails authenticity checking with something a little more TML-friendly...
-    skip_before_filter :verify_authenticity_token
-    
-    before_filter :format_filter
-    #before_filter :headers_filter
-    before_filter :load_state
-    
-    hide_action :embedded_app, :url_for
-    
-    # 080609:
-    # save_state changed to a before_render filter because the user is more likely to change it
-    # in the TML helper than they are in the View, and after much research I had to take sides
-    # (RTML documents do a lot of render_or_redirect-ing, which halts the filter chain).
-    before_render :save_state
-    #after_filter  :save_state
-    
-    append_view_path File.join(PLUGIN_BASE, "app", "views", "rtml", "tml_app")
-    
-    # Action reserved for retrieving TML state data. See
-    # app/views/rtml/tml_app/get_terminal_info.rtml.erb for customization.
-    # You can also override this view within your controller's views, if needed.
-    #
-    # Note that this file should be either a straight TML template (using ERB of course)
-    # or "document-level" RTML (essentially breaking the MVC rules and running the TML
-    # generation in the View). If you don't know what any of that means, then don't touch it.
-    def get_terminal_info
-    end
-  
-    # Action reserved for redirect_to directives. This functionality will be removed
-    # when Incendo supports HTTP redirects, but until then, the only way to do it
-    # is in the terminal-side TML. See app/views/rtml/tml_app/do_tml_redirect.rtml.erb
-    # for customization.
-    # You can also override this view within your controller's views, if needed.
-    #
-    # Note that this file should be either a straight TML template (using ERB of course)
-    # or "document-level" RTML (essentially breaking the MVC rules and running the TML
-    # generation in the View). If you don't know what any of that means, then don't touch it.
-    def do_tml_redirect
-    end
-    
-    def url_for(options = {})
-      super(options.reverse_merge(:format => params[:format]))
-    end
-    
-    class << self
-      # Allows you to provide an expiration timeout. This must be done with a block so that it
-      # can be evaluated only when the expiration headers are being sent.
-      #
-      # Example:
-      #   expires_at { 7.days.from_now }
-      #   expires_at { |controller| controller.current_user.id == 1 ? Time.now : 3.days.from_now }
-      #
-      def expires_at(&block)
-        @expires_at_block = block if block_given?
-        return @expires_at_block
-      end
-      public :expires_at
-    end
-
-    # Allows you to provide an expiration timeout. This must be done with a block so that it
-    # can be evaluated only when the expiration headers are being sent.
-    #
-    # Example:
-    #   expires_at { 7.days.from_now }
-    #   expires_at { |controller| controller.current_user.id == 1 ? Time.now : 3.days.from_now }
-    #
-    def expires_at(&block)
-      @expires_at_block ||= self.class.expires_at
-      @expires_at_block = block if block_given?
-      return @expires_at_block
-    end
-
-    protected
-    # Overrides the set of defaults for when a Web browser (as opposed to a terminal browser)
-    # connects and requests this RTML resource.
-    #
-    # Example:
-    #   class MyAppController < Rtml::RtmlAppController
-    #     rtml_debug do |config|
-    #       config[:model] = 5100
-    #     end
-    #   end
-    #
-    def self.rtml_debug(&blk)
-      yield self.rtml_debug_config
-    end
-    
-    # Returns the hash of RTML debug options, for use when a Web browser (and not a terminal
-    # browser) requests this RTML resource.
-    def self.rtml_debug_config
-      @rtml_debug_config ||= HashWithIndifferentAccess.new({
-        :datetime_start => Date.parse('2006/01/01'),
-        :os => '03.27',
-        :itid => '111111111',
-        :model => 8550,
-        :datetime => Time.now,
-        :part_number => 'I8550_BROWSER',
-        :dump_tml => false
-      })
-    end
-    
-    # Provides a tml_redirect method because Incendo won't understand the "Location"
-    # header that redirect_to produces. (Groupe has agreed to implement this missing
-    # functionality in an upcoming release.) This new redirect_to method will render the
-    # do_tml_redirect action instead, which results in a TML-based redirect.
-    # This is only done for the MicroBrowser. Any other browser gets the standard
-    # Rails functionality unless it passed in the .rtml extension to this request.
-    def redirect_to(a,&b)
-      if request.is_terminal? or params[:format] == 'rtml'
-        if a.kind_of? Hash
-          @redirect_to = url_for(a.merge(:only_path => true))
-        else
-          @redirect_to = url_for(:action => a)
-        end
-        render :action => 'do_tml_redirect'
-      else
-        super
-      end
-    end
-    
-    # Forces the user to use the specified format, regardless of what was requested by the
-    # browser or detected by RTML. You should be very careful with this, because it can have
-    # unintended consequences such as feeding TML to a browser expecting HTML. In fact, it's
-    # generally better to leave the format handling for the RTML Core to worry about. You
-    # have been warned.
-    def force_format(fmt)
-      fmt = params[:format] || 'html' if fmt.nil?
-      request.format = fmt
-      format_filter
-      #headers_filter
-    end
-    
-    # Allows you to toggle whether or not form data sent from a terminal via TMLPOST data should
-    # be available directly via the params object, or whether it should be isolated in params[:tml].
-    # For example, the "user_name" parameter would be stored in params[:user_name] if collect_params
-    # is false, or params[:tml][:user_name] if collect_params is true. By default, params are
-    # stored directly in the params hash (in other words, the default is "false") -- but if you
-    # call this method with no arguments, it will be set to TRUE.
-    #
-    # Example:
-    #   class MyTmlController < Rtml::TmlAppController
-    #     collect_params  # => true
-    #     collect_params false
-    #     collect_params true
-    #     . . .
-    #   end
-    def self.collect_params(tf = true)
-      self.class_eval { def collect_params?; tf; end }
-    end
-    
-    # Returns the terminal state hash. Raises an error if the state is not available (but this
-    # shouldn't happen unless you forgot to run rake rtml:setup). Note that you only need to run
-    # rake rtml:setup if you plan to actually make use of the state hash.
-    def state
-      @terminal_state.nil? ? (raise "State not available; run rake rtml:setup to enable it") :
-                             @terminal_state#.state
-    end
-
-    # If true, TML params will be segregated into params[:tml]
-    # If false, default functionality is assumed, and params will be stored directly within the
-    # params hash. While you can override this if you wish, you're probably better off using
-    # the #collect_params method within your controller.
-    def collect_params?(); false; end
-
-    # This method is responsible for making view inheritance possible.
-    def default_template_name(action_name = self.action_name,
-                              ext         = response.template.template_format,
-                              klass       = self.class) #:nodoc:
-      if action_name && klass == self.class
-        action_name = action_name.to_s
-        if action_name.include?('/') && template_path_includes_controller?(action_name)
-          action_name = strip_out_controller(action_name)
-        end
-      end
-      if !klass.superclass.method_defined?(:controller_path)
-        return "#{self.controller_path}/#{action_name}"
-      end
-      template_name = "#{klass.controller_path}/#{action_name}"
-      if template_exists? template_name, ext
-        return template_name
-      else
-        return default_template_name(action_name, ext, klass.superclass)
-      end
-    end
-    
-    # Checks to see if a template with the specified name and optional format exists.
-    unless ActionController::Base.private_instance_methods.include? 'template_exists?'
-      def template_exists?(template_name, fmt = response.template.template_format) #:nodoc:
-        self.view_paths.find_template(template_name, fmt)
-      rescue ActionView::MissingTemplate, Errno::ENOENT
-        false
-      end
-    end
-
-    # If a catastrophic error would otherwise result in a 500 Internal Server Error
-    # and the application server is running in PRODUCTION mode,
-    # this method will be called instead, and the terminal user will instead see a
-    # pretty error message. It's something generic like "Contact an administrator",
-    # and it can be overridden by creating a "rescue_action_in_public.rtml.erb" file
-    # somewhere in your view path. You can find the original at
-    # app/views/rtml/tml_app/rescue_action_in_public.rtml.erb.
-    #
-    # Note that this file should be either a straight TML template (using ERB of course)
-    # or "document-level" RTML (essentially breaking the MVC rules and running the TML
-    # generation in the View).
-    def rescue_action_in_public(exception) #:nodoc:
-      if request.is_terminal? or params[:error_mode] == 'rtml'
-        @exception = exception
-        render :action => 'rescue_action_in_public'
-      else
-        super
-      end
-    end
-    
-    # If a catastrophic error would otherwise result in a 500 Internal Server Error
-    # and the application server is running in DEVELOPMENT mode,
-    # this method will be called instead, and the terminal user will instead see a
-    # detailed error report like the default ones that Rails generates for your
-    # Web browser.
-    # If you need to tweak the message, it can be overridden by creating a
-    # "rescue_action_locally.rtml.erb" file
-    # somewhere in your view path. You can find the original at
-    # app/views/rtml/tml_app/rescue_action_locally.rtml.erb.
-    #
-    # Note that this file should be either a straight TML template (using ERB of course)
-    # or "document-level" RTML (essentially breaking the MVC rules and running the TML
-    # generation in the View).
-    def rescue_action_locally(exception) #:nodoc:
-      if request.is_terminal? or params[:error_mode] == 'rtml'
-        @exception = exception
-        #if self.respond_to? :rtml_interface and rtml_interface
-          #rtml_interface.instance_variable_set("@exception", exception)
-        #end
-        render :action => 'rescue_action_locally'
-      else
-        super
-      end
-    end
-    
-    
-    private
-    # If params[:format] is specified as 'tml', it is changed to 'rtml' and the method returns.
-    # If it is set to any
-    # other non-nil value, nothing happens. If it is nil, then the following happens:
-    #   If a template of the requested format exists, the method returns as no further action is
-    #     necessary. (The matching template will be rendered unless you intervene.)
-    #   If the requested format is 'tml', or the client is a terminal, the format is forced to 'rtml'.
-    #   If the client is not a terminal and the requested format is not 'tml', nothing happens.
-    #
-    # This method also defines a singleton method for the request object called is_terminal? which
-    # returns true if the client for this request is a terminal (as opposed to a browser). Note that
-    # the is_terminal? method always tells the "truth" -- even if the browser is emulating a terminal
-    # for this request, it will still return false for a browser.
-    def format_filter
-      def request.is_terminal?
-        self.user_agent and (self.user_agent['OE MicroBrowser'] || self.user_agent['IO Browser'])
-      end
-      
-      params[:format] = 'rtml' if params[:format] == 'tml'
-      return if params[:format] # Client-specified formats trump anything automatically assigned
-      return if template_exists? default_template_name(action_name, request.format)
-      
-      fmt = request.format#response.template.template_format.to_s
-      fmt = 'rtml' if fmt == 'tml' or request.is_terminal?
-      request.format = fmt
-#      response.template.template_format = fmt # params[:format] = fmt
-    end
-    
-    # Sets the content-type to XML instead of TML for anything but OEGW. This makes it viewable
-    # in a user's browser as an XML document. Also rebuilds the ETag header to be compatible with
-    # OpenEstate/Incendo Online. (Default Rails ETags are 1 character too long. Painful debugging,
-    # that.)
-    def headers_filter
-      if [:rtml, :tml].include? request.format.to_sym
-        headers['content-type'] = 'text/xml' unless request.is_terminal?
-        headers['content-type'] = 'text/tml' if request.is_terminal?
-        headers['Cache-Control'] = 'no-cache ' # trailing space is important!
-        headers['ETag'] = "W/\"329-#{Time.now.to_i}#{rand(9999)}\" "
-        headers['Expires'] =
-          if expires_at
-            expires_at.call(self)
-          else
-            Time.at(0) # always expired
-          end.strftime("%a, %d %b %Y %H:%M:%S GMT")
-      end
-    end
-    
-    # Loads the terminal's (or browser's) state hash from the database.
-    # TODO: Use Rails.cache for the state whenever possible.
-    def load_state
-      if params[:tml]
-        term_params = params[:tml][:terminal]
-      else
-        term_params = params[:terminal]
-      end
-      fail = false # if true, the get_terminal_info TML page will be rendered.
-      repost = false # if true, the terminal data is out of date and needs to be refreshed.
-      
-      headers = request.headers
-      unless request.is_terminal?
-        # Build some fake data if the user is viewing with a browser, for debugging
-        # Otherwise, user would just always see get_terminal_info. Epic debugfail.
-        p = params[:browser] || {}
-        headers = Rtml::Debug::BrowserEmulator.new(headers.merge(self.class.rtml_debug_config.merge(p)))
-        repost = true # always use current browser details. This enables debug configuration override.
-      end
-      
-      itid = headers['ITID'] || headers['HTTP_ITID']
-      itsn = headers['ITSN'] || headers['HTTP_ITSN']
-      itpn = headers['ITPN'] || headers['HTTP_ITPN']
-      
-      if itid && itsn && itpn or not request.is_terminal?
-        signature = "#{itsn}:#{itpn}:#{itid}"
-        @terminal_state = Rtml::State.find_by_signature(signature)
-        if @terminal_state.nil?
-          logger.debug "Terminal state for signature '#{signature}' not found; creating"
-          @terminal_state = Rtml::State.new(:signature => signature,
-                                           :terminal => Terminal.new(:itid => itid))
-          @terminal_state.state ||= HashWithIndifferentAccess.new
-          logger.debug "Saving empty state"
-          @terminal_state.save!
-        end
-
-        if @terminal_state.state.empty?
-          logger.debug "Terminal state needs populated."
-          repost = true
-        elsif @terminal_state.created_at < 1.day.ago
-          logger.debug "Terminal state is outdated (#{@terminal_state.created_at} < #{1.day.ago}) and will be repopulated."
-          repost = true
-        end
-        
-        if repost
-          p = term_params
-          p = headers if headers.kind_of? Rtml::Debug::BrowserEmulator
-          
-          if p
-            logger.debug "Found terminal information in headers."
-            @terminal_state.state.merge! p
-            @terminal_state.state[:signature] = @terminal_state.signature
-            @terminal_state.created_at = Time.now
-            # State is saved as a part of the before_render filter.
-#            @terminal_state.save!
-            
-            if term_params
-              # FIXME: First I need to remember what this was designed to do (dumb me and no comments),
-              # and then I need to make it work. Whatever it was, it was causing an infinite loop when
-              # redirect_to resulted in reposting state data.
-              #
-              #params.delete :terminal
-              #params[:tml].delete :terminal if params[:tml]
-              #redirect_to params
-            end
-            return true
-          else
-            logger.debug "Could not find terminal information in headers; triggering a data post"
-            logger.debug "term_params: #{term_params.inspect}"
-            logger.debug "params: #{params.inspect}"
-            fail = true
-          end
-        end
-      else
-        raise "Could not find TID header!" unless itid
-        raise "Could not find SN header!" unless itsn
-        raise "Could not find PN header!" unless itpn
-        raise "Unknown error -- something to do with the TID/SN/PN headers!"
-      end
-      return true unless fail
-
-      unless request.post? # don't want to interfere with POSTing
-        force_format :rtml
-        # FIXME: It may be preferable to use redirect_to instead of render
-        # because if the terminal hits an error in get_terminal_info (or
-        # more likely, after it posts the data get_terminal_info is asking
-        # for), the user is going to be somewhat confused by an error message
-        # blaming HIS action, not the get_terminal_info action.
-        # However, also need to be sure that when the user hits get_terminal_info,
-        # he'll be sent back to the current action.
-        #redirect_to :action => 'get_terminal_info'
-
-        render :action => 'get_terminal_info'
-        headers_filter
-        return false
-      end
-      
-    # If we get an ActiveRecord error, it's probably because RTML state has not been initialized.
-    # Fail silently. Then, if the user tries to access state, they'll get the "rake first"
-    # error via the #rtml_state method (above).
-    rescue ActiveRecord::StatementInvalid
-      true
-    end
-    
-    # Saves the terminal's (or browser's) state hash to the database.
-    # TODO: Use Rails.cache for the state (as opposed to the database) whenever possible.
-    def save_state
-      if @terminal_state
-        begin
-          @terminal_state.save
-        rescue #save_state
-          logger.error $!
-          logger.error $!.backtrace.join("\n\t")
-        end
-      end
-      true
-    end
-  end
-end