rtml 1.2.2 → 2.0.0.alpha.1

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

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

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

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

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

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

@@ -1,51 +0,0 @@
-# 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/validation/dom_rule_parser.rb

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

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

@@ -1,52 +0,0 @@
-class Rtml::Validation::DomTag
-  attr_accessor :name
-  attr_accessor :children
-  attr_accessor :child_order
-  attr_writer :root
-  
-  def root?; @root end
-    
-  def initialize(name)
-    @name = name.to_s
-    @children = []
-    @child_order = []
-  end
-  
-  def validate(validator, ruleset, xml)
-    # note that validate does NOT validate *this* element -- only children!
-    tml_elements = xml/"/#{self.name}"
-    tml_elements.each do |element|
-      #validate that children specified are present
-      children.each do |set|
-        for chele in set[0]
-          chele = ruleset.tags.find_by_name(chele) if chele.kind_of? Symbol or chele.kind_of? String
-          options = set[1].reverse_merge(:minimum => 0)
-          found = chele.validate(validator, ruleset, element).length
-
-          validator.test_case.assert_operator found, ">=", options[:minimum],
-            "Found #{found} occurrances of #{chele.name}; expected to find at least #{options[:minimum]}"
-          
-          if options[:maximum]
-            validator.test_case.assert_operator found, "<=", options[:maximum],
-              "Found #{found} occurrances of #{chele.name}; expected to find at most #{options[:maximum]}"
-          end
-        end
-      end
-
-      # validate that children not specified are not present
-      acceptable = children.collect { |c| c[0] }.flatten.collect do |c|
-        ((c.kind_of? Symbol or c.kind_of? String) ? ruleset.tags.find_by_name(c) : c)
-      end
-      forbidden = ruleset.tags - acceptable
-      forbidden.each do |tag|
-        count = (element/"/#{tag.name}").length
-        validator.test_case.assert_equal count, 0,
-          "Element #{tag.name} is not allowed to appear within parent #{element.name}"
-      end
-    end
-  end
-  
-  def to_s
-    name
-  end
-end