rtml 1.2.2

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/core_helpers/widget_support.rb

@@ -0,0 +1,181 @@
+module Rtml::Helpers::CoreHelpers
+  # Adds support to this class for Widgets to be added. Note that this does not
+  # immediately mean that the Widget can be added to the class -- only that the
+  # Widget can now specify this module as a legal accessor. See Rtml::Widgets::Widget
+  # for more details.
+  module WidgetSupport
+    include Rtml::TextUtils
+   
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods
+    end
+    
+    # Returns the controller that is constructing the current document. Equivalent to
+    # <code>action_view.controller</code>.
+    def controller
+      action_view ? action_view.controller : nil
+    end
+    
+    # The content_of_view method can be called in a variety of ways, and provides a great
+    # deal of functionality depending on how it is called. In all cases,
+    # it returns a String:
+    #
+    # 1. You can pass a hash to it, and the hash will be proxied into either
+    # ActionController::Base#render or ActionView::Base#render, depending
+    # on whether you are calling it from a View or a TML Helper. The result
+    # of this render method is returned.
+    #
+    #   content_of_view :partial => 'menu'
+    #   content_of_view :file => 'common/raw_tml/something_important.tml'
+    #
+    #   content_of_view :action => 'index' # though this case probably wouldn't happen often.
+    #
+    # 2. You can pass a String to it, and that String will be returned.
+    #
+    #   content_of_view "Hello, world!"
+    #
+    # 3. You can pass a Block to it, and the result value of that Block will
+    # be returned.
+    #
+    #   content_of_view do
+    #     if current_user then "Hello, #{current_user.name}"
+    #     else "You must log in."
+    #     end
+    #   end
+    #
+    # 4. You can pass it any RTML object that responds_to? :render_tml (which should
+    # be most objects -- Screens, TMLDocument itself, and Widgets), and the result
+    # of calling #render_tml on that object will be returned.
+    #
+    #    content_of_view self.document # This would render a snapshot of the entire TML document
+    #                                  # into the return value.
+    # 
+    # 5. You can pass it nil, or no arguments at all, and content_of_view will look for a View
+    # file with the same name as the current screen ID.
+    #
+    #    screen :index do
+    #      concat content_of_view      # looks for index.rtml.erb and concatenates that to
+    #    end                           # the :index TML screen that is currently being generated.
+    #
+    # Note that a great number of RTML methods forward their arguments into this method,
+    # so the above is applicable to most of them.
+    #
+    def content_of_view(content = nil, &blk)
+      content = yield if content.nil? and block_given?
+      if content.nil?
+        return action_view_render(:file => "#{current_screen_id}.rtml.erb")
+      else
+        if content.kind_of? Hash
+          if content.keys.length == 1 && content.keys[0].to_s == 'locals'
+            action_view_render :file => "#{current_screen_id}.rtml.erb", :locals => content.values[0]
+          else
+            action_view_render content
+          end
+        elsif content.respond_to? :render_tml
+          return content.render_tml
+        else
+          return content.to_s
+        end
+      end
+    end
+    
+    @@widget_action_view_render_buffer = {}
+
+    # Sets up the locals hash and some instance variables within the ActionView,
+    # and then calls ActionView#render on the supplied Hash.
+    def action_view_render(hash = {})
+      # 110509: I'm buffering the results of action_view#render within this hash
+      # so that #render doesn't have to be called again in the future, ie for tests
+      # that run after all of the view paths have been unloaded due to firing
+      # controller#after_filter's.
+      #
+      # TODO: See how this affects production mode. Is this hash ever released between
+      # requests??
+      @@widget_action_view_render_buffer[self] ||= (
+        # HACK HACK HACK, FIXME:
+        # Apparently, the commented line below is the cause of some huge delays
+        # seemingly due to recursion. These delays show up only when an error is
+        # encountered, which makes the issue even harder to understand.
+        # 
+        # I'm not sure, but I think that the reference that RTML elements maintain
+        # to action_view is causing recursion issues when errors are raised. Perhaps
+        # ActiveSupport is calling #inspect, which would kick off a huge set of
+        # recursive calls to convert both elements to Strings all the way up the
+        # element chain. This would also explain why the delay seems to last much
+        # longer as elements are nested within each other.
+        #
+        # The solution seems to be to replace @current with the method definition
+        # below, because method definitions aren't included in #inspect.
+        #
+        # action_view.instance_variable_set("@current", self)
+        #
+        $current_rtml_element = self
+        def action_view.current_rtml_element() $current_rtml_element end
+        #copy_ivars_to action_view
+        action_view.render(hash)
+      )
+    end
+    
+    # Adds the specified Widget to this object.
+    # Other parameters will be passed to the Widget initializer, and are optional.
+    def add_widget(klass, *args, &blk)
+      klass = klass.class if klass.kind_of? Rtml::Widgets::Widget
+      k = klass.new(self, *args, &blk);
+      widgets << k
+      document.modify!
+      k
+    end
+    
+    # Returns the TML document object, no matter how deeply this
+    # Widget is nested into the document.
+    def document
+      root_element
+    end
+    
+    # Returns a list of all ancestors of this Widget, beginning with its
+    # immediate parent and ending with its most distant grandparent.
+    def ancestors
+      ((parent.nil?) ? [] : (parent.ancestors + [ parent ]))
+    end
+    
+    # Returns an array of Widgets that have been added to this object.
+    def widgets
+      return @widgets if @widgets
+      @widgets = []
+      protected_instance_variables << "@widgets"
+      @widgets
+    end
+
+    # Concatenates the supplied String to the Widgets. For example,
+    # if the following code were run:
+    #   add_widget(widget1, . . .)
+    #   concat "Hello World"
+    #   add_widget(widget2, . . .)
+    # Then the output would be:
+    #   [widget1_output] Hello World [widget2_output]
+    def concat(str)
+      str = content_of_view str
+      widgets << str
+      str
+    end
+    
+    # Iterates through each Widget that has been added to this object,
+    # rendering them and returning the combined generated
+    def render_widget_tml
+      event_handler.process_event_handling_for(self)
+      ret = ""
+      cnt = ''
+      widgets.each do |t|
+        ret.concat "".ljust(1, "\n") if ret.length > 0 && cnt.count("\n") > 2
+        ret.concat(cnt = t.to_s)
+        ret.concat "\n"
+      end
+      ret
+    end
+    
+    alias tml_for_widgets render_widget_tml
+    
+    # Returns true if the specified name is an accessor alias of this Widget.
+    def is_accessor?(name); Rtml::Widgets::Widget.is_accessor? name, self.class.name; end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/core_helpers/widget_support/class_methods.rb

