rtml 2.0.3 → 2.0.4

data/spec/lib/rtml/reverse_engineering/crawler_spec.rb

@@ -1,24 +0,0 @@
-require File.join(__FILE__.gsub(/(.*)?\/spec\/.*$/, '\1'), 'spec/spec_helper')
-
-describe Rtml::ReverseEngineering::Crawler do
-  context "with a prefab TML document" do
-    before :each do
-      subject.tml = File.read(File.join(Rtml.root, "spec/support/raw_tml/valid_document.tml"))
-    end
-
-    it "should visit #init and then #main" do
-      subject.visit "#init"
-      subject.current_screen.should == "main"
-    end
-  end
-
-  context "with a missing action" do
-    before :each do
-      subject.visit "/rtml/missing_action.rtml?ignore_state=true" #"/rtml-2.0.0/missing_action.tml?ignore_state=true"
-    end
-
-    it "should pause at #rescue" do
-      subject.current_screen.should == "rescue"
-    end
-  end
-end

data/spec/lib/rtml/reverse_engineering/simulator/variable_value_spec.rb

@@ -1,120 +0,0 @@
-require File.join(__FILE__.gsub(/(.*)?\/spec\/.*$/, '\1'), 'spec/spec_helper')
-
-def varval(setvar, type, vars = {})
-  Rtml::ReverseEngineering::Simulator::VariableValue.new(setvar, vars, {setvar['name'] => type})
-end
-
-describe Rtml::ReverseEngineering::Simulator::VariableValue do
-  it "should resolve variable names in operands" do
-    var = varval(Hpricot::XML("<setvar name='count' lo='tmlvar:start' />").root, :integer, :start => 0)
-    var.send(:lo).should == 0
-  end
-
-  context "with an assignment" do
-    it "should == an operation with same result" do
-      varval(Hpricot::XML("<setvar name='count' lo='5' />").root, :integer).should ==
-      varval(Hpricot::XML("<setvar name='count' lo='2' op='plus' ro='3' />").root, :integer)
-    end
-
-    context "given an integer" do
-      before :each do
-        @subject = varval(Hpricot::XML("<setvar name='count' lo='5' />").root, :integer)
-      end
-
-      it "should set value to :lo" do
-        subject.value.should == 5
-      end
-    end
-
-    context "given a string" do
-      before :each do
-        @subject = varval(Hpricot::XML("<setvar name='count' lo='5' />").root, :string)
-      end
-
-      it "should set value to :lo" do
-        subject.value.should == '5'
-      end
-    end
-
-    context "given an opaque" do
-      before :each do
-        @subject = varval(Hpricot::XML("<setvar name='count' lo='5' />").root, :opaque)
-      end
-
-      it "should set value to :lo" do
-        subject.value.should == '5'
-      end
-    end
-
-    context "given a date" do
-      before :each do
-          @subject = varval(Hpricot::XML("<setvar name='count' lo='5/5/5' />").root, :date)
-      end
-
-      it "should set value to :lo" do
-        subject.value.should == "5/5/5"
-      end
-    end
-  end
-
-  context "with an operation" do
-    it "should resolve operands" do
-      var = varval(Hpricot::XML("<setvar name='count' lo='tmlvar:count' op='plus' ro='1' />").root, :integer,
-                   'count' => varval(Hpricot::XML("<setvar name='count' lo='2' />").root, :integer))
-      var.value.should == 3
-    end
-
-    it "should == an assignment with same result" do
-      varval(Hpricot::XML("<setvar name='count' lo='2' op='plus' ro='3' />").root, :integer).should ==
-              varval(Hpricot::XML("<setvar name='count' lo='5' />").root, :integer)
-    end
-
-    context "given an integer" do
-      it "should set value to :lo plus :ro" do
-        varval(Hpricot::XML("<setvar name='count' lo='2' op='plus' ro='3' />").root, :integer).value.should == 5
-      end
-
-      it "should set value to :lo minus :ro" do
-        varval(Hpricot::XML("<setvar name='count' lo='7' op='minus' ro='2' />").root, :integer).value.should == 5
-      end
-    end
-
-    context "given an opaque" do
-      it "should raise an error because no operations are possible" do
-        proc do
-          varval(Hpricot::XML("<setvar name='count' lo='7' op='minus' ro='2' />").root, :opaque)
-        end.should raise_error(Rtml::Errors::InvalidOperation)
-      end
-    end
-
-    context "given a string" do
-      it "should set value to :lo plus :ro" do
-        varval(Hpricot::XML("<setvar name='count' lo='3' op='plus' ro='2' />").root, :string).value.should == "32"
-      end
-
-      it "should set value to :lo minus :ro" do
-        varval(Hpricot::XML("<setvar name='count' lo='72' op='minus' ro='1' />").root, :string).value.should == "7"
-      end
-
-      it "should set value to :lo format :ro" #do
-        #varval(Hpricot::XML("<setvar name='count' lo='7' op='format' ro='c' />").root, :string)
-      #end
-    end
-
-    context "given a string list" do
-      it "should set value to :lo item :ro" do
-        varval(Hpricot::XML("<setvar name='count' lo='1;2;3;4' op='item' ro='1' />").root, :string).value.should == "2"
-      end
-
-      it "should set value to :lo number :ro" do
-        varval(Hpricot::XML("<setvar name='count' lo='1;2;3;4' op='number' />").root, :integer).value.should == 4
-      end
-    end
-
-    context "given a date" do
-      it "should set value to :lo plus :ro"
-
-      it "should set value to :lo minus :ro"
-    end
-  end
-end

