rtml 1.2.2 → 2.0.0.alpha.1

data/lib/rtml/configuration.rb

@@ -0,0 +1,40 @@
+module Rtml
+  class Configuration
+    attr_accessor :widget_paths
+    attr_accessor :rtml_helper_paths
+    attr_accessor :widget_logging_enabled
+    attr_accessor :log_tml
+
+    def initialize
+      self.widget_paths = default_widget_paths
+      self.rtml_helper_paths = default_rtml_helper_paths
+      self.widget_logging_enabled = default_widget_logging_enabled
+      self.log_tml = default_log_tml
+    end
+
+    # does some basic manipulation to options in order to guesstimate the correct values for erroneous configurations
+    def validate!
+      widget_paths.flatten!
+      widget_paths.uniq!
+      rtml_helper_paths.flatten!
+      rtml_helper_paths.uniq!
+    end
+
+    private
+    def default_log_tml
+      false
+    end
+
+    def default_widget_paths
+      ['lib/rtml/widgets', File.join(Rtml.root, 'builtin/widgets')]
+    end
+
+    def default_rtml_helper_paths
+      ['app/rtml_helpers']
+    end
+
+    def default_widget_logging_enabled
+      false
+    end
+  end
+end

data/lib/rtml/controller/before_filters.rb

@@ -0,0 +1,51 @@
+module Rtml::Controller::BeforeFilters
+  protected
+  def rtml_format
+    def request.is_terminal?
+      self.user_agent and (self.user_agent['OE MicroBrowser'] || self.user_agent['IO Browser'])
+    end
+    def request.terminal?; is_terminal?; end
+
+    def request.rtml?
+      format == :rtml || params[:format] == 'rtml'
+    end
+
+    def response.rtml?
+      request.is_terminal? || request.format == :rtml || template.template_format == :rtml
+    end
+
+    params[:format] = 'rtml' if params[:format] == 'tml'
+    return if params[:format]
+
+    if request.format == :tml || request.is_terminal?
+      request.format = :rtml
+    end
+  end
+
+  def set_rtml_etag
+    # TODO: The lines below were in RTML 1.x; see if they are necessary now that caching has been addressed.
+    headers['Cache-Control'] = 'no-cache '
+    headers['ETag'] = "W/\"329-#{Time.now.to_i}#{rand(9999)}\" "
+  end
+
+  def set_rtml_headers
+    if request.format == 'rtml'
+      headers['content-type'] = (request.is_terminal? ? 'text/tml' : 'text/xml')
+      headers['Expires'] =
+              if expires_at then expires_at.call(self)
+              else Time.at(0) # always expired
+              end.strftime("%a, %d %b %Y %H:%M:%S GMT")
+    end
+  end
+
+  public
+  class << self
+    def included(base)
+      base.instance_eval do
+        skip_before_filter :verify_authenticity_token
+        before_filter :rtml_format
+        before_filter :set_rtml_etag
+      end
+    end
+  end
+end

data/lib/rtml/controller/cache_helpers.rb

@@ -0,0 +1,26 @@
+module Rtml::Controller::CacheHelpers
+  def expires_at(val = nil, &block)
+    if val
+      @expires_at = proc { val }
+    else
+      @expires_at = block if block_given?
+    end
+
+    if @expires_at
+      @expires_at
+    else
+      if self.class.respond_to?(:expires_at)
+        self.class.expires_at
+      else
+        nil
+      end
+    end
+  end
+
+  def self.included(base)
+    base.send(:extend, self)
+    base.instance_eval do
+      hide_action :expires_at
+    end
+  end
+end

data/lib/rtml/controller/class_methods/rtml_action_helpers.rb

@@ -0,0 +1,18 @@
+# Extended by RtmlController, this module provides class methods to assist adding new RTML actions to the controller.
+module Rtml::Controller::ClassMethods::RtmlActionHelpers
+  def add_rtml_proxy_action(method_name)
+    if defined?(Rails) && Rails.logger
+      Rails.logger.debug "Adding RTML proxy action #{method_name.inspect} to #{name}"
+    end
+
+    define_method method_name do
+      render :rtml => method_name unless default_template_exists?
+    end
+
+    recalculate_action_methods!
+  end
+
+  def recalculate_action_methods!
+    @action_methods = nil
+  end
+end

