0.7.0 -> 0.8.0
--------------
* Sample programs use UTF-8 encoding instead of EUC-JP.

* All the programs and libraries are checked using ruby-1.8 and ruby-1.9. 

0.6.0 -> 0.7.0
--------------
* XPath expression was extended so that we can directly invoke a method
  of an expansion data.
  ex) <xt:select id="link.url" />   (See sample40.rb)

* XData was removed.

* New Tags:
  - <xt:property id="oid" name="recv">
    = <xt:select id="oid.recv">

  - <xt:property id="oid" name="recv" with="a0,a1,...">
    = <xt:select id="oid.recv(a0,a1,...)">

  - Use 'alt' attribute instead of case-when expression.
    See sample50.rb and sample51.rb for an example.

0.5.4 -> 0.6.0
---------------
* New Actions:
  - each()   converts an Enumerable object to an array.

* New Tags:
  - <xt:each id="..."> is equal to <xt:select id="...{array()}">.

* Bug Fixes:
  - Immutable objects in an expansion data could not be duplicated
    when calling XMLTemplate#expand using ':keep_data=true'.

* Keep empty-element tags.

0.5.3 -> 0.5.4
---------------
* bugfix release.

0.5.2 -> 0.5.3
--------------
* bugfix release.

0.5.1 -> 0.5.2
--------------
* If a value of TextNode is not nil in an expansion data, an existing text is
  replaced with the value. In an older version, the value is appended to the
  existing text. (See sample4.rb)

* Fixed bugs in Node#prepare().

* New Actions:
  - sanitize(), unsanitize()
  - mktime(fmt)

0.5.0 -> 0.5.1
--------------
* Added XMLTemplate#<< to append sub-template. (sample32.rb)

* XMLTemplate#[]= doesn't make a copy of a given sub-template. (sample31.rb)
  - You should explicitly make a copy of a sub-template using XMLTemplate#dup().

* XMLTemplate#expand() returns a sanitized string.

* Added XPath::Action.

* Plugin method was changed. (See sample19.rb)

* New Actions:
  - time(fmt,[tag])
  - import(soap-url, namespace, method, arg0, ...)
  - import(xmlrpc-url, method, arg0, ...)

0.4.6 -> 0.5.0
--------------
* Added XMLTemplate#[] to obtain a sub-template which is enclosed by
 <template name="...">.

* Added XMLTemplate#[]= to replace a sub-template with a copy of another
  sub-template. (See also sample31.rb)

* XMLTemplate#expand(data, opts = nil)
  XMLTemplate#expand2(io, data, opts = nil)
  - For example, use expand(data, :plugin => my_plugin_object) to give a plugin object.
    - :plugin         specify a plugin object. [nil]
    - :keep_template  If true, don't modify a template for an expansion. [true]
    - :keep_data      If true, don't modify a given expansion data. [false]

* All process instructions are removed.

* The experimental function of embedding script in <--%...%--> is removed.

0.4.5 -> 0.4.6
--------------
* Some functions are implemented in an extension module 'xtemplate_ext'.
  - Run 'install.rb config --with-ext' to install the extension.

* Added XTemplate::YAMLDocument. (requires YAML4R, See sampleY1.rb)
  - http://yaml4r.sourceforge.net/

* XTemplate::TextNode is defined to be nil.

* '?' is a new path separator. "path1?path2" returns values indicated by
  "path2" if there is no value indicated by "path1".

* XTemplate automatically transforms a XArray object to a Hash object if
  possible.
  - You don't need to use the action 'flatten()' and 'hash()' when using
    a XML document as an expansion data.

0.4.4 -> 0.4.5
---------------
* 'expand' tag supports 'strip' attribute.
  EX. <xt:expand id="foo" strip="yes">

* Added XTemplate::XArray.
  - String objects which consists of only spaces in a XArray object is
    automatically eliminated when expanding a template. This facility is
    for XMLDocument.
    EX. ["   ", {'tag1' => '  '}, "  \n  ", {'tag2' => '  '}]
        => [{'tag1' => '  '}, {'tag2' => '  '}]

* Multiple conditions and actions are available.
  EX. id="foo{...}[...]{...}[...]"

* Added XTemplate::use_simple_xpath().
  This function speeds up evaluation of XPath expression. However we can't
  use actions and conditions after calling this function.

* Added XTemplate::use_simple_expand().  (speed_xt1.rb and speed_xt2.rb)
  More speedup! However we can't use any XPath expression after calling this
  function.