@@ -0,0 +1,28 @@
+# Class methods for all objects which are to support Widgets
+module Rtml::Helpers::CoreHelpers::WidgetSupport::ClassMethods
+  # Returns true if this method is allowed to be used as an access point for a
+  # Widget. By default, this is always true unless the method is already defined.
+  def access_point_valid?(name)
+    v = eval("not defined? #{name}", binding, __FILE__, __LINE__)
+    return false unless v
+    if self.superclass.respond_to? :access_point_valid?
+      self.superclass.access_point_valid? name
+    else
+      true
+    end
+  end
+
+  # If true, will suppress the raising of errors when a Widget defines an accessor that is not allowed.
+  # (In that event, the accessor will still not be created -- it will just fail silently and continue defining
+  # the rest of the accessors.) Default implementation always returns false (raises errors).
+  #
+  # See also silence_accessor_failures!
+  def silence_accessor_failures?; false; end
+  
+  # Enable silent failures when a Widget defines an accessor that cannot be used. By default, an error is
+  # raised in this event; calling this method will suppress those errors, and continue with the next accessor
+  # declaration.
+  def silence_accessor_failures!
+    instance_eval { def silence_accessor_failures?; true; end }
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/core_helpers/yield_helpers.rb

@@ -0,0 +1,33 @@
+module Rtml::Helpers::CoreHelpers
+  module YieldHelpers
+    # Begins processing the block to build a TML page
+    def process_block(&blk)
+      yield_with_optional_param self, &blk if block_given?
+    end
+    
+    # If the block accepts a parameter, yields and passes param to it.
+    # If not, yields to the block in the context of self.
+    def yield_with_optional_param(param, &blk)
+      # arity == -1 is known bug 574; should be 0
+      ((blk.arity == 0 or blk.arity == -1) ? self.instance_eval(&blk) : (blk.call(param)))
+    end
+    
+    # Yields to the given block with only the first element of the given array.
+    def with_first_argument(*a, &blk)
+      if a.length > 0
+        blk.call(a[0])
+      end
+    end
+    
+    # Yields to the given block with only the Nth element of the given array (or :first, or :last)
+    def with_argument(n, *a, &blk)
+      if a.length > 0
+        case n
+          when :first then blk.call(a.first)
+          when :last  then blk.call(a.last)
+          else blk.call(a[n])
+        end
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/proxy_helpers/feature_helpers.rb

