fabulator 0.0.1 → 0.0.2

data/features/primitives.feature

@@ -0,0 +1,9 @@
+Feature: Expression primitives
+
+ @tuple
+ Scenario: Simple 1-tuple
+   Given a context
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+     And that [/a] is set to [([1,1])]
+   Then the expression (/a/@size) should equal [2]
+     And the expression (f:string(/a/@type)) should equal [f:uri-prefix('f') + "tuple"]

data/features/simple-control.feature

@@ -0,0 +1,13 @@
+Feature: Simple Flow Control
+
+  Scenario: 'If' with a true condition
+   Given a context
+   When I run the expression (if ( 1 = 1 ) then 'foo' else 'bar')
+   Then I should get 1 item
+     And item 0 should be ['foo']
+
+  Scenario: 'If' with a false condition
+   Given a context
+   When I run the expression (if ( 1 = 0 ) then 'foo' else 'bar')
+   Then I should get 1 item
+     And item 0 should be ['bar']

data/features/simple-math.feature

@@ -0,0 +1,18 @@
+Feature: Simple Math
+
+  Scenario Outline: binary math
+    Given a context
+      And that [/a] is set to [<a>]
+      And that [/b] is set to [<b>]
+    When I run the expression (a <op> b)
+    Then I should get 1 item
+      And item 0 should be [<ans>]
+
+    Examples:
+      |  a |  op | b | ans |
+      |  2 |  +  | 1 |  3  |
+      |  2 |  -  | 1 |  1  |
+      |  3 |  *  | 7 | 21  |
+      | 30 | div | 6 |  5  |
+      | 15 | mod | 4 |  3  |
+

data/features/simple-statemachine.feature

@@ -0,0 +1,192 @@
+@sm
+Feature: Simple state machines
+
+  Scenario: simple machine with just one state and no transitions
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#" />
+      """
+    Then it should be in the 'start' state
+
+  Scenario: simple machine with a simple transition
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:view f:name="start">
+            <f:goes-to f:view="stop">
+              <f:params>
+                <f:param f:name="foo"/>
+              </f:params>
+            </f:goes-to>
+          </f:view>
+          <f:view f:name="stop" />
+        </f:application>
+      """
+    Then it should be in the 'start' state
+    When I run it with the following params:
+      | key   | value |
+      | foo   | bar   |
+    Then it should be in the 'stop' state
+     And the expression (/foo) should equal ['bar']
+    When I run it with the following params:
+      | key   | value |
+      | foo   | bar   |
+    Then it should be in the 'stop' state
+     And the expression (/foo) should equal ['bar']
+
+  Scenario: simple machine with a simple transition and filter
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:view f:name="start">
+            <f:goes-to f:view="stop">
+              <f:params>
+                <f:param f:name="foo">
+                  <f:filter f:name="trim" />
+                </f:param>
+              </f:params>
+            </f:goes-to>
+          </f:view>
+          <f:view f:name="stop" />
+        </f:application>
+      """
+    Then it should be in the 'start' state
+    When I run it with the following params:
+      | key   | value         |
+      | foo   | bar  b  que   |
+    Then it should be in the 'stop' state
+     And the expression (/foo) should equal ['bar b que']
+
+  Scenario: simple machine with a simple transition and simple value constraint
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:view f:name="start">
+            <f:goes-to f:view="stop">
+              <f:params>
+                <f:param f:name="foo">
+                  <f:filter f:name="trim" />
+                  <f:value>bar</f:value>
+                </f:param>
+              </f:params>
+            </f:goes-to>
+          </f:view>
+          <f:view f:name="stop" />
+        </f:application>
+      """
+    Then it should be in the 'start' state
+    When I run it with the following params:
+      | key   | value         |
+      | foo   | bar  b  que   |
+    Then it should be in the 'start' state
+     And the expression (/foo) should be nil
+    When I run it with the following params:
+      | key   | value |
+      | foo   | bar   |
+    Then it should be in the 'stop' state
+     And the expression (/foo) should equal ['bar']
+
+  Scenario: simple machine with a <ensure />
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:value f:path="/foo" f:select="'bar'" />
+          <f:ensure>
+            <f:value f:path="/foo" f:select="'baz'" />
+          </f:ensure>
+        </f:application>
+      """
+    Then it should be in the 'start' state
+     And the expression (/foo) should equal ['baz']
+
+  Scenario: simple machine with a <catch />
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:value f:path="/foo" f:select="'bar'" />
+          <f:ensure>
+            <f:value f:path="/foo" f:select="'baz'" />
+          </f:ensure>
+          <f:raise f:select="'yay'" />
+          <f:catch>
+            <f:value f:path="/foo" f:select="'boo'" />
+          </f:catch>
+        </f:application>
+      """
+    Then it should be in the 'start' state
+     And the expression (/foo) should equal ['baz']
+
+  Scenario: simple machine with a <div />
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:value f:path="/foo" f:select="'bar'" />
+          <f:div>
+            <f:value f:path="/foo" f:select="'baz'" />
+          </f:div>
+        </f:application>
+      """
+    Then it should be in the 'start' state
+     And the expression (/foo) should equal ['baz']
+
+  Scenario: simple machine with a <div /> and <ensure />
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:value f:path="/foo" f:select="'bar'" />
+          <f:div>
+            <f:value f:path="/foo" f:select="'baz'" />
+          </f:div>
+          <f:ensure>
+            <f:value f:path="/foo" f:select="'boo'" />
+          </f:ensure>
+        </f:application>
+      """
+    Then it should be in the 'start' state
+     And the expression (/foo) should equal ['boo']
+
+  @steps
+  Scenario: simple machine with a 2 simple transitions
+    Given the statemachine
+      """
+        <f:application xmlns:f="http://dh.tamu.edu/ns/fabulator/1.0#">
+          <f:view f:name="start">
+            <f:goes-to f:view="step1">
+              <f:params>
+                <f:param f:name="foo">
+                  <f:filter f:name="trim" />
+                  <f:value>bar</f:value>
+                </f:param>
+              </f:params>
+            </f:goes-to>
+          </f:view>
+          <f:view f:name="step1">
+            <f:goes-to f:view="stop">
+              <f:params>
+                <f:param f:name="bar">
+                  <f:filter f:name="trim" />
+                  <f:value>baz</f:value>
+                </f:param>
+              </f:params>
+            </f:goes-to>
+          </f:view>
+          <f:view f:name="stop" />
+        </f:application>
+      """
+    Then it should be in the 'start' state
+    When I run it with the following params:
+      | key   | value         |   
+      | foo   | bar  b  que   |
+    Then it should be in the 'start' state
+     And the expression (/foo) should be nil
+    When I run it with the following params:
+      | key   | value |
+      | foo   | bar   |
+    Then it should be in the 'step1' state
+     And the expression (/foo) should equal ['bar']
+    When I run it with the following params:
+      | key   | value |
+      | bar   | baz   |
+    Then it should be in the 'stop' state
+     And the expression (/foo) should equal ['bar']
+     And the expression (/bar) should equal ['baz']

