rtml 2.0.3 → 2.0.4

data/builtin/models/rtml/dom/frontend_element.rb

@@ -20,29 +20,50 @@ class Rtml::Dom::FrontendElement < Rtml::Dom::Element
 
   def to_tml
     if self.property('inner_content').blank?
-      options = HashWithIndifferentAccess.new
-      properties.each { |p| options[p.name] = p.value unless p.blank? }
-      if (options.keys - ['layout']).empty?
-        options[:file] = screen.path
-      elsif document && document.name
-        options.each do |key, value|
-          case key.to_s
-            when 'partial', 'file', 'template'
-              unless document.nil? or document.name.blank? or value =~ /\//
-                value = "#{document.name}/#{value}"
-                options[key] = value
-              end
-          end
+      to_tml_with_view
+    else
+      self.property('inner_content').to_s
+    end
+  end
+
+  private
+  def options
+    options = HashWithIndifferentAccess.new
+    properties.each { |p| options[p.name] = p.value unless p.blank? }
+    preprocess_options(options)
+  end
+
+  def preprocess_options(options)
+    if !has_filename_or_content?(options)
+      options[:file] = screen.path
+    elsif document && document.name
+      options.each do |key, value|
+        case key
+          when 'partial', 'file', 'template'
+            options[key] = "#{document.name}/#{value}" unless document.name.blank? or value =~ /\//
         end
       end
-      # Options is passed directly into the document's view.
-      if document
-        document.render(options)
-      else
-        raise Rtml::Errors::MissingDocumentError, "No document through which to render options: #{options.inspect}"
-      end
+    end
+    options
+  end
+
+  def has_filename_or_content?(options)
+    (options.keys - %w(partial file template text)) != options.keys
+  end
+
+  def to_tml_with_view
+    # Options is passed directly into the document's view.
+    if document
+      copy_ivars_to_view(options[:assigns])
+      document.render(options, options[:locals])
     else
-      self.property('inner_content').to_s
+      raise Rtml::Errors::MissingDocumentError, "No document through which to render options: #{options.inspect}"
     end
   end
+
+  def copy_ivars_to_view(hash)
+    hash.each do |name, value|
+      document.view.instance_variable_set("@#{name}", value)
+    end if hash
+  end
 end

data/builtin/models/rtml/dom/property.rb

@@ -1,25 +1,28 @@
-class Rtml::Dom::Property < ActiveRecord::Base
-  set_table_name 'rtml_dom_properties'
-  serialize :options, HashWithIndifferentAccess
-  serialize :value
-  belongs_to :element, :class_name => 'Rtml::Dom::Element'
-  delegate :document, :to => :element
-  validates_presence_of :name
-  validates_uniqueness_of :name, :scope => :element_id
+class Rtml::Dom::Property < Rtml::DocumentModelObject
+  include Rtml::Links
+  #set_table_name 'rtml_dom_properties'
+  #serialize :options, HashWithIndifferentAccess
+  #serialize :value
+  #belongs_to :element, :class_name => 'Rtml::Dom::Element'
+  #validates_presence_of :name
+  #validates_uniqueness_of :name, :scope => :element_id
+  attr_accessor :options, :name, :element
+  attr_writer :value
 
-  def after_initialize
-    self.options ||= HashWithIndifferentAccess.new
+  def document
+    element ? element.document : nil
   end
 
-  def value
-    r = super
-    return r.to_s if r.kind_of? Symbol
-    r
+  def initialize(options = {})
+    options.reverse_merge!(:options => HashWithIndifferentAccess.new)
+    self.options = options[:options].with_indifferent_access
+    self.value = options[:value]
+    self.name = options[:name]
+    after_initialize if respond_to?(:after_initialize)
   end
 
-  # See +Rtml::Dom::Element#lookup_tml_id(name)+
-  def self.lookup_tml_id(name)
-    Rtml::Dom::Element.lookup_tml_id(name)
+  def value
+    @value.kind_of?(Symbol) ? @value.to_s : @value
   end
 
   def to_s
@@ -35,21 +38,35 @@ class Rtml::Dom::Property < ActiveRecord::Base
   end
 
   # Returns the TML counterpart of just the value of this property.
-  # If this is a TML ID property, the return value is a call to #lookup_tml_id.
+  # If this is a TML ID property, the return value is a call to Rtml::Dom::Element.find_or_create_tml_id(name).
   # If this is has the :id_ref option, the return value is a reference to the element with this ID.
   # In all other cases, the value of this property is returned.
   def tml_value