data/lib/rtml/controller/document_generator.rb

@@ -0,0 +1,60 @@
+# This is what every "RTML Helper" ends up instantiating -- eventually.
+#
+# The process of loading an RTML helper actually begins in +Rtml::Controller::RtmlHelpers+, which loads the relevant
+# helpers after being included into a descendant of +ActionController::Base+. After finding the helpers and loading
+# them, the helpers themselves invoke +Rtml::actions_for+, which analyzes the methods they define and adds them to
+# an instance of Rtml::Controller::DocumentGenerator. It is at this time that default actions are created in the
+# controller, where they haven't already been defined, which proxy the actions into a call to
+#
+#    "render :rtml_helpers => {method_name}"
+#
+# - where {method_name} is the name of a given RTML Helper method (also called an RTML Action).
+#
+module Rtml::Controller::DocumentGenerator
+  def generate_rtml_helpers(base)
+    base.instance_eval do
+      def hidden_action?(*names)
+        !names.select { |name| hidden_actions.include?(name) }.empty?
+      end
+
+      def hidden_actions
+        @hidden_actions ||= []
+      end
+
+      def hide_action(*names)
+        hidden_actions.concat names.flatten
+      end
+    end
+
+    base.class_eval do
+      attr_reader :controller
+      delegate :rtml_document, :params, :url_for, :expires_at, :to => :controller
+      delegate :rtml_actions, :to => 'self.class'
+
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def respond_to?(name, *args, &block)
+        return super || rtml_document.respond_to?(name, *args, &block)
+      end
+
+      def method_missing(name, *args, &block)
+        rtml_document.send(name, *args, &block)
+      rescue
+        raise $!, $!.message, caller
+      end
+
+      def copy_ivars_from(source)
+        ivars = source.instance_variables
+        ivars -= source.protected_instance_variables if source.respond_to?(:protected_instance_variables)
+        ivars.each { |ivar| instance_variable_set(ivar, source.instance_variable_get(ivar)) }
+        rtml_document.copy_ivars_from(self)
+      end
+
+      hide_action :initialize, :method_missing, :respond_to?, :copy_ivars_from
+    end
+    
+    base
+  end
+end

data/lib/rtml/controller/render_helpers.rb

@@ -0,0 +1,29 @@
+module Rtml::Controller::RenderHelpers
+  def render_with_rtml_option(options = nil, extra_options = {}, &block)
+    if (h = options).is_a?(Hash) || (h = extra_options).is_a?(Hash)
+      h = extra_options if !h.key?(:rtml) && extra_options.is_a?(Hash)
+      if rtml_action = h.delete(:rtml)
+        if rtml_helpers.respond_to?(rtml_action)
+          request.format = :rtml
+          rtml_helpers.send(rtml_action)
+          set_rtml_headers
+          response.template.template_format = :rtml
+          tml = rtml_document.to_tml
+          if Rtml.configuration.log_tml
+            Rails.logger.debug tml
+          end
+          return render_without_rtml_option(h.merge(:text => tml))
+        else
+          raise Rtml::Errors::UnknownRtmlAction,
+                "No RTML action responded to #{rtml_action}. RTML actions: #{rtml_actions.sort.to_sentence(:locale => :en)}",
+                caller
+        end
+      end
+    end
+    render_without_rtml_option(options, extra_options, &block)
+  end
+
+  def self.included(base)
+    base.send(:alias_method_chain, :render, :rtml_option)
+  end
+end

data/lib/rtml/controller/rtml_helpers.rb

