rtml 1.2.2 → 2.0.0.alpha.1

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

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

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

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

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

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

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

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

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

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

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

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