para

use v6.d;
use XML;
use Syndicate::Stats;

unit module Syndicate::Extensions:ver<0.0.6>:auth<zef:sasha>;

# Populated at compile-time by use-statements in parser modules.
# Runtime calls to register-ext are supported but must not race
# with concurrent run-parsers/run-generators calls.
my @ext-snapshot;
my $ext-lock = Lock.new;
my atomicint $extension-errors = 0;

our sub extension-count(--> Int) is export { @ext-snapshot.elems }

our sub extension-errors(--> Int) is export { ⚛$extension-errors }

our sub remove-last-ext(--> Nil) is export {
    $ext-lock.protect: {
        my @new = @ext-snapshot.List;
        @new.pop if @new;
        @ext-snapshot = @new;
    }
}

our sub register-ext(:&parse, :&generate, Str :$namespace?, Str :$namespace-uri?) is export {
    $ext-lock.protect: {
        my @new = @ext-snapshot.List;
        @new.push: %(:&parse, :&generate, :$namespace, :$namespace-uri);
        @ext-snapshot = @new;
    }
}

our sub run-parsers($elem, %attrs, :$active?) is export {
    my @exts = @ext-snapshot;
    return unless @exts;
    my $act = $active // set-active(@exts, $elem);
    for @exts.kv -> $i, %ext {
        next unless $act{$i};
        %ext<parse>($elem, %attrs);
        CATCH {
            when X::Control { .rethrow }
            default {
                $extension-errors⚛++;
                Syndicate::Stats.record-error;
            }
        }
    }
}

our sub run-generators($xml, $item, :$active?) is export {
    my @exts = @ext-snapshot;
    return unless @exts;
    # An empty/absent set means "no restriction": items built from scratch
    # (Builder) default to Set.new/undef and must run every registered
    # generator, gated only by the item's own data.
    for @exts.kv -> $i, %ext {
        next if $active.defined && $active.elems && !$active{$i};
        %ext<generate>($xml, $item);
        CATCH {
            when X::Control { .rethrow }
            default {
                $extension-errors⚛++;
                Syndicate::Stats.record-error;
            }
        }
    }
}

our sub active-extensions(--> List) is export { @ext-snapshot }

our sub set-active(@exts, $elem) is export {
    my @prefixes = @exts.map({ .<namespace> }).grep(*.defined);
    return @exts.keys.Set unless @prefixes;

    # Fast path: activation requires a ':'-prefixed element name (see
    # activate below), so a document with no prefixed element names anywhere
    # can activate no namespaced extension. This replaces the
    # binding-aware BFS below with a plain name scan for extension-free
    # feeds. Extensions registered without a namespace stay active
    # regardless (mirroring the final activation set below).
    my sub has-prefixed-name($e) {
        return True if $e.name.contains(':');
        for $e.nodes -> $node {
            return True if $node ~~ XML::Element && has-prefixed-name($node);
        }
        False
    }
    return @exts.kv.map(-> $i, %ext { $i if !%ext<namespace> }).grep(*.defined).Set
        unless has-prefixed-name($elem);

    my %present = @prefixes.map({ $_ => False });
    my %ext-by-prefix = @exts.grep({ .<namespace>.defined }).map({ .<namespace> => $_ });
    my %ext-by-uri = @exts.grep({ .<namespace-uri>.defined }).map({ .<namespace-uri> => $_ });

    # Thread in-scope xmlns URI bindings through the tree walk. A fresh
    # hash is built only when an element actually declares xmlns:
    # attributes; otherwise the parent's hash is shared.
    my sub with-bindings(%parent, $e) {
        my %b = %parent;
        my $declared = False;
        for $e.attribs.kv -> $k, $v {
            if $k.starts-with('xmlns:') {
                %b{$k.substr(6)} = ~$v;
                $declared = True;
            }
        }
        $declared ?? %b !! %parent
    }

    # An element using a registered prefix counts when the prefix is bound
    # to the extension's namespace-uri, or — for an unbound prefix — when it
    # is the extension's own canonical prefix (lenient feeds omit the
    # xmlns declaration). A non-canonical prefix bound to a registered
    # namespace-uri activates the extension too, while a prefix bound to a
    # wrong namespace-uri never does. Returns True when the extension
    # newly activated.
    my sub activate($name, %bindings --> Bool) {
        return False unless $name.defined;
        with $name.index(':') -> $j {
            my $prefix = $name.substr(0, $j);
            my $uri = %bindings{$prefix};
            my $ext = %ext-by-prefix{$prefix}
                // ($uri.defined ?? %ext-by-uri{$uri} !! Nil);
            $ext or return False;
            my $ext-prefix = $ext.<namespace>;
            return False unless %present{$ext-prefix}:exists;
            return False if %present{$ext-prefix};
            my $canonical-undeclared = !$uri.defined && $prefix eq $ext-prefix;
            if !$ext.<namespace-uri>
                || $canonical-undeclared
                || ($uri.defined && $uri eq $ext.<namespace-uri>) {
                %present{$ext-prefix} = True;
                return True;
            }
        }
        False
    }

    my %b = with-bindings({}, $elem);
    my Int $remaining = +@prefixes;
    $remaining-- if activate($elem.name, %b);
    my @stack = ($elem, %b);
    my $i = 0;
    while $i < @stack.elems {
        my $e = @stack[$i++];
        my %bindings = @stack[$i++];
        for $e.nodes -> $node {
            next unless $node ~~ XML::Element;
            my %nb = with-bindings(%bindings, $node);
            $remaining-- if activate($node.name, %nb);
            last unless $remaining;
            @stack.push: $node;
            @stack.push: %nb;
        }
        last unless $remaining;
    }
    @exts.kv.map(-> $i, %ext { $i if !%ext<namespace> || %present{%ext<namespace>} }).grep(*.defined).Set
}



head

Syndicate::Extensions - Extension registration registry


Central registry for feed format extensions. Extensions register
parse/generate callbacks that run automatically during RSS item
parsing and XML generation.


B<Note:> All RSS parsers (RSS 0.91, RSS 1.0, RSS 2.0) unconditionally
load the DublinCore, MediaRSS, and ITunes extensions at compile time.
There is currently no opt-out mechanism to disable individual extensions.


Register an extension. C<&parse> receives an XML::Element and a mutable
hash of attributes. C<&generate> receives an XML::Element and the item
object.


Removes the most recently registered extension. Designed for test
teardown only. Must not be called concurrently with C<run-parsers>
or C<run-generators>.


Runs all registered parse callbacks. Called during RSS item parsing.
The extension snapshot is read atomically; concurrent calls to
C<remove-last-ext> during parsing are unsupported.


Runs all registered generate callbacks. Called during RSS item XML output.
Same atomic-read caveat as C<run-parsers>.


root

Feed

MediaRSS

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<AI|file:../mcp/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Extensions

NAME

DESCRIPTION

EXPORTED SUBS

`register-ext(:&parse, :&generate)`

`remove-last-ext`

`run-parsers($elem, %attrs)`

`run-generators($xml, $item)`

Syndicate v0.0.6

Authors

License

Dependencies

Test Dependencies

Provides

Documentation