data/spec/lib/rtml/reverse_engineering/simulator_spec.rb

@@ -1,96 +0,0 @@
-require File.join(__FILE__.gsub(/(.*)?\/spec\/.*$/, '\1'), 'spec/spec_helper')
-
-describe Rtml::ReverseEngineering::Simulator do
-  context "with a valid TML document" do
-    before :each do
-      subject.tml = File.read(File.join(Rtml.root, "spec/support/raw_tml/valid_document.tml"))
-    end
-
-    it "should allow visiting without interaction (ignoring hotkeys, hrefs, etc)" do
-      subject.visit(:nointerstart).should == 'nointerdone'
-    end
-
-    context "with preassigned variables" do
-      before :each do
-        subject.set :counter => 4
-      end
-
-      it "should use its values" do
-        subject.analyze(:variantcheck, :variantdone).should == :completion
-        subject.route.should == ['variantcheck', 'variantdone']
-      end
-    end
-
-    it "should calculate #route accurately" do
-      subject.analyze(:init, :main)
-      subject.route.should == ["init", "main"]
-    end
-
-    it "should follow variants" do
-      subject.analyze(:variantstart, :variantdone).should == :completion
-    end
-
-    it "should auto-follow variants with hotkeys" do
-      subject.analyze(:variantstart, :varianthk).should == :completion
-    end
-
-    it "should auto-follow variants with timeouts" do
-      subject.analyze(:variantstart, :variantto).should == :completion
-    end
-
-    it "should auto-follow hrefs" do
-      subject.analyze(:variantstart, :variantcancl).should == :completion
-    end
-
-    it "should return :completion when given a valid route" do
-      subject.analyze(:init, :main).should == :completion
-    end
-
-    it "should return :circular when given a circular document and invalid route" do
-      subject.analyze(:init, :main, :dead_start).should == :circular
-    end
-
-    it "should return :assertion when it results in a visit to the #assert screen" do
-      subject.analyze(:assert_start, :dead_start).should == :assertion
-    end
-
-    it "should return :dead_end when route ends before completion is met" do
-      subject.analyze(:dead_start, :dead_end, :dead_start).should == :dead_end
-    end
-
-    it "should raise an error when given a nonexistent screen ID" do
-      proc { subject.analyze :idle }.should raise_error(Rtml::Errors::ScreenNotFound)
-    end
-  end
-  
-
-  context "with an invalid XML document" do
-    # TODO: Consider moving entirely to rexml?
-    it "should raise an error" do
-      pending "migration from hpricot to rexml"
-      proc { subject.tml = "<malformedRoot>" }.should raise_error
-    end
-  end
-
-  context "with an invalid TML document" do
-    it "should raise an error when given" do
-      proc do
-        subject.tml = <<-end_tml
-          <?xml version="1.0" encoding="ISO-8859-1"?>
-          <tml xmlns="http://www.ingenico.co.uk/tml" cache="deny">
-             <head />
-
-             <screen id="main" cancel="emb://embedded.tml">
-
-               <!--error here-->  <screen />
-
-               <display>
-                 <h1>Hello, World!</h1>
-               </display>
-             </screen>
-          </tml>
-        end_tml
-      end.should raise_error(Rtml::Errors::RulesViolationError)
-    end
-  end
-end

data/spec/support/config/tml_dom_ruleset.rb