+    val = value_or_id(tml_valid(@value))
+    val.kind_of?(String) ? val : val.to_s
+  end
+
+  def value_or_id(value) #:nodoc:
     id_ref = options.key?(:id_ref) ? options[:id_ref] : self.name == 'uri'
-    val = tml_valid(self.value)
-    val = val.to_s if val.kind_of?(Symbol) or val.kind_of?(Numeric)
-    val = self.class.lookup_tml_id(value) if name == 'id'
-    if id_ref && element && document
-      match = document.screens.select { |s| s.property(:id).to_s == val.to_s }.first
-      if match
-        val = "##{self.class.lookup_tml_id(val)}"
+
+    if self.name == 'id'
+      Rtml::Dom::Element.find_or_create_tml_id(value)
+    else
+      if value.kind_of?(String)
+        if value[0] == ?#
+          id_ref = true
+          value = value[1..-1]
+        else
+          return value unless id_ref
+        end
+      end
+
+      if document && (screen = document.find_screen(value))
+        id_for(screen.tml_id)
+      else
+        id_ref && local?(value) ? "##{value}" : value
       end
     end
-    val
   end
 
   # Produces the TML for this property.

data/builtin/models/rtml/dom/screen_element.rb

@@ -4,6 +4,19 @@ class Rtml::Dom::ScreenElement < Rtml::Dom::Element
     find_or_add_property(:next, :id_ref => true, :drop_if_blank => true)
   end
 
+  # TML has issues with empty Screen tags
+  def build_empty_tag
+    build_content_tag do
+      if !property('next').blank?
+        property = find_property('next')
+        value = property.tml_value
+        "<next uri=\"#{value}\" />"
+      else
+        '<next uri="#assert" />'
+      end
+    end
+  end
+
   def path
     if document && document.name
       "#{document.name}/#{property('id')}"

data/builtin/widgets/document_variable_processing.rb

@@ -1,15 +1,22 @@
 class Rtml::Widgets::DocumentVariableProcessing < Rtml::Widget
   VALID_OPTIONS = %w(type name format perms value)
-  VALID_TYPES = %w(integer string opaque datetime)
+  VALID_TYPES = %w(integer string opaque date)
 
   affects :document
   entry_point :declare_variable, :define_variable, :variable?, :variable_declared?, :variable_defined?
-  entry_point :string, :integer, :opaque, :datetime, :binary, :boolean
-  entry_point :strings, :integers, :opaques, :datetimes, :binaries, :booleans
-  entry_point :string?, :integer?, :opaque?, :datetime?, :binary?, :boolean?
+  entry_point :string, :integer, :opaque, :date, :binary, :boolean, :datetime
+  entry_point :strings, :integers, :opaques, :date, :binaries, :booleans, :datetimes
+  entry_point :string?, :integer?, :opaque?, :date?, :binary?, :boolean?, :datetime?
   entry_point :defined_variables, :variable_definitions
   entry_point :declared_variables, :variable_declarations
-  entry_point :variable
+  entry_point :variable, :variable_names
+
+  def initialize(*args, &block)
+    super(*args, &block)
+    Rtml::Test::BuiltinVariables::BUILTIN_VARIABLES.each do |name, options|
+      define_variable(name, options)
+    end
+  end
 
   # Declares a TML variable to be used within this document. Valid options include:
   #   :name       the name of the variable
@@ -23,6 +30,11 @@ class Rtml::Widgets::DocumentVariableProcessing < Rtml::Widget
     end
   end
 
+  # Returns an array containing the name of each defined variable.
+  def variable_names
+    variable_definitions.collect { |i| i['name'] }
+  end
+
   # Defines a TML variable to be used within this document, without explicitly declaring it.
   # This is useful for adding built-in TML variables, or those set at the Incendo gateway level,
   # to RTML's scope.
@@ -30,7 +42,8 @@ class Rtml::Widgets::DocumentVariableProcessing < Rtml::Widget
     options_with_name = options.merge(:name => name.to_s)
     validate_options(options_with_name)
     vd = variable_definitions(options[:type])
-    vd << options_with_name.with_indifferent_access
+    options = options_with_name.with_indifferent_access
+    vd << options unless vd.include?(options)
     vd
   end
 
