XForms 2.0 xf:function support

[ebruchez]

See:

http://www.w3.org/TR/xforms20/#The_function_Element

[ebruchez]

Note that the spec is not final on this yet. I had proposed a lighter syntax for the body, e.g.:

<function signature="my:foo($p as xs:decimal*) as xs:decimal">
    ...XPath expression here...
</function>

[ebruchez]

See also:

http://lists.w3.org/Archives/Public/public-forms/2013Jan/0039.html

[ebruchez]

Implementation plan:

Phase 1: only define top-level functions in the model

• static analysis
  • extract xf:function from models
  • compile functions
  • create function library for each model
• runtime
  • pass function library in scope based on model

Phase 2: functions everywhere

• in controls
• in actions
• reusable function libraries

[ebruchez]

How can a function library be reused?

• It's not practical to copy function definitions into each model.
• An "import" might be desirable, so each model can import functions.

NOTE: Imported functions wouldn't run in the scope of the model. E.g. say you have:

<xf:var name="foo"/>
<xf:function>
  $foo
</xf:function>

This would work if the function is defined directly in the model, but not if it is imported as where the function would be defined, $foo wouldn't be visible. Scoping would be lexical. However, imported functions become visible to the model as well as the view when the model is in scope.

[ebruchez]

Since #2812, XFormsStaticState exposes a function library. So now we have a convenient location to store the functions coming from <xf:function> as well.

[ebruchez]

However, the spec says:

A custom function is included in the in-scope functions of the static context for all XPath expressions associated with the model that contains the function definition

So we need a function library for each model and scope them appropriately.

[ebruchez]

Finding that I could use this right now, where I have this logic which I must duplicate:

let $key   := name/value,
    $label :=
        if (exists($key)) then
            if (not(xxf:is-blank($key))) then
                let $r := xxf:r(concat('buttons.', $key), '|fr-fr-resources|')
                return
                    if (exists($r)) then $r else $key
            else
                $key
        else
            name/name
return
    if (xxf:non-blank($label)) then
        $label
    else
        'Untitled'

[ebruchez]

+1 from customer

[ebruchez]

So right now, we have XFormsStaticState.functionLibrary, which returns a function library global to the form definition. This is used by:

• static analysis
  • CaseControl via evaluateAsLiteralIfPossible
  • PathMapXPathAnalysis
  • XPathMIP
  • XFormsStaticStateImpl.uploadMaxSizeAggregateExpression
  • XFormsStaticStateImpl.nonDefaultPropertiesOnly
• runtime
  • stored in XFormsContainingDocument
  • 19 usages for evaluation

Changes:

• [ ] Each Model has an Option[FunctionLibrary] (with the default being the part's library, or maybe the XFormsStaticState's).
• [ ] Each Model compiles it's xf:functions if any and adds them to its FunctionLibrary.
  • [ ] check/compile function signature
  • [ ] implement basic support
  • no xf:var/xf:result (we support let anyway)
  • no capturing of in-scope variables
  • Create a new SystemFunction and add it to the library.
• [ ] All callers use the Model's library when available.
• [ ] P2
  • [ ] What would it take to capture in-scope variables?
  • [ ] What would it take to support placing xf:function anywhere?
  • [ ] Possibly, support for xf:var/xf:result.

[ebruchez]

Since we need to parse the function signature, I looked at how Saxon does it in QueryParser. I managed to run simple code to just parse a declare function with the function body.

It might be possible to use that not only to parse the signature but also to parse the entire function body. The result is an XQueryFunction which is then registered with declareFunction into the QueryModule's local XQueryFunctionLibrary as well as the module's top-level (main) module's globalFunctionLibrary.

XQueryFunctionLibrary then creates instances of UserFunctionCall (or some other Expression if optimized.

We should be able to just leverage this machinery to register a model's set of xf:function:

• for each xf:function, create a string which looks like an XQuery function declaration and body
• parse the function declaration using QueryParser
• in the end, we have an XQueryFunctionLibrary

We should be able to use the resulting XQueryFunctionLibrary as context for XPath expressions. There is one question of which Executable should be passed to the functions.

When we use our own XPathCache, we create an IndependentContext for each pooled expression, which creates a new Executable(config) with XPATH as language. However, there are no tests in the code to later distinguish whether the language is set to XPATH or XQUERY. The Executable also holds the function library.

So we'll need to see whether we need to play with the QueryModule's StaticQueryContext for the function libraries at all.

With this, in the future, we might be able to leverage this to create global/importable function library modules for XForms too. For now, just one module per model should be fine.

[ebruchez]

Not easy to figure out which code keeps a pointer to Executable. It seems that the following, non-XSLT code does:

• AbstractStaticContext (super of IndependentContext)
• ExpressionVisitor (should be transient)
• GlobalVariable (not sure if used by XQuery stuff)
• QueryModule
• QueryParser (should be transient)
• StaticQueryContext
• XPathExpressionImpl (JAXP, not sure if we use)
• XQueryExpression
• XQueryFunction

[ebruchez]

It would definitely be nice if we could load function libraries shared between forms, without duplication. These libraries would be compiled once only and made available globally/per form.

[ebruchez]

At first glance, I think that for the Executable, we pretty much only need the FunctionLibrary which results from the expression compilation. So we could:

• compile a Model's functions
• get the relevant FunctionLibrary
• store that FunctionLibrary as the Model's Option[FunctionLibrary]
• that library will be in use when compiling expressions put in the XPathCache
• there might be references pointing from the FunctionLibrary, directly or indirectly, to a different Executable, but that should be fine, right?

[avernet]

+1 from customer

[ebruchez]

+1 from customer

[ebruchez]

Would be nice for a validation function like in case of customer.

[ebruchez]

+1 from Stack Overflow

[ebruchez]

Also would be good if functions could be global without duplicating them. For example:

• in runtime actions
• in Form Builder Test Service dialog

[avernet]

+1 from customer