@@ -1,82 +0,0 @@
-# This file quite literally tells RTML the "rules" governing the TML document structure. You could modify this file
-# if you are directly inventing a TML-ish language of your own, but otherwise it's probably best to leave this file
-# as it is, or else you are at risk of generating invalid TML.
-#
-# Was going to store all of this in the DB, but decided it's probably better for everyone to just static load it.
-# Might revisit this someday, but for now, whatever.
-
-tags %W{
-  a baddata base br call_func card col colgroup dd defaults display div dl dt econn error form getvar h1 h2 h3 h4 h5
-  h6 head hr img input layout li link log logdcl logrec next ol p pinentry postvar pre print prompt screen setvar span
-  strtemplate submit submit_log table tbody td textarea tfoot tform th thead tml tmlpost tr ul vardcl variant
-}
-
-root :tml
-order do
-  head :base, :link, :defaults, :error
-  logdcl :vardcl, :layout
-  screen :setvar, :strtemplate, :logrec, :next, :error, :call_func, :display, :print, :submit, :tform
-  submit :econn, :getvar, :submit_log
-  table :col, :colgroup, :thead, :tfoot, :tbody, :tr
-  tform :baddata, :card, :prompt, :pinentry
-  tml :head, :vardcl, :logdcl, :screen
-end
-children :layout, all_tag_names - [:form]
-children :print, %W{div dl h1 h2 h3 h4 h5 h6 hr img log ol p pre table ul form}
-children :display, %W{a br div dl form getvar h1 h2 h3 h4 h5 h6 hr img input log ol p pre span table textarea ul}
-children :p, %W{a br getvar input span textarea}
-children do
-  a :img
-  baddata %W{a br div dl h1 h2 h3 h4 h5 h6 hr img getvar ol p pre span table ul}
-  colgroup :col
-  dd %W{a br span getvar input textarea div dl h1 h2 h3 h4 h5 h6 hr img ol p pre table ul form}
-  div %W{a br div dl form getvar h1 h2 h3 h4 h5 h6 hr img input ol p pre span table textarea ul}
-  dl %W{dt dd}, :minimum => 1 #dt+ dd+
-  dt %W{a br div dl form getvar h1 h2 h3 h4 h5 h6 hr img input ol p pre span table textarea ul}
-  econn :variant #variant*
-  error :variant #variant*
-  form %W{div dl h1 h2 h3 h4 h5 h6 hr img ol p pre table ul input textarea}
-  h1 %W{a br getvar input span textarea}
-  h2 %W{a br getvar input span textarea}
-  h3 %W{a br getvar input span textarea}
-  h4 %W{a br getvar input span textarea}
-  h5 %W{a br getvar input span textarea}
-  h6 %W{a br getvar input span textarea}
-  head %W{base defaults error}, :minimum => 0, :maximum => 1 #base?, defaults?, error?
-  head :link # link*
-  input :baddata, :minimum => 0, :maximum => 1
-  li %W{a br span getvar input textarea div dl h1 h2 h3 h4 h5 h6 hr img ol p pre table ul form}
-  log %W{vardcl layout}
-  send :next, %W{variant}
-  ol :li
-  pre %W{a br getvar input span textarea}
-  prompt %W{div dl h1 h2 h3 h4 h5 h6 hr img ol p pre table ul}
-  screen %W{setvar strtemplate logrec}
-  screen %W{next error call_func display print submit tform}, :maximum => 1
-  span %W{a br span getvar input textarea}
-  strtemplate :getvar, :minimum => 0, :maximum => 9
-  submit :econn, :maximum => 1
-  submit %W{getvar submit_log}
-  table %W{col colgroup tbody tr}
-  table %W{thead tfoot}, :maximum => 1
-  tbody :tr
-  td %W{a br span getvar input textarea div dl h1 h2 h3 h4 h5 h6 hr img ol p pre table ul form dd display li print td
-        th}
-  textarea :baddata, :maximum => 1
-  tfoot :tr
-  tform %W{baddata prompt}, :maximum => 1
-  tform :card
-  tform :pinentry, :maximum => 1
-  th %W{a br span getvar input textarea div dl h1 h2 h3 h4 h5 h6 hr img ol p pre table ul form dd display li print td
-        th}
-  thead :tr
-  tml :head, :maximum => 1
-  tml %W{vardcl logdcl screen}
-  tmlpost :postvar
-  tr :th, :td
-  ul :li
-  variant :li
-end
-
-freeze # prevent further modification of the rules
-

data/spec/widgets/subroutine_spec.rb