data/features/step_definitions/expression_steps.rb

@@ -0,0 +1,102 @@
+require 'yaml'
+
+Transform /^(expression|context) \((.*)\)$/ do |n, arg|
+  @context ||= Fabulator::Expr::Context.new
+  @parser ||= Fabulator::Expr::Parser.new
+  @parser.parse(arg, @context)
+end
+
+Transform /^\[(.*)\]$/ do |arg|
+  @context ||= Fabulator::Expr::Context.new
+  @parser ||= Fabulator::Expr::Parser.new
+  @parser.parse(arg, @context)
+end
+
+Transform /^(\d+)$/ do |arg|
+  arg.to_i
+end
+
+Given 'a context' do
+  @context ||= Fabulator::Expr::Context.new
+  @parser ||= Fabulator::Expr::Parser.new
+end
+
+Given /the prefix (\S+) as "([^"]+)"/ do |p,h|
+  @context ||= Fabulator::Expr::Context.new
+  @context.set_ns(p, h)
+end
+
+Given /that (\[.*\]) is set to (\[.*\])/ do |l,r|
+  @context.set_value(l, r)
+end
+
+When /I run the (expression \(.*\)) in the (context \(.*\))/ do |exp, cp|
+  @expr = exp
+  if cp.nil? || cp == ''
+    @result = []
+    @cp = @context.root
+  else
+    @cp = cp.run(@context).first || @context.root
+    @result = @expr.run(@context.with_root(@cp))
+  end
+end
+
+When /I run the (expression \(.*\))/ do |exp|
+  ## assume '/' as the context here
+  @expr = exp
+  @cp = @data
+  #puts YAML::dump(@expr)
+  @result = @expr.run(@context.with_root(@cp))
+  #puts YAML::dump(@result)
+end
+
+When /I unify the types? (.*)/ do |ts|
+  types = ts.split(/\s*,\s*/)
+  typea = types.collect { |t|
+      pn = t.split(/:/, 2)
+      [ @context.get_ns(pn[0]), pn[1] ]
+    }
+  @type_result = Fabulator::ActionLib.unify_types(
+    types.collect { |t|
+      pn = t.split(/:/, 2)
+      [ @context.get_ns(pn[0]), pn[1] ]
+    }
+  )
+end
+
+Then /I should get the type (.*)/ do |t|
+  pn = t.split(/:/, 2)
+  @type_result[0].should == @context.get_ns(pn[0])
+  @type_result[1].should == pn[1]
+end
+
+Then /I should get (\d+) items?/ do |count|
+  @result.length.should == count
+end
+
+Then /item (\d+) should be (\[.*\])/ do |i,t|
+  test = t.run(@context.with_root(@cp)).first
+   #puts "Result: #{@result[i.to_i].to_s.class.to_s}"
+  @result[i.to_i].to_s.should == test.to_s
+end
+
+Then /item (\d+) should be false/ do |i|
+  (!!@result[i.to_i].value).should == false
+end
+
+Then /item (\d+) should be true/ do |i|
+  (!!@result[i.to_i].value).should == true
+end
+
+Then /the (expression \(.*\)) should equal (\[.*\])/ do |x, y|
+  a = x.run(@context)
+  b = y.run(@context)
+  #puts YAML::dump(a)
+  #puts YAML::dump(b)
+  #puts YAML::dump(@context)
+  a.first.value.should == b.first.value
+end
+
+Then /the (expression \(.*\)) should be nil/ do |x|
+  x.run(@context).first.should == nil
+end