@@ -49,10 +62,10 @@ class Rtml::Widgets::DocumentVariableProcessing < Rtml::Widget
   end
 
   # Returns all known variable definitions of the specified type, which can be one of
-  # :all, :string, :datetime, :opaque, :binary, :integer, :boolean
+  # :all, :string, :date, :opaque, :binary, :integer, :boolean
   def variable_definitions(type = :all)
     vdn = '@variable_definitions'
-    type = "opaque" if type.to_s == "binary"
+    type = valid_tml_type(type)
     vd = document.instance_variable_get(vdn) || document.instance_variable_set(vdn, {}.with_indifferent_access)
     if type == :all
       vd.collect { |i, j| j }.flatten
@@ -65,11 +78,10 @@ class Rtml::Widgets::DocumentVariableProcessing < Rtml::Widget
   alias defined_variables variable_definitions
 
   # Returns all explicit variable declarations of the specified type, which can be one of
-  # :all, :string, :datetime, :opaque, :binary, :integer, :boolean
+  # :all, :string, :date, :opaque, :binary, :integer, :boolean
   def variable_declarations(type = :all)
     r = []
-    type = "opaque" if type.to_s == "binary"
-    type = "integer" if type.to_s == "boolean"
+    type = valid_tml_type(type)
     vardecs = (document / 'vardcl') || []
     vardecs = [vardecs] unless vardecs.kind_of? Array
     vardecs.each do |vardec|
@@ -82,7 +94,7 @@ class Rtml::Widgets::DocumentVariableProcessing < Rtml::Widget
 
   alias declared_variables variable_declarations
 
-  %w(string integer opaque datetime).each do |type|
+  %w(string integer opaque date).each do |type|
     line = __LINE__ + 2
     code = <<-end_code
     def #{type}(*names)
@@ -119,15 +131,27 @@ class Rtml::Widgets::DocumentVariableProcessing < Rtml::Widget
 
   alias variable? variable_defined?
 
-  alias binary opaque
-  alias binaries opaques
-  alias binary? opaque?
+  alias datetime  date
+  alias datetimes dates
+  alias datetime? date?
+
+  alias binary    opaque
+  alias binaries  opaques
+  alias binary?   opaque?
 
-  alias boolean integer
-  alias booleans integers
-  alias boolean? integer?
+  alias boolean   integer
+  alias booleans  integers
+  alias boolean?  integer?
 
   def document
     parent
   end
+
+  private
+  def valid_tml_type(type)
+    type = "opaque" if type.to_s == "binary"
+    type = "integer" if type.to_s == "boolean"
+    type = "date" if type.to_s == "datetime"
+    type
+  end
 end

data/builtin/widgets/element_builder.rb

@@ -60,11 +60,11 @@ class Rtml::Widgets::ElementBuilder < Rtml::Widget
     # validation passed, so create the element
     @element = parent.build_element(name, properties)
     if @element.respond_to?(:parent=)
-      if @element.changed? || @element.new_record?
+      #if @element.changed? || @element.new_record?
         @element.parent = parent
-      else
-        @element.update_attribute(:parent, parent)
-      end
+      #else
+      #  @element.update_attribute(:parent, parent)
+      #end
     end
 
     rebuild_invalid_elements

data/builtin/widgets/screen_variable_processing.rb

@@ -42,9 +42,9 @@ class Rtml::Widgets::ScreenVariableProcessing < Rtml::Widget
   def options_for(value_or_array)
     if value_or_array.kind_of? Array
       value_or_array = tmlize_condition(*value_or_array)
-      { :lo => value_or_array[0], :op => value_or_array[1], :ro => value_or_array[2] }
+      { :lo => (value_or_array[0]), :op => value_or_array[1], :ro => (value_or_array[2]) }
     else
-      { :lo => value_or_array }
+      { :lo => (value_or_array) }
     end
   end
 

data/builtin/widgets/screen_variants.rb

@@ -14,7 +14,13 @@ class Rtml::Widgets::ScreenVariants < Rtml::Widget
   #     next_screen :terminate_loop
   #     next_screen :loop_again, :if => 'tmlvar:counter < tmlvar:loop_count'
   #   end
-  def next(uri, options = {})
+  def next(uri = :__not_set, options = {})
+    if uri == :__not_set
+      next_element = (parent / 'next').first
+      return next_element.property('uri') if next_element
+      return parent.property('next')
+    end
+
     unless options.empty?
       variant process_variant_options(options.merge(:uri => uri))
     else
