From ffb0397721a50682b2fc54f53ea6bf94937b21c8 Mon Sep 17 00:00:00 2001
From: dakkar <dakkar@thenautilus.net>
Date: Thu, 16 Apr 2009 22:12:47 +0200
Subject: documentation, and a few author-tests

---
 Makefile.PL                               |   2 +
 lib/Tree/Transform/XSLTish.pm             | 103 +++++++++++++++++++++++++-
 lib/Tree/Transform/XSLTish/Context.pm     |  10 +++
 lib/Tree/Transform/XSLTish/Transformer.pm | 119 ++++++++++++++++++++++++++++++
 lib/Tree/Transform/XSLTish/Utils.pm       |  11 +++
 t/00-author-deps.t                        |   6 ++
 t/00-author-pod-cover.t                   |   7 ++
 t/00-author-pod.t                         |   6 ++
 8 files changed, 261 insertions(+), 3 deletions(-)
 create mode 100644 t/00-author-deps.t
 create mode 100644 t/00-author-pod-cover.t
 create mode 100644 t/00-author-pod.t

diff --git a/Makefile.PL b/Makefile.PL
index 5f0c3d4..8912266 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -6,9 +6,11 @@ all_from 'lib/Tree/Transform/XSLTish.pm';
 
 requires 'Tree::XPathEngine' => 0,
          'Moose'             => 0,
+         'Class::MOP'        => 0,
          'Params::Validate'  => 0,
          'Carp::Clan'        => 0,
          'Sub::Exporter'     => 0,
+         'MooseX::AttributeHelpers' => 0,
 ;
 
 test_requires 'Test::Most'   => 0,
diff --git a/lib/Tree/Transform/XSLTish.pm b/lib/Tree/Transform/XSLTish.pm
index e754cd0..2176aea 100644
--- a/lib/Tree/Transform/XSLTish.pm
+++ b/lib/Tree/Transform/XSLTish.pm
@@ -6,6 +6,7 @@ use Params::Validate ':all';
 use Tree::Transform::XSLTish::Utils;
 use Tree::Transform::XSLTish::Transformer;
 use Carp::Clan qw(^Tree::Transform::XSLTish);
+use v5.8;
 
 our $VERSION='0.1';
 
@@ -40,7 +41,7 @@ sub tree_rule {
     });
 
     # TODO at least one of 'name' and 'match' must be specified
-    # TODO default priority mased on match
+    # TODO default priority based on match
 
     my $store=Tree::Transform::XSLTish::Utils::_rules_store(scalar caller);
 
@@ -117,6 +118,8 @@ Transforming an HTML document:
  use strict;
  use warnings;
 
+ engine_class 'XML::XPathEngine';
+
  default_rules;
 
  tree_rule match => 'img[@alt="pick"]', action => sub {
@@ -124,13 +127,12 @@ Transforming an HTML document:
  };
 
  package main;
- use XML::XPathEngine;
  use HTML::TreeBuilder::XPath;
 
  my $tree=HTML::TreeBuilder::XPath->new();
  $tree->parse_file('mypage.html');
 
- my $trans=HtmlTransform->new(engine=>XML::XPathEngine->new());
+ my $trans=HtmlTransform->new();
  my ($image_srce)=$trans->transform($tree);
 
 =head1 DESCRIPTION
@@ -153,6 +155,101 @@ that are compatible with the XPath engine; for example,
 L<Tree::DAG_Node::XPath> if you use L<Tree::XPathEngine>, or
 L<HTML::TreeBuilder::XPath> if you use L<XML::XPathEngine>.
 
+=head1 EXPORTS
+
+=head2 C<tree_rule>
+
+  tree_rule match => '//node_name',
+            priority => 1,
+            action => sub { ... };
+
+This is the basic fuction to declare a transformation rule; it's
+equivalent to the C<template> element is XSLT. It takes its parameters
+as a hash:
+
+=over 4
+
+=item C<match>
+
+this is equivalent to the C<match> attribute of C<template>: it
+specifies the pattern for the nodes to which this rule applies.
+
+From the L<XSLT spec|http://www.w3.org/TR/xslt.html#NT-Pattern>:
+
+I<A pattern is defined to match a node if and only if there is a
+possible context such that when the pattern is evaluated as an
+expression with that context, the node is a member of the resulting
+node-set. When a node is being matched, the possible contexts have a
+context node that is the node being matched or any ancestor of that
+node, and a context node list containing just the context node.>
+
+=item C<name>
+
+this is equivalent of the C<name> attribute of C<template>: it allows
+calling rules by name (see
+L<call_rule|Tree::Transform::XSLTish::Transformer/call_rule>)
+
+=item C<priority>
+
+this is equivalent of the C<priority> attribute of C<template>;
+currently the "default priority" as specified in the
+L<spec|http://www.w3.org/TR/xslt.html#conflict> is not implemented
+
+=item C<action>
+
+this code-ref will be called (in list context) when the rule is to be
+applied; it can return whatever you want:
+L<call_rule|Tree::Transform::XSLTish::Transformer/call_rule> will
+return the result unchanged,
+L<apply_rules|Tree::Transform::XSLTish::Transformer/apply_rules> will
+return the list of all results of all the applied rules
+
+=back
+
+The C<action> code-ref will be called (by
+L<apply_rules|Tree::Transform::XSLTish::Transformer/apply_rules> or
+L<call_rule|Tree::Transform::XSLTish::Transformer/call_rule>) with a
+L<Tree::Transform::XSLTish::Transformer> object as its only parameter.
+
+=head2 C<default_rules>
+
+This function will declare two rules that mimic the implicit rules of
+XSLT. It's equivalent to:
+
+ tree_rule match => '/', priority => 0, action => sub {$_[0]->apply_rules};
+ tree_rule match => '*', priority => 0, action => sub {$_[0]->apply_rules};
+
+=head2 C<engine_class>
+
+  engine_class 'XML::LibXML::XPathContext';
+
+This function declares that the
+L<Tree::Transform::XSLTish::Transformer> object returned by L</new>
+should use this class to build its XPath engine.
+
+=head2 C<engine_factory>
+
+  engine_factory { My::XPath::Engine->new(params=>$whatever) };
+
+This function declares that the
+L<Tree::Transform::XSLTish::Transformer> object returned by L</new>
+should call the passed code-ref to get its engine.
+
+C<engine_class $classname> is equivalent to C<engine_factory {
+$classname->new }>.
+
+=head2 C<new>
+
+Returns a L<Tree::Transform::XSLTish::Transformer> for the rules
+declared in this package.
+
+=head1 INHERITANCE
+
+L<Stylesheet import|http://www.w3.org/TR/xslt.html#import> is implented
+with the usual Perl inheritance scheme. It should even work with
+L<Class::C3>, since we use L<Class::MOP>'s C<class_precedence_list> to
+get the list of inherited packages.
+
 =head1 AUTHOR
 
 Gianni Ceccarelli <dakkar@thenautilus.net>