@@ -1,109 +0,0 @@
-require File.join(__FILE__.gsub(/(.*)?\/spec\/.*$/, '\1'), 'spec/spec_helper')
-
-describe Rtml::Widgets::Subroutine do
-  before :each do
-    @doc = Rtml::Document.new
-    @doc.boolean :condition_var
-    @doc.boolean :txn_is_emv
-
-    @doc.subroutine :return_true do |args|
-      return true
-    end
-
-    @doc.subroutine :return_false do |args|
-      return false
-    end
-
-    @doc.subroutine :check_is_emv do |args|
-      _if(tvars[:txn_is_emv] == true) { return true }
-      _else { return false }
-    end
-
-    @doc.subroutine :check_condition do |args|
-      tvars[args[:name]] = args[:value]
-      _if(tvars[args[:name]] == true) { goto :condition_is_true }
-      _else { goto :condition_is_untrue }
-    end
-  end
-
-  it "should declare the subroutine return variable" do
-    # the var isn't created until a sub is called.
-    @doc.screen :i do call(:return_true) end
-    assert @doc.variable?(:rtml_sub_return_val)
-  end
-
-  it "should be able to query whether a symbol or string is a subroutine name" do
-    assert @doc.subroutine?("return_true")
-    assert @doc.subroutine?(:return_false)
-    assert @doc.subroutine?(:check_condition)
-    assert !@doc.subroutine?(:not_a_sub)
-    assert !@doc.subroutine?('not_a_sub')
-
-    # and now from a child...
-    assert_raises RuntimeError, "subroutine :return_true not found" do
-      @doc.screen :some_screen do
-        raise if subroutine?("return_true")
-      end
-    end
-  end
-
-  it "should be able to transform the document directly" do
-    @doc.screen :condition_check_screen do
-      call :check_condition, :name => :condition_var, :value => true
-    end
-    
-    #puts @tml_docs.to_tml
-  end
-
-  # add your own tests here
-  it "should contain 2 subroutines called return_true and return_false" do
-    #assert_length 4, @tml_docs.subroutines
-    assert @doc.subroutines.keys.include?('return_true')
-    assert @doc.subroutines.keys.include?('return_false')
-  end
-
-  it "should raise NoMethodError if subroutine does not exist" do
-    assert_raises NoMethodError do
-      @doc.screen(:a_screen).call :no_method
-    end
-  end
-
-  it "should be able to call a subroutine and get the correct response" do
-    @scr = @doc.screen :a_screen
-    assert_equal ["tmlvar:rtml_sub_return_val", "equal", "tmlvar:rtml_sub_return_val"],
-                 @scr.call(:return_true) == "tmlvar:rtml_sub_return_val"
-    assert_not_nil(@var = (@scr / "setvar[name=rtml_sub_return_val]").first)
-    assert_equal true, @var.property('lo')
-    @var.to_tml.should be_valid_tml
-    assert((tml = @scr.to_tml) =~ /setvar[^>]+?lo=["']1["']/, tml)
-
-    assert_equal ["tmlvar:rtml_sub_return_val", "equal", "tmlvar:rtml_sub_return_val"],
-                 @scr.call(:return_false) == "tmlvar:rtml_sub_return_val"
-    assert_not_nil(@var = (@scr / "setvar[name=rtml_sub_return_val]").last)
-    assert_equal false, @var.property('lo')
-    @var.to_tml.should be_valid_tml
-    assert((tml = @scr.to_tml) =~ /setvar[^>]+?lo=["']0["']/, tml)
-
-    # make sure it generated setvars -- why is this necessary??
-    # update - turns out to be an artifact from reordering elements in ElementBuilder#rebuild_invalid_elements.
-    # Resolved, by simply re-adding the same element instead of building an all new one.
-    assert @doc.to_tml =~ /setvar[^>]+?lo=["']1["']/, "element missing - check ElementBuilder#rebuild_invalid_elements"
-    assert @doc.to_tml =~ /setvar[^>]+?lo=["']0["']/, "element missing - check ElementBuilder#rebuild_invalid_elements"
-  end
-
-  it "should be able to conditionally respond to subroutine results" do
-    @doc.string :ret
-    @doc.screen :get_return_value, :check_return_value do
-      tvars[:ret] = call(:check_is_emv)
-    end
-
-    @doc.screen :check_return_value do
-      _if(tvars[:ret] == true) { goto :condition_was_true }
-      _elsif(tvars[:ret] == false) { goto :condition_was_false }
-      _else { goto :condition_was_not_boolean }
-    end
-
-    # TODO: Above produces the expected TML result. Assert that this is true, and then start playing with syntax.
-    #puts @tml_docs.to_tml
-  end
-end