@@ -56,9 +62,7 @@ class Rtml::Widgets::ScreenVariants < Rtml::Widget
     variants = (next_element / "variant")
     variants.each do |variant|
       # If variant contains the same conditions, replace the URI and return.
-      if (variant.property('lo') == options[:lo] && variant.property('ro') == options[:ro] && variant.property('op') == options[:op]) ||
-          (options.key?('key') && variant.property('key') == options[:key]) ||
-          (options.key?('timeout') && variant.property('timeout') == options[:timeout])
+      if replaces_variant?(variant, options)
         variant.property('uri', options[:uri])
         return variant
       end
@@ -67,6 +71,29 @@ class Rtml::Widgets::ScreenVariants < Rtml::Widget
   end
 
   private
+  def replaces_variant?(variant, options)
+    equivalent_operation?(variant, options)     \
+    || same_key?(variant, options)              \
+    || both_timeout?(variant, options)
+  end
+
+  def equivalent_operation?(variant, options)
+    options.key?(:lo)                           \
+      && variant.property('lo') == options[:lo] \
+      && variant.property('ro') == options[:ro] \
+      && variant.property('op') == options[:op]
+  end
+
+  def same_key?(variant, options)
+    options.key?(:key)                         \
+      && variant.property('key') == options[:key]
+  end
+
+  def both_timeout?(variant, options)
+    options.key?(:timeout)                     \
+      && variant.property('timeout') == options[:timeout]
+  end
+
   def process_variant_options(options)
     ret = {}
     if options[:lo] || options[:ro] || options[:op]

data/builtin/widgets/screens.rb

@@ -1,6 +1,6 @@
 class Rtml::Widgets::Screens < Rtml::Widget
   affects :document
-  entry_point :screen, :remove_screen
+  entry_point :screen, :find_screen, :remove_screen, :screen?
 
   gui do |config|
     config.entry_points = :screen
@@ -10,6 +10,18 @@ class Rtml::Widgets::Screens < Rtml::Widget
     config.initializer_arguments { |fields| [ fields.delete(:name), fields ] }
   end
 
+  # Finds a screen by its name instead of its ID
+  # This works even if the screen hasn't been saved to the database.
+  def find_screen(name)
+    name = name.to_s if !name.kind_of?(String)
+    parent.screens.select { |s| s.property(:id).to_s == name }.first
+  end
+
+  # Returns the screen with the specified ID, or nil. No changes are made.
+  def screen?(id)
+    (parent / "screen[id=#{id}]").first
+  end
+
   # Creates or modifies a screen with the specified name.
   # If a second argument is specified, it is expected to be the ID of the next screen in the flow.
   # Various configuration options may also be supplied as the last argument.

data/builtin/widgets/static_content.rb

@@ -23,13 +23,9 @@ class Rtml::Widgets::StaticContent < Rtml::Widget
   end
 
   def static_content(options = { }, &block)
-    options = {:text => options} if options.kind_of?(String)
-    options = {:file => file_path(options)} if options.kind_of?(Symbol)
-
-    options[:layout] = default_layout unless options.key?(:layout)
-    #layout = (options.kind_of?(Hash) && options.key?(:layout) ? options.delete(:layout) : default_layout)
+    options = infer_options_from(options)
     frontend_element = parent.build :frontend, :skip_validation => true
-    #frontend_element.property(:layout, layout) if layout
+
     unless options.nil?
       frontend_element.content_options = options
       if block_given?
@@ -48,4 +44,22 @@ class Rtml::Widgets::StaticContent < Rtml::Widget
     controller ? filename.to_s : #"#{controller.action_name}/#{filename}" :
             (document && document.name ? "#{document.name}/#{filename}" : filename.to_s)
   end
+
+  private
+  def infer_options_from(options)
+    options = {:text => options} if options.kind_of?(String)
+    options = {:file => file_path(options)} if options.kind_of?(Symbol)
+
+    if options
+      options[:layout] = default_layout unless options.key?(:layout)
+      if options.kind_of?(Hash)
+        if options[:assigns]
+          options[:assigns].reverse_merge!(assigns)
+        else
+          options[:assigns] = assigns
+        end
+      end
+    end
+    options
+  end
 end