<!doctype html>
<!-- Generated by FreeMarker/Docgen from DocBook -->
<html lang="en" class="page-type-section">
<head prefix="og: http://ogp.me/ns#">
<meta charset="utf-8">
<title>2.3.25 (incubating at Apache) - Apache FreeMarker Manual</title>
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width,initial-scale=1">
<meta name="format-detection" content="telephone=no">
<meta property="og:site_name" content="Apache FreeMarker Manual">
<meta property="og:title" content="2.3.25 (incubating at Apache)">
<meta property="og:locale" content="en_US">
<meta property="og:url" content="https://freemarker.apache.org/docs/versions_2_3_25.html">
<link rel="canonical" href="https://freemarker.apache.org/docs/versions_2_3_25.html">
<link rel="icon" href="favicon.png" type="image/png">
<link rel="stylesheet" type="text/css" href="https://fonts.googleapis.com/css?family=Roboto:500,700,400,300|Droid+Sans+Mono">
<link rel="stylesheet" type="text/css" href="docgen-resources/docgen.min.css?1707770044859">
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/cookie-bar/cookiebar-latest.min.js"></script>
</head>
<body itemscope itemtype="https://schema.org/Code">
    <meta itemprop="url" content="https://freemarker.apache.org/docs/">
    <meta itemprop="name" content="Apache FreeMarker Manual">

  <!--[if lte IE 9]>
  <div class="oldBrowserWarning" style="display: block">
    Unsupported web browser - Use a modern browser to view this website!
  </div>
  <![endif]-->  <div class="oldBrowserWarning">
    Unsupported web browser - Use a modern browser to view this website!
  </div>
<div class="header-top-bg"><div class="site-width header-top"><div id="hamburger-menu" role="button"></div>          <div class="logo">
<a href="https://freemarker.apache.org" role="banner"><img itemprop="image" src="logo.png" alt="FreeMarker"></a>          </div>
<ul class="tabs"><li><a href="https://freemarker.apache.org/">Home</a></li><li class="current"><a href="index.html">Manual</a></li><li><a class="external" href="api/index.html">Java API</a></li></ul><ul class="secondary-tabs"><li><a class="tab icon-heart" href="https://freemarker.apache.org/contribute.html" title="Contribute"><span>Contribute</span></a></li><li><a class="tab icon-bug" href="https://issues.apache.org/jira/projects/FREEMARKER" title="Report a Bug"><span>Report a Bug</span></a></li><li><a class="tab icon-download" href="https://freemarker.apache.org/freemarkerdownload.html" title="Download"><span>Download</span></a></li></ul></div></div><div class="header-bottom-bg"><div class="site-width search-row"><a href="index.html" class="navigation-header">Manual</a><div class="navigation-header"></div><form method="get" class="search-form" action="search-results.html"><fieldset><legend class="sr-only">Search form</legend><label for="search-field" class="sr-only">Search query</label><input id="search-field" name="q" type="search" class="search-input" placeholder="Search" spellcheck="false" autocorrect="off" autocomplete="off"><button type="submit" class="search-btn"><span class="sr-only">Search</span></button></fieldset></form></div><div class="site-width breadcrumb-row">  <div class="breadcrumbs">
<ul class="breadcrumb" itemscope itemtype="http://schema.org/BreadcrumbList"><li class="step-0" itemprop="itemListElement" itemscope itemtype="http://schema.org/ListItem"><a class="label" itemprop="item" href="index.html"><span itemprop="name">Apache FreeMarker Manual</span></a></li><li class="step-1" itemprop="itemListElement" itemscope itemtype="http://schema.org/ListItem"><a class="label" itemprop="item" href="app.html"><span itemprop="name">Appendixes</span></a></li><li class="step-2" itemprop="itemListElement" itemscope itemtype="http://schema.org/ListItem"><a class="label" itemprop="item" href="app_versions.html"><span itemprop="name">Version history</span></a></li><li class="step-3" itemprop="itemListElement" itemscope itemtype="http://schema.org/ListItem"><a class="label" itemprop="item" href="versions_2_3_25.html"><span itemprop="name">2.3.25 (incubating at Apache)</span></a></li></ul>  </div>
<div class="bookmarks" title="Bookmarks"><span class="sr-only">Bookmarks:</span><ul><li><a href="alphaidx.html">Alpha. index</a></li><li><a href="gloss.html">Glossary</a></li><li><a href="dgui_template_exp.html#exp_cheatsheet">Expressions</a></li><li><a href="ref_builtins_alphaidx.html">?builtins</a></li><li><a href="ref_directive_alphaidx.html">#directives</a></li><li><a href="ref_specvar.html">.spec_vars</a></li><li><a href="app_faq.html">FAQ</a></li></ul></div></div></div>    <div class="main-content site-width">
      <div class="content-wrapper">
  <div id="table-of-contents-wrapper" class="col-left">
      <script>var breadcrumb = ["Apache FreeMarker Manual","Appendixes","Version history","2.3.25 (incubating at Apache)"];</script>
      <script src="toc.js?1707770044859"></script>
      <script src="docgen-resources/main.min.js?1707770044859"></script>
  </div>
