rtml 1.2.2 → 2.0.0.alpha.1

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

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

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

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

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

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

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

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

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

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

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