AxKit2

 view release on metacpan or  search on metacpan

demo/webmail/js/prototype.js  view on Meta::CPAN

}

var Insertion = new Object();

Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
  initializeRange: function() {
    this.range.setStartBefore(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.parentNode.insertBefore(fragment, this.element);
    }).bind(this));
  }
});

Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(true);
  },

  insertContent: function(fragments) {
    fragments.reverse(false).each((function(fragment) {
      this.element.insertBefore(fragment, this.element.firstChild);
    }).bind(this));
  }
});

Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
  initializeRange: function() {
    this.range.selectNodeContents(this.element);
    this.range.collapse(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.appendChild(fragment);
    }).bind(this));
  }
});

Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
  initializeRange: function() {
    this.range.setStartAfter(this.element);
  },

  insertContent: function(fragments) {
    fragments.each((function(fragment) {
      this.element.parentNode.insertBefore(fragment,
        this.element.nextSibling);
    }).bind(this));
  }
});

/*--------------------------------------------------------------------------*/

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
  initialize: function(element) {

lib/AxKit2/XSP/SimpleTaglib.pm  view on Meta::CPAN

    my ($document, $parent, $namespaces, @data) = @_;
    foreach my $data (@data) {
        if (UNIVERSAL::isa($data,'XML::LibXML::Document')) {
            $data = $data->getDocumentElement();
        }
        if (UNIVERSAL::isa($data,'XML::LibXML::Node')) {
            $document->importNode($data);
            $parent->appendChild($data);
            next;
        }
        die 'data is not a hash ref or DOM fragment!' unless ref($data) eq 'HASH';
        while (my ($key, $val) = each %$data) {
            my $outer_namespaces_added = 0;
            if (substr($key,0,1) eq '@') {
                $key = substr($key,1);
                die 'attribute value is not a simple scalar!' if ref($val);
                next if $key =~ m/^xmlns(?::|$)/; # already processed these
                my ($ns, $prefix, $name) = parse_namespace($key);
                #$prefix = _lookup_prefix($ns, $namespaces) if $ns and not $prefix;
                $ns = _lookup_ns($prefix, $namespaces) if not $ns and $prefix;
                $name = $prefix.':'.$name if $prefix;

lib/AxKit2/XSP/SimpleTaglib.pm  view on Meta::CPAN

What happens in between can be configured in many ways
using Perl function attributes. In the rare cases where some action has to happen during
the opening tag event, you may provide a sub "foo__open" (double underscore)
which will be called at the appropriate time. Usually you would only do that for 'if'-
style tags which enclose some block of code. 'if'-style tags usually also need the C<XSP_compile>
flag.

Contrary to the former behaviour, your tag handler is called during the XSP execution stage,
so you should directly return the result value. The C<XSP_compile> flag is available to
have your handler called in the parse stage, when the XSP script is being constructed. Then,
it is the responsibility of the handler to return a I<Perl code fragment> to be appended to
the XSP script.

As a comparison, TaglibHelper subs are strictly run-time called, while plain taglibs without
any helper are strictly compile-time called.

B<Warning:> The old usage is still fully supported, but you should not use it anymore. It may
become deprecated in a future release and will be removed entirely afterwards. Porting it
to the new style usage is quite easy: remove the line reading "package I<your-taglib>::Handler;",
then prefix "XSP_" to all Perl attributes (e.g., "childStruct" becomes "XSP_childStruct"), and add
"XSP_compile" to every handler sub. If after your refactoring some handler sub doesn't carry any

lib/AxKit2/XSP/SimpleTaglib.pm  view on Meta::CPAN

In the default (run-time called) mode, subs get 4 parameters: the tag name, a hashref
containing attributes and child tags specified through C<XSP_child>/C<XSP_attribOrChild>, a
hashref for taglib private data (the current C<XSP_stack> hashref, if C<XSP_stack> is used),
and the C<XSP_smart> object, if applicable.

In C<XSP_compile> mode, the called subs get passed 3 parameters: The parser object, the tag name,
and an attribute hash (no ref!). This hash only contains XML attributes declared using the
'attrib()' Perl function attribute. (Try not to confuse these two meanings of 'attribute' -
unfortunately XML and Perl both call them that way.) The other declared parameters get converted
into local variables with prefix 'attr_', or, in the case of 'XSP_smart', converted into the
'$xml_subtree' object. These local variables are only available inside your code fragment which
becomes part of the XSP script, unlike the attribute hash which is passed directly to
your handler as the third parameter.

If a sub has an output attribute ('node', 'expr', etc.), the sub (or code fragment) will be run
in list context. If necessary, returned lists get converted to scalars by joining them
without separation. Code fragments from plain subs (without an output attribute) inherit
their context and have their return value left unmodified.

=head2 Precedence

If more than one handler matches a tag, the following rules determine which one is chosen.
Remember, though, that only tags in your namespace are considered.

=over 4

=item 1.

lib/AxKit2/XSP/SimpleTaglib.pm  view on Meta::CPAN

XML::Smart object tree.

=item 4.

If no handler sub matches, sub "_default" is tried.

=back

=head2 Utility functions

AxKit2::Transformer::XSP contains a few handy utility subs to help build your code fragment:

=over 4

=item start_elem, end_elem, start_attr, end_attr

these create elements and attributes
in the output document. Call them just like you call start_expr and end_expr.

=item makeSingleQuoted

given a scalar as input, it returns a scalar which yields
the exact input value when evaluated; handy when using unknown text as-is in code fragments.

=item makeVariableName

creates a valid, readable perl identifier from arbitrary input text.
The return values might overlap.

=back

=head1 PERL ATTRIBUTES

Perl function attributes are used to define how XML output should be generated from your
code fragment and how XML input should be presented to your handler.  Note that
parameters to attributes get handled as if 'q()' enclosed them (explicit quote marks are
not needed). Furthermore, commas separate parameters (except for childStruct), so a
parameter cannot contain a comma.

=head2 Output attributes

Choose exactly one of these to select output behaviour.

=head3 C<XSP>

lib/AxKit2/XSP/SimpleTaglib.pm  view on Meta::CPAN

otherwise it will work like 'expr'. C<attrname> defaults to 'as', C<attrvalue> defaults to
'node', thus leaving out both parameters means that 'as="node"' will select 'node()' behaviour.
Choose this if you want to let the XSP author decide what to generate.

=head3 C<XSP_exprOrNodelist(name,attrname,attrvalue)>

Like exprOrNode, selecting between 'expr' and 'nodelist()' behaviour.

=head3 C<XSP_struct>

Makes this tag create a more complex XML fragment. You may return a single hashref or an array
of hashrefs, which get converted into an XML structure. Each hash element may contain a scalar,
which gets converted into an XML tag with the key as name and the value as content. Alternatively,
an element may contain an arrayref, which means that an XML tag encloses each single array element.
Finally, you may use hashrefs in place of scalars to create substructures. To create attributes on
tags, use a hashref that contain the attribute names prefixed by '@'. A '' (empty
string) as key denotes the text contents of that node.

You can also use a XML::LibXML::Document or XML::LibXML::Node object in place of a hashref. You
can, for example, simply return an XML::LibXML::Document object and it gets inserted at the current
location. You may also return an array of documents/nodes, and you may even mix plain hashrefs

lib/AxKit2/XSP/SimpleTaglib.pm  view on Meta::CPAN

Finally, you may also return an XML::Simple object.

In an expression context, passes on the unmodified return value.

=head2 Other output attributes

These may appear more than once and modify output behaviour.

=head3 C<XSP_compile>

Makes this tag called at XSP compile time, not run time. It must return a Perl code fragment.
For more details, see the sections above.

=head3 C<XSP_nodeAttr(name,expr,...)>

Adds an XML attribute named C<name> to all generated nodes. C<expr> gets evaluated at run time.
Evaluation happens once for each generated node. Of course, this tag only makes sense with
'node()' type handlers.

=head2 Input attributes

lib/AxKit2/XSP/SimpleTaglib.pm  view on Meta::CPAN

=head3 C<XSP_attrib(name,...)>

Declares C<name> as a (non-mandatory) XML attribute. All attributes declared this way get
passed to your handler sub in the attribute hash (the third argument to your handler).

=head3 C<XSP_child(name,...)>

Declares a child tag C<name>. It always lies within the same namespace as the taglib itself. The
contents of the tag, if any, get saved in a local variable named $attr_C<name> and made
available to your code fragment. If the child tag appears more than once, the last value
overrides any previous value.

=head3 C<XSP_attribOrChild(name,...)>

Declares an attribute or child tag named C<name>. A variable is created just like for 'child()',
containing the attribute or child tag contents. If both appear, the contents of the child tag take
precedence.

=head3 C<XSP_keepWhitespace>

Makes this tag preserve contained whitespace.

=head3 C<XSP_captureContent>

Makes this tag store the enclosed content in '$_' for later retrieval in your code fragment instead
of adding it to the enclosing element. Non-text nodes will not work as expected.

=head3 C<XSP_stack(attrname)>

This will create a stack of objects for your taglib. Each taglib has exactly one stack, however.

Stacks work like this:

Whenever a tag is encountered that is flagged with C<XSP_stack>, a new empty stack frame (hashref) is created.
ALL handler subs get this hashref as their third argument where they may store/retrieve any data.

lib/AxKit2/XSP/SimpleTaglib.pm  view on Meta::CPAN

code of AxKit::XSP::Sessions and AxKit::XSP::Auth for full-featured examples. Beware, though,
they probably still use the old syntax.

=head1 BUGS AND HINTS

=head2 Miscellaneous

Because of the use of perl attributes, SimpleTaglib will only work with Perl 5.6.0 or later.
This software is already tested quite well and works for a number of simple and complex
taglibs. Still, you may have to experiment with the attribute declarations, as the differences
can be quite subtle but decide between 'it works' and 'it doesn't'. XSP can be quite fragile if
you start using heavy trickery.

If some tags don't work as expected, try surrounding the offending tag with
<xsp:content>, this is a common gotcha (but correct and intended). If you find you need
<xsp:expr> around a tag, please contact the author, that is probably a bug.

=head1 AUTHOR

Jörg Walter <jwalt@cpan.org>

lib/AxKit2/XSP/TaglibHelper.pm  view on Meta::CPAN

    my ($name) = @_;
    return { 
        person => { 
        name => $name,
        age => 25,
        height => 200,
        }
    }
  }

...and you called them with this xsp fragment:

  <test:hello>
    <test:name>Joe</test:name>
  </test:hello>

  <test:get-person name="Bob"/>

...you would get this XML result:

  Hello, Joe!