<div class="col-right"><div class="page-content"><div class="page-title"><div class="pagers top"><a class="paging-arrow previous" href="versions_2_3_26.html"><span>Previous</span></a><a class="paging-arrow next" href="versions_2_3_24.html"><span>Next</span></a></div><div class="title-wrapper">
<h1 class="content-header header-section1" id="versions_2_3_25" itemprop="headline">2.3.25 (incubating at Apache)</h1>
</div></div><div class="page-menu">
<div class="page-menu-title">Page Contents</div>
<ul><li><a class="page-menu-link" href="#autoid_166" data-menu-target="autoid_166">Changes on the FTL side</a></li><li><a class="page-menu-link" href="#autoid_167" data-menu-target="autoid_167">Changes on the Java side</a></li></ul> </div><p>Release date: 2016-06-26</p><p><strong>This is a stable, final
        release.</strong> The "incubating" suffix is required
        by the Apache Software Foundation until the project becomes a fully
        accepted (graduated) Apache project.</p>
          



<h2 class="content-header header-section2" id="autoid_166">Changes on the FTL side</h2>


          <ul>
            <li>
              <p>Extended the <a href="ref_directive_list.html#ref.directive.list"><code>list</code>
              directive</a> to support listing hashes (such as
              <code class="inline-code">Map</code>-s), like <code class="inline-code">&lt;#list map as k,
              v&gt;${k}: ${v}&lt;/#list&gt;</code>, where
              <code class="inline-code">k</code> and <code class="inline-code">v</code> are the key and
              value in the key-value pairs of the hash.</p>
            </li>
          </ul>
        
          