@@ -0,0 +1,37 @@
+module Rtml::Controller::RtmlHelpers
+  def self.included(base)
+    base.instance_eval do
+      extend Rtml::Controller::DocumentGenerator
+
+      hide_action :load_rtml_helpers!, :render_with_rtml_option, :rtml_helpers, :rtml_actions, :rtml_actions=
+      before_filter :load_rtml_helpers!
+      class_inheritable_array :rtml_actions
+      read_inheritable_attribute(:rtml_actions) || write_inheritable_attribute(:rtml_actions, [])
+
+      def rtml_helpers
+        return @rtml_helpers if @rtml_helpers
+
+        if superclass.respond_to?(:rtml_helpers)
+          @rtml_helpers = generate_rtml_helpers(Class.new(superclass.rtml_helpers))
+        else
+          @rtml_helpers = generate_rtml_helpers(Class.new)
+        end
+      end
+    end
+  end
+
+  # This is where the instance of +Rtml::Controller::DocumentGenerator+ is finally instantiated. See
+  # that class for more information.
+  def rtml_helpers
+    @rtml_helpers ||= self.class.rtml_helpers.new(self)
+  end
+
+  # This method kicks off the sequence that culminates with the instantiation of a
+  # +Rtml::Controller::DocumentGenerator+ object. See documentation for that class for more information.
+  def load_rtml_helpers!
+    Rtml.configuration.rtml_helper_paths.each do |path|
+      path = File.join(Rails.root, path) unless File.exist?(path)
+      Dir[File.join(path, "**/*.rb")].each { |fi| require_dependency fi if File.file?(fi) }
+    end
+  end
+end

data/lib/rtml/controller/state.rb

@@ -0,0 +1,73 @@
+module Rtml::Controller::State
+  def find_or_build_state
+    if params[:terminal] && params[:terminal][:itid]
+      itid = params[:terminal][:itid]
+    elsif request.terminal?
+      itid = headers['ITID'] || headers['HTTP_ITID'] || params['itid']
+    else
+      itid = headers['ITID'] || headers['HTTP_ITID'] || params['itid'] || 'web-browser'
+    end
+    
+    @terminal_state = Rtml::State.find_by_itid(itid) || Rtml::State.new(:itid => itid,
+                                                                        :model => params[:model])
+
+    set_state_values
+    verify_state unless request.post? || params.key?(:ignore_state) || !request.rtml?
+  end
+
+  def set_state_values
+    state_variable_mapping.each do |tmlvar, state_attribute|
+      if params[:terminal] && params[:terminal][state_attribute]
+        value = params[:terminal][state_attribute]
+      else
+        code = "params['#{tmlvar.to_s.gsub(/\./, '\'][\'')}']"
+        begin
+          value = eval(code, binding, __FILE__, __LINE__)
+        rescue NoMethodError
+          value = nil
+        end
+      end
+      state[state_attribute] = value
+    end
+  end
+
+  def verify_state
+    if @terminal_state.new_record?
+      Rails.logger.debug "Terminal state for ITID #{@terminal_state[:itid]} needs to be created"
+      render :rtml => 'get_state'
+    elsif @terminal_state.updated_at < 1.day.ago
+      Rails.logger.debug "Terminal state for ITID #{@terminal_state[:itid]} needs to be updated"
+      render :rtml => 'get_state'
+    end
+  end
+
+  def state
+    @terminal_state
+  end
+
+  def save_state
+    if @terminal_state.changed?
+      @terminal_state.save # can fail silently
+    end
+    true
+  end
+
+  def state_variable_mapping
+    self.class.state_variable_mapping
+  end
+
+  class << self
+    def included(base)
+      base.instance_eval do
+        hide_action :find_or_build_state, :set_state_values, :verify_state, :save_state, :state, :state_variable_mapping
+        before_filter :find_or_build_state
+        after_filter :save_state
+        helper_method :state
+
+        def state_variable_mapping
+          @state_variable_mapping ||= Rtml::State::VariableMapping.new
+        end
+      end
+    end
+  end
+end

data/lib/rtml/controller/template_helpers.rb

@@ -0,0 +1,21 @@
+module Rtml::Controller::TemplateHelpers
+  def default_template_exists?
+    template_exists?(default_template_name)
+  end
+
+  unless ActionController::Base.private_instance_methods.include? 'template_exists?'
+    def template_exists?(template_name, fmt = response.template.template_format)
+      self.view_paths.find_template(template_name, fmt)
+    rescue ActionView::MissingTemplate, Errno::ENOENT
+      false
+    end
+  end
+
+  class << self
+    def included(base)
+      base.instance_eval do
+        hide_action :default_template_exists?, :template_exists?
+      end
+    end
+  end
+end

data/lib/rtml/controller/url_helpers.rb

