//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

* The root module for Tapestry.

*/

    private final PipelineBuilder pipelineBuilder;

    private final ApplicationGlobals applicationGlobals;

    private final PropertyShadowBuilder shadowBuilder;

    private final Environment environment;

    private final StrategyBuilder strategyBuilder;

    private final PropertyAccess propertyAccess;

    private final ChainBuilder chainBuilder;

    private final Request request;

    private final Response response;

    private final ThreadLocale threadLocale;

    private final RequestGlobals requestGlobals;

    private final EnvironmentalShadowBuilder environmentalBuilder;

    private final EndOfRequestEventHub endOfRequestEventHub;

    /**

     * We inject all sorts of common dependencies (including builders) into the module itself (note: even though some of

     * these service are defined by the module itself, that's ok because services are always lazy proxies).  This isn't

     * about efficiency (it may be slightly more efficient, but not in any noticable way), it's about eliminating the

     * need to keep injecting these dependencies into invividual service builder and contribution methods.

     */

    public TapestryModule(PipelineBuilder pipelineBuilder,

                          PropertyShadowBuilder shadowBuilder,

                          RequestGlobals requestGlobals,

                          ApplicationGlobals applicationGlobals,

                          ChainBuilder chainBuilder,

                          Environment environment,

                          StrategyBuilder strategyBuilder,

                          PropertyAccess propertyAccess,

                          Request request,

                          Response response,

                          ThreadLocale threadLocale,

                          EnvironmentalShadowBuilder environmentalBuilder,

                          EndOfRequestEventHub endOfRequestEventHub)

    {

        this.pipelineBuilder = pipelineBuilder;

        this.shadowBuilder = shadowBuilder;

        this.requestGlobals = requestGlobals;

        this.applicationGlobals = applicationGlobals;

        this.chainBuilder = chainBuilder;

        this.environment = environment;

        this.strategyBuilder = strategyBuilder;

        this.propertyAccess = propertyAccess;

        this.request = request;

        this.response = response;

        this.threadLocale = threadLocale;

        this.environmentalBuilder = environmentalBuilder;

        this.endOfRequestEventHub = endOfRequestEventHub;

    }

    // A bunch of classes "promoted" from inline inner class to nested classes,

    // just so that the stack trace would be more readable. Most of these

    // are teminators for pipeline services.

    /**

     * @since 5.1.0.0

     */

    private class ApplicationInitializerTerminator implements ApplicationInitializer

    {

        public void initializeApplication(Context context)

        {

            applicationGlobals.storeContext(context);

        }

    }

    /**

     * @since 5.1.0.0

     */

    private class HttpServletRequestHandlerTerminator implements HttpServletRequestHandler

    {

        private final RequestHandler handler;

        private final String applicationCharset;

        private final SessionPersistedObjectAnalyzer analyzer;

        public HttpServletRequestHandlerTerminator(RequestHandler handler, String applicationCharset,

                                                   SessionPersistedObjectAnalyzer analyzer)

        {

            this.handler = handler;

            this.applicationCharset = applicationCharset;

            this.analyzer = analyzer;

        }

        public boolean service(HttpServletRequest servletRequest, HttpServletResponse servletResponse)

                throws IOException

        {

            requestGlobals.storeServletRequestResponse(servletRequest, servletResponse);

            Request request = new RequestImpl(servletRequest, applicationCharset, analyzer);

            Response response = new ResponseImpl(servletResponse);

            // TAP5-257: Make sure that the "initial guess" for request/response is available, even if

            // some filter in the RequestHandler pipeline replaces them.

            requestGlobals.storeRequestResponse(request, response);

            // Transition from the Servlet API-based pipeline, to the Tapestry-based pipeline.

            return handler.service(request, response);

        }

    }

    /**

     * @since 5.1.0.0

     */

    private class ServletApplicationInitializerTerminator implements ServletApplicationInitializer

    {

        private final ApplicationInitializer initializer;

        public ServletApplicationInitializerTerminator(ApplicationInitializer initializer)

        {

            this.initializer = initializer;

        }

        public void initializeApplication(ServletContext servletContext)

        {

            applicationGlobals.storeServletContext(servletContext);

            // And now, down the (Web) ApplicationInitializer pipeline ...

            ContextImpl context = new ContextImpl(servletContext);

            applicationGlobals.storeContext(context);

            initializer.initializeApplication(context);

        }

    }

     * @since 5.1.0.0

     */

    private class RequestHandlerTerminator implements RequestHandler

    {

        private final Dispatcher masterDispatcher;

        public RequestHandlerTerminator(Dispatcher masterDispatcher)

        {

            this.masterDispatcher = masterDispatcher;

        }

        public boolean service(Request request, Response response) throws IOException

        {

            // Update RequestGlobals with the current request/response (in case some filter replaced the

            // normal set).

            requestGlobals.storeRequestResponse(request, response);

            return masterDispatcher.dispatch(request, response);

        }

    }

    public static void bind(ServiceBinder binder)

    {

        binder.bind(ClasspathAssetAliasManager.class, ClasspathAssetAliasManagerImpl.class);

        binder.bind(PersistentLocale.class, PersistentLocaleImpl.class);

        binder.bind(ApplicationStateManager.class, ApplicationStateManagerImpl.class);

        binder.bind(ApplicationStatePersistenceStrategySource.class,

                    ApplicationStatePersistenceStrategySourceImpl.class);

        binder.bind(BindingSource.class, BindingSourceImpl.class);

        binder.bind(FieldValidatorSource.class, FieldValidatorSourceImpl.class);

        binder.bind(ApplicationGlobals.class, ApplicationGlobalsImpl.class);

        binder.bind(AssetSource.class, AssetSourceImpl.class);

        binder.bind(Cookies.class, CookiesImpl.class);

        binder.bind(FieldValidatorDefaultSource.class, FieldValidatorDefaultSourceImpl.class);

        binder.bind(RequestGlobals.class, RequestGlobalsImpl.class);

        binder.bind(ResourceDigestGenerator.class, ResourceDigestGeneratorImpl.class);

        binder.bind(ValidationConstraintGenerator.class, ValidationConstraintGeneratorImpl.class);

        binder.bind(EnvironmentalShadowBuilder.class, EnvironmentalShadowBuilderImpl.class);

        binder.bind(ComponentSource.class, ComponentSourceImpl.class);

        binder.bind(BeanModelSource.class, BeanModelSourceImpl.class);

        binder.bind(BeanBlockSource.class, BeanBlockSourceImpl.class);

        binder.bind(ComponentDefaultProvider.class, ComponentDefaultProviderImpl.class);

        binder.bind(MarkupWriterFactory.class, MarkupWriterFactoryImpl.class);

        binder.bind(FieldValidationSupport.class, FieldValidationSupportImpl.class);

        binder.bind(ObjectRenderer.class, LocationRenderer.class).withId("LocationRenderer");

        binder.bind(ObjectProvider.class, AssetObjectProvider.class).withId("AssetObjectProvider");

        binder.bind(RequestExceptionHandler.class, DefaultRequestExceptionHandler.class);

        binder.bind(ComponentEventResultProcessor.class, ComponentInstanceResultProcessor.class).withId(

                "ComponentInstanceResultProcessor");

        binder.bind(NullFieldStrategySource.class, NullFieldStrategySourceImpl.class);

        binder.bind(HttpServletRequestFilter.class, IgnoredPathsFilter.class).withId("IgnoredPathsFilter");

        binder.bind(ContextValueEncoder.class, ContextValueEncoderImpl.class);

        binder.bind(BaseURLSource.class, BaseURLSourceImpl.class);

        binder.bind(BeanBlockOverrideSource.class, BeanBlockOverrideSourceImpl.class);

        binder.bind(AliasManager.class, AliasManagerImpl.class).withId("AliasOverrides");

        binder.bind(HiddenFieldLocationRules.class, HiddenFieldLocationRulesImpl.class);

        binder.bind(PageDocumentGenerator.class, PageDocumentGeneratorImpl.class);

        binder.bind(ResponseRenderer.class, ResponseRendererImpl.class);

        binder.bind(FieldTranslatorSource.class, FieldTranslatorSourceImpl.class);

        binder.bind(BindingFactory.class, MessageBindingFactory.class).withId("MessageBindingFactory");

        binder.bind(BindingFactory.class, ValidateBindingFactory.class).withId("ValidateBindingFactory");

        binder.bind(BindingFactory.class, TranslateBindingFactory.class).withId("TranslateBindingFactory");

        binder.bind(BindingFactory.class, AssetBindingFactory.class).withId("AssetBindingFactory");

        binder.bind(BindingFactory.class, ContextBindingFactory.class).withId("ContextBindingFactory");

        binder.bind(BindingFactory.class, NullFieldStrategyBindingFactory.class).withId(

                "NullFieldStrategyBindingFactory");

        binder.bind(URLEncoder.class, URLEncoderImpl.class);

        binder.bind(ContextPathEncoder.class, ContextPathEncoderImpl.class);

        binder.bind(UpdateListenerHub.class, UpdateListenerHubImpl.class);

        binder.bind(ApplicationStatePersistenceStrategy.class, SessionApplicationStatePersistenceStrategy.class).withId(

                "SessionApplicationStatePersistenceStrategy");

        binder.bind(AssetPathConverter.class, IdentityAssetPathConverter.class);

        binder.bind(NumericTranslatorSupport.class);

        binder.bind(ClientDataEncoder.class, ClientDataEncoderImpl.class);

        binder.bind(ComponentEventLinkEncoder.class, ComponentEventLinkEncoderImpl.class);

        binder.bind(PageRenderLinkSource.class, PageRenderLinkSourceImpl.class);

        binder.bind(ClientInfrastructure.class, ClientInfrastructureImpl.class);

    }

    // ========================================================================

    //

    // Service Builder Methods (static)

    //

    // ========================================================================

    @PreventServiceDecoration

    public static Alias buildAlias(Logger logger,

                                   @Inject @Symbol(InternalSymbols.ALIAS_MODE)

                                   String mode,

                                   @InjectService("AliasOverrides")

                                   AliasManager overridesManager,

                                   Collection<AliasContribution> configuration)

    {

        AliasManager manager = new AliasManagerImpl(logger, configuration);

        return new AliasImpl(manager, mode, overridesManager);

    }

    // ========================================================================

    //

    // Service Contribution Methods (static)

    //

    // ========================================================================

    /**

     * Contributes the factory for serveral built-in binding prefixes ("asset", "block", "component", "literal", prop",

     * "nullfieldstrategy", "message", "validate", "translate", "var").

     */

    public static void contributeBindingSource(MappedConfiguration<String, BindingFactory> configuration,

                                               @InjectService("PropBindingFactory")

                                               BindingFactory propBindingFactory,

                                               @InjectService("MessageBindingFactory")

                                               BindingFactory messageBindingFactory,

                                               @InjectService("ValidateBindingFactory")

                                               BindingFactory validateBindingFactory,

                                               @InjectService("TranslateBindingFactory")

                                               BindingFactory translateBindingFactory,

                                               @InjectService("AssetBindingFactory")

                                               BindingFactory assetBindingFactory,

                                               @InjectService("NullFieldStrategyBindingFactory")

                                               BindingFactory nullFieldStrategyBindingFactory,

                                               @InjectService("ContextBindingFactory")

                                               BindingFactory contextBindingFactory)

    {

        configuration.add(BindingConstants.LITERAL, new LiteralBindingFactory());

        configuration.add(BindingConstants.COMPONENT, new ComponentBindingFactory());

        configuration.add(BindingConstants.VAR, new RenderVariableBindingFactory());

        configuration.add(BindingConstants.BLOCK, new BlockBindingFactory());

        configuration.add(BindingConstants.PROP, propBindingFactory);

        configuration.add(BindingConstants.MESSAGE, messageBindingFactory);

        configuration.add(BindingConstants.VALIDATE, validateBindingFactory);

        configuration.add(BindingConstants.TRANSLATE, translateBindingFactory);

        configuration.add(BindingConstants.ASSET, assetBindingFactory);

        configuration.add(BindingConstants.NULLFIELDSTRATEGY, nullFieldStrategyBindingFactory);

        configuration.add(BindingConstants.CONTEXT, contextBindingFactory);

    }

    public static void contributeClasspathAssetAliasManager(MappedConfiguration<String, String> configuration,

                                                            @Symbol(SymbolConstants.TAPESTRY_VERSION)

                                                            String tapestryVersion,

                                                            @Symbol(SymbolConstants.APPLICATION_VERSION)

                                                            String applicationVersion,

                                                            @Symbol(InternalConstants.TAPESTRY_APP_PACKAGE_PARAM)

                                                            String appPackage,

                                                            // @Inject not needed, because this isn't a service builder method

                                                            @Symbol("tapestry.scriptaculous.path")

                                                            String scriptaculousPath,

                                                            @Symbol("tapestry.datepicker.path")

                                                            String datepickerPath,

                                                            @Symbol("tapestry.blackbird.path")

                                                            String blackbirdPath)

    {

        // TAPESTRY-2159:  All the classpath assets are inside a version numbered folder (i.e., 5.0.12).

        // For scriptaculous, etc., this version is not the version of the library, but the version

        // of Tapestry.

        configuration.add("tapestry/" + tapestryVersion, "org/apache/tapestry5");

        configuration.add("scriptaculous/" + tapestryVersion, scriptaculousPath);

        configuration.add("datepicker/" + tapestryVersion, datepickerPath);

        configuration.add("blackbird/" + tapestryVersion, blackbirdPath);

        configuration.add("app/" + applicationVersion, appPackage.replace('.', '/'));

        configuration.add("classpath/" + applicationVersion, "");

    }

    public static void contributeComponentClassResolver(Configuration<LibraryMapping> configuration)

    {

        configuration.add(new LibraryMapping("core", "org.apache.tapestry5.corelib"));

    }

    /**

     * Adds a number of standard component class transform workers: <dl> <dt>Retain </dt> <dd>Allows fields to retain

     * their values between requests</dd> <dt>Persist </dt> <dd>Allows fields to store their their value persistently

     * between requests</dd> <dt>Parameter </dt> <dd>Identifies parameters based on the {@link

     * org.apache.tapestry5.annotations.Parameter} annotation</dd> <dt>Component </dt> <dd>Defines embedded components

     * based on the {@link org.apache.tapestry5.annotations.Component} annotation</dd> <dt>Mixin </dt> <dd>Adds a mixin

     * as part of a component's implementation</dd> <dt>Environment </dt> <dd>Allows fields to contain values extracted

     * from the {@link org.apache.tapestry5.services.Environment} service</dd> <dt>Inject </dt> <dd>Used with the {@link

     * org.apache.tapestry5.ioc.annotations.Inject} annotation, when a value is supplied</dd> <dt>InjectService</dt>

     * <dd>Handles the {@link org.apache.tapestry5.ioc.annotations.InjectService} annotation</dd> <dt>InjectPage</dt>

     * <dd>Adds code to allow access to other pages via the {@link org.apache.tapestry5.annotations.InjectPage} field

     * annotation</dd> <dt>InjectBlock </dt> <dd>Allows a block from the template to be injected into a field</dd>

     * <dt>IncludeStylesheet </dt> <dd>Supports the {@link org.apache.tapestry5.annotations.IncludeStylesheet}

     * annotation</dd> <dt>IncludeJavaScriptLibrary </dt> <dd>Supports the {@link org.apache.tapestry5.annotations.IncludeJavaScriptLibrary}

     * annotation</dd> <dt>SupportsInformalParameters </dt> <dd>Checks for the annotation</dd> <dt>Meta </dt> <dd>Checks

     * for meta data and adds it to the component model</dd> <dt>ApplicationState </dt> <dd>Converts fields that

     * reference application state objects <dt>UnclaimedField </dt> <dd>Identifies unclaimed fields and resets them to

     * null/0/false at the end of the request</dd> <dt>RenderCommand </dt> <dd>Ensures all components also implement

     * {@link org.apache.tapestry5.runtime.RenderCommand}</dd> <dt>SetupRender, BeginRender, etc. </dt> <dd>Correspond

     * to component render phases and annotations</dd> <dt>InvokePostRenderCleanupOnResources </dt> <dd>Makes sure

     * {@link org.apache.tapestry5.internal.InternalComponentResources#postRenderCleanup()} is invoked after a component

     * finishes rendering</dd> <dt>Secure</dt> <dd>Checks for the {@link org.apache.tapestry5.annotations.Secure}

     * annotation</dd> <dt>ContentType</dt> <dd>Checks for {@link org.apache.tapestry5.annotations.ContentType}

     * annotation</dd> <dt>GenerateAccessors</dt> <dd>Generates accessor methods if {@link

     * org.apache.tapestry5.annotations.Property} annotation is present </dd> <dt>Cached</dt> <dd>Checks for the {@link

     * org.apache.tapestry5.annotations.Cached} annotation</dd><dt>Log</dt> <dd>Checks for the {@link

     * org.apache.tapestry5.annotations.Log} annotation</dd></dl>

     */

    public static void contributeComponentClassTransformWorker(

            OrderedConfiguration<ComponentClassTransformWorker> configuration,

            ObjectLocator locator,

            InjectionProvider injectionProvider,

            ComponentClassResolver resolver)

    {

        // TODO: Proper scheduling of all of this. Since a given field or method should

        // only have a single annotation, the order doesn't matter so much, as long as

        // UnclaimedField is last.

        configuration.addInstance("Cached", CachedWorker.class);

        configuration.add("Meta", new MetaWorker());

        configuration.add("Inject", new InjectWorker(locator, injectionProvider));

        configuration.addInstance("InjectService", InjectServiceWorker.class);

        configuration.add("Secure", new SecureWorker());

        configuration.add("MixinAfter", new MixinAfterWorker());

        configuration.add("Component", new ComponentWorker(resolver));

        configuration.add("Mixin", new MixinWorker(resolver));

        configuration.add("OnEvent", new OnEventWorker());

        configuration.add("SupportsInformalParameters", new SupportsInformalParametersWorker());

        configuration.addInstance("InjectPage", InjectPageWorker.class);

        configuration.add("InjectContainer", new InjectContainerWorker());

        configuration.add("InjectComponent", new InjectComponentWorker());

        configuration.add("RenderCommand", new RenderCommandWorker());

        // Default values for parameters are often some form of injection, so make sure

        // that Parameter fields are processed after injections.

        configuration.addInstance("Parameter", ParameterWorker.class, "after:Inject*");

        // Workers for the component rendering state machine methods; this is in typical

        // execution order.

        add(configuration, TransformConstants.SETUP_RENDER_SIGNATURE, SetupRender.class, false);

        add(configuration, TransformConstants.BEGIN_RENDER_SIGNATURE, BeginRender.class, false);

        add(configuration, TransformConstants.BEFORE_RENDER_TEMPLATE_SIGNATURE, BeforeRenderTemplate.class, false);

        add(configuration, TransformConstants.BEFORE_RENDER_BODY_SIGNATURE, BeforeRenderBody.class, false);

        // These phases operate in reverse order.

        add(configuration, TransformConstants.AFTER_RENDER_BODY_SIGNATURE, AfterRenderBody.class, true);

        add(configuration, TransformConstants.AFTER_RENDER_TEMPLATE_SIGNATURE, AfterRenderTemplate.class, true);

        add(configuration, TransformConstants.AFTER_RENDER_SIGNATURE, AfterRender.class, true);

        add(configuration, TransformConstants.CLEANUP_RENDER_SIGNATURE, CleanupRender.class, true);

        // Ideally, these should be ordered pretty late in the process to make sure there are no

        // side effects with other workers that do work inside the page lifecycle methods.

        add(configuration, PageLoaded.class, TransformConstants.CONTAINING_PAGE_DID_LOAD_SIGNATURE, "pageLoaded");

        add(configuration, PageAttached.class, TransformConstants.CONTAINING_PAGE_DID_ATTACH_SIGNATURE, "pageAttached");

        add(configuration, PageDetached.class, TransformConstants.CONTAINING_PAGE_DID_DETACH_SIGNATURE, "pageDetached");

        configuration.add("Retain", new RetainWorker());

        configuration.add("Persist", new PersistWorker());

        configuration.addInstance("IncludeStylesheet", IncludeStylesheetWorker.class, "after:SetupRender");

        configuration.addInstance("IncludeJavaScriptLibrary", IncludeJavaScriptLibraryWorker.class,

                                  "after:SetupRender");

        configuration.add("InvokePostRenderCleanupOnResources", new InvokePostRenderCleanupOnResourcesWorker());

        configuration.add("ContentType", new ContentTypeWorker());

        configuration.add("Property", new PropertyWorker());

        // These must come after Property, since they actually delete fields that may still have the annotation

        configuration.addInstance("ApplicationState", ApplicationStateWorker.class, "after:Property");

        configuration.addInstance("Environment", EnvironmentalWorker.class, "after:Property");

        configuration.addInstance("Log", LogWorker.class);

        // This one is always last. Any additional private fields that aren't annotated will

        // be converted to clear out at the end of the request.

        configuration.add("UnclaimedField", new UnclaimedFieldWorker(), "after:*");

        configuration.add("PageActivationContext", new PageActivationContextWorker(), "before:OnEvent");

    }

    /**

     * <dl> <dt>Annotation</dt> <dd>Checks for {@link org.apache.tapestry5.beaneditor.DataType} annotation</dd>

     * <dt>Default  (ordered last)</dt> <dd>{@link org.apache.tapestry5.internal.services.DefaultDataTypeAnalyzer}

     * service ({@link #contributeDefaultDataTypeAnalyzer(org.apache.tapestry5.ioc.MappedConfiguration)} })</dd> </dl>

     */

    public static void contributeDataTypeAnalyzer(OrderedConfiguration<DataTypeAnalyzer> configuration,

                                                  @InjectService("DefaultDataTypeAnalyzer")

                                                  DataTypeAnalyzer defaultDataTypeAnalyzer)

    {

        configuration.add("Annotation", new AnnotationDataTypeAnalyzer());

        configuration.add("Default", defaultDataTypeAnalyzer, "after:*");

    }

    /**

     * Maps property types to data type names: <ul> <li>String --&gt; text <li>Number --&gt; number <li>Enum --&gt; enum

     * <li>Boolean --&gt; boolean <li>Date --&gt; date </ul>

     */

    public static void contributeDefaultDataTypeAnalyzer(MappedConfiguration<Class, String> configuration)

    {

        // This is a special case contributed to avoid exceptions when a property type can't be

        // matched. DefaultDataTypeAnalyzer converts the empty string to null.

        configuration.add(Object.class, "");

        configuration.add(String.class, "text");

        configuration.add(Number.class, "number");

        configuration.add(Enum.class, "enum");

        configuration.add(Boolean.class, "boolean");

        configuration.add(Date.class, "date");

    }

    public static void contributeBeanBlockSource(Configuration<BeanBlockContribution> configuration)

    {

        addEditBlock(configuration, "text");

        addEditBlock(configuration, "number");

        addEditBlock(configuration, "enum");

        addEditBlock(configuration, "boolean");

        addEditBlock(configuration, "date");

        addEditBlock(configuration, "password");

        // longtext uses a text area, not a text field

        addEditBlock(configuration, "longtext");

        addDisplayBlock(configuration, "enum");

        addDisplayBlock(configuration, "date");

        // Password and long text have special output needs.

        addDisplayBlock(configuration, "password");

        addDisplayBlock(configuration, "longtext");

    }

    private static void addEditBlock(Configuration<BeanBlockContribution> configuration, String dataType)

    {

        addEditBlock(configuration, dataType, dataType);

    }

    private static void addEditBlock(Configuration<BeanBlockContribution> configuration, String dataType,

                                     String blockId)

    {

        configuration.add(new BeanBlockContribution(dataType, "PropertyEditBlocks", blockId, true));

    }

    private static void addDisplayBlock(Configuration<BeanBlockContribution> configuration, String dataType)

    {

        addDisplayBlock(configuration, dataType, dataType);

    }

    private static void addDisplayBlock(Configuration<BeanBlockContribution> configuration, String dataType,

                                        String blockId)

    {

        configuration.add(new BeanBlockContribution(dataType, "PropertyDisplayBlocks", blockId, false));

    }

    /**

     * Contributes the basic set of validators: <ul> <li>required</li> <li>minlength</li> <li>maxlength</li>

     * <li>min</li> <li>max</li> <li>regexp</li> </ul>

     */

    public static void contributeFieldValidatorSource(MappedConfiguration<String, Validator> configuration)

    {

        configuration.add("required", new Required());

        configuration.add("minlength", new MinLength());

        configuration.add("maxlength", new MaxLength());

        configuration.add("min", new Min());

        configuration.add("max", new Max());

        configuration.add("regexp", new Regexp());

        configuration.add("email", new Email());

    }

    /**

     * Contributes the base set of injection providers: <dl> <dt>Default</dt> <dd>based on {@link

     * MasterObjectProvider}</dd> <dt>Block</dt> <dd>injects fields of type Block</dd> <dt>ComponentResources</dt>

     * <dd>give component access to its resources</dd> <dt>CommonResources</dt> <dd>access to properties of resources

     * (log, messages, etc.)</dd> <dt>Asset</dt> <dd>injection of assets (triggered via {@link Path} annotation), with

     * the path relative to the component class</dd> <dt>Service</dt> <dd>ordered last, for use when Inject is present

     * and nothing else works, matches field type against Tapestry IoC services</dd> </dl>

     */

    public static void contributeInjectionProvider(OrderedConfiguration<InjectionProvider> configuration,

                                                   MasterObjectProvider masterObjectProvider,

                                                   ObjectLocator locator,

                                                   SymbolSource symbolSource,

                                                   AssetSource assetSource)

    {

        configuration.add("Default", new DefaultInjectionProvider(masterObjectProvider, locator));

        configuration.add("ComponentResources", new ComponentResourcesInjectionProvider());

        // This comes after default, to deal with conflicts between injecting a String as the

        // component id, and injecting a string with @Symbol or @Value.

        configuration.add("CommonResources", new CommonResourcesInjectionProvider(), "after:Default");

        configuration.add("Asset", new AssetInjectionProvider(symbolSource, assetSource), "before:Default");

        configuration.add("Block", new BlockInjectionProvider(), "before:Default");

        // This needs to be the last one, since it matches against services

        // and might blow up if there is no match.

        configuration.add("Service", new ServiceInjectionProvider(locator), "after:*");

    }

    /**

     * Contributes two object providers: <dl> <dt>Alias</dt> <dd> Searches by type among {@linkplain AliasContribution

     * contributions} to the {@link Alias} service</dd> <dt>Asset<dt> <dd> Checks for the {@link Path} annotation, and

     * injects an {@link Asset}</dd> <dt>Service</dt> <dd>Injects based on the {@link Service} annotation, if

     * present</dd> </dl>

     */

    public static void contributeMasterObjectProvider(OrderedConfiguration<ObjectProvider> configuration,

                                                      @Local

                                                      final Alias alias,

                                                      @InjectService("AssetObjectProvider")

                                                      ObjectProvider assetObjectProvider)

    {

        // There's a nasty web of dependencies related to Alias; this wrapper class lets us

        // defer instantiating the Alias service implementation just long enough to defuse those

        // dependencies. The @Local annotation prevents a recursive call through the

        // MasterObjectProvider to resolve the Alias service itself; that is MasterObjectProvider

        // gets built using this proxy, then the proxy will trigger the construction of AliasImpl

        // (which itself needs MasterObjectProvider to resolve some dependencies).

        ObjectProvider wrapper = new ObjectProvider()

        {

            public <T> T provide(Class<T> objectType, AnnotationProvider annotationProvider, ObjectLocator locator)

            {

                return alias.getObjectProvider().provide(objectType, annotationProvider, locator);

            }

        };

        configuration.add("Alias", wrapper, "after:ServiceOverride");

        configuration.add("Asset", assetObjectProvider, "before:AnnotationBasedContributions");

        configuration.add("Service", new ServiceAnnotationObjectProvider(), "before:AnnotationBasedContributions");

    }

    /**

     * <dl> <dt>StoreIntoGlobals</dt> <dd>Stores the request and response into {@link

     * org.apache.tapestry5.services.RequestGlobals} at the start of the pipeline</dd> <dt>IgnoredPaths</dt>

     * <dd>Identifies requests that are known (via the IgnoredPathsFilter service's configuration) to be mapped to other

     * applications</dd> <dt>GZip</dt> <dd>Handles GZIP compression of response streams (if supported by client)</dd>

     */

    public void contributeHttpServletRequestHandler(OrderedConfiguration<HttpServletRequestFilter> configuration,

                                                    @Symbol(SymbolConstants.GZIP_COMPRESSION_ENABLED)

                                                    boolean gzipCompressionEnabled,

                                                    @Autobuild GZipFilter gzipFilter,

                                                    @InjectService("IgnoredPathsFilter")

                                                    HttpServletRequestFilter ignoredPathsFilter)

    {

        configuration.add("IgnoredPaths", ignoredPathsFilter);

        configuration.add("GZIP",

                          gzipCompressionEnabled ? gzipFilter : null,

                          "after:IgnoredPaths");

        HttpServletRequestFilter storeIntoGlobals = new HttpServletRequestFilter()

        {

            public boolean service(HttpServletRequest request, HttpServletResponse response,

                                   HttpServletRequestHandler handler)

                    throws IOException

            {

                requestGlobals.storeServletRequestResponse(request, response);

                return handler.service(request, response);

            }

        };

        configuration.add("StoreIntoGlobals", storeIntoGlobals, "before:*");

    }

    /**

     * Continues a number of filters into the RequestHandler service: <dl> <dt>StaticFiles</dt> <dd>Checks to see if the

     * request is for an actual file, if so, returns true to let the servlet container process the request</dd>

     * <dt>CheckForUpdates</dt> <dd>Periodically fires events that checks to see if the file system sources for any

     * cached data has changed (see {@link org.apache.tapestry5.internal.services.CheckForUpdatesFilter}).

     * <dt>ErrorFilter</dt> <dd>Catches request errors and lets the {@link org.apache.tapestry5.services.RequestExceptionHandler}

     * handle them</dd>  <dt>StoreIntoGlobals</dt> <dd>Stores the request and response into the {@link

     * org.apache.tapestry5.services.RequestGlobals} service (this is repeated at the end of the pipeline, in case any

     * filter substitutes the request or response).  </dl>

     */

    public void contributeRequestHandler(OrderedConfiguration<RequestFilter> configuration, Context context,

                                         // @Inject not needed because its a long, not a String

                                         @Symbol(SymbolConstants.FILE_CHECK_INTERVAL)

                                         @IntermediateType(TimeInterval.class)

                                         long checkInterval,

                                         @Symbol(SymbolConstants.FILE_CHECK_UPDATE_TIMEOUT)

                                         @IntermediateType(TimeInterval.class)

                                         long updateTimeout,

                                         UpdateListenerHub updateListenerHub,

                                         URLRewriterService urlRewriterService)

    {

        RequestFilter staticFilesFilter = new StaticFilesFilter(context);

        RequestFilter storeIntoGlobals = new RequestFilter()

        {

            public boolean service(Request request, Response response, RequestHandler handler)

                    throws IOException

            {

                requestGlobals.storeRequestResponse(request, response);

                return handler.service(request, response);

            }

        };

        RequestFilter fireEndOfRequestEvent = new RequestFilter()

        {

            public boolean service(Request request, Response response, RequestHandler handler)

                    throws IOException

            {

                try

                {

                    return handler.service(request, response);

                }

                finally

                {

                    endOfRequestEventHub.fire();

                }

            }

        };

        configuration.add("CheckForUpdates", new CheckForUpdatesFilter(updateListenerHub,

                                                                       checkInterval, updateTimeout), "before:*");

        // we just need the URLRewriterRequestFilter if we have URL rewriter rules, of course.

        if (urlRewriterService.getRules().isEmpty() == false)

        {

            URLRewriterRequestFilter urlRewriterRequestFilter = new URLRewriterRequestFilter(

                    urlRewriterService);

            configuration.add("URLRewriter", urlRewriterRequestFilter, "before:StaticFiles");

        }

        configuration.add("StaticFiles", staticFilesFilter);

        configuration.addInstance("ErrorFilter", RequestErrorFilter.class);

        configuration.add(

                "StoreIntoGlobals",

                storeIntoGlobals,

                "after:StaticFiles",

                "before:ErrorFilter");

        configuration.add(

                "EndOfRequest",

                fireEndOfRequestEvent,

                "after:StoreIntoGlobals",

                "before:ErrorFilter");

    }

    /**

     * Contributes the basic set of translators: <ul>  <li>string</li>  <li>byte</li> <li>short</li> <li>integer</li>

     * <li>long</li> <li>float</li> <li>double</li>  <li>BigInteger</li> <li>BigDecimal</li></ul>

     */

    public static void contributeTranslatorSource(Configuration<Translator> configuration,

                                                  NumericTranslatorSupport support)

    {

        configuration.add(new StringTranslator());

        Class[] types = new Class[] { Byte.class, Short.class, Integer.class, Long.class, Float.class, Double.class,

                BigInteger.class, BigDecimal.class };

        for (Class type : types)

        {

            String name = type.getSimpleName().toLowerCase();

            configuration.add(new NumericTranslator(name, type, support));

        }

    }

    /**

     * Adds coercions: <ul> <li>String to {@link org.apache.tapestry5.SelectModel} <li>String to {@link

     * org.apache.tapestry5.corelib.data.InsertPosition} <li>Map to {@link org.apache.tapestry5.SelectModel}