diff --git a/lib/Tree/Transform/XSLTish/Context.pm b/lib/Tree/Transform/XSLTish/Context.pm
index 2e696a5..0890401 100644
--- a/lib/Tree/Transform/XSLTish/Context.pm
+++ b/lib/Tree/Transform/XSLTish/Context.pm
@@ -7,3 +7,13 @@ has 'node_list' => ( is => 'rw', isa => 'ArrayRef[Object]' );
 
 __PACKAGE__->meta->make_immutable;no Moose;1;
 __END__
+
+=head1 NAME
+
+Tree::Transform::XSLTish::Context - helper class
+
+=head1 AUTHOR
+
+Gianni Ceccarelli <dakkar@thenautilus.net>
+
+=cut
diff --git a/lib/Tree/Transform/XSLTish/Transformer.pm b/lib/Tree/Transform/XSLTish/Transformer.pm
index fd61ea6..c4ff53f 100644
--- a/lib/Tree/Transform/XSLTish/Transformer.pm
+++ b/lib/Tree/Transform/XSLTish/Transformer.pm
@@ -150,6 +150,8 @@ sub find_rule_in_package {
     elsif (@candidates >= 1) {
         return $candidates[0];
     }
+
+    return;
 }
 
 sub find_rule_by_name_in_package {
@@ -214,3 +216,120 @@ sub DESTROY {
 
 1;
 __END__
+
+=head1 NAME
+
+Tree::Transform::XSLTish::Transformer - transformer class for L<Tree::Transform::XSLTish>
+
+=head1 METHODS
+
+=head2 C<new>
+
+  $trans=Tree::Transform::XSLTish::Transformer->new(
+    rules_package => 'Some::Package',
+    engine => $engine_instance,
+  );
+
+You usually don't call this constructor directly, but instead use L<<
+the C<new> function exported by
+Tree::Transform::XSLTish|Tree::Transform::XSLTish/new >>, which passes
+the correct C<rules_package> automatically.
+
+If you don't specify an C<engine>, it will be constructed using the
+class or factory declared in the rules package; if you didn't declare
+anything, it will be an instance of L<Tree::XPathEngine>
+
+=for comment
+
+engine factories are not inherited!
+
+=head2 C<transform>
+
+  @results=$trans->transform($tree);
+
+When you call this function on a tree, the transformer will transform
+it according to your rules and to the L<XSLT processing
+model|http://www.w3.org/TR/xslt.html#section-Processing-Model>.
+
+C<< $trans->transform($node) >> is equivalent to C<<
+$trans->apply_rules($trans->engine->findnodes('/',$node)) >>.
+
+Always call this method in list context.
+
+=head2 C<apply_rules>
+
+   $trans->apply_rules(@nodes);
+
+Just like C<apply-rules> in XSLT, this function will apply the rules
+to the specified nodes, or to the children of the current node if none
+are passed, and return all the results in a single list.
+
+This will die if there are no matching rules, or if there are more
+than one matching rule with highest priority.
+
+Always call this method in list context.
+
+=head2 C<call_rule>
+
+  $trans->call_rule('rule-name');
+
+This fuction will apply the named rule to the current node, and return
+the result.
+
+This will die if there is no rule with the given name.
+
+Always call this method in list context.
+
+=head2 C<it>
+
+  $current_node = $trans->it;
+
+Inside a rule, this fuction will return the node to which the rule is
+being applied.
+
+=head1 INTERNAL FUNCTIONS
+
+These functions should not be called from outside this module.
+
+=head2 C<find_rule>
+
+For each package in the linearized inheritance chain of the rules
+package on which this transformer has been instantiated, calls
+L<find_rule_in_package> and returns the first defined result.
+
+=head2 C<find_rule_in_package>
+
+Gets all the rules having a C<match> attribute, filters those for
+which L<rule_matches> returns true, sorts them priority, and returns
+the one with the highest priority.
+
+Dies if there is more than one rule with the highest priority; returns
+undef if there are no matching rules.
+
+=head2 C<find_rule_by_name>
+
+For each package in the linearized inheritance chain of the rules
+package on which this transformer has been instantiated, calls
+L<find_rule_by_name_in_package> and returns the first defined result.
+
+=head2 C<find_rule_by_name_in_package>
+
+Returns the rule with the given name, if any; returns undef otherwise.
+
+=head2 C<rule_matches>
+
+Evaluates the C<match> XPath expression in a sequence of contexts, to
+see if the current node appears in the resulting node-set. If it does,
+returns true; if there is no such context, returns false.
+
+The first context is the current node; following contexts are each the
+parent node of the previous one.
+
+NOTE: to check whether a node appears in a node-set, we either use the
+C<isSameNode> method, or check the stringifications for equality.
+
+=head1 AUTHOR
+
+Gianni Ceccarelli <dakkar@thenautilus.net>
+
+=cut
diff --git a/lib/Tree/Transform/XSLTish/Utils.pm b/lib/Tree/Transform/XSLTish/Utils.pm
index bed1167..bfb438c 100644
--- a/lib/Tree/Transform/XSLTish/Utils.pm
+++ b/lib/Tree/Transform/XSLTish/Utils.pm
@@ -31,3 +31,14 @@ sub _get_inheritance {
 }
 
 1;
+__END__
+
+=head1 NAME
+
+Tree::Transform::XSLTish::Utils - utility functions
+
+=head1 AUTHOR
+
+Gianni Ceccarelli <dakkar@thenautilus.net>
+
+=cut
diff --git a/t/00-author-deps.t b/t/00-author-deps.t
new file mode 100644
index 0000000..f92ec06
--- /dev/null
+++ b/t/00-author-deps.t
@@ -0,0 +1,6 @@
+#!perl
+use Test::Most;
+plan skip_all => "skipping author-only test" unless $ENV{RUN_AUTHOR_TESTS};
+eval "use Test::Dependencies exclude => [qw(Tree::Transform::XSLTish XML::LibXML Moose::Util::TypeConstraints)]";
+
+ok_dependencies();
diff --git a/t/00-author-pod-cover.t b/t/00-author-pod-cover.t
new file mode 100644
index 0000000..9bace3e
--- /dev/null
+++ b/t/00-author-pod-cover.t
@@ -0,0 +1,7 @@
+#!perl
+use Test::Most;
+plan skip_all => "skipping author-only test" unless $ENV{RUN_AUTHOR_TESTS};
+eval "use Test::Pod::Coverage";
+all_pod_coverage_ok({
+    trustme=> [qr(^new_transformer$)],
+});
diff --git a/t/00-author-pod.t b/t/00-author-pod.t
new file mode 100644
index 0000000..5177b0c
--- /dev/null
+++ b/t/00-author-pod.t
@@ -0,0 +1,6 @@
+#!perl
+use Test::Most;
+plan skip_all => "skipping author-only test" unless $ENV{RUN_AUTHOR_TESTS};
+eval "use Test::Pod";
+
+all_pod_files_ok();
-- 
cgit v1.2.3


From 43217e6ce9a7cae817d391e9bb10a3410c88e6e2 Mon Sep 17 00:00:00 2001
From: dakkar <dakkar@thenautilus.net>
Date: Sat, 18 Apr 2009 15:26:50 +0200
Subject: factories are inherited now, added test

---
 lib/Tree/Transform/XSLTish.pm             | 12 ++++++++----
 lib/Tree/Transform/XSLTish/Transformer.pm |  6 +++---
 lib/Tree/Transform/XSLTish/Utils.pm       | 13 ++++++-------
 t/02-inherit.t                            | 11 +++++++++--
 4 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/lib/Tree/Transform/XSLTish.pm b/lib/Tree/Transform/XSLTish.pm
index 2176aea..7053428 100644
--- a/lib/Tree/Transform/XSLTish.pm
+++ b/lib/Tree/Transform/XSLTish.pm
@@ -62,8 +62,10 @@ sub tree_rule {
 sub engine_class {
     my ($classname)=@_;
 
-    my $factory=Tree::Transform::XSLTish::Utils::_engine_factory(scalar caller);
-    $$factory=sub{$classname->new()};
+    Tree::Transform::XSLTish::Utils::_set_engine_factory(
+        scalar caller,
+        sub{$classname->new()},
+    );
 
     return;
 }
@@ -71,8 +73,10 @@ sub engine_class {
 sub engine_factory(&) {
     my ($new_factory)=@_;
 
-    my $factory=Tree::Transform::XSLTish::Utils::_engine_factory(scalar caller);
-    $$factory=$new_factory;
+    Tree::Transform::XSLTish::Utils::_set_engine_factory(
+        scalar caller,
+        $new_factory,
+    );
 
     return;
 }
diff --git a/lib/Tree/Transform/XSLTish/Transformer.pm b/lib/Tree/Transform/XSLTish/Transformer.pm
index c4ff53f..dae5821 100644
--- a/lib/Tree/Transform/XSLTish/Transformer.pm
+++ b/lib/Tree/Transform/XSLTish/Transformer.pm
@@ -44,9 +44,9 @@ sub _build_engine {
     my ($self)=@_;
 
     if ($self->rules_package) {
-        my $factory=Tree::Transform::XSLTish::Utils::_engine_factory($self->rules_package);
-        if ($$factory) {
-            return $$factory->();
+        my $factory=$self->rules_package->can($Tree::Transform::XSLTish::Utils::ENGINE_FACTORY_NAME);
+        if ($factory) {
+            return $factory->();
         }
     }
     return Tree::XPathEngine->new();
diff --git a/lib/Tree/Transform/XSLTish/Utils.pm b/lib/Tree/Transform/XSLTish/Utils.pm
index bfb438c..770426f 100644
--- a/lib/Tree/Transform/XSLTish/Utils.pm
+++ b/lib/Tree/Transform/XSLTish/Utils.pm
@@ -14,15 +14,14 @@ sub _rules_store {
     return $pack->get_package_symbol($RULES_NAME);
 }
 
-my $ENGINE_FACTORY_NAME='$_tree_transform_engine_factory';
+our $ENGINE_FACTORY_NAME='_tree_transform_engine_factory';
+my $ENGINE_FACTORY_NAME_WITH_SIGIL='&'.$ENGINE_FACTORY_NAME;
 
-sub _engine_factory {
-    my $pack=Class::MOP::Class->initialize($_[0]);
+sub _set_engine_factory {
+    my ($pack_name,$factory)=@_;
+    my $pack=Class::MOP::Class->initialize($pack_name);
 
-    if (! $pack->has_package_symbol($ENGINE_FACTORY_NAME) ) { 
-        $pack->add_package_symbol($ENGINE_FACTORY_NAME,undef);
-    }
-    return $pack->get_package_symbol($ENGINE_FACTORY_NAME);
+    $pack->add_package_symbol($ENGINE_FACTORY_NAME_WITH_SIGIL,$factory);
 }
 
 
diff --git a/t/02-inherit.t b/t/02-inherit.t
index fb8e238..f11d116 100644
--- a/t/02-inherit.t
+++ b/t/02-inherit.t
@@ -1,8 +1,15 @@
 #!perl
 package TransformA;{
- use Tree::Transform::XSLTish;
+ use Tree::Transform::XSLTish ':engine';
  use strict;
  use warnings;
+ use Tree::XPathEngine;
+ use Test::Most;
+
+ engine_factory {
+     ok 1,'custom factory called';
+     Tree::XPathEngine->new();
+ };
 
  default_rules;
 
@@ -29,7 +36,7 @@ package TransformB;{
 }
 
 package main;
-use Test::Most qw(no_plan die);
+use Test::Most tests=>2,'die';
 use strict;
 use warnings;
 use Tree::DAG_Node::XPath;
-- 
cgit v1.2.3


From fde2553f6e2ab87b0dc3806b2dfdb67cac1aea71 Mon Sep 17 00:00:00 2001
From: dakkar <dakkar@thenautilus.net>
Date: Sat, 18 Apr 2009 15:27:10 +0200
Subject: put proper plans in every test

---
 t/01-basic.t  | 2 +-
 t/03-byname.t | 2 +-
 t/04-errors.t | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/t/01-basic.t b/t/01-basic.t
index a6670a5..e947e7a 100644
--- a/t/01-basic.t
+++ b/t/01-basic.t
@@ -32,7 +32,7 @@ package OtherTransform;{
 }
 
 package main;
-use Test::Most qw(no_plan die);
+use Test::Most tests=>2,'die';
 use strict;
 use warnings;
 use Tree::DAG_Node::XPath;
diff --git a/t/03-byname.t b/t/03-byname.t
index 784138b..8c3723f 100644
--- a/t/03-byname.t
+++ b/t/03-byname.t
@@ -17,7 +17,7 @@ package NameTransform;{
 }
 
 package main;
-use Test::Most qw(no_plan die);
+use Test::Most tests=>1,'die';
 use strict;
 use warnings;
 use Tree::DAG_Node::XPath;
diff --git a/t/04-errors.t b/t/04-errors.t
index 107c1bd..ae02713 100644
--- a/t/04-errors.t
+++ b/t/04-errors.t
@@ -1,6 +1,6 @@
 #!perl
 package main;
-use Test::Most qw(no_plan);
+use Test::Most tests=>7;
 use strict;
 use warnings;
 use Tree::DAG_Node::XPath;
-- 
cgit v1.2.3


From 859fb85ae9063926cbdae3d7612a42d5777993a1 Mon Sep 17 00:00:00 2001
From: dakkar <dakkar@thenautilus.net>
Date: Sat, 18 Apr 2009 15:28:57 +0200
Subject: clarified docs on factories

---
 lib/Tree/Transform/XSLTish.pm             | 4 ++++
 lib/Tree/Transform/XSLTish/Transformer.pm | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/Tree/Transform/XSLTish.pm b/lib/Tree/Transform/XSLTish.pm
index 7053428..3dfb430 100644
--- a/lib/Tree/Transform/XSLTish.pm
+++ b/lib/Tree/Transform/XSLTish.pm
@@ -254,6 +254,10 @@ with the usual Perl inheritance scheme. It should even work with
 L<Class::C3>, since we use L<Class::MOP>'s C<class_precedence_list> to
 get the list of inherited packages.
 
+Engine factories are inherited, too, so you can extend a rules package
+without re-specifying the engine (you can, of course, override this
+and specify another one).
+
 =head1 AUTHOR
 
 Gianni Ceccarelli <dakkar@thenautilus.net>
diff --git a/lib/Tree/Transform/XSLTish/Transformer.pm b/lib/Tree/Transform/XSLTish/Transformer.pm
index dae5821..857143a 100644
--- a/lib/Tree/Transform/XSLTish/Transformer.pm
+++ b/lib/Tree/Transform/XSLTish/Transformer.pm
@@ -237,7 +237,7 @@ the correct C<rules_package> automatically.
 
 If you don't specify an C<engine>, it will be constructed using the
 class or factory declared in the rules package; if you didn't declare
-anything, it will be an instance of L<Tree::XPathEngine>
+anything, it will be an instance of L<Tree::XPathEngine>.
 
 =for comment
 
-- 
cgit v1.2.3


From 65e68ab4d03131e4193595c2b8fb215ba3735ed5 Mon Sep 17 00:00:00 2001
From: dakkar <dakkar@thenautilus.net>
Date: Sun, 19 Apr 2009 15:40:31 +0200
Subject: doc about importing

---
 lib/Tree/Transform/XSLTish.pm | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/lib/Tree/Transform/XSLTish.pm b/lib/Tree/Transform/XSLTish.pm
index 3dfb430..4c29afa 100644
--- a/lib/Tree/Transform/XSLTish.pm
+++ b/lib/Tree/Transform/XSLTish.pm
@@ -231,6 +231,10 @@ This function declares that the
 L<Tree::Transform::XSLTish::Transformer> object returned by L</new>
 should use this class to build its XPath engine.
 
+This function is not exported by default: you have to use the module as:
+
+ use Tree::Transform::XSLTish ':engine';
+
 =head2 C<engine_factory>
 
   engine_factory { My::XPath::Engine->new(params=>$whatever) };
@@ -242,6 +246,10 @@ should call the passed code-ref to get its engine.
 C<engine_class $classname> is equivalent to C<engine_factory {
 $classname->new }>.
 
+This function is not exported by default: you have to use the module as:
+
+ use Tree::Transform::XSLTish ':engine';
+
 =head2 C<new>
 
 Returns a L<Tree::Transform::XSLTish::Transformer> for the rules
@@ -258,6 +266,11 @@ Engine factories are inherited, too, so you can extend a rules package
 without re-specifying the engine (you can, of course, override this
 and specify another one).
 
+=head1 IMPORTING
+
+This module uses L<Sub::Exporter>, see that module's documentation for
+things like renaming the imports.
+
 =head1 AUTHOR
 
 Gianni Ceccarelli <dakkar@thenautilus.net>
-- 
cgit v1.2.3


From 1f9c8426a9bf1c94a6cf00edd85628d1c09e22e0 Mon Sep 17 00:00:00 2001
From: Gianni Ceccarelli <dakkar@dechirico.(none)>
Date: Thu, 23 Apr 2009 15:04:07 +0200
Subject: new tests

---
 Makefile.PL             |  1 +
 t/00-author-critic.t    | 33 +++++++++++++++++++++++++++++++++
 t/00-author-deps.t      |  6 ------
 t/00-author-minver.t    | 33 +++++++++++++++++++++++++++++++++
 t/00-author-pod-cover.t |  7 -------
 t/00-author-pod.t       | 35 +++++++++++++++++++++++++++++++----
 6 files changed, 98 insertions(+), 17 deletions(-)
 create mode 100644 t/00-author-critic.t
 delete mode 100644 t/00-author-deps.t
 create mode 100644 t/00-author-minver.t
 delete mode 100644 t/00-author-pod-cover.t

diff --git a/Makefile.PL b/Makefile.PL
index 8912266..1971a86 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -11,6 +11,7 @@ requires 'Tree::XPathEngine' => 0,
          'Carp::Clan'        => 0,
          'Sub::Exporter'     => 0,
          'MooseX::AttributeHelpers' => 0,
+         'perl'              => '5.6.0',
 ;
 
 test_requires 'Test::Most'   => 0,
diff --git a/t/00-author-critic.t b/t/00-author-critic.t
new file mode 100644
index 0000000..d0a133a
--- /dev/null
+++ b/t/00-author-critic.t
@@ -0,0 +1,33 @@
+#!/usr/bin/perl
+
+# Test that the module passes perlcritic
+use strict;
+BEGIN {
+	$|  = 1;
+	$^W = 1;
+}
+
+my @MODULES = (
+	'Perl::Critic 1.098',
+	'Test::Perl::Critic 1.01',
+);
+
+# Don't run tests during end-user installs
+use Test::More;
+unless ( $ENV{AUTOMATED_TESTING} or $ENV{RELEASE_TESTING} ) {
+	plan( skip_all => "Author tests not required for installation" );
+}
+
+# Load the testing modules
+foreach my $MODULE ( @MODULES ) {
+	eval "use $MODULE";
+	if ( $@ ) {
+		$ENV{RELEASE_TESTING}
+		? die( "Failed to load required release-testing module $MODULE" )
+		: plan( skip_all => "$MODULE not available for testing" );
+	}
+}
+Test::Perl::Critic->import( -exclude => ['ProhibitSubroutinePrototypes']);
+all_critic_ok();
+
+1;
diff --git a/t/00-author-deps.t b/t/00-author-deps.t
deleted file mode 100644
index f92ec06..0000000
--- a/t/00-author-deps.t
+++ /dev/null
@@ -1,6 +0,0 @@
-#!perl
-use Test::Most;
-plan skip_all => "skipping author-only test" unless $ENV{RUN_AUTHOR_TESTS};
-eval "use Test::Dependencies exclude => [qw(Tree::Transform::XSLTish XML::LibXML Moose::Util::TypeConstraints)]";
-
-ok_dependencies();
diff --git a/t/00-author-minver.t b/t/00-author-minver.t
new file mode 100644
index 0000000..4dfb876
--- /dev/null
+++ b/t/00-author-minver.t
@@ -0,0 +1,33 @@
+#!/usr/bin/perl
+
+# Test that our declared minimum Perl version matches our syntax
+use strict;
+BEGIN {
+	$|  = 1;
+	$^W = 1;
+}
+
+my @MODULES = (
+	'Perl::MinimumVersion 1.20',
+	'Test::MinimumVersion 0.008',
+);
+
+# Don't run tests during end-user installs
+use Test::More;
+unless ( $ENV{AUTOMATED_TESTING} or $ENV{RELEASE_TESTING} ) {
+	plan( skip_all => "Author tests not required for installation" );
+}
+
+# Load the testing modules
+foreach my $MODULE ( @MODULES ) {
+	eval "use $MODULE";
+	if ( $@ ) {
+		$ENV{RELEASE_TESTING}
+		? die( "Failed to load required release-testing module $MODULE" )
+		: plan( skip_all => "$MODULE not available for testing" );
+	}
+}
+
+all_minimum_version_from_metayml_ok();
+
+1;
diff --git a/t/00-author-pod-cover.t b/t/00-author-pod-cover.t
deleted file mode 100644
index 9bace3e..0000000
--- a/t/00-author-pod-cover.t
+++ /dev/null
@@ -1,7 +0,0 @@
-#!perl
-use Test::Most;
-plan skip_all => "skipping author-only test" unless $ENV{RUN_AUTHOR_TESTS};
-eval "use Test::Pod::Coverage";
-all_pod_coverage_ok({
-    trustme=> [qr(^new_transformer$)],
-});
diff --git a/t/00-author-pod.t b/t/00-author-pod.t
index 5177b0c..2cdfcc4 100644
--- a/t/00-author-pod.t
+++ b/t/00-author-pod.t
@@ -1,6 +1,33 @@
-#!perl
-use Test::Most;
-plan skip_all => "skipping author-only test" unless $ENV{RUN_AUTHOR_TESTS};
-eval "use Test::Pod";
+#!/usr/bin/perl
+
+# Test that the syntax of our POD documentation is valid
+use strict;
+BEGIN {
+	$|  = 1;
+	$^W = 1;
+}
+
+my @MODULES = (
+	'Pod::Simple 3.07',
+	'Test::Pod 1.26',
+);
+
+# Don't run tests during end-user installs
+use Test::More;
+unless ( $ENV{AUTOMATED_TESTING} or $ENV{RELEASE_TESTING} ) {
+	plan( skip_all => "Author tests not required for installation" );
+}
+
+# Load the testing modules
+foreach my $MODULE ( @MODULES ) {
+	eval "use $MODULE";
+	if ( $@ ) {
+		$ENV{RELEASE_TESTING}
+		? die( "Failed to load required release-testing module $MODULE" )
+		: plan( skip_all => "$MODULE not available for testing" );
+	}
+}
 
 all_pod_files_ok();
+
+1;
-- 
cgit v1.2.3


From b0c300919fd33fbff9167b294dca14dff0250bc1 Mon Sep 17 00:00:00 2001
From: Gianni Ceccarelli <dakkar@dechirico.(none)>
Date: Thu, 23 Apr 2009 15:29:16 +0200
Subject: passes critic

---
 lib/Tree/Transform/XSLTish.pm             |  7 +++----
 lib/Tree/Transform/XSLTish/Context.pm     |  2 ++
 lib/Tree/Transform/XSLTish/Transformer.pm | 21 ++++++++++-----------
 lib/Tree/Transform/XSLTish/Utils.pm       |  6 +++++-
 t/00-author-critic.t                      |  4 +++-
 5 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/lib/Tree/Transform/XSLTish.pm b/lib/Tree/Transform/XSLTish.pm
index 4c29afa..42b7222 100644
--- a/lib/Tree/Transform/XSLTish.pm
+++ b/lib/Tree/Transform/XSLTish.pm
@@ -12,7 +12,8 @@ our $VERSION='0.1';
 
 my @DEFAULT_EXPORTS=('tree_rule',
                      'default_rules',
-                     'new_transformer' => {-as => 'new'});
+                     'new_transformer' => {-as => 'new'},
+                 );
 
 Sub::Exporter::setup_exporter({
     exports => [qw(tree_rule default_rules new_transformer engine_class engine_factory)],
@@ -81,12 +82,10 @@ sub engine_factory(&) {
     return;
 }
 
-sub _transformer_class { 'Tree::Transform::XSLTish::Transformer' };
-
 sub new_transformer {
     my $rules_package=shift;
 
-    return _transformer_class->new(rules_package=>$rules_package,@_);
+    return Tree::Transform::XSLTish::Transformer->new(rules_package=>$rules_package,@_);
 }
 
 1;
diff --git a/lib/Tree/Transform/XSLTish/Context.pm b/lib/Tree/Transform/XSLTish/Context.pm
index 0890401..96670ec 100644
--- a/lib/Tree/Transform/XSLTish/Context.pm
+++ b/lib/Tree/Transform/XSLTish/Context.pm
@@ -2,6 +2,8 @@ package Tree::Transform::XSLTish::Context;
 use Moose;
 use Carp::Clan qw(^Tree::Transform::XSLTish);
 
+our $VERSION='0.1';
+
 has 'current_node' => ( is => 'rw', isa => 'Object' );
 has 'node_list' => ( is => 'rw', isa => 'ArrayRef[Object]' );
 
diff --git a/lib/Tree/Transform/XSLTish/Transformer.pm b/lib/Tree/Transform/XSLTish/Transformer.pm
index 857143a..0d241e4 100644
--- a/lib/Tree/Transform/XSLTish/Transformer.pm
+++ b/lib/Tree/Transform/XSLTish/Transformer.pm
@@ -8,14 +8,12 @@ use Tree::Transform::XSLTish::Context;
 use Tree::XPathEngine;
 use Carp::Clan qw(^Tree::Transform::XSLTish);
 
+our $VERSION='0.1';
+
 subtype 'Tree::Transform::XSLTish::Engine'
     => as 'Object'
     => where {
-        my $object=$_;
-        for my $meth (qw(findnodes)) {
-            return unless $object->can($meth);
-        }
-        return 1;
+        return $_->can('findnodes') ? 1 : ();
     };
 
 has 'rules_package' => (is => 'ro', isa => 'ClassName');
@@ -52,7 +50,7 @@ sub _build_engine {
     return Tree::XPathEngine->new();
 }
 
-sub it { $_[0]->context->current_node }
+sub it { return $_[0]->context->current_node }
 
 sub transform {
     my ($self,$tree)=@_;
@@ -115,7 +113,7 @@ sub find_rule {
         return $ret if $ret;
     }
 
-    croak "No valid rule";
+    croak 'No valid rule';
 }
 
 sub find_rule_by_name {
@@ -140,12 +138,12 @@ sub find_rule_in_package {
     my $rules=$store->{by_match};
 
     my @candidates=
-        sort { $b->{priority} <=> $a->{priority} }
-            grep { $self->rule_matches($_) } @$rules;
+        sort { $b->{priority} <=> $a->{priority} } ## no critic (ProhibitReverseSortBlock)
+            grep { $self->rule_matches($_) } @{$rules};
     if (@candidates > 1 and
             $candidates[0]->{priority} ==
                 $candidates[1]->{priority}) {
-        croak "Ambiguous rule application";
+        croak 'Ambiguous rule application';
     }
     elsif (@candidates >= 1) {
         return $candidates[0];
@@ -202,7 +200,7 @@ sub rule_matches {
 
 __PACKAGE__->meta->make_immutable;no Moose;
 
-package Tree::Transform::XSLTish::ContextGuard;
+package Tree::Transform::XSLTish::ContextGuard; ## no critic (ProhibitMultiplePackages)
 
 sub new {
     my ($class,$trans,$context)=@_;
@@ -212,6 +210,7 @@ sub new {
 
 sub DESTROY {
     $_[0]->{trans}->leave();
+    return;
 }
 
 1;
diff --git a/lib/Tree/Transform/XSLTish/Utils.pm b/lib/Tree/Transform/XSLTish/Utils.pm
index 770426f..8546919 100644
--- a/lib/Tree/Transform/XSLTish/Utils.pm
+++ b/lib/Tree/Transform/XSLTish/Utils.pm
@@ -3,12 +3,14 @@ use strict;
 use warnings;
 use Class::MOP;
 
+our $VERSION='0.1';
+
 my $RULES_NAME='%_tree_transform_rules';
 
 sub _rules_store {
     my $pack=Class::MOP::Class->initialize($_[0]);
 
-    if (! $pack->has_package_symbol($RULES_NAME) ) { 
+    if (! $pack->has_package_symbol($RULES_NAME) ) {
         $pack->add_package_symbol($RULES_NAME,{});
     }
     return $pack->get_package_symbol($RULES_NAME);
@@ -22,6 +24,8 @@ sub _set_engine_factory {
     my $pack=Class::MOP::Class->initialize($pack_name);
 
     $pack->add_package_symbol($ENGINE_FACTORY_NAME_WITH_SIGIL,$factory);
+
+    return;
 }
 
 
diff --git a/t/00-author-critic.t b/t/00-author-critic.t
index d0a133a..79ed2b7 100644
--- a/t/00-author-critic.t
+++ b/t/00-author-critic.t
@@ -10,6 +10,7 @@ BEGIN {
 my @MODULES = (
 	'Perl::Critic 1.098',
 	'Test::Perl::Critic 1.01',
+        'File::Spec',
 );
 
 # Don't run tests during end-user installs
@@ -27,7 +28,8 @@ foreach my $MODULE ( @MODULES ) {
 		: plan( skip_all => "$MODULE not available for testing" );
 	}
 }
-Test::Perl::Critic->import( -exclude => ['ProhibitSubroutinePrototypes']);
+my $rcfile = File::Spec->catfile( 't', 'perlcriticrc' );
+Test::Perl::Critic->import( -profile => $rcfile );
 all_critic_ok();
 
 1;
-- 
cgit v1.2.3


From 9361a9cbd67e58a0ada9da0f8c81428805e3d0b5 Mon Sep 17 00:00:00 2001
From: Gianni Ceccarelli <dakkar@dechirico.(none)>
Date: Sat, 25 Apr 2009 09:39:43 +0200
Subject: forgot the p::c profile

---
 t/perlcriticrc | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 t/perlcriticrc

diff --git a/t/perlcriticrc b/t/perlcriticrc
new file mode 100644
index 0000000..4185498
--- /dev/null
+++ b/t/perlcriticrc
@@ -0,0 +1,11 @@
+severity = 1
+theme = core || bug || maintenance || complexity || security
+color = 1
+
+[-Miscellanea::RequireRcsKeywords]
+[-Documentation::RequirePodSections]
+[-ValuesAndExpressions::ProhibitNoisyQuotes]
+[-Subroutines::ProhibitSubroutinePrototypes]
+[-Subroutines::RequireArgUnpacking]
+[-Subroutines::ProtectPrivateSubs]
+[-ControlStructures::ProhibitUnlessBlocks]
-- 
cgit v1.2.3


From de1a2f95f3ff6cf1d09e0f4df10f4c5e1c67aead Mon Sep 17 00:00:00 2001
From: dakkar <dakkar@thenautilus.net>
Date: Sat, 25 Apr 2009 09:42:27 +0200
Subject: updated dependencies, removed work-arounds

---
 Makefile.PL      | 2 +-
 t/01-basic.t     | 3 ---
 t/02-inherit.t   | 3 ---
 t/03-byname.t    | 3 ---
 t/04-errors.t    | 3 ---
 t/05-html-tree.t | 6 ++----
 t/perlcriticrc   | 1 +
 7 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/Makefile.PL b/Makefile.PL
index 1971a86..d387a46 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -15,7 +15,7 @@ requires 'Tree::XPathEngine' => 0,
 ;
 
 test_requires 'Test::Most'   => 0,
-              'Tree::DAG_Node::XPath' => 0,
+              'Tree::DAG_Node::XPath' => '0.10',
 ;
 
 WriteAll;
diff --git a/t/01-basic.t b/t/01-basic.t
index e947e7a..a8e2474 100644
--- a/t/01-basic.t
+++ b/t/01-basic.t
@@ -37,9 +37,6 @@ use strict;
 use warnings;
 use Tree::DAG_Node::XPath;
 
-sub Tree::DAG_Node::XPath::Root::xpath_get_root_node { return $_[0] }
-sub Tree::DAG_Node::XPath::Root::xpath_get_parent_node { return }
-
 my $tree=Tree::DAG_Node::XPath->new();
 $tree->name('base');
 $tree->new_daughter->name("coso$_") for 1..5;
diff --git a/t/02-inherit.t b/t/02-inherit.t
index f11d116..e882b53 100644
--- a/t/02-inherit.t
+++ b/t/02-inherit.t
@@ -41,9 +41,6 @@ use strict;
 use warnings;
 use Tree::DAG_Node::XPath;
 
-sub Tree::DAG_Node::XPath::Root::xpath_get_root_node { return $_[0] }
-sub Tree::DAG_Node::XPath::Root::xpath_get_parent_node { return }
-
 my $tree=Tree::DAG_Node::XPath->new();
 $tree->name('base');
 $tree->new_daughter->name("coso$_") for 1..5;
diff --git a/t/03-byname.t b/t/03-byname.t
index 8c3723f..a16b2d6 100644
--- a/t/03-byname.t
+++ b/t/03-byname.t
@@ -22,9 +22,6 @@ use strict;
 use warnings;
 use Tree::DAG_Node::XPath;
 
-sub Tree::DAG_Node::XPath::Root::xpath_get_root_node { return $_[0] }
-sub Tree::DAG_Node::XPath::Root::xpath_get_parent_node { return }
-
 my $tree=Tree::DAG_Node::XPath->new();
 $tree->name('base');
 $tree->new_daughter->name("coso$_") for 1..5;
diff --git a/t/04-errors.t b/t/04-errors.t
index ae02713..6656933 100644
--- a/t/04-errors.t
+++ b/t/04-errors.t
@@ -5,9 +5,6 @@ use strict;
 use warnings;
 use Tree::DAG_Node::XPath;
 
-sub Tree::DAG_Node::XPath::Root::xpath_get_root_node { return $_[0] }
-sub Tree::DAG_Node::XPath::Root::xpath_get_parent_node { return }
-
 my $tree=Tree::DAG_Node::XPath->new();
 $tree->name('base');
 $tree->new_daughter->name("coso$_") for 1..5;
diff --git a/t/05-html-tree.t b/t/05-html-tree.t
index eb990e8..2973d25 100644
--- a/t/05-html-tree.t
+++ b/t/05-html-tree.t
@@ -18,12 +18,10 @@ package main;
 use Test::Most 'die';
 use strict;
 use warnings;
-eval 'use XML::XPathEngine;use HTML::TreeBuilder::XPath;';
-plan skip_all => 'XML::XPathEngine and HTML::TreeBuilder::XPath needed for this test' if $@;
+eval 'use XML::XPathEngine;use HTML::TreeBuilder::XPath 0.10;';
+plan skip_all => 'XML::XPathEngine and HTML::TreeBuilder::XPath 0.10 needed for this test' if $@;
 plan tests=> 1;
 
-sub HTML::TreeBuilder::XPath::Root::getRootNode { return $_[0] }
-
 my $tree=HTML::TreeBuilder::XPath->new();
 $tree->parse(<<'HTML');$tree->eof;
 <html>
diff --git a/t/perlcriticrc b/t/perlcriticrc
index 4185498..5ad1ad7 100644
--- a/t/perlcriticrc
+++ b/t/perlcriticrc
@@ -9,3 +9,4 @@ color = 1
 [-Subroutines::RequireArgUnpacking]
 [-Subroutines::ProtectPrivateSubs]
 [-ControlStructures::ProhibitUnlessBlocks]
+[-CodeLayout::RequireTidyCode]
-- 
cgit v1.2.3


From b7a218903103b5f32360dce11523b76c6b5de5ae Mon Sep 17 00:00:00 2001
From: Gianni Ceccarelli <dakkar@dechirico.(none)>
Date: Wed, 29 Apr 2009 15:53:30 +0200
Subject: hopefully fixed P::C tests, and upped version

---
 lib/Tree/Transform/XSLTish.pm             |  20 ++++-
 lib/Tree/Transform/XSLTish/Context.pm     |   2 +-
 lib/Tree/Transform/XSLTish/Transformer.pm |   6 +-
 lib/Tree/Transform/XSLTish/Utils.pm       |   2 +-
 t/perlcriticrc                            | 128 +++++++++++++++++++++++++++---
 5 files changed, 141 insertions(+), 17 deletions(-)

diff --git a/lib/Tree/Transform/XSLTish.pm b/lib/Tree/Transform/XSLTish.pm
index 42b7222..9c4b1ec 100644
--- a/lib/Tree/Transform/XSLTish.pm
+++ b/lib/Tree/Transform/XSLTish.pm
@@ -8,7 +8,7 @@ use Tree::Transform::XSLTish::Transformer;
 use Carp::Clan qw(^Tree::Transform::XSLTish);
 use v5.8;
 
-our $VERSION='0.1';
+our $VERSION='0.2';
 
 my @DEFAULT_EXPORTS=('tree_rule',
                      'default_rules',
@@ -270,6 +270,24 @@ and specify another one).
 This module uses L<Sub::Exporter>, see that module's documentation for
 things like renaming the imports.
 
+=head1 KNOWN BUGS & ISSUES
+
+=over 4
+
+=item *
+
+It's I<slow>. Right now each rule application is linear in the number
+of defined rules I<times> the depth of the node being
+transformed. There are several ways to optimize this for most common
+cases (patches welcome), but I prefer to "make it correct, before
+making it fast"
+
+=item *
+
+Some sugaring with L<Devel::Declare> could make everything look better
+
+=back
+
 =head1 AUTHOR
 
 Gianni Ceccarelli <dakkar@thenautilus.net>
diff --git a/lib/Tree/Transform/XSLTish/Context.pm b/lib/Tree/Transform/XSLTish/Context.pm
index 96670ec..bb7c9de 100644
--- a/lib/Tree/Transform/XSLTish/Context.pm
+++ b/lib/Tree/Transform/XSLTish/Context.pm
@@ -2,7 +2,7 @@ package Tree::Transform::XSLTish::Context;
 use Moose;
 use Carp::Clan qw(^Tree::Transform::XSLTish);
 
-our $VERSION='0.1';
+our $VERSION='0.2';
 
 has 'current_node' => ( is => 'rw', isa => 'Object' );
 has 'node_list' => ( is => 'rw', isa => 'ArrayRef[Object]' );
diff --git a/lib/Tree/Transform/XSLTish/Transformer.pm b/lib/Tree/Transform/XSLTish/Transformer.pm
index 0d241e4..a36bd6a 100644
--- a/lib/Tree/Transform/XSLTish/Transformer.pm
+++ b/lib/Tree/Transform/XSLTish/Transformer.pm
@@ -8,7 +8,7 @@ use Tree::Transform::XSLTish::Context;
 use Tree::XPathEngine;
 use Carp::Clan qw(^Tree::Transform::XSLTish);
 
-our $VERSION='0.1';
+our $VERSION='0.2';
 
 subtype 'Tree::Transform::XSLTish::Engine'
     => as 'Object'
@@ -238,10 +238,6 @@ If you don't specify an C<engine>, it will be constructed using the
 class or factory declared in the rules package; if you didn't declare
 anything, it will be an instance of L<Tree::XPathEngine>.
 
-=for comment
-
-engine factories are not inherited!
-
 =head2 C<transform>
 
   @results=$trans->transform($tree);
diff --git a/lib/Tree/Transform/XSLTish/Utils.pm b/lib/Tree/Transform/XSLTish/Utils.pm
index 8546919..c760585 100644
--- a/lib/Tree/Transform/XSLTish/Utils.pm
+++ b/lib/Tree/Transform/XSLTish/Utils.pm
@@ -3,7 +3,7 @@ use strict;
 use warnings;
 use Class::MOP;
 
-our $VERSION='0.1';
+our $VERSION='0.2';
 
 my $RULES_NAME='%_tree_transform_rules';
 
diff --git a/t/perlcriticrc b/t/perlcriticrc
index 5ad1ad7..8503255 100644
--- a/t/perlcriticrc
+++ b/t/perlcriticrc
@@ -1,12 +1,122 @@
 severity = 1
-theme = core || bug || maintenance || complexity || security
 color = 1
+only = 1
 
-[-Miscellanea::RequireRcsKeywords]
-[-Documentation::RequirePodSections]
-[-ValuesAndExpressions::ProhibitNoisyQuotes]
-[-Subroutines::ProhibitSubroutinePrototypes]
-[-Subroutines::RequireArgUnpacking]
-[-Subroutines::ProtectPrivateSubs]
-[-ControlStructures::ProhibitUnlessBlocks]
-[-CodeLayout::RequireTidyCode]
+[BuiltinFunctions::ProhibitBooleanGrep]
+[BuiltinFunctions::ProhibitComplexMappings]
+[BuiltinFunctions::ProhibitLvalueSubstr]
+[BuiltinFunctions::ProhibitReverseSortBlock]
+[BuiltinFunctions::ProhibitSleepViaSelect]
+[BuiltinFunctions::ProhibitStringyEval]
+[BuiltinFunctions::ProhibitStringySplit]
+[BuiltinFunctions::ProhibitUniversalCan]
+[BuiltinFunctions::ProhibitUniversalIsa]
+[BuiltinFunctions::ProhibitVoidGrep]
+[BuiltinFunctions::ProhibitVoidMap]
+[BuiltinFunctions::RequireBlockGrep]
+[BuiltinFunctions::RequireBlockMap]
+[BuiltinFunctions::RequireGlobFunction]
+[BuiltinFunctions::RequireSimpleSortBlock]
+[ClassHierarchies::ProhibitAutoloading]
+[ClassHierarchies::ProhibitExplicitISA]
+[ClassHierarchies::ProhibitOneArgBless]
+[CodeLayout::ProhibitHardTabs]
+[CodeLayout::ProhibitParensWithBuiltins]
+[CodeLayout::ProhibitQuotedWordLists]
+[CodeLayout::ProhibitTrailingWhitespace]
+[CodeLayout::RequireConsistentNewlines]
+[CodeLayout::RequireTrailingCommas]
+[ControlStructures::ProhibitCStyleForLoops]
+[ControlStructures::ProhibitCascadingIfElse]
+[ControlStructures::ProhibitDeepNests]
+[ControlStructures::ProhibitLabelsWithSpecialBlockNames]
+[ControlStructures::ProhibitMutatingListFunctions]
+[ControlStructures::ProhibitNegativeExpressionsInUnlessAndUntilConditions]
+[ControlStructures::ProhibitPostfixControls]
+[ControlStructures::ProhibitUnreachableCode]
+[ControlStructures::ProhibitUntilBlocks]
+[Documentation::RequirePackageMatchesPodName]
+[Documentation::RequirePodAtEnd]
+[ErrorHandling::RequireCarping]
+[ErrorHandling::RequireCheckingReturnValueOfEval]
+[InputOutput::ProhibitBacktickOperators]
+[InputOutput::ProhibitBarewordFileHandles]
+[InputOutput::ProhibitExplicitStdin]
+[InputOutput::ProhibitInteractiveTest]
+[InputOutput::ProhibitJoinedReadline]
+[InputOutput::ProhibitOneArgSelect]
+[InputOutput::ProhibitReadlineInForLoop]
+[InputOutput::ProhibitTwoArgOpen]
+[InputOutput::RequireBracedFileHandleWithPrint]
+[InputOutput::RequireBriefOpen]
+[InputOutput::RequireCheckedClose]
+[InputOutput::RequireCheckedOpen]
+[InputOutput::RequireCheckedSyscalls]
+[Miscellanea::ProhibitFormats]
+[Miscellanea::ProhibitTies]
+[Miscellanea::ProhibitUnrestrictedNoCritic]
+[Miscellanea::ProhibitUselessNoCritic]
+[Modules::ProhibitAutomaticExportation]
+[Modules::ProhibitExcessMainComplexity]
+[Modules::ProhibitMultiplePackages]
+[Modules::RequireBarewordIncludes]
+[Modules::RequireEndWithOne]
+[Modules::RequireExplicitPackage]
+[Modules::RequireFilenameMatchesPackage]
+[Modules::RequireNoMatchVarsWithUseEnglish]
+[Modules::RequireVersionVar]
+[NamingConventions::Capitalization]
+[NamingConventions::ProhibitAmbiguousNames]
+[References::ProhibitDoubleSigils]
+[RegularExpressions::ProhibitCaptureWithoutTest]
+[RegularExpressions::ProhibitFixedStringMatches]
+[RegularExpressions::ProhibitUnusualDelimiters]
+[RegularExpressions::RequireBracesForMultiline]
+[RegularExpressions::RequireDotMatchAnything]
+[RegularExpressions::RequireExtendedFormatting]
+[RegularExpressions::RequireLineBoundaryMatching]
+[Subroutines::ProhibitAmpersandSigils]
+[Subroutines::ProhibitBuiltinHomonyms]
+[Subroutines::ProhibitExcessComplexity]
+[Subroutines::ProhibitExplicitReturnUndef]
+[Subroutines::ProhibitManyArgs]
+[Subroutines::ProhibitNestedSubs]
+[Subroutines::ProhibitReturnSort]
+[Subroutines::RequireFinalReturn]
+[TestingAndDebugging::ProhibitNoStrict]
+[TestingAndDebugging::ProhibitNoWarnings]
+[TestingAndDebugging::ProhibitProlongedStrictureOverride]
+[TestingAndDebugging::RequireTestLabels]
+[TestingAndDebugging::RequireUseStrict]
+[TestingAndDebugging::RequireUseWarnings]
+[ValuesAndExpressions::ProhibitCommaSeparatedStatements]
+[ValuesAndExpressions::ProhibitConstantPragma]
+[ValuesAndExpressions::ProhibitEmptyQuotes]
+[ValuesAndExpressions::ProhibitEscapedCharacters]
+[ValuesAndExpressions::ProhibitImplicitNewlines]
+[ValuesAndExpressions::ProhibitInterpolationOfLiterals]
+[ValuesAndExpressions::ProhibitLeadingZeros]
+[ValuesAndExpressions::ProhibitLongChainsOfMethodCalls]
+[ValuesAndExpressions::ProhibitMagicNumbers]
+[ValuesAndExpressions::ProhibitMismatchedOperators]
+[ValuesAndExpressions::ProhibitMixedBooleanOperators]
+[ValuesAndExpressions::ProhibitQuotesAsQuotelikeOperatorDelimiters]
+[ValuesAndExpressions::ProhibitSpecialLiteralHeredocTerminator]
+[ValuesAndExpressions::ProhibitVersionStrings]
+[ValuesAndExpressions::RequireInterpolationOfMetachars]
+[ValuesAndExpressions::RequireNumberSeparators]
+[ValuesAndExpressions::RequireQuotedHeredocTerminator]
+[ValuesAndExpressions::RequireUpperCaseHeredocTerminator]
+[Variables::ProhibitConditionalDeclarations]
+[Variables::ProhibitLocalVars]
+[Variables::ProhibitMatchVars]
+[Variables::ProhibitPackageVars]
+[Variables::ProhibitPerl4PackageNames]
+[Variables::ProhibitPunctuationVars]
+[Variables::ProhibitReusedNames]
+[Variables::ProhibitUnusedVariables]
+[Variables::ProtectPrivateVars]
+[Variables::RequireInitializationForLocalVars]
+[Variables::RequireLexicalLoopIterators]
+[Variables::RequireLocalizedPunctuationVars]
+[Variables::RequireNegativeIndices]
-- 
cgit v1.2.3


From 1df747c49a45d4e50a0bdeede26b0650002312ef Mon Sep 17 00:00:00 2001
From: Gianni Ceccarelli <dakkar@dechirico.(none)>
Date: Wed, 29 Apr 2009 16:10:33 +0200
Subject: changelog

---
 ChangeLog | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 ChangeLog

diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000..5d625b8
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,7 @@
+.. -*- mode: rst; coding: utf-8 -*-
+
+0.2 2009-04-30
+  - fixed Perl::Critic tests
+
+0.1 2009-04-27
+  - initial version
-- 
cgit v1.2.3


From 5c8faae4e315397ce41848e30731dbd406723d4e Mon Sep 17 00:00:00 2001
From: Gianni Ceccarelli <dakkar@dechirico.(none)>
Date: Wed, 29 Apr 2009 16:23:21 +0200
Subject: better perl version requirements

---
 ChangeLog                     | 1 +
 lib/Tree/Transform/XSLTish.pm | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/ChangeLog b/ChangeLog
index 5d625b8..7ce649d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -2,6 +2,7 @@
 
 0.2 2009-04-30
   - fixed Perl::Critic tests
+  - fixed perl version requirement
 
 0.1 2009-04-27
   - initial version
diff --git a/lib/Tree/Transform/XSLTish.pm b/lib/Tree/Transform/XSLTish.pm
index 9c4b1ec..e489992 100644
--- a/lib/Tree/Transform/XSLTish.pm
+++ b/lib/Tree/Transform/XSLTish.pm
@@ -6,7 +6,7 @@ use Params::Validate ':all';
 use Tree::Transform::XSLTish::Utils;
 use Tree::Transform::XSLTish::Transformer;
 use Carp::Clan qw(^Tree::Transform::XSLTish);
-use v5.8;
+use 5.006;
 
 our $VERSION='0.2';
 
-- 
cgit v1.2.3