@@ -0,0 +1,17 @@
+module Rtml::Helpers::ProxyHelpers::FeatureHelpers
+  def features
+    controller.features
+  end
+  
+  def add_features!
+    controller.add_features
+  end
+  
+  def feature_menu(*items)
+    controller.feature_config.to_menu(self, *items)
+  end
+  
+  def feature_events(*items)
+    controller.feature_config.events(self, *items)
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/render_helper.rb

@@ -0,0 +1,71 @@
+module Rtml::Helpers::RenderHelper
+  def h(a,&b) #:nodoc:
+    CGI::escapeHTML(a.to_s,&b)
+  end
+
+  # Overrides the default #render methods to provide the following additional functionality:
+  #
+  #   1. Render override to support :rtml as a parameter. This is similar to render :action,
+  #      except that it will include the necessary TML helpers and view paths. Note that it is
+  #      still run within the context of THIS controller, just like :action.
+  #   
+  #   2. Allows for #render to be called with a :super argument, to render a parent controller's view 
+  #      instead of the current.
+  #      
+  #   3. Allows a :partial or :file to be located in views/[controller]/[action]/[screen_id].rtml.erb
+  #      and checks for it there if no file of the same name is already located in
+  #      views/[controller]/[screen_id.rtml].erb
+  #
+  #
+  # Any other usage is passed to super.
+  #
+  # Example:
+  #   def index
+  #     # produce a clone of the TML from the #main action
+  #     render :rtml => :main
+  #     
+  #     # render the default TML document.
+  #     render :super
+  #   end
+  #
+  def render(*a,&b)
+    if a[0] and a[0].kind_of? Hash and a[0][:rtml]
+      # render :rtml => :some_action_to_render
+      # updates the view paths to include the specified action, then executes it
+      ctrlr = ((self.kind_of? ActionController::Base) ? self : controller)
+      action = ctrlr.action_name
+      ctrlr.action_name = a[0].delete(:rtml)
+      ctrlr.send :add_instance_view_paths, ctrlr.action_name
+      ctrlr.send(ctrlr.action_name)
+      ctrlr.action_name = action
+    else
+      if a.length == 1 and a[0] == :super
+        # render :super
+        # renders the view from the parent controller
+        c = self.controller
+        if c.class.superclass.method_defined? :controller_path
+          tmp = c.send :default_template_name, params[:action], c.response.template.template_format, c.class.superclass
+          return super(:file => tmp)
+        end
+      else
+        # Partials are handled in extensions/action_view/base
+        begin
+          super
+        rescue ActionView::MissingTemplate => mt
+          # To handle controllers within modules: [/rtml/beryl]/[index]/[main_menu]
+          if a[0].kind_of? Hash and a[0].keys[0] == :file
+            hash = a[0]
+            unless hash[:file].include? '/' or not ['rtml','tml'].include? self.controller.response.template.template_format.to_s
+              hash[:file] = "#{self.controller.class.controller_path}/#{self.controller.action_name}/#{hash[:file]}"
+            end
+          end
+          begin
+            super
+          rescue ActionView::MissingTemplate
+            raise mt
+          end
+        end
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/terminal_helpers.rb

@@ -0,0 +1,21 @@
+module Rtml::Helpers::TerminalHelpers
+  # Returns true if this terminal has a graphic, color display and
+  # a larger screen size capable of showing graphics and all that
+  # pretty stuff.
+  #
+  # Useful for determining which layout to render.
+  def color_display?
+    ['8550', '6780', '6580'].include? state[:model].to_s
+  end
+
+  def graphical_display?
+    logger.warn "Warning: #graphical_display? has been renamed to #color_display? and will be removed!"
+    color_display?
+  end
+
+  # Points to the embedded TML application on a terminal. Easier to type than
+  # all that "emb://" stuff.
+  def embedded_app
+    "emb://embedded.tml"
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/test_helpers.rb

@@ -0,0 +1,6 @@
+module Rtml::Helpers::TestHelpers
+  def self.included(base)
+    base.send :include, Rtml::Helpers::TestHelpers::TmlValidationAssertions
+    base.send :include, Rtml::Helpers::TestHelpers::VariableAssertions
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/test_helpers/tml_validation_assertions.rb

