rtml 1.2.2

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

@@ -0,0 +1,79 @@
+module Rtml::Core::TMLDocument::ScreenMethods
+  # Declares a new screen to be embedded within this document. The screen ID must
+  # be supplied, as well as a block to configure its contents.
+  # *other takes the place of options when the :next key is omitted. Example:
+  #
+  #   screen :first, :second, :timeout => 2
+  #
+  # is equivalent to:
+  #
+  #   screen :first, :next => :second, :timeout => 2
+  #
+  def screen(id, options = {}, *other, &blk)
+    scr = nil
+    index = -1
+    
+    @screens.each_with_index { |s,i| index = i if s.id.to_s == id.to_s } if @screens
+    
+    if index == -1 or block_given? then scr = Rtml::Core::Screen.new(action_view, id, self, &blk)
+    else scr = @screens[index]
+    end
+  
+    scr.layout self.layout unless self.layout.nil? or not scr.layout.nil?
+    
+    if options.kind_of? String or options.kind_of? Symbol
+      options = other.extract_options!.merge(:next_screen => options)
+    end
+
+    if options.kind_of? Hash then options.each { |n,v| scr.send(n, v) }
+    else raise ArgumentError.new("Invalid type for options in screen #{id}: Expected String, Symbol or Hash")
+    end
+  
+    if index == -1 then @screens << scr if @screens
+    else
+      scr.next_screen(@screens[index].next_screen) unless scr.next_screen
+      @screens[index] = scr
+    end
+    scr
+  end
+  
+  # Returns the screen with the specified ID, or nil if it cannot be found.
+  def find(id)
+    screens.find(id)
+  end
+  
+  # Deletes and returns the screen with the specified ID from the list of screens.
+  # Alternatively, an actual Screen object may be supplied.
+  def remove_screen(id)
+    ret = nil
+    if id.kind_of? Rtml::Core::Screen
+      screens.delete((ret = id))
+    else
+      screens.delete((ret = screens.find(id)))
+    end
+    ret
+  end
+  
+  alias delete_screen remove_screen
+  
+  # Declares multiple screens to be embedded within this document. Takes an
+  # array of screen IDs, or an array of Hashes, in which case the keys are screen IDs
+  # and the values are either the "next" screen, or a set of options to be passed directly
+  # to that Screen's initializer. Also expects a block, which has an optional parameter
+  # (the screen itself). If the optional parameter is omitted, the screen's context is
+  # transferred to the supplied block.
+  #
+  # Alternatively, if no parameters are supplied, and a block is given, then a
+  # ScreenBuilderWidget will be constructed and the block will be passed to it.
+  def screens(list_of_screens = nil, &block)
+    return Rtml::Widgets::ScreenBuilderWidget.new(self, &block) if list_of_screens.nil? and block_given?
+    return @screens if list_of_screens.nil?
+    list_of_screens.each do |scrid|
+      id, options = ((scrid.is_a? Array) ? [scrid[0],scrid[1]] : [scrid,{}])
+      options = { :next => options } unless options.kind_of? Hash
+      if block.arity <= 0 then screen id, options do yield end 
+      else screen id, options do |scr| yield scr end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Rtml::Core::TMLDocument::VariableMethods
+  def self.included(base) #:nodoc:
+    base.send :attr_reader, :variables
+    base.send :attr_reader, :vardecs
+  end
+  
+  # Returns an array of strings, containing the name of each variable used in this document
+  def variables_used
+    used = []
+    screens.each do |scr|
+      used.concat scr.variables_used
+#      variables.select { |var| not used.include? var }.each do |var|
+#        used << var if scr.uses_variable? var
+#      end
+    end
+    used
+  end
+  
+  def self.variable_declarators(type, *method_names) #:nodoc:
+    method_names.each do |method_name|
+      module_eval <<-end_code
+        def #{method_name}(*var_names)
+          options = var_names.extract_options!
+          # If hash notation was used (:transid => -1, :currency_code => 'USD'),
+          # then extract_options! may have mistakenly placed it within the variable options.
+          # We need to manually put them back into the var_names array if that's the case.
+          var_names.concat((options.keys - Rtml::Core::Variable::VALID_OPTIONS).collect do |a|
+            { a => options.delete(a) }
+          end)
+          for var_name in var_names
+            if var_name.kind_of? Hash
+              var_hash = var_name
+              var_hash.each do |var_name,value|
+                var_options = (value.kind_of?(Hash) ? value : { :value => value })
+                variable variable_options(var_name, var_options).merge(:type => #{type.inspect})
+              end
+            elsif var_name.kind_of? Array
+              #{method_name} *var_name
+            else
+              variable variable_options(var_name, options).merge(:type => #{type.inspect})
+            end
+          end
+        end
+      end_code
+    end
+  end
+
+  # Declares a new variable to be used with this TML document.
+  def declare_variable(var)
+    register_variable var
+    @vardecs << var unless @vardecs.include? var
+  end
+  
+  # Registers a variable for use with this document, even if it has not been declared.
+  # This is important for built-in TML variables.
+  def register_variable(var)
+    @variables << var unless @variables.include? var
+  end
+  
+  variable_declarators :integer, :integer, :integers
+  variable_declarators :string,  :string,  :strings
+  variable_declarators :opaque,  :opaque,  :opaques
+  variable_declarators :date,    :date,    :dates
+  
+  def variable_options(name, options = {}) #:nodoc:
+    options.merge(
+      case name
+        when Hash then { :name => name.keys[0], :value => name.values[0] }
+        else { :name => name }
+      end
+    )
+  end
+
+  # Declares an arbitrary variable to be used in this terminal application. Note that you must
+  # supply the :type option, which is one of :integer, :string, :opaque or :date. See the
+  # Rtml::Helpers::Variable class for more information on other options. Calls declare_variable.
+  def variable(options)
+    #options[:name] = qualified_variable_name options[:name]
+    var = Rtml::Core::Variable.new(action_view, options, self)
+    declare_variable var if self.respond_to? :declare_variable
+    var
+  end
+end

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

@@ -0,0 +1,123 @@
+module Rtml
+  module Core
+    #Defines a TML variable declaration (vardcl).
+    #User should not have to instantiate this object directly.
+    #See TMLDocument for details.
+    class Variable < Element
+      include Rtml::Common::Renderable
+      VALID_OPTIONS = [ :name, :type, :volatile, :value, :format, :perms ]
+
+      #Construct a new Variable using the specified ActionView and options hash.
+      #options[:type] defaults to :string if not found, and must be one of
+      #  [:string, :integer, :date, :opaque]
+      #Other options include :name, :volatile, :value, :format, and :perms, and
+      #correlate to the TML definitions for these parameters.
+      def initialize(view = nil, options = { }, parent = nil)
+        raise "Must specify variable name" if options[:name].nil?
+        unless (o = (options.keys - VALID_OPTIONS)).empty?
+          raise "Invalid options specified for variable #{options[:name]}: #{o.join("; ")}"
+        end
+        options[:name] = options[:name].to_s if options[:name].kind_of? Symbol
+        options[:type] ||= :string
+        if options[:volatile].nil? or (options[:volatile] and options[:volatile].downcase != 'no')
+          options[:volatile] = 'yes'
+        else
+          options[:volatile] = 'no'
+        end
+
+        raise "Variable type must be one of :string, :integer, :date, :opaque" unless [:string,:integer,:date,:opaque].include? options[:type]
+        super view, options, VALID_OPTIONS, parent
+      end
+      
+      VALID_OPTIONS.each do |method|
+        define_method method do
+          properties[method]
+        end
+        define_method "#{method}=" do |a|
+          properties[method] = a
+        end
+      end
+      
+      # Constructs the TML declaration for this variable.
+      def to_tml; declaration; end
+      # Constructs the TML declaration for this variable.
+      def declaration; "<vardcl " + properties.to_s + " />"; end
+        
+      # Constructs a TML getvar directive
+      def getvar(fmt = nil)
+        r = "<getvar name='#{name}' "
+        r.concat "format='#{fmt}'" if fmt
+        r.concat "/>"
+      end
+
+      # Constructs a TML variable assignment with the specified value.
+      # Examples:
+      #  setvar [ "tmlvar:i", "+", "1" ]
+      #  setvar "tmlvar:i"
+      #  setvar :true
+      #  setvar "tmlvar:i + 1"
+      #  setvar :to => [ "tmlvar:i", "+", "1" ]
+      #  setvar :to => "tmlvar:i + 1"
+      #  setvar :to => true
+      #  setvar :value => [ "tmlvar:i", "+", "1" ]
+      #  setvar :value => "tmlvar:i + 1"
+      #  setvar :value => "tmlvar:i"
+      def setvar(a, options = {})
+        valid_operators = [ '+', '-', 'plus', 'minus', 'item']
+        tml = "<setvar name='#{name}' "
+        lo = ''
+        ro = op = nil
+        case a.class.to_s
+          when 'Array'
+            raise "Variable#setvar(Array) should be given exactly 3 elements in [lo,op,ro] order." unless a.length == 3
+            (lo, op, ro) = a
+          when 'Hash'
+            a.merge! options
+            los = ros = ops = nil
+            lo = (a[:to] or a[:value])
+            return setvar(lo, a.merge(:to => nil, :value => nil)) if lo
+            a.keys.each { |key| (los = key) and break if [ :lo, :left, :left_operand, :left_op, :lop, :lft ].include? key }
+            a.keys.each { |key| (ros = key) and break if [ :ro, :right,:right_operand,:right_op,:rop, :rgt ].include? key }
+            a.keys.each { |key| (ops = key) and break if [ :op, :operation, :operator, :oper ].include? key }
+            raise "Variable#setvar(Hash) must include a :left_operand (:lo, :left, :left_opeand, :left_op, :lop, :rgt)" unless los
+            lo = a[los]
+            ro = a[ros]
+            op = a[ops]
+            options[:format] = (a[:format] or a[:fmt]) unless options[:format]
+          when 'String', 'Fixnum', 'Symbol'
+            ary = a.to_s.split(/[\s\n\t]+/m)
+#            ary = %W(#{a})
+            return setvar(ary) if ary.length == 3 and valid_operators.include? ary[1]
+            lo = a.to_s
+          else
+            raise "Variable#setvar(#{a.class}): Could not determine how to handle value of type #{a.class}"
+        end
+#        if not (op and ro) and (op or ro)
+#          raise "Variable#setvar: If either :op or :ro is specified, the other must also be supplied."
+#        end
+
+        case op.to_s
+          when '+','plus' then op = 'plus'
+          when '-','minus' then op = 'minus'
+#          else raise "Variable#setvar: Invalid operation '#{op}'. Specify plus or minus; shorthand '+' and '-' are allowed"
+        end unless op.nil?
+        
+        case lo.to_s
+          when 'true' then lo = 'yes'
+          when 'false' then lo = 'no'
+        end
+        
+        case ro.to_s
+          when 'true' then ro = 'yes'
+          when 'false' then ro = 'no'
+        end
+        
+        tml.concat "lo=#{lo.to_s.inspect} "
+        tml.concat "op=#{op.to_s.inspect} " if op
+        tml.concat "ro=#{ro.to_s.inspect} " if ro
+        tml.concat "format=#{options[:format].to_s.inspect}" if options[:format]
+        tml.concat "/>"
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/debug/browser_emulator.rb

@@ -0,0 +1,59 @@
+module Rtml
+  module Debug
+    # BrowserEmulator is a glorified Hash that stores faked request headers, similar
+    # in structure to the object returned by ActionController::Base#headers. The reason
+    # for this is so that a standard browser (Internet Explorer, Firefox, etc.) can be
+    # made to look like OpenEstate/Incendo terminal browsers which download TML. This
+    # creates a "state" object so that your RTML doesn't croak when it is referenced
+    # from within your browser.
+    #
+    # The reason this is useful is because it is often much easier to debug TML when you
+    # can simply view its XML structure in your browser -- and, of course, it makes
+    # Rails' error reporting much easier to follow, too.
+    class BrowserEmulator < HashWithIndifferentAccess
+      # Initialize this emulator from the actual headers sent by the browser.
+      def initialize(headers)
+        @defaults = { :debugger => true,
+                     :datetime_start => Date.parse('2006/01/01'),
+                     :os => '03.27',
+                     :itid => '111111111',
+                     :itsn => headers['HTTP_USER_AGENT'],
+                     :itpn => 'I8550_BROWSER',
+                     :model => 8550,
+                     :datetime => Time.now,
+                     :part_number => 'I8550_BROWSER' }
+        
+        headers = headers.dup
+        # As of Rails 2.3.2 ActionController::Request inherits from Rack::Request, so all of the
+        # Rack stuff has to be removed by hand.
+        %W(action_controller. rack. HTTP_ REQUEST_ SERVER_
+           SCRIPT_ PATH_ REMOTE_ QUERY_ GATEWAY_).each do |i|
+          headers.keys.select { |j| j =~ /^#{Regexp.escape i}/ }.each { |key| headers.delete key }
+        end
+        super(headers)
+        self.defaults = @defaults
+        #@defaults.keys.each { |key| self[key.to_s.upcase] ||= self[key] }
+      end
+      
+      def [](a) #:nodoc:
+        return super(a.to_s.downcase) if a.kind_of? String or a.kind_of? Symbol
+        super
+      end
+      
+      def []=(a, b) #:nodoc:
+        return super(a.to_s.downcase, b) if a.kind_of? String or a.kind_of? Symbol
+        super
+      end
+      
+      # Assigns default values to this object. If a value already exists for a given key,
+      # and it is not an empty string, then that key is ignored.
+      def defaults=(hash)
+        hash.each do |key,val|
+          # this includes empty strings, in the case of incomplete query strings
+          self[key] = val if self[key].blank?
+        end
+        self
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/debug/rtml_controller_test_case.rb

@@ -0,0 +1,7 @@
+class Rtml::Debug::RtmlControllerTestCase < ActionController::TestCase
+  include Rtml::Helpers::TestHelpers
+  
+  def document
+    (@controller ? @controller.rtml_document : nil)
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/debug/rtml_core_unit_test.rb

@@ -0,0 +1,11 @@
+class Rtml::Debug::RtmlCoreUnitTest < Rtml::Debug::RtmlControllerTestCase
+  def setup
+    @controller = Rtml::RtmlAppController.new
+    get :get_terminal_info, :format => :rtml
+    document.reset!
+  end
+
+  def teardown
+    assert_valid_tml(document.to_tml) if document
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/debug/unit_test.rb

@@ -0,0 +1,3 @@
+class Rtml::Debug::UnitTest < ActiveSupport::TestCase
+  include Rtml::Helpers::TestHelpers
+end

data/app_generators/rtml/templates/rtml/lib/rtml/delegation.rb

@@ -0,0 +1,8 @@
+module Rtml::Delegation
+  # controller methods
+  delegate :feature_config, :request, :response, :params, :state, :logger, :menu_item, :render, :to => :controller
+  
+  # view methods
+  delegate :link_to, :link_to_if, :link_to_unless, :link_to_unless_current, :mail_to,
+           :url_for, :h, :to => :action_view
+end

data/app_generators/rtml/templates/rtml/lib/rtml/doc.rb

@@ -0,0 +1,12 @@
+module Rtml
+  # Helper module defining some constants to help with documentation generation
+  # when the user runs rake doc:plugins:rtml.
+  module Doc
+    AccessorList = [ :property, :accessor, :accessor_alias ]
+    AccessorText = {
+      :property => 'property',
+      :accessor => 'accessors',
+      :accessor_alias => 'access name'
+    }
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/element.rb

@@ -0,0 +1,75 @@
+module Rtml
+  # The lowest level of RTML. \Element is extended by most base objects, such as
+  # TMLDocument, Screen and Display, but is not used or extended by Widgets.
+  # The \Element class is essentially an object representation of a generic
+  # \TML \element. It includes properties like id and class.
+  class Element
+    include Rtml::Delegation
+    include Rtml::Common::Renderable
+    include Rtml::Helpers::ViewHelpers::FormHelpers
+    include Rtml::Helpers::CoreHelpers::WidgetSupport
+    include Rtml::Helpers::CoreHelpers::YieldHelpers
+    include Rtml::Helpers::CoreHelpers::EventHelpers
+    include Rtml::Helpers::CoreHelpers::ActionViewWrapper
+    include Rtml::Helpers::TerminalHelpers
+
+    attr_reader :event_handler
+    # A Hash containing the properties for this Element.
+    attr_reader :properties
+    # A unique numeric ID for this element
+    attr_reader :element_id
+    
+    # A reference to this element's parent element, or nil if there is none.
+    attr_reader :parent
+    
+    @@id_tracker = 0
+    
+    def initialize(view = nil, props = { }, valids = nil, parent = nil)
+      @element_id = (@@id_tracker += 1)
+      props ||= {}
+      @event_handler = Events::EventHandler.new
+      check_valid_properties props, valids unless valids.class != Array or props.class != Hash
+      @parent = parent
+      @root_element = parent.root_element if parent.respond_to? :root_element
+      if root_element.class.name != 'Rtml::Core::TMLDocument'
+        raise "Assertion error: Expected root_element of #{self.class} to be TMLDocument (found #{root_element.class})"
+      end
+      document.modify! if document
+      @properties = HashWithIndifferentAccess.new
+      @properties.merge! props if props.class == Hash
+      protect_all_instance_variables!
+      wrap_view(view)
+    end
+
+    def protect_all_instance_variables!
+      instance_variables.each { |v| protected_instance_variables << v unless protected_instance_variables.include? v }
+    end
+
+    def protected_instance_variables
+      @protected_instance_variables ||= ["@protected_instance_variables"]
+    end
+    
+    def inspect
+      x = "#<#{self.class.name} "
+      x.concat "#{@properties.to_s} " unless @properties.empty?
+      x.concat "widgets=#{widgets.inspect}" if self.respond_to? :widgets
+      x.concat ">"
+    end
+    
+    # Returns the value of the requested property for this element.
+    def [](a); @properties[a]; end
+      
+    # Sets the value of the specified property for this element.
+    def []=(a,b); @properties[a] = b; end
+      
+    def root_element; @root_element || self; end
+
+    private
+    def check_valid_properties(properties, valids)
+      properties.each do |n,v|
+        raise "Invalid property: #{n}" unless valids.include? n
+      end
+      true
+    end
+  end
+end