* XMLDocument.new() creates an object of XMLDocument from an expansion data,
  if the data is a kind of Hash or Array.

* <foo xt:flat="yes"> is obsoleted. Use <foo xt:type="hash">.
  - "int" and "float" are also available.

* Added an action 'index(a,i)' for indexing an array data with the tag 'a' and
  the initial value 'i'. (See sample30.rb)

* Added functionality for embedding a ruby script instead of using a plugin
  object. [experimental]
  - <!--%|value| script %-->: 'value' is bound to a current node. (See sample19.rb)

* bin/xtemplate supports options -c and -T.
  - -c: to serialize a template object and output it.
  - -T: to load a serialized template object.

0.4.2 -> 0.4.4
---------------
* bin/xtemplate supports --with-erb, --with-eruby options.

* Added <xt:template> and <xt:expand id="...">.
  - <xt:expand id="ID">...</xt:expand> replaces the specified data with
    the result of the expansion. (See sample27.rb, sample28.rb and sample29.rb)

* Fixed many bugs.


0.4.1 -> 0.4.2
---------------
* An algorithm for transforming XML to Hash was changed.
  Examples:
  (1) <items><item>item1</item><item>item2</item></items>
      => {'items' => [{'item' => 'item1'}, {'item' => 'item2'}]}
  (2) <person><name>name</name><age>26</age></person>
      => {'person' => [{'name' => 'name'}, {'age'  => '26'}]}
      If you'd like to obtain {'name'=>'name', 'age'=>'26'} by id="person",
      use id="person{flatten()}".
  (3) <person xt:flat="yes"><name>name</name><age>26</age></person>
      => {'person' => {'name' => 'name', 'age'  => '26'}}

* The following actions were added.
  - flatten()   (convert an array of Hash to a hash data)
  - hash()      (equivalent to flatten())
  - dump()      (dump data as a XML document)
  - import(xml://file)  (import a XML document as an expansion data)
  - import(var://xxx)   (import a expansion data from the variable 'xxx'.)
  - import(data://file) (import a expansion data from the file 'file'.)

* <xt:copy-of id="path" /> was added.
  - This is equivalent to <xt:value-of id="path{dump()}" />.

* <xt:import src="..."> was added.
  - This is equivalent to <xt:value-of id="{import(...)}">.

* <xt:include src="..." /> was added.
  - <xt:include src="$foo" />: includes a document from a global variable '$foo'.
  - <xt:include src="foo" />: includes a document from a file 'foo'.
  - <xt:include src="file://foo" />: includes a document from a file 'foo'.


0.4.0 -> 0.4.1
---------------
* A value of ID in '@{ID}' should be sanitized. (Checked with sample23.rb)

* <xt:attribute> and <xt:element> can also be expanded. (See sample23.rb)
  - <xt:attribute [id="..."] name="attr">value</xt:attribute>
  - <xt:element   [id="..."] name="attr">.....</xt:element>

0.3.1 -> 0.4.0
---------------
* License of XTemplate is changed to modified BSD license. See COPYING.

* '@{ID}' is replaced with specified 'ID' in an attribute.

* If namespace is defined for a template, the following tags are available.
  - <xt:select   id="..." [propagation="..."]>
  - <xt:value-of id="..." [propagation="..."]> (equivalent to 'select')
  - <xt:attribute name="attr">value</xt:attribute>
  - <xt:element   name="attr">.....</xt:element>
  where 'xt' is a namespace bound with 'xmlns:xt="http://xtemplate.sourceforge.net/xtemplate"'.

* <?xtemplate ...?> has been obsoleted.
  - Use namespace of XTemplate as follows:
    <xt:select xmlns:xt="http://xtemplate.sourceforge.net/xtemplate">
      ...
    </xt:select>

* All strings are sanitized in XNode#add_attrval() and XNode#add_child().

0.2.9 -> 0.3.0
---------------
* Works with REXML.
  - If you first load 'rexml/document', XTemplate uses REXML parser.
  - By default, XTemplate uses XMLScan.

* Remove 'xtemplate/html.rb', since it is unusable.

* int() and float() can be used in conditions.

0.2.8 -> 0.2.9
---------------
* Improved README.
  - Data Format Specification
  - Refine Syntax of XPath

* Strictly deal with data.
  - Hash, Array and XNode objects are not allowed to be
    children nodes of a text node.

* XTemplate's XPath can be used with XTemplate::XMLDocument#[],
  which extract data specified by the XPath.