<h2 class="content-header header-section2" id="autoid_167">Changes on the Java side</h2>


          <ul>
            <li>
              <p>Added the <code class="inline-code">TemplateModelHashEx2</code>
              interface that extends <code class="inline-code">TemplateModelHashEx</code>
              with a method for listing the content of the key-value pairs of
              the hash. (This is utilized by the new hash listing capability
              of the <a href="ref_directive_list.html#ref.directive.list"><code>list</code>
              directive</a>, but it&#39;s not required by it if all keys are
              strings.)</p>
            </li>

            <li>
              <p>Lazy imports: With the new boolean settings,
              <code class="inline-code">lazy_imports</code> and
              <code class="inline-code">lazy_auto_imports</code>, you can make imports (as
              in <code class="inline-code">&lt;#import &quot;lib/utils.ftl&quot; as u&gt;</code>)
              and/or auto-imports to be lazy. When the import is lazy, the
              namespace variable (<code class="inline-code">u</code> in this example) will
              be created immediately, just like before, but the imported
              template will be loaded and processed only when (and if ever)
              the content of the imported namespace is accessed. The main
              application of this is with auto-imports, where you don&#39;t want
              the overhead of importing templates that aren&#39;t actually used in
              a template. (Also, a new
              <code class="inline-code">Environment.importLib</code> method overload was
              added, where you can specify if you want a lazy or an eager
              import.) These new settings can be set on
              <code class="inline-code">Configuration</code>, <code class="inline-code">Template</code>
              (<code class="inline-code">TemplateConfiguration</code>) and
              <code class="inline-code">Environment</code> level.</p>
            </li>

            <li>
              <p>It&#39;s now possible to set the
              <code class="inline-code">auto_import</code> and
              <code class="inline-code">auto_include</code> settings on a per template basis
              (like templates with a certain name pattern has different
              auto-imports). This is now possible as these settings were moved
              from the <code class="inline-code">Configuration</code> level down to the more
              generic <code class="inline-code">Configurable</code> level, and so are
              inherited by <code class="inline-code">TemplateConfiguration</code> and
              <code class="inline-code">Environment</code> too.</p>
            </li>

            <li>
              <p>New <code class="inline-code">Configuration</code> (and
              <code class="inline-code">TemplateConfiguration</code>) setting,
              <code class="inline-code">tab_size</code>. This only influences how the column
              number reported in error messages is calculated (and the column
              number available with other API-s). It doesn&#39;t influence the
              output of the templates. Defaults to 8.</p>
            </li>

            <li>
              <p>Added new setting to
              <code class="inline-code">DefaultObjectWrapper</code> (and to
              <code class="inline-code">DefaultObjectWrapperBuilder</code>):
              <code class="inline-code">iterableSupport</code>. This fixes the issue when
              you couldn&#39;t use <code class="inline-code">#list</code> (or
              <code class="inline-code">?has_next</code>, etc.) on a value that only
              implements Java 5 <code class="inline-code">java.lang.Iterable</code> (not to
              be confused with <code class="inline-code">Iterator</code>), but not
              <code class="inline-code">Collection</code>. This is not enabled by default as
              it&#39;s not compatible with some existing templates, most often
              because they have used
              <code class="inline-code">someIterable.iterator()</code> in the template as a
              workaround. When this is enabled, the
              <code class="inline-code">Iterable</code> object won&#39;t be seen as a generic
              Java object by FreeMarker anymore, and thus just like with
              <code class="inline-code">Collection</code>-s, its API won&#39;t be exposed to the
              templates (except through <code class="inline-code">?api</code>, of
              course).</p>
            </li>

            <li>
              <p>Added
              <code class="inline-code">Configurable.getCustomNumberFormatsWithoutFallback</code>
              and
              <code class="inline-code">Configurable.getCustomDateFormatsWithoutFallback</code>
              methods to make it easier for custom code to investigate the
              custom formal setting <code class="inline-code">Map</code> hierarchy.</p>
            </li>

            <li>
              <p>Bug fixed (<a href="https://issues.apache.org/jira/browse/FREEMARKER-18">FREEMARKER-18</a>):
              If you had a JSP custom tag and an EL function defined in the
              same TLD with the same name, the EL function has overwritten the
              custom tag. This is a bug introduced in 2.3.23, when EL function
              support was added. JSP allows a custom tag and an EL function in
              the same TLD to have the same name. In such case now we combine
              the two into a single value that is both callable as an user
              defined directive (<code class="inline-code">&lt;@my.foo...&gt;</code>) and as
              a function (<code class="inline-code">my.f(...)</code>).</p>
            </li>

            <li>
              <p>Bug fixed (<a href="https://issues.apache.org/jira/browse/FREEMARKER-19">FREEMARKER-19</a>):
              The column numbers calculated by the parser has assumed tab size
              1 since 2.3.25 (an unwanted side effect of updating JavaCC),
              while before it has assumed tab size 8. The default was restored
              to 8. This bug has affected the column numbers in error
              messages. It also broke the output of some rarely used AIP-s,
              namely <code class="inline-code">Template.getSource(beginCol, beginLine, endCol,
              endLine)</code>,
              <code class="inline-code">TemplateObject.getSource()</code> and through that
              <code class="inline-code">TemplateObject.toString()</code>, if the first or
              last line has contain tab characters.</p>
            </li>

            <li>
              <p>Bug fixed: There was a regression with 2.3.24, where
              <code class="inline-code">Configuration.setAutoImports()</code> haven&#39;t
              removed auto-imports added earlier. (Though it&#39;s unlikely that
              an application uses that method and also adds auto-imports
              earlier.)</p>
            </li>

            <li>
              <p>Bug fixed:
              <code class="inline-code">TemplateConfiguration.apply(Template)</code> didn&#39;t
              merge the <code class="inline-code">customDateFormats</code> and
              <code class="inline-code">customNumberFormats</code> <code class="inline-code">Map</code>-s
              when they were set both in the <code class="inline-code">Template</code> and
              in the applied <code class="inline-code">TemplateConfiguration</code>, instead
              it just kept the value in the <code class="inline-code">Template</code> (just
              like with atomic setting values). Note that it was unlikely to
              run into this bug, as usually you (or FreeMarker) create a
              single merged <code class="inline-code">TemplateConfiguration</code> with
              <code class="inline-code">TemplateConfiguration.merge(TemplateConfiguration)</code>
              and then apply it on a fresh template.</p>
            </li>

            <li>
              <p>Removed FindBugs <code class="inline-code">@SuppressFBWarnings</code>
              annotations from the binary (<code class="inline-code">freemarker.jar</code>),
              as they have caused warnings like this when compiling dependant
              project with Gradle: "warning: Cannot find annotation
              method &#39;value()&#39; in type &#39;SuppressFBWarnings&#39;"</p>
            </li>

            <li>
              <p>The Maven source artifact now contains the JavaCC
              generated java files and <code class="inline-code">FTL.jj</code>.</p>
            </li>
          </ul>
        <div class="bottom-pagers-wrapper"><div class="pagers bottom"><a class="paging-arrow previous" href="versions_2_3_26.html"><span>Previous</span></a><a class="paging-arrow next" href="versions_2_3_24.html"><span>Next</span></a></div></div></div></div>      </div>
    </div>