@@ -0,0 +1,9 @@
+module Rtml::Controller::UrlHelpers
+  def url_for(options = {})
+    options ||= {}
+    if options.kind_of?(Hash)
+      options.reverse_merge! :only_path => true
+    end
+    super(options)
+  end
+end

data/lib/rtml/dependencies.rb

@@ -0,0 +1,27 @@
+unless defined?(Gem) && defined?(ActiveSupport::Dependencies) && defined?(ActionController::Base)
+  require 'rubygems'
+  gem 'hpricot', ">= 0.8.2"
+  gem 'sc-core-ext', ">= 1.1.1"
+  gem 'activesupport', '>= 2.3.5'
+  gem 'actionpack', '>= 2.3.5'
+  gem 'activerecord', '>= 2.3.5'
+
+  require 'active_support'
+  require 'action_controller'
+  require 'action_view'
+  require 'active_record'
+  require 'active_resource'
+end
+
+require 'hpricot'
+require 'sc-core-ext'
+
+path = File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+%w(lib
+   builtin/controllers
+   builtin/models
+   builtin/views).each do |p|
+  $LOAD_PATH << File.join(path, p)
+  ActiveSupport::Dependencies.load_paths << File.join(path, p)
+  ActiveSupport::Dependencies.load_once_paths << File.join(path, p)
+end

data/lib/rtml/dsl.rb

@@ -0,0 +1,81 @@
+module Rtml::DSL
+  # Processes the given block using the RTML DSL
+  # Examples:
+  #  tml_docs = Rtml::Document.new
+  #  tml_docs.process_block do
+  #    # scope is transferred to the element
+  #    screen :init, :next => :idle do
+  #      display
+  #    end
+  #  end
+  #
+  #  tml_docs.process_block do |document|
+  #    # scope is maintained and element is referenced explicitly
+  #    document.screen :init, :next => :idle do |scr|
+  #      scr.display
+  #    end
+  #
+  #    # note that these approaches are interchangeable:
+  #    document.screen :idle do
+  #      display
+  #    end
+  #  end
+  #
+  def process(&block)
+    # arity == -1 is bug 574 in Ruby 1.8 -- should be 0. It's of no consequence in this case.
+    if block.arity == 0 || block.arity == -1 then self.instance_eval &block
+    else block.call(self)
+    end
+  end
+
+  # Constructs and returns a new instance of Rtml::Dom::Element. If Rtml::Dom::[name]Element exists, that is built
+  # instead. The model is added to the "elements" array (if available), but not saved.
+  def build_element(name, properties = {})
+    document = self.respond_to?(:document) ? self.document :
+            (self.respond_to?(:parent) && parent ? parent.document : self)
+    type = begin
+      ("Rtml::Dom::#{name.to_s.camelize}Element".constantize)
+    rescue NameError
+      Rtml::Dom::Element
+    end
+    if new_record? || changed?
+      element = type.new(:name => name, :document => document)
+      if respond_to?(:elements)
+        elements << element
+      elsif respond_to?(:root)
+        root = element
+      end
+#      element = elements.build(:name => name, :document => document, :type => type.to_s)
+#      element.document = document if element.respond_to?(:document)
+      element.parent = self if element.respond_to?(:parent)
+    else
+      element = type.create!(:name => name, :document => document)
+      if respond_to?(:elements)
+        elements << element
+      elsif respond_to?(:root)
+        self.root = element
+      end
+      #element = elements.create!(:name => name, :document => document, :type => type.to_s)
+    end
+    #element = type.new(:name => name, :document => document)
+    #self.elements << element if respond_to?(:elements)
+#    element = if respond_to?(:elements) && elements.respond_to?(:build)
+#      el = self.elements.build(:name => name, :document => document)
+#      el.type = type.to_s
+#      el
+#    else
+#      element = type.new(:name => name, :document => document)
+#      self.elements << element if respond_to?(:elements)
+#      element
+#    end
+    properties.each { |key, value| element.property key, value }
+    if respond_to?(:root) && !self.root
+      self.root = element
+    end
+    element
+  end
+
+  # backward compatibility to RTML 1
+  alias process_block process
+  deprecate :process_block
+end