data/features/step_definitions/template_steps.rb

@@ -0,0 +1,25 @@
+Given /^the template$/ do |doc_xml|
+  @template_text = doc_xml
+end
+
+When /^I render the template$/ do
+  parser = Fabulator::Template::Parser.new
+  @template_result = parser.parse(@context, @template_text)
+end
+
+When /^I set the captions to:$/ do |caption_table|
+  captions = { }
+  caption_table.hashes.each do |h|
+    captions[h['path']] = h['caption']
+  end
+
+  @template_result.add_captions(captions)
+end
+
+Then /^the rendered text should equal$/ do |doc|
+  @template_result.to_s.should == %{<?xml version="1.0" encoding="UTF-8"?>\n} + doc + "\n"
+end
+
+Then /^the rendered html should equal$/ do |doc|
+  @template_result.to_html.should == doc
+end

data/features/step_definitions/xml_steps.rb

@@ -0,0 +1,23 @@
+Given /the statemachine/ do |doc_xml|
+  @context ||= Fabulator::Expr::Context.new
+
+  if @sm.nil?
+    @sm = Fabulator::Core::StateMachine.new.compile_xml(doc_xml)
+  else
+    @sm.compile_xml(doc_xml)
+  end
+  @sm.init_context(@context)
+end
+
+When /I run it with the following params:/ do |param_table|
+  params = { }
+  param_table.hashes.each do |hash|
+    params[hash['key']] = hash['value']
+  end
+  @sm.run(params)
+  #puts YAML::dump(@sm)
+end
+
+Then /it should be in the '(.*)' state/ do |s|
+  @sm.state.should == s
+end

data/features/support/env.rb

@@ -0,0 +1,7 @@
+# This file makes it possible to install RubyCAS-Client as a Rails plugin.
+
+$: << File.expand_path(File.dirname(__FILE__))+'/../../lib'
+
+require 'fabulator'
+require 'fabulator/template'
+require 'spec/expectations'

data/features/templates.feature

@@ -0,0 +1,100 @@
+@tmpl
+Feature: Templates
+
+  Scenario: Rendering a simple template
+   Given a context
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+     And the template
+       """
+<foo></foo>
+       """
+   When I render the template
+   Then the rendered text should equal
+       """
+<foo/>
+       """
+
+  Scenario: Rendering a choice in a template
+   Given a context
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+     And the template
+       """
+<foo>
+  <r:choose>
+    <r:when test="f:true()">
+      true
+    </r:when>
+    <r:otherwise>
+      false
+    </r:otherwise>
+  </r:choose>
+</foo>
+       """
+   When I render the template
+   Then the rendered text should equal
+       """
+<foo>
+
+
+      true
+
+
+
+</foo>
+       """
+
+  Scenario: Rendering a choice in a template
+   Given a context
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+     And the template
+       """
+<foo>
+  <r:choose>
+    <r:when test="f:false()">
+      true
+    </r:when>
+    <r:otherwise>
+      false
+    </r:otherwise>
+  </r:choose>
+</foo>
+       """
+   When I render the template
+   Then the rendered text should equal
+       """
+<foo>
+
+
+
+      false
+
+
+</foo>
+       """
+
+  Scenario: Rendering a form with captions
+   Given a context
+     And the prefix f as "http://dh.tamu.edu/ns/fabulator/1.0#"
+     And the template
+       """
+<view>
+  <form>
+    <textline id='foo'><caption>Foo</caption></textline>
+    <submit id='submit'/>
+  </form>
+</view>
+       """
+   When I render the template
+    And I set the captions to:
+      | path   | caption       |
+      | foo    | FooCaption    |
+      | submit | SubmitCaption |
+   Then the rendered text should equal
+       """
+<view>
+  <form>
+    <textline id="foo"><caption>FooCaption</caption></textline>
+    <submit id="submit"><caption>SubmitCaption</caption></submit>
+  </form>
+</view>
+       """