<div class="site-footer"><div class="site-width"><div class="footer-top"><div class="col-left sitemap"><div class="column"><h3 class="column-header">Overview</h3><ul><li><a href="https://freemarker.apache.org/">What is FreeMarker?</a></li><li><a href="https://freemarker.apache.org/freemarkerdownload.html">Download</a></li><li><a href="app_versions.html">Version history</a></li><li><a href="app_faq.html">FAQ</a></li><li><a itemprop="license" href="app_license.html">License</a></li><li><a href="https://privacy.apache.org/policies/privacy-policy-public.html">Privacy policy</a></li></ul></div><div class="column"><h3 class="column-header">Often used / Reference</h3><ul><li><a href="https://try.freemarker.apache.org/">Try template online</a></li><li><a href="dgui_template_exp.html#exp_cheatsheet">Expressions cheatsheet</a></li><li><a href="ref_directive_alphaidx.html">#directives</a></li><li><a href="ref_builtins_alphaidx.html">?built_ins</a></li><li><a href="ref_specvar.html">.special_vars</a></li><li><a href="api/freemarker/core/Configurable.html#setSetting-java.lang.String-java.lang.String-">Configuration settings</a></li></ul></div><div class="column"><h3 class="column-header">Community</h3><ul><li><a href="https://github.com/apache/freemarker">Github project page</a></li><li><a href="https://issues.apache.org/jira/projects/FREEMARKER">Report a bug</a></li><li><a href="https://freemarker.apache.org/report-security-vulnerabilities.html">Report security vulnerability</a></li><li><a href="https://stackoverflow.com/questions/ask?tags=freemarker">Get help on StackOverflow</a></li><li><a href="https://twitter.com/freemarker">Announcements on Twitter</a></li><li><a href="https://freemarker.apache.org/mailing-lists.html">Discuss on mailing lists</a></li></ul></div></div><div class="col-right"><ul class="social-icons"><li><a class="github" href="https://github.com/apache/freemarker">Github</a></li><li><a class="twitter" href="https://twitter.com/freemarker">Twitter</a></li><li><a class="stack-overflow" href="https://stackoverflow.com/questions/ask?tags=freemarker">Stack Overflow</a></li></ul><a class="xxe" href="http://www.xmlmind.com/xmleditor/" rel="nofollow" title="Edited with XMLMind XML Editor"><span>Edited with XMLMind XML Editor</span></a></div></div><div class="footer-bottom"> <p class="last-generated">
Last generated:
<time itemprop="dateModified" datetime="2024-02-12T20:34:04Z" title="Monday, February 12, 2024 at 8:34:04 PM Greenwich Mean Time">2024-02-12 20:34:04 GMT</time>, for Freemarker 2.3.32 </p>
<p class="copyright">
© <span itemprop="copyrightYear">1999</span>–2024
<a itemtype="http://schema.org/Organization" itemprop="copyrightHolder" href="https://apache.org/">The Apache Software Foundation</a>. Apache FreeMarker, FreeMarker, Apache Incubator, Apache, the Apache FreeMarker logo are trademarks of The Apache Software Foundation. All other marks mentioned may be trademarks or registered trademarks of their respective owners. </p>
</div></div></div></body>
</html>
