rtml 1.2.2 → 2.0.0.alpha.1

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

@@ -0,0 +1,196 @@
+class Rtml::Dom::Element < ActiveRecord::Base
+  @@tml_ids = {}
+  set_table_name 'rtml_dom_elements'
+  belongs_to :document, :class_name => 'Rtml::Document'
+  belongs_to :parent, :polymorphic => true#:class_name => 'Rtml::Dom::Element'
+  has_many :elements, :class_name => 'Rtml::Dom::Element', :as => :parent, :autosave => true
+  has_many :properties, :class_name => 'Rtml::Dom::Property', :foreign_key => 'element_id', :autosave => true
+  #alias_method :children, :elements
+  include Rtml::DSL
+  include Rtml::Widgets
+  
+  delegate :request, :response, :params, :flash, :controller, :to => :document
+  delegate :params, :url_for, :to => :controller
+
+  def initialize(*args) #:nodoc:
+    options = args.extract_options!
+    options[:name] = options[:name].to_s if options.key?(:name)
+    properties = options.delete(:properties)
+    if options.empty? then super(options)
+    else super options
+    end
+    update_properties(properties) if properties
+  end
+
+  include Rtml::InheritedInstanceVariables
+  protected_instance_variables.concat ["@controller", "@changed_attributes", "@view", "@new_record", "@initialize_to_empty", "@widget_instances", "@rules", "@root", "@attributes_cache", "@attributes"]
+
+  def after_initialize
+    Rtml::Widgets.add_proxies_to_base(self)
+  end
+
+  def rules; document ? document.rules : nil; end           #:nodoc:
+
+  def name #:nodoc:
+    (s = super).kind_of?(String) ? s : s.to_s
+  end
+
+  def contains?(query)
+    !(self / query).empty?
+  end
+
+#  def respond_to?(name) #:nodoc:
+#    if name.to_s == 'name'
+#      attributes.keys.include?('name')
+#    else super
+#    end
+#  end
+
+  # call-seq:
+  #   ele / str => ele
+  #   ele / str => nil
+  #   ele / str => [ele, ele, ...]
+  #
+  # Searches this element and sub-elements for those whose tag names are equal to the specified one.
+  # Returns an array of matching elements, or an empty array if none match.
+  #
+  # Also accepts attribute-based searching in the form of [name1=value1&name2=value2]
+  #
+  # Examples:
+  #   tml / 'screen'
+  #   tml / 'screen[id=idle]'
+  #
+  def /(query)
+    attr_query = []
+    element_name = query
+    if element_name =~ /\[(.*)?\]/
+      m = $~[1]
+      element_name.sub! /#{Regexp::escape $~[0]}/, ''
+      m.split(/\&/).each do |attr|
+        attr_query << attr.split(/=/)
+      end
+    end
+    ret = full_tree.flatten.select do |i|#([self] + elements).select do |i|
+      attr_match = true
+      attr_query.each { |k| attr_match = false unless i.property(k[0]) == k[1] }
+      (i.name == element_name.to_s || i.property('id').to_s == element_name.to_s) && attr_match
+    end
+#    attr_match = true
+#    attr_query.each { |k| attr_match = false unless self[k[0]] == k[1] }
+#
+#    ret = []
+#    ret << self if (self.name == element_name || self['id'] == element_name.to_s) && attr_match
+#    elements.each { |i| ret.concat(i / query) }
+    ret
+  end
+
+  def full_tree
+    [self] + elements.collect { |child| child.full_tree }
+  end
+
+  # Produces the TML for this element and its children.
+  def to_tml
+    top = "#{name} #{properties_string}".strip
+    # Going to add a comment here to make it easier for the user to find their junk in raw TML
+    r = (property?('id') && !property('id').blank?) ? "<!--#{property('id')}-->".ljust(30) : ""
+    if elements.empty?
+      "#{r}<#{top} /> "
+    else
+      "#{r}<#{top}> \n#{elements.collect { |i| i.to_tml }.join("\n").indent}\n</#{name}>"
+    end
+  end
+
+  # Produces the TML properties string for this element.
+  # For instance, if this element has a property with name :next and value 'credit', this method will return:
+  #   "next=\"credit\""
+  def properties_string
+    if properties.empty?
+      ""
+    else
+      properties.collect { |a| a.to_tml }.select { |a| !a.blank? }.join(" ")
+    end
+  end
+
+  # Assigns the properties contained by the keys in the hash to their corresponding values for this Element.
+  def update_properties(props_hash)
+    props_hash.each do |key, value|
+      self.find_or_add_property(key, value)
+    end
+  end
+
+  # Returns true if a property with this name can be found.
+  def property?(name)
+    not properties.select { |p| p.name.to_s == name.to_s }.empty?
+  end
+
+  # Finds or adds a property to this element with the specified name, assigns its value if given, and returns its value.
+  def property(name, value = :__no_assignment, options = {})
+    if value == :__no_assignment
+      prop = find_or_add_property(name, options.merge(:drop_if_blank => true))
+    else
+      prop = find_or_add_property(name, options.merge(:value => value, :drop_if_blank => true))
+    end
+    prop.value
+  end
+
+  # Finds or adds a property for this element with the specified name
+  def find_or_add_property(name, options={:drop_if_blank => true})
+    options = {:value => options} unless options.kind_of?(Hash)
+    prop = properties.select { |p| p.name == name.to_s }.first
+    if prop
+      if options.key?(:value)
+        if prop.new_record? || prop.changed?
+          prop.value = options.delete(:value)
+        else
+          prop.update_attribute(:value, options.delete(:value))
+        end
+      end
+    else
+      if new_record? || changed?
+        prop = properties.build(:name => name.to_s, :value => options.delete(:value), :options => options.with_indifferent_access)
+        prop.element = self
+      else
+        prop = properties.create!(:name => name.to_s, :value => options.delete(:value), :options => options.with_indifferent_access)
+      end
+      #prop = Rtml::Dom::Property.new(:name => name.to_s, :element => self)
+      #properties << prop
+      #prop.options.merge!(options)
+    end
+    prop
+  end
+
+  class << self #:nodoc:
+    ## STI hack; allows you to pass :type => 'SomeClassName' so that they're not all instances of Element
+    def new_with_cast(*a, &b)
+      if (h = a.first).is_a? Hash and (type = (h[:type] || h['type'])) and (klass = type.constantize) != self
+        raise Rtml::Errors::StiTypeError  unless klass < self  # klass should be a descendant of us
+        return klass.new(*a, &b)
+      end
+
+      new_without_cast(*a, &b)
+    end
+    alias_method_chain :new, :cast
+
+    # Some elements must have an "id" property according to the TML specification, and other elements must be able to
+    # reference them by this ID. Unfortunately, according to the spec, the ID must not be greater than 12 characters long.
+    # This is a decided disadvantage, so we're going to allow RTML developers to create elements with longer names and
+    # reference them -- within RTML. The generated TML itself must conform to TML standards, of course, so the IDs may
+    # need to be truncated. Also, they need a unique identifier attached to them in case the truncation results in
+    # ambiguities with other screens. This method takes the specified name and processes it as mentioned, returning
+    # this element's TML-ID counterpart.
+    def lookup_tml_id(rtml_name)
+      rtml_name = rtml_name.to_s
+      if @@tml_ids.key?(rtml_name)
+        return @@tml_ids[rtml_name]
+      end
+
+      next_tml_id = @@tml_ids.keys.length.to_s
+      tmlid = rtml_name
+      @@tml_ids[rtml_name] =
+        if tmlid.length > 12
+          tmlid[0...(12-next_tml_id.length)] + next_tml_id
+        else tmlid.dup
+        end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+class Rtml::Dom::FrontendElement < Rtml::Dom::Element
+  def screen
+    return @screen if @screen
+    p = self
+    while (p = p.parent).kind_of?(Rtml::Dom::Element)
+      return @screen = p if p.name == 'screen'
+    end
+    raise "Could not find screen for #{self.inspect}"
+  end
+
+  def inner_content=(text)
+    self.property 'inner_content', text
+  end
+
+  def content_options=(hash)
+    hash.each do |key, value|
+      self.property key, value
+    end
+  end
+
+  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
+        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
+    else
+      self.property('inner_content').to_s
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+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
+
+  def after_initialize
+    self.options ||= HashWithIndifferentAccess.new
+  end
+
+  def value
+    r = super
+    return r.to_s if r.kind_of? Symbol
+    r
+  end
+
+  # See +Rtml::Dom::Element#lookup_tml_id(name)+
+  def self.lookup_tml_id(name)
+    Rtml::Dom::Element.lookup_tml_id(name)
+  end
+
+  def to_s
+    value.to_s
+  end
+
+  def blank?
+    value.blank?
+  end
+
+  def nil?
+    value.nil?
+  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 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
+    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)}"
+      end
+    end
+    val
+  end
+
+  # Produces the TML for this property.
+  def to_tml
+    val = tml_value
+    return val if val.blank? and options[:drop_if_blank]
+    return "" if val.nil? # always drop nils
+    "#{self.name}=#{val.inspect.ljust(15)}" # the ljust is for pretty formatting during my tests and could be removed
+  end
+  
+  # Handles various special-case values, like "true" and "false", which must be converted to 1, 0, and so on.
+  def tml_valid(i)
+    case i
+      when true,  :true  then 1
+      when false, :false then 0
+      else i
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+class Rtml::Dom::ScreenElement < Rtml::Dom::Element
+  def after_initialize
+    super
+    find_or_add_property(:next, :id_ref => true, :drop_if_blank => true)
+  end
+
+  def path
+    if document && document.name
+      "#{document.name}/#{property('id')}"
+    else
+      property('id').to_s
+    end
+  end
+end

data/builtin/models/rtml/instruction.rb

@@ -0,0 +1,52 @@
+class Rtml::Instruction < ActiveRecord::Base
+  extend Rtml::Instruction::FollowClassMethods
+  
+  set_table_name 'rtml_instructions'
+  serialize :arguments#, Array
+  belongs_to :source, :polymorphic => true
+  validates_presence_of :source, :name, :x, :y
+  validates_presence_of :widget
+
+  #has_many :instructions, :as => :source  # referencing this seems to raise Rtml is not missing constant Instruction ??
+  #So I added a migration and an extra key (parent_id) and source_id and source_type aren't used for children. Whatever.
+  #has_many :instructions, :class_name => 'Rtml::Instruction', :foreign_key => 'parent_id', :dependent => :destroy
+  #belongs_to :parent, :foreign_key => 'parent_id', :class_name => 'Rtml::Instruction'
+
+  # It's because of the namespace.
+  has_many :instructions, :as => :source, :class_name => 'Rtml::Instruction'
+  delegate :gui_configuration, :to => :widget
+
+  def to_json(options = {})
+    super(options.merge(:methods => :widget_fields))
+  end
+
+  def after_initialize
+    self.arguments ||= Hash.new
+  end
+
+  def widget
+    return nil unless source
+    source_name = source.kind_of?(Rtml::Document) ? 'document' : source.name
+    Rtml::Widgets.affecting(source_name).each do |widget|
+      return widget if widget.entry_points.include?(name)
+    end
+    nil
+  end
+
+  def widget_name
+    widget.name
+  end
+
+  def widget_fields
+    gui_configuration.fields_with_inferences
+  end
+
+  def follow(source = self.source)
+    raise ArgumentError, "Source is required" unless source
+
+    src = source.send("#{name}_from_hash", arguments)
+    instructions.each do |instruction|
+      instruction.follow(src)
+    end
+  end
+end

