NAME
    Text::MicroMason::Docs::ToDo - Development Plans for the MicroMason
    Distribution

TO DO
    This document outlines various development plans and ideas for
    Text::MicroMason.

    The priority and schedule for these items are not well defined; if you
    are interested in a specific feature please contact the author as
    described in Text::MicroMason::Docs::ReadMe.

  Distribution
    *   Consider reorganizing the Text::MicroMason::* modules into a number
        of subdirectories. There are currently over two dozen of them, and
        it's bound to get worse as time goes on. Perhaps separate them by
        intent: Cache::*, Errors::*, Syntax::*, Features::*, etc.

    *   Finish and test the ParseInfo module to facilitate template
        introspection.

    *   Rewrite the MOTIVATION section of the ReadMe pod to reflect the
        shift from an HTML::Mason clone to a more general templating engine
        that has at least partial compatibilty with quite a few other
        modules.

  Interfaces
    *   Test and improve the ApacheHandler interface.

        Map user-friendly Apache config directives to mixin and
        initialization options. Review HTML::Mason::ApacheHandler,
        HTML::Mason::Params, and HTML::Mason::Admin.

        Headers need to be constructed as per
        http://modperlbook.org/html/ch06_11.html and not sent until our
        first print statement; see PLP::Tie::Print.

    *   Review integration with Inline::Mason. Facilitate use of mixins so
        this can also do inline ServerPages and other syntaxes.

  Core Syntax
    *   Determine how to best stack lex_token() method so that multiple
        syntax plugins can work together.

    *   Extract named blocks parsing from HTMLMason to form a separate
        mixin.

    *   Extract variable interpolation syntax to allow it to be stacked with
        other lexers.

  Syntax Emulations
    *   Add TemplateToolkit module with support for the basic TT syntax. The
        key syntax definition is in Parser.yp, which is used to build
        Template::Grammar.
        (<http://search.cpan.org/src/ABW/Template-Toolkit-2.14/parser/Parser
        .yp>) The Template::Stash dot notation can be handled by Data::DRef.

    *   Extend HTMLTemplate module with a hash mapping options that could be
        passed to HTML::Template's new() into the equivalent behavior, or
        croak if they're unsupported.

    *   Consider extending Embperl module to support dynamic HTML tags.

    *   Consider extending ServerPages module to support dynamic XML tags.

  Template Sources
    *   Improve TemplateDir and/or add related file-search mixin classes:

        Perhaps optionally accept a search path listing multiple directories
        to search for templates?

        Perhaps add methods to search for all files matching a given regex
        to facilitate tree searches and cache pre-fetching?

        Perhaps optionally chdir() during the execution of each template?

    *   Add a DHandlers mixin that supports default files. On file requests,
        if file not found, look for default file. (Attribute dhandler_name
        controls name of file to look for.)

    *   Add an AutoHandlers mixin that supports wrapper files. On file
        requests, also search hierarchy for autohandler files. (Attribute
        autohandler_name controls name of file to look for.) Build a stack
        of autohandlers and store it in a mason attribute. Support
        ->call_next() to work through the chain.

        (I've also gotten a user request for "decorator files" which turns
        out to be roughly equivalent to the AutoHandler system.)

    *   Add a TemplateDB mixin which shows how to retrieve templates from a
        database table. Provides a read_db() method. Accept a DBI connection
        as an attribute -- or a reference to a function which will return
        rows from a sql statement.

        Consider how to support caching for templates drawn from a
        TemplateDB. Perhaps in addition to the source_file there can be some
        kind of opaque cache key returned by the prepare method?

  Caching
    *   Add a DataCache mixin that provides a pre-configured cache object
        for use within template code. Requires cache() method and
        configuration attributes. Cache namespace should be based on source
        file name or arbitrary instance for text compilation.

    *   Add an InterpretCache mixin that allows caching of the parsed and
        assembled Perl code for a template file, akin to Mason's var/obj/
        directory. (This would also allow visual review when debugging the
        converted code.)

    *   The InterpretCache and CompileCache benefit from using a cache
        object that checks the keys as filenames to see if the source file
        has been updated and forces cache expiration; find a way to extract
        and reuse this capability from Text::MicroMason::Cache::File.

  Blessing Templates
    *   Add a BlessSub mixin that blesses the compiled subroutine. This
        would let us add support for template-specific behaviors and
        attributes. Override eval_sub() to bless sub before returning.
        Attribute bless_sub controls initializer arguments passed to
        BlessedSub class. BlessedSub class is base class for blessed
        template objects. Provides execute() method.

        BlessedSub classes may need their own mixin factory... To avoid
        having to define separate mixins for both packages, perhaps the
        methods should be delegated from the coderef to the Mason instance?
        (This becomes particularly attractive if each sub is automatically
        getting its own cloned mason instance anyway.)

    *   Add an AttrBlock mixin, using BlessedSub. Override lexer methods to
        parse <%attr> blocks. Stores attribute definitions in a %once block.
        Provides attr() method.

    *   Add a MethodBlock mixin, using BlessedSub. Override lexer methods to
        parse <%method> blocks. Stores method definitions in a %once block.
        Hooks AUTOLOAD to catch method calls.

  Internals
    *   Consider moving output_sub to a new OutputHandle mixin which accepts
        a handle as an attribute, then prints output to it rather than
        returning the results as a string.

    *   Clarify and document the clone-on-change behavior of prepare() and
        its effects when making changes to a mason object after compiling a
        template. Perhaps we should ensure that we clone every time, or at
        least every time that it matters?

  Testing
    *   Set up a benchmarking tool to compare subclasses with other
        templating solutions. Take an example from ApacheBench but execute
        templates directly rather than via Apache. Store the expected output
        in a text file for comparison.

        Other links to considerÊwhen benchmarking:

          http://www.chamas.com/bench/
          http://use.perl.org/~hctif/journal/25211
          http://www.gtchat.de/templateengines/templateengines_en.html

    *   Set up a compliance test tool that compares the output of the
        various MicroMason mixins with the other modules they emulate. This
        should be able to use many of the same data files as the
        benchmarking tool.

    *   Add more templates to samples directory and test them.

SEE ALSO
    For distribution, installation, support, copyright and license
    information, see Text::MicroMason::Docs::ReadMe.