@@ -0,0 +1,10 @@
+module Rtml::Helpers::TestHelpers::TmlValidationAssertions
+  def assert_valid_tml(tml = nil)
+    if tml.nil?
+      assert_response :success
+      tml = self.instance_variable_get("@response").body if self.instance_variable_get("@response")
+      raise "TML content expected" if tml.nil?
+    end
+    Rtml::Validation::TmlValidator.new(self, tml)
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/test_helpers/variable_assertions.rb

@@ -0,0 +1,27 @@
+module Rtml::Helpers::TestHelpers::VariableAssertions
+  def assert_all_variables_declared(doc = nil)
+    @parser ||= Rtml::Validation::PredefinedVariableRuleParser.new("predefined_tml_variables")
+    doc ||= self.document
+    raise "TMLDocument object expected" if doc.nil?
+    
+    ### Removed the warnings because they'll come up if a variable is used on a different
+    # page than it is declared on. This is a fairly frequent occurrence. When/if those related
+    # pages can be checked in the same pass, we can uncomment the warnings code.
+    #
+    #vars = doc.vardecs.collect { |v| v.name } - doc.variables_used
+    #unless vars.empty?
+    #  vd = "\n\t- #{vars.join("\n\t- ")}"
+    #  i = (doc.controller ? "\n  in #{doc.controller.class}##{doc.params[:action]}" : "")
+    #  puts "\nwarning: unused variable declarations#{i}:#{vd}"
+    #end
+    
+    vars = doc.variables_used - doc.vardecs.collect { |v| v.name }
+    unless vars.empty?
+      vars.each do |v|
+        predefined = @parser.to_a.select { |i| i[:name] == v }
+        assert !predefined.empty?, "Variable #{v} not declared and not predefined"
+      end
+    end
+#  rescue Test::Unit::AssertionFailedError ### was going to do something here. but never mind.
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/helpers/view_helpers/form_helpers.rb

@@ -0,0 +1,70 @@
+module Rtml::Helpers::ViewHelpers
+  # So I haven't had time to finish writing, much less documenting, the FormHelpers module.
+  # Basically, it works the same way as Rails-based FormHelpers. Some of the methods are
+  # only going to be available to TMLDocument, Screen, Display and/or your Widgets, and
+  # some are only going to be available to the ActionView itself; I'll split the two types
+  # up and document them before long, I promise.
+  module FormHelpers
+    def variables_for(model, opt = {})
+      options_for(model).each do |options|
+        unless opt[:except] and (opt[:except].to_s == options[:column].name.to_s or (opt.kind_of? Array and opt[:except].collect { |i| i.to_s }.include? options[:column].name.to_s))
+          variable({ :name => options[:name], :type => options[:type], :value => options[:value], :format => options[:format] })
+        end
+      end
+    end
+    
+    def get_all_variables
+      document.variables.each do |var|
+        r.concat "<getvar name='#{var.properties[:name]}' />\n"
+      end
+      concat r
+      nil
+    end
+    
+    def get_variables(*var_names)
+      var_names.each do |name|
+        if name.kind_of? Array
+          get_variables *name
+        else
+          get_variable :name => name
+        end
+      end
+    end
+    
+    def variable_for(model, name)
+      options_for(model).each do |options|
+        get_variable :name => options[:name] if options[:column].name == (name ? name.name : nil)
+      end
+    end
+    
+    def set_variable_for(model, name, opt = {})
+      options_for(model).each do |options|
+        set_variable(options[:name], opt) if options[:column].name.to_s == (name ? name.name.to_s : "")
+      end
+    end
+    
+    def populate_from(model, opt = {})
+      options_for(model).each do |options|
+        unless opt[:except] and (opt[:except].to_s == options[:column].name.to_s or (opt.kind_of? Array and opt[:except].collect { |i| i.to_s }.include? options[:column].name.to_s))
+          set_variable options[:name], :to => (options[:value])
+        end
+      end
+    end
+    
+    def variables_for_model(model)
+      options_for(model).each do |options|
+        get_variable :name => options[:name]
+      end
+    end
+  
+    def rails_to_tml(type)
+      case type
+        when :string, :text then :string
+        when :integer then :integer
+        when :date, :time, :datetime then :date
+        when :boolean then :opaque
+        else raise "Cannot convert type #{type.inspect} to a valid TML type"
+      end
+    end
+  end
+end