data/builtin/models/rtml/instruction/follow_class_methods.rb

@@ -0,0 +1,101 @@
+module Rtml::Instruction::FollowClassMethods
+  # Simply follows the supplied array of instructions. Each instruction is considered to have run on the result
+  # of the previous instruction. If that result doesn't respond_to? the instruction or does not support
+  # subprocessing, then the instruction is run on its parent result instead.
+  #
+  # Use "pop" as an instruction at any time to force the next instruction to run on the current result's parent.
+  #
+  # Examples:
+  #
+  #   follow_instructions ['screen :init, :idle',
+  #                        'screen :idle',
+  #                        'display',
+  #                        'screen :main',
+  #                        'submit "http://www.google.com"',
+  #                        'getvar "txn.amount"'
+  #                       ]
+  #
+  # The above instructions are equivalent to the following RTML code:
+  #
+  #    screen :init, :idle
+  #
+  #    screen :idle do
+  #      display
+  #    end
+  #
+  #    screen :main do
+  #      submit "http://www.google.com" do
+  #        getvar "txn.amount"
+  #      end
+  #    end
+  #
+  def follow(instructions_array, options = {})
+    instructions = instructions_array
+    options.each { |k, v| options[k] = v.to_s if [:controller, :action].include?(k) && v.is_a?(Symbol) }
+    if controller = options.delete(:controller)
+      action = options.delete(:action) || "index"
+      controller = "#{controller.camelize}Controller".constantize
+
+      Rtml::actions_for controller do
+        define_method action do
+          Rtml::Instruction.follow instructions
+        end
+      end
+    else
+      rtml_document = options.delete(:rtml_document) || options.delete(:document) || Rtml::Document.new(:name => "untitled")
+
+      instructions = instructions.raw.flatten if defined?(Cucumber) && instructions.kind_of?(Cucumber::Ast::Table)
+      reset_stack(rtml_document)
+      process_instructions(instructions)
+
+      rtml_document
+    end
+  end
+
+
+  def process_instructions(instructions)
+    remaining = instructions
+    if current = remaining.shift
+      arguments = current.split
+      method_name = arguments.shift
+      arguments = arguments.join(" ").strip
+
+      if current.strip == 'pop'
+        @stack.pop
+      elsif current_target.respond_to?(method_name) || @stack.length == 1
+        block = remaining.empty? ? nil : proc { |target| @stack.push target }
+        evaluate_instruction(method_name, arguments, &block)
+      else
+        @stack.pop
+        remaining = [current]+remaining
+      end
+      process_instructions(remaining)
+    end
+  end
+
+  def evaluate_instruction(method_name, arguments, &block)
+    arguments = "*[]" if arguments.blank?
+    instruction = "current_target.#{method_name}(#{arguments}, &block)"
+    eval(instruction, binding, __FILE__, __LINE__)
+  rescue Rtml::Errors::SubprocessingNotSupported
+    # This error is raised before the block is evaluated, hence, @stack.push never occurs, hence, there's
+    # no need to pop. Simply perform the next instruction on the current_target, which hasn't changed.
+  rescue SyntaxError
+    # This is usually because instruction looked something like:
+    #   current_target.controller.response.status(= 500, &block)
+    # The solution is to simply evaluate it exactly as it was written in the instruction:
+    #   [current_target.]controller.response.status = 500
+    eval("current_target.#{method_name} #{arguments}", binding, __FILE__, __LINE__)
+  end
+
+  def current_target
+    @stack.last
+  end
+
+  def reset_stack(document)
+    if @stack then @stack.clear
+    else @stack = []
+    end
+    @stack << document
+  end
+end