rtml 1.2.2

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

@@ -0,0 +1,174 @@
+class Rtml::Helpers::ViewHelpers::RtmlFormBuilder < ActionView::Helpers::FormBuilder
+  def file_field(method, options = {})
+    raise "No file_field support for TML"
+  end
+  
+  def select(method, choices, options = {}, tml_options = {})
+    raise "No select support in TML; see tml_select (and note the differences!)"
+  end
+
+  def collection_select(method, collection, value_method, text_method, options = {}, tml_options = {})
+    raise "No collection_select support in TML; see tml_select (and note the differences!)"
+  end
+  
+  [ :date_select, :datetime_select, :time_select, :country_select, :time_zone_select ].each do |method|
+    define_method method do |*args|
+      raise "No #{method} support in TML; see tml_select (and note the differences!)"
+    end
+  end
+  
+  def tml_select(method, choices, options = {})
+    input_field(method, options.reverse_merge(:type => :list, :value => choices.join(";")))
+  end
+
+  def check_box(method, options = {}, checked_value = "1")
+    input_field(method, options.reverse_merge(:type => :checkbox, :value => checked_value))
+  end
+  
+  def hidden_field(method, options = {})
+    add_to_submit_variables(name_for(method, options)) unless options[:do_not_submit]
+  end
+  
+  def label(method, text = nil, options = {})
+    super
+  end
+  
+  def radio_button(method, tag_value, options = {})
+    input_field(method, options.reverse_merge(:type => :radio, :value => tag_value))
+  end
+  
+  def text_area(method, options = {})
+    super
+  end
+  
+  def currency_field(method, options = {})
+    options.reverse_merge! :precision => 2, :currency_sign => '$'
+    precision = options.delete(:precision)
+    currency_sign = options.delete(:currency_sign)
+    fmt = "#{currency_sign}0*.#{'0'*precision}"
+    input_field(method, options.reverse_merge(:type => :number, :format => fmt))
+  end
+
+  [:date, :password, :text, :number].each do |method|
+    code = <<-end_code
+      def #{method}_field(method, options = {})
+        input_field(method, options.reverse_merge(:type => #{method.inspect}))
+      end
+    end_code
+    eval code, binding, __FILE__, __LINE__ - (code.to_a.length+1)
+  end
+
+  def submit(label = "OK", options = {})
+    options, label = label, "OK" if label.kind_of? Hash
+    
+    post = options.delete(:post)
+    cache = options.delete(:cache)
+    post = true if post.nil? # false is acceptable
+    tml = input_field(label, options.reverse_merge(:no_name => true, :alt => label, :type => :submit, :do_not_submit => true))
+    if post
+      screen = @template.current_rtml_element.current_screen
+      new_id = "s#{screen.id.hash.to_s.gsub(/-/, '_')}" # max 1+11=12 characters
+      err_id = new_id.sub(/s/, 'e')
+      
+      target = @template.url_for(@options[:url] || {})
+      screen.next new_id
+      tmldoc = @template.controller.rtml_interface
+      tmldoc.screen new_id, :next => err_id do |scr|
+        scr.submit :cache => cache, :target => target, :on_error => err_id do |subm|
+          @template.instance_variable_get("@tml_variables_for_submit").each do |tmlvar|
+            subm.getvar tmlvar
+          end
+        end
+      end
+      
+      tmldoc.screen err_id, :next => tmldoc.default_screen do |err|
+        err.display do |disp|
+          disp.build :table, :border => 2, :height => '100%', :width => '100%' do
+            tr { td :valign => :middle, :align => :center do
+              h1 { "Error Submitting Data" }
+              br
+              getvar :name => 'err.baddata_reason'
+            end }
+          end
+        end
+      end
+    end
+    tml
+  end
+
+  def reset(label = "Reset", options = {})
+    input_field(label, options(:no_name => true, :alt => label, :type => 'reset', :do_not_submit => true))
+  end
+
+  def baddata
+    @baddata ||= HashWithIndifferentAccess.new
+  end
+  
+  def baddata_for(method, options = {}, &block)
+    baddata[method] = Rtml::Widgets::ElementBuilderWidget.new(@template.current_rtml_element, options.merge(:name => :baddata), &block).to_tml
+  end
+  
+  def input_field(method, options = {})
+    validate_input_field(method, options)
+    alt = "#{method.to_s.titleize}:"
+    name = name_for(method, options)
+    bd = (baddata[method] || default_baddata_for(method, options))
+    opt = options.reverse_merge(:name => name, :alt => alt)
+    
+    add_to_submit_variables name unless opt.delete :do_not_submit
+    opt.delete :name if opt.delete :no_name
+    if bd
+      "<input #{opt.without_values(nil).to_s}>\n\t#{bd.indent}\n</input>"
+    else
+      "<input #{opt.without_values(nil).to_s} />"
+    end
+  end
+  
+  private
+  def name_for(method, options)
+    if options[:prefix]
+      if options[:prefix].blank?
+        method
+      else
+        "#{options[:prefix]}.#{method}"
+      end
+    else
+      ((object_name.blank? or object_name == 'nil_class') ? method : "#{object_name}.#{method}")
+    end
+  end
+  
+  def add_to_submit_variables(name)
+    arr = @template.instance_variable_get("@tml_variables_for_submit")
+    arr << name unless arr.include? name
+  end
+  
+  # some validation, because debugging TML sucks
+  def validate_input_field(method, options)
+    valid_types = [ :checkbox, :date, :number, :password, :radio, :reset, :submit, :text, :list ]
+    valid_options = [ :type, :class, :alt, :name, :value, :format, :do_not_submit, :no_name ]
+    if options[:type] == :list then valid_options.concat [ :multiple, :rows, :width, :height ]
+    else valid_options.concat [ :id, :readonly, :size, :equal, :not_equal, :max, :min ]
+    end
+  
+    raise "Required option: type (one of #{valid_types.inspect})" unless options[:type]
+    raise "Unknown type: #{options[:type]} (valid types: #{valid_types.inspect}" unless valid_types.include? options[:type]
+    options.each { |k,v| raise "Unknown option #{k} (value: #{v})" unless valid_options.include?(k) }
+  end
+  
+  def default_baddata_for(method, options)
+    bd = false
+    reasons_for_bd = [ :equal, :not_equal, :max, :min, :format ]
+    options.each { |key,val| bd = true if reasons_for_bd.include? key }
+    return nil unless bd
+    
+    baddata_for method, :class => 'c_center', :next => @template.current_rtml_element.current_screen_id.to_screen_ref do
+      table :border => 2, :height => '100%', :width => '100%' do
+        tr do
+          td :valign => :middle, :align => :center do
+            getvar :name => 'err.baddata_reason'
+          end
+        end
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/oe/btmlpa_constants.rb

@@ -0,0 +1,48 @@
+module Rtml
+  module Oe
+    # Constants used for the Basic TML payment application (BTMLPA).
+    # 
+    module BtmlpaConstants
+      module Value
+        NOT_SPECIFIED = 0
+      end
+      
+      module State
+        NEW = 0
+        APPROVED = 1
+        DECLINED = 2
+        FAILED = 3
+        REVERSED = 4
+        CANCELED = 5
+      end
+      
+      module TxnType
+        SALE = 1
+        SALE_CASHBACK = 2
+        REFUND = 3
+        REVERSAL = 4
+      end
+      
+      module ResultCode
+        ACCEPTED = 0
+        REFUSED = 1
+      end
+      
+      module AuthReply
+        AUTHORIZED = 0
+        DECLINED =1
+      end
+      
+      module AuthCode
+        NONE = "NONE"
+        OK = "OK"
+      end
+      
+      module InputMethod
+        MAGNETIC = 1
+        ICC = 2
+        KEYED = 3
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/proxying/method_missing_methods.rb

@@ -0,0 +1,14 @@
+module Rtml #:nodoc:
+  module Proxying #:nodoc:
+    module MethodMissingMethods #:nodoc:
+      def method_missing(name, *args, &block) #:nodoc:
+        return @rtml_document.send(name, *args, &block) if @rtml_document.respond_to? name
+        return super
+      end
+      
+      def respond_to?(*a,&b) #:nodoc:
+        super or @rtml_document.respond_to?(*a,&b)
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/proxying/rtml_interface.rb

@@ -0,0 +1,33 @@
+module Rtml #:nodoc:
+  module Proxying #:nodoc:
+    class RtmlInterface #:nodoc:
+      include Rtml::Proxying::MethodMissingMethods
+      
+      def initialize #:nodoc:
+        @modules = []
+      end
+      
+      def fire_action(action, controller) #:nodoc:
+        @controller = controller
+        @rtml_document = controller.send :tml_document
+        _copy_ivars_from_controller
+        self.send action
+      end
+      
+      def add_actions_from_module(m) #:nodoc:
+        me = (class << self; self; end)
+        me.send :include, m
+        @modules << m
+      end
+      
+      private
+      def _copy_ivars_from_controller #:nodoc:
+        if controller
+          variables = controller.instance_variable_names
+          variables -= controller.protected_instance_variables if controller.respond_to?(:protected_instance_variables)
+          variables.each { |name| instance_variable_set(name, controller.instance_variable_get(name)) }
+        end
+      end
+    end
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/proxying/sandbox.rb

@@ -0,0 +1,18 @@
+module Rtml #:nodoc:
+  module Proxying #:nodoc:
+    class Sandbox < Module #:nodoc:
+      def respond_to?(*a,&b) #:nodoc:
+        super || @__controller.respond_to?(*a,&b)
+      end
+      
+      def method_missing(name, *args, &block) #:nodoc:
+        @__controller.send name, *args, &block
+      end
+      
+      def initialize(controller, &block) #:nodoc:
+        @__controller = controller
+        super(&block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# RTML text formatting utilities.
+# Note that these utilities may be deprecated in the near future, so 
+# don't write code that relies on them. They're left over from RTML 0.1
+# (and were copied and pasted even then), and they stink of bad design.
+#
+module Rtml::TextUtils
+  
+  # Removes all preceeding white space (except new lines) from the given
+  # text, but keeps indentation past the first non-white character. For
+  # example:
+  # 
+  #       begin
+  #         raise "error"
+  #       rescue
+  #         puts $!
+  #       end
+  # 
+  # would become:
+  # 
+  #  begin
+  #    raise "error"
+  #  rescue
+  #    puts $!
+  #  end
+  # 
+  #
+  # The optional tab_stop parameter determines how many white spaces each
+  # tab stop will correlate to. This is important for strings that contain
+  # both white space indentation and tab character indentation, in order
+  # to properly format the result.
+#  def format_text(text, tab_stop = 8)
+#    code = ((text.respond_to? :render_tml) ? text.render_tml :
+#           ((text.respond_to? :to_tml) ? text.to_tml : text.to_s)).gsub(/\t/m, (" "*tab_stop))
+#    min_spaces = -1
+#    #figure out how many spaces NOT to keep
+#    code.split(/\n/m).each do |line|
+#      if not line.strip.blank?
+#        sp = 0
+#        line.each_byte do |ch|
+#          case ch
+#            when ?\s then sp += 1
+#            else break
+#          end
+#        end
+#        min_spaces = sp if min_spaces > sp or min_spaces == -1
+#      end
+#    end
+#  
+#    code.gsub(/^#{"".ljust(min_spaces)}/m, '').gsub("".ljust(tab_stop), "\t")
+#  end
+end

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

@@ -0,0 +1,95 @@
+# TML data, when sent as an HTTP POST payload, is in XML format. This class is
+# responsible for processing TMLPOST data into the familiar name-value pairs.
+#
+# TODO: Groupe has agreed to look into implementing TML POST data as
+# application/x-www-form-urlencoded data instead of XML, which would
+# render this class unnecessary overhead.
+#
+class Rtml::TmlParamParser
+  attr_reader :params
+  
+  def initialize(data)
+    tml = Hpricot.XML(data)
+    tmlpost = tml.at('tmlpost')
+    postvars = tml.search("//postvar")
+    @params = {}.with_indifferent_access
+    
+    if tmlpost and postvars
+      params[:post_id] = tmlpost['post_id'].to_i
+      params[:date]    = Date.parse(tmlpost['date'])
+      params[:itid]    = tmlpost['itid']
+      params[:xmlns]   = tmlpost['xmlns']
+      p = {}
+      postvars.each do |postvar|
+        name, value = name_and_value_of postvar
+        p[name] = value
+      end
+      
+      # The reason this is broken into two phases is because if we don't, there's a chance we'll
+      # miss a value that looks like (but isn't) a namespace. Example:
+      #
+      #  card.pin      = '3C30E0EEB1978A58' # this is actually the pin block itself
+      #  card.pin.smid = '00000E0001E000CB' # this is the smid
+      #
+      # When parsed from parmstr, card.pin.smid would normally create params[:card][:pin] = {:smid => '...'}
+      # But this would overwrite card.pin = '3C30E0EEB1978A58', and we'd lose the pin block. It'd probably
+      # be more correct to fix this at the TML level, but we can't expect every TML developer to figure that
+      # out, and RTML can only help so much. It breaks the convention, but I think it's safer in the
+      # long run to turn this into params[:card][:pin] and params[:card]['pin.smid']. Even though it
+      # will doubtlessly add confusion to a developer who has to work with it, at least this confusion 
+      # should be rare in RTML (because RTML sorts all this info into its Transaction model and expects
+      # the developer to deal with transactions through the model, and not the params themselves).
+      #
+      # TODO: Check with Groupe about addressing this. Obviously, 'card.pin.block' would be the preferred
+      # syntax and this problem would never come up if all variables followed the same naming conventions.
+      #
+      # We have to sort the keys so that the shortest ones will be on top (and therefore card.pin will be
+      # processed before card.pin.smid has a chance to determine that it's OK to make it a hash).
+      #
+      p.sort { |a,b| a[0] <=> b[0] }.each do |arr|
+        name, value = arr
+        sort_and_assign name, value
+      end
+    end
+  end
+  
+  private
+  def sort_and_assign(name, value, p = params)
+    if name =~ /\./
+      ns, *remainder = name.split(/\./)
+      p[ns] = {}.with_indifferent_access unless p.key? ns
+      if p[ns].kind_of? Hash then
+        remainder = remainder.join(".") if remainder.kind_of? Array
+        sort_and_assign(remainder, value, p[ns])
+      else p[name] = value
+      end
+    else
+      p[name] = value
+    end
+  end
+  
+  def name_and_value_of(postvar)
+    type = postvar['type']
+    name = postvar['name']
+    value = if postvar['value'].blank? then nil
+    else
+      value = postvar['value']
+      begin
+        case type
+          when 'date'    then DateTime.strptime(value, "%d %m %Y %H:%M:%S").to_time
+          when 'integer' then value.to_i
+          when 'string'  then value
+          # TODO: this is actually hex; maybe unpack into true binary at some point?
+          when 'opaque'  then value
+          # Decided to simply assign string value instead of raising error on unknown types, so that user
+          # can handle it without having to hack the framework.
+          else value
+          #else raise "Unknown TML type: #{type}"
+        end
+      rescue
+        warn "Error #{$!.message} while parsing value #{value.inspect} for TML param #{name.inspect} (#{type})"
+      end
+    end
+    [name, value]
+  end
+end

data/app_generators/rtml/templates/rtml/lib/rtml/validation/dom_rule_parser.rb

@@ -0,0 +1,61 @@
+class Rtml::Validation::DomRuleParser
+  def parse!(rules_file)
+    eval File.read(rules_file), binding, rules_file, 1
+  end
+  
+  def define_tags(*tag_list)
+    tag_list.each do |tag|
+      define_tags *tag and return if tag.kind_of? Array
+      tags << Rtml::Validation::DomTag.new(tag)
+    end
+  end
+  
+  def validate(validator, tml, root = nil)
+    if root.nil?
+      tags.each { |t| root = t if t.root? }
+      raise "No root tag specified" if root.nil?
+    elsif root.kind_of? String or root.kind_of? Symbol
+      root = tags.find_by_name(root)
+    end
+    
+    count = root.validate(validator, self, ::Hpricot::XML(tml)).length
+    validator.test_case.assert_equal count, 1, "Expected to find exactly 1 occurrance of #{root.name}; found #{count}"
+  end
+  
+  def root(tag)
+    tags.each { |t| t.root = false }
+    r = tags.find_by_name(tag)
+    r.root = true and return if r
+    raise "Could not find root tag #{tag}"
+  end
+  
+  def order(&block)
+    
+  end
+  
+  def children(&block)
+    singleton = Class.new.new
+    tags.each do |tag|
+      singleton.class.send :define_method, tag.name do |children, *options|
+        children = [children] if children.kind_of? String or children.kind_of? Symbol
+        tag.children << [ children, options[0] || HashWithIndifferentAccess.new ]
+      end
+    end
+    
+    singleton.class.send :define_method, :all_elements do @all_elements end
+    singleton.instance_variable_set "@all_elements", tags
+    
+    singleton.instance_eval &block
+  end
+  
+  def tags
+    return @tags if @tags
+    @tags = []
+    def @tags.find_by_name(name)
+      r = nil
+      self.each { |t| r = t and break if t.name == name.to_s }
+      r
+    end
+    @tags
+  end
+end