Changeset 21998 for lang/perl/MooseX-DOM

Timestamp:

10/24/08 00:34:02 (5 years ago)

Author:

daisuke

Message:

merge the rewrite branch

Location:

lang/perl/MooseX-DOM/trunk

Files:

• Changes (modified) (1 diff)
• Makefile.PL (modified) (1 diff)
• eg (added)
• eg/synopsis.pl (added)
• lib/MooseX/DOM.pm (modified) (2 diffs)
• lib/MooseX/DOM/LibXML.pm (modified) (1 diff)
• lib/MooseX/DOM/LibXML/ContextNode.pm (deleted)
• lib/MooseX/DOM/LibXML/XPathContext.pm (added)
• lib/MooseX/DOM/Meta/Class.pm (added)
• lib/MooseX/DOM/Meta/LibXML (deleted)
• lib/MooseX/DOM/Meta/LibXML.pm (deleted)
• t/00_compile.t (deleted)
• t/01_simple.t (deleted)
• t/lib/Test/MooseX (added)
• t/lib/Test/MooseX/DOM (added)
• t/lib/Test/MooseX/DOM/Recipe001.pm (added)
• t/lib/Test/MxD (deleted)

lang/perl/MooseX-DOM/trunk/Changes

@@ -1 +1 @@
 Changes
 =======
+
+0.00999_01 - 23 Oct 2008
+  * Major rewrite. Beware! Backwards incompatible!
+    Everything is changed, except for the core idea.
+    This release should make it really easy to create DOM based objects.
 
 0.00004 - 12 Aug 2008

lang/perl/MooseX-DOM/trunk/Makefile.PL

@@ -5 +5 @@
 all_from('lib/MooseX/DOM.pm');
 
-requires 'Class::Inspector';
 requires 'Moose';
-requires 'XML::LibXML', 1.63;
-requires 'XML::LibXML::XPathContext';
+requires 'XML::LibXML';
 
 test_requires 'Test::More';
 test_requires 'Test::UseAllModules';
 
-auto_include;
+auto_include_deps;
 WriteAll;
+

lang/perl/MooseX-DOM/trunk/lib/MooseX/DOM.pm

@@ -3 +3 @@
 package MooseX::DOM;
 use strict;
-use Moose::Util;
-use Carp ();
+use warnings;
+use 5.008;
+use MooseX::DOM::Meta::Class;
 
 our $AUTHORITY = 'cpan:DMAKI';
-our $VERSION   = '0.00004';
-
-BEGIN {
-    my $engine = $ENV{MOOSEX_DOM_ENGINE} || 'MooseX::DOM::LibXML';
-    Class::MOP::load_class( $engine );
-
-    constant->import(ENGINE => $engine);
-}
+our $VERSION   = '0.00999';
 
 sub import {
     my $class = shift;
-    my $caller = caller(0);
-
-    return if $caller eq 'main';
-
-    # if $caller is already meta-fied.
-    if ( $caller->can('meta') ) {
-        Carp::confess "You already have 'meta' initialized. you need to 'use MooseX::DOM' /instead/ of 'use Moose'";
-    }
-
-    my $engine = &ENGINE;
-    $engine->init_meta( $caller );
-    Moose::Util::apply_all_roles($caller->meta, $engine);
-    Moose->import( { into => $caller }, @_ );
-
-    my $exporter = join('::', $engine, 'export_dsl');
-    goto &$exporter;
+    my $caller = caller();
+
+    my $backend = 'MooseX::DOM::LibXML';
+    Class::MOP::load_class($backend);
+
+    Moose::Util::MetaRole::apply_metaclass_roles(
+        for_class => $caller,
+        metaclass_roles => [ 'MooseX::DOM::Meta::Class' ]
+    );
+    $backend->setup($caller);
+    $class->export_keywords($caller);
 }
 
 sub unimport {
     my $class = shift;
-
-    my $caller = caller(0);
-    Moose->unimport( { into => $caller }, @_ );
-
-    my $engine = &ENGINE;
-    my $unexporter = join('::', $engine, 'unexport_dsl' );
-    goto &$unexporter;
-}
-
-    
-
+    my $caller = caller();
+
+    $class->unexport_keywords($caller);
+}
+
+sub export_keywords {
+    my ($class, $caller) = @_;
+
+    my $exporter = Sub::Exporter::build_exporter({
+        into => $caller,
+        groups => { default => [ ':all' ] },
+        exports => [
+            dom_nodes      => sub { $class->build_dom_nodes($caller) },
+            dom_fetchnodes => sub { $class->build_dom_fetchnodes($caller) },
+            dom_to_class   => sub { $class->build_dom_to_class($caller) },
+            dom_value      => sub { $class->build_dom_value($caller) },
+        ]
+    });
+    $exporter->($class);
+}
+
+sub unexport_keywords {
+    my ($class, $caller) = @_;
+    my @keywords = qw(dom_nodes dom_fetchnodes dom_to_class dom_value);
+
+    { no strict 'refs';
+        foreach my $name (@keywords) {
+            if ( defined &{ $caller . '::' . $name }) {
+                delete ${ $caller . '::' }{$name};
+            }
+        }
+    }
+}
+
+sub build_dom_value {
+    my ($class, $caller) = @_;
+
+    return sub {
+        my $name = shift;
+        my $args = { @_ == 1 ? (fetch => {xpath => $_[0]}) : @_ };
+
+        my $fetch = $args->{fetch};
+        my $fetch_xpath = $fetch->{xpath} || $name;
+        my $meta = $caller->meta;
+        $meta->add_method(
+            $name,
+            Moose::Meta::Method->wrap(
+                package_name => $caller,
+                name         => $name,
+                body         => sub {
+                    my $self = shift;
+                    $self->dom_root->findvalue($fetch_xpath);
+                }
+            )
+        );
+    };
+}
+
+sub build_dom_nodes {
+    my ($class, $caller) = @_;
+
+    return sub {
+        my $name = shift;
+        my $args = { @_ == 1 ? (fetch => $_[0]) : @_ };
+
+        $args->{into} = $caller;
+        my @methods = (
+            $class->build_dom_nodes_accessor($name, $args),
+            $class->build_dom_nodes_appender($name, $args),
+        );
+
+        my $meta = $caller->meta;
+        foreach my $method (@methods) {
+            $meta->add_method($method->{name}, $method->{code});
+        }
+    }
+}
+
+sub build_dom_nodes_appender {
+    my ($class, $name, $args) = @_;
+
+    # I can't figure out this one automatically (I think). 
+    # just expect a code, and if I can't find it, not methods are
+    # returned to the callee
+    my $config = ref $args->{append} eq 'HASH' ? $args->{append} : 
+        { code => $args->{append} };
+    my $method = $config->{name} || "add_$name";
+    my $code = $config->{code};
+    my $ret;
+    if ($code) {
+        $ret = {
+            $method,
+            Moose::Meta::Method->wrap(
+                package_name => $args->{into},
+                name         => $method,
+                body         => $code
+            )
+        };
+    }
+    return $ret ? $ret : ();
+}
+
+sub build_dom_nodes_accessor {
+    my ($class, $name, $args) = @_;
+
+    my $fetch = $args->{fetch};
+    my $store = $args->{store};
+
+    if (! ref $fetch) {
+        my $xpath = $fetch;
+        $fetch = sub { shift->dom_root->findnodes($xpath) };
+    }
+
+    my $code = <<"    EOSUB";
+        sub {
+            my \$self = shift;
+            my \@ret = \$fetch->(\$self);
+    EOSUB
+    if ($store) {
+        $code .= <<"        EOSUB";
+            if (\@_) {
+                \$store->(\$self, \@_);
+            }
+        EOSUB
+    }
+
+    $code .= <<"    EOSUB";
+            return \@ret;
+        }
+    EOSUB
+    my $cv = eval $code; Carp::confess($@) if $@;
+
+    return {
+        name => $name,
+        code => Moose::Meta::Method->wrap(
+            package_name => $args->{into},
+            name         => $name,
+            body         => $cv,
+        )
+    };
+}
+
+sub build_dom_fetchnodes {
+    my ($class, $caller) = @_;
+
+    return sub {
+        my $args = {@_ == 1 ? (xpath => $_[0]) : @_};
+        my $filter = $args->{filter};
+        my $xpath  = $args->{xpath};
+        return $filter ?
+            sub {
+                my $self = shift;
+                return $filter->($self->dom_root->findnodes($xpath));
+            } :
+            sub {
+                my $self = shift;
+                return $self->dom_root->findnodes($xpath);
+            }
+    };
+}
+
+sub build_dom_to_class {
+    my ($class, $caller) = @_;
+
+    return sub {
+        my $args = {@_ == 1 ? (to_class => $_[0]) : @_};
+        my $to_class = $args->{to_class};
+        Class::MOP::load_class($to_class);
+        return sub {
+            map { $to_class->new($_) } @_;
+        }
+    }
+}
 1;
 
@@ -55 +206 @@
 =head1 NAME
 
-MooseX::DOM - Simplistic Object XML Mapper
+MooseX::DOM - Easily Create DOM Based Objects
 
 =head1 SYNOPSIS
 
-  package MyObject;
-  use MooseX::DOM;
- 
-  has_dom_child 'title';
-
-  no Moose;
-  no MoooseX::DOM;
-
-  my $obj = MyObject->new(node => <<EOXML);
-  <feed>
-    <title>Foo</title>
-  </feed>
-  EOXML
-
-  print $obj->title(), "\n"; # Foo
-  $obj->title('Bar');
-  print $obj->title(), "\n"; # Bar
+    package RSS;
+    use Moose;
+    use MooseX::DOM;
+
+    dom_value 'version' => '@version';
+    dom_nodes 'items' => (
+        fetch => dom_fetchnodes(
+            xpath => 'channel/item',
+            filter => dom_to_class('RSS::Item')
+        )
+    );
+
+    # or, easy way (just get some DOM nodes)
+    # dom_nodes 'items' => 'channel/items';
+
+    # or, create your own way to fetch the nodes
+    # dom_nodes 'items' => (
+    #     fetch => sub { ... }
+    # );
+
+    no Moose;
+    no MooseX::DOM;
+
+    package RSS::Item;
+    use Moose;
+    use MooseX::DOM;
+
+    dom_value 'title';
+    dom_value 'description';
+    dom_value 'link';
+
+    no Moose;
+    no MooseX::DOM;
+
+    sub BUILDARGS {
+        my $class = shift;
+        my $args  = {@_ == 1? (dom_root => $_[0]) : @_};
+        return $args;
+    }
+
+    package main;
+
+    # parse_file() is automatically created for you.
+    my $rss = RSS->parse_file('rss.xml');
+    foreach my $item ($rss->items) {
+        print "item link  = ", $item->link, "\n";
+        print "item title = ", $item->title, "\n";
+    }
 
 =head1 DESCRIPTION
 
-This module is intended to be used in conjunction with other modules
-that encapsulate XML data (for example, XML feeds).
-
-=head1 DECLARATION
-
-=head2 has_dom_root $name[, %opts]
-
-Specifies that the given XML have the specified tag. This specification is
-also used when creating new root node for creating the underlying XML
-
-  has_dom_root $name => (
-    # attributes => { ... }
-  );
-
-=head2 has_dom_attr $name[, %opts]
-
-Specifies that the object should contain an attribute by the given name
-
-=head2 has_dom_child $name[, %opts]
-
-Specifies that the object should contain a single child by the given name.
-Will generate accessor that can handle set/get
-
-  has_dom_child 'foo';
-
-  $obj->foo(); # get the value of child element foo
-  $obj->foo("bar"); # set the value of child element foo to bar
-
-%opts may contain C<namespace>, C<tag>, and C<filter>
-
-Specifying C<namespace> forces MooseX::DOM to look for tags in a specific
-namespace uri.
-
-Specifying C<tag> allows MooseX::DOM to look for the tag name given in C<tag>
-while making the generated method name as C<$name>
-
-The optional C<filter> parameter should be a subroutine that takes the object 
-itself as the first parameter, and the DOM node(s) as the rest of the 
-parameters.  You are allowed to transform the node as you like. By default, 
-a filter that converts the node to its text content is used.
-
-  has_dom_child 'foo' => (
-    filter => sub {
-      my ($self, $node) = @_;
-      # return whatever you want to return, perhaps transforming $node
-    }
-  );
-
-The optional C<create> parameter should be a subroutine that does the
-does the actual insertion of the new node, given the arguments.
-By default it expects a list of text argument, and creates a child node
-with those arguments.
-
-  has_dom_child 'foo' => (
-    create => sub {
-      my($self, %args) = @_;
-      # keys in %args:
-      #   child
-      #   namespace
-      #   tag
-      #   value
-    }
-  );
-
-=head2 has_dom_children 
-
-Specifies that the object should contain possibly multiple children by the
-given name
-
-  has_dom_children 'foo';
-
-  $obj->foo(); # Returns a list of values for each child element foo
-  $obj->foo(qw(1 2 3)); # Discards old values of foo, and create new nodes
-
-%opts may contain C<namespace>, C<tag>, C<filter>, and C<create>
-
-The optional C<namespace> parameter forces MooseX::DOM to look for tags in a 
-specific namespace uri.
-
-The optional C<tag> parameter allows MooseX::DOM to look for the tag name given 
-in C<tag> while making the generated method name as C<$name>
-
-The optional C<filter> parameter should be a subroutine that takes the object 
-itself as the first parameter, and the DOM node(s) as the rest of the 
-parameters.  You are allowed to transform the node as you like. By default, 
-a filter that converts the node to its text content is used.
-
-  has_dom_children 'foo' => (
-    filter => sub {
-      my ($self, @nodes) = @_;
-      # return whatever you want to return, perhaps transforming @nodes
-    }
-  );
-
-The optional C<create> parameter should be a subroutine that does the
-does the actual insertion of the new nodes, given the arguments.
-By default it expects a list of text arguments, and creates child nodes
-with those arguments.
-
-  has_dom_children 'foo' => (
-    create => sub {
-      my($self, %args) = @_;
-      # keys in %args:
-      #   children
-      #   namespace
-      #   tag
-      #   values
-    }
-  );
-
-=head2 has_dom_content $name
-
-If your node only contains text data (that is, your root node does not have any
-subsequent element nodes as its child), you can access the text data directly
-with this declaration
+MooseX::DOM is a tool that allows you to define classes that are based on
+XML DOM.
+
+=head1 PROVIDED DSL
+
+The following DSL is provided upon calling C<MooseX::DOM>. When 
+C<no MooseX::DOM> is used, these functions are removed from your namespace.
+
+=head2 dom_nodes $name => %spec
+
+Declares that a method named $name should be built, using the given spec.
+Returns a list of nodes, or what the filter argument trasnlates them to.
+
+If %spec is omitted, $name is taken to be the xpath to fetch.
+
+=head2 dom_value $name => %spec
+
+Declares that a method named $name should be built, using the given spec.
+Returns the result of the fetch, whatever that may be.
+
+If %spec is omitted, $name is taken to be the xpath to fetch.
+
+=head2 dom_fetchnodes %spec
+
+Creates a closure that fetches some nodes
+
+=head2 dom_to_class %spec
+
+Creates a closure that transforms nodes to something else, typically an object.
+
+=head1 PROVIDED METHODS
+
+The following methods are built onto your class automatically.
+
+=head2 parse_file
+
+=head2 parse_string
+
+=head2 parse_fh
+
+These methods allow you to parse a piece of XML, and build a MooseX::DOM
+object based on it.
+
+=head2 dom_findnodes($xpath)
+
+Does a DOM XPath lookup. Returns a plain DOM object.
+
+=head2 dom_findvalue($xpath)
+
+Does a DOM XPath lookup. Returns whatever value the XPath results to.
 
 =head1 AUTHOR

lang/perl/MooseX-DOM/trunk/lib/MooseX/DOM/LibXML.pm

@@ -2 +2 @@
 
 package MooseX::DOM::LibXML;
-use Moose::Role;
-use MooseX::DOM::LibXML::ContextNode;
-use MooseX::DOM::Meta::LibXML;
-use MooseX::DOM::Meta::LibXML::Attribute::Content;
+# I want to use MooseX::Singleton, but it generates some warnings,
+# so thi is a plain moose class with package level global
+use Moose;
+use MooseX::DOM::LibXML::XPathContext;
 
-use constant DEFAULT_NAMESPACE_PREFIX => "#default";
-
-has 'node' => (
+has 'dom_root_attr' => (
     is => 'rw',
-    isa => 'MooseX::DOM::LibXML::ContextNode',
-    coerce => 1,
+    isa => 'Moose::Meta::Attribute',
+    lazy    => 1,
+    builder => 'build_dom_root_attr'
 );
 
-has 'namespaces' => (
-    is => 'rw',
-    isa => 'HashRef',
-    required => 1,
-    default => sub { +{} }
-);
+my @METHODS = qw(parse_file parse_string dom_findvalue dom_findnodes);
+foreach my $method (@METHODS) {
+    my $attr    = "${method}_method";
+    my $builder = "build_${method}_method";
 
-no Moose;
-
-sub BUILD {
-    my $self = shift;
-    $self->node->register_namespaces( $self->namespaces );
-    $self;
-}
-
-sub init_meta {
-    # Only MooseX::DOM knows the true caller, so we expect it to
-    # provide us with one
-    my ($class, $caller) = @_;
-
-    Moose::init_meta( 
-        $caller, 
-        undef,
-        'MooseX::DOM::Meta::LibXML'
+    has $attr=> (
+        is => 'rw',
+        isa => 'Moose::Meta::Method',
+        lazy    => 1,
+        builder => $builder
     );
 }
 
-BOOTSTRAP: {
-    my $subname = sub { join('::', $_[1] || __PACKAGE__, $_[0]) };
-    my $subassign = sub {
-        no strict 'refs';
-        *{$_[0]} = Class::MOP::subname($_[0], $_[1]);
-    };
+__PACKAGE__->meta->make_immutable;
+    
+no Moose;
 
-    # Used to convert element node to its text content
-    my $textfilter = sub {
-        my $self = shift;
-        return map { blessed $_ && $_->can('textContent') ? $_->textContent : $_ } @_;
-    };
+our $INSTANCE;
 
-    # Used only in has_dom_children, to create a list of element nodes from
-    # list of text
-    my $text2elements = Class::MOP::subname($subname->('text2elements') => sub {
-        my($self, %args) = @_;
+sub setup {
+    my ($class, $caller) = @_;
 
-        my $values = $args{values};
-        my $namespace = $args{namespace} || '';
-        my $tag = $args{tag};
+    my $meta = $caller->meta;
+    my $self = ($INSTANCE ||= $class->new());
+    $self->add_attributes($meta);
+    $self->add_methods($meta);
+    $meta->backend($self);
+}
 
-        my $node = $self->node;
+sub add_attributes {
+    my ($self, $meta) = @_;
 
-        my $nsuri = $self->namespaces->{ $namespace };
-        my $document = $node->ownerDocument;
-        my @children;
-        foreach my $data (@$values) {
-            my $child = ($nsuri) ?
-                $document->createElementNS($nsuri, $tag) :
-                $document->createElement($tag)
-            ;
-            $child->appendTextNode($data);
-            push @children, $child;
-            $node->appendChild($child);
-        }
-        return @children;
-    });
+    $meta->add_attribute( $self->dom_root_attr );
+}
 
-    my %exports = (
-        has_dom_root => sub {
-            return Class::MOP::subname($subname->('has_dom_root') => sub ($;%) {
-                my $caller = caller();
-                my ($tag, %args) = @_;
-                # tag => $tag
-                # attributes => { attr1 => $val1, attr2 => $val2 }
+sub add_methods {
+    my ($self, $meta) = @_;
 
-                # Find the meta attribute for 'node', and add type constraints
-                
-                $tag = $args{tag} if $args{tag};
-                my $attrs = $args{attributes};
-
-                my $meta = $caller->meta;
-                my $node_attr = $meta->get_attribute('node');
-                return () unless $node_attr;
-
-
-                $meta->dom_root( { tag => $tag, attributes => $attrs } );
-
-                # This needs to be done here so that the /applied/ class
-                # can use it instead of this class, which is a role
-                $meta->add_around_method_modifier(new => sub {
-                    my $next = shift;
-                    my $self = $next->(@_);
-                    $self->meta->assert_root_node($self);
-                    return $self;
-                });
-                $meta->add_after_method_modifier(node => sub {
-                    my $self = shift;
-                    if (@_) {
-                        $self->meta->assert_root($self, @_);
-                    }
-                });
-            });
-        },
-        has_dom_content => sub {
-            return Class::MOP::subname($subname->('has_dom_content') => sub ($;%) {
-                my ($name, %args) = @_;
-                my $caller = caller();
-                my $meta = $caller->meta;
-                my $metaclass = 'MooseX::DOM::Meta::LibXML::Attribute::Content';
-                my $attr = Moose::Meta::Attribute->interpolate_class_and_new(
-                    $name,
-                    metaclass => $metaclass,
-                    is        => 'rw',
-                    tag       => $name,
-                    accessor  => $name,
-                    %args,
-                );
-                $meta->add_attribute( $attr );
-            });
-        },
-        has_dom_attr => sub {
-            return Class::MOP::subname($subname->('has_dom_attr') => sub ($;%) {
-                my $caller = caller();
-                my ($name, %args) = @_;
-
-                my $meta = $caller->meta;
-                my $metaclass = 'MooseX::DOM::Meta::LibXML::Attribute::Attribute';
-    
-                my $attr = Moose::Meta::Attribute->interpolate_class_and_new(
-                    $name,
-                    metaclass => $metaclass,
-                    is        => 'rw',
-                    accessor  => $name,
-                    %args,
-                );
-                $meta->add_attribute( $attr );
-            });
-        },
-        has_dom_children => sub {
-            return Class::MOP::subname($subname->('has_dom_children') => sub ($;%) {
-                my ($name, %args) = @_;
-                my $caller = caller();
-                my $meta = $caller->meta;
-                my $metaclass = 'MooseX::DOM::Meta::LibXML::Attribute::Element';
-                my $attr = Moose::Meta::Attribute->interpolate_class_and_new(
-                    $name,
-                    metaclass => $metaclass,
-                    is        => 'rw',
-                    accessor  => $name,
-                    tag       => $name,
-                    create    => $text2elements,
-                    filter    => $textfilter,
-                    %args,
-                );
-                $meta->add_attribute( $attr );
-            });
-        },
-        has_dom_child => sub {
-            return Class::MOP::subname($subname->('has_dom_child') => sub ($;%) {
-                my ($name, %args) = @_;
-                my $caller = caller();
-                my $meta = $caller->meta;
-                my $metaclass = 'MooseX::DOM::Meta::LibXML::Attribute::Element';
-                my $attr = Moose::Meta::Attribute->interpolate_class_and_new(
-                    $name,
-                    metaclass => $metaclass,
-                    is        => 'rw',
-                    accessor  => $name,
-                    tag       => $name,
-                    create    => $text2elements,
-                    filter    => $textfilter,
-                    single    => 1,
-                    %args,
-                );
-                $meta->add_attribute( $attr );
-            });
-        }
-    );
-
-    my $export = Sub::Exporter::build_exporter({
-        exports => \%exports,
-        groups  => { default => [ ':all' ] }
-    });
-    sub export_dsl {
-        goto &$export if $export;
-    }
-
-    sub unexport_dsl {
-        no strict 'refs';
-        my $class = caller();
-
-        # loop through the exports ...
-        foreach my $name ( keys %exports ) {
-
-            # if we find one ...
-            if ( defined &{ $class . '::' . $name } ) {
-                my $keyword = \&{ $class . '::' . $name };
-
-                # make sure it is from Moose
-                my ($pkg_name) = Class::MOP::get_code_info($keyword);
-                next if $pkg_name ne __PACKAGE__;
-
-                # and if it is from Moose then undef the slot
-                delete ${ $class . '::' }{$name};
-            }
-        }
+    foreach my $method (@METHODS) {
+        my $attr = "${method}_method";
+        $meta->add_method($method => $self->$attr);
     }
 }
 
-sub from_xml {
-    my $class = shift;
-    return $class->new(node => XML::LibXML->new->parse_string($_[0])->documentElement);
-}
-sub from_file {
-    my $class = shift;
-    return $class->new(node => XML::LibXML->new->parse_file($_[0])->documentElement);
+sub build_dom_root_attr {
+    Moose::Meta::Attribute->new(
+        dom_root => (
+            is     => 'rw',
+            isa    => 'MooseX::DOM::LibXML::XPathContext',
+            coerce => 1,
+        )
+    )
 }
 
-sub as_xml {
+sub build_parse_file_method {
     my $self = shift;
-    $self->node->toString(1);
+    return Moose::Meta::Method->wrap(
+        package_name => Scalar::Util::blessed $self,
+        name         => 'parse_file',
+        body         => sub {
+            my ($class, $file) = @_;
+            $class->new(dom_root =>  XML::LibXML->new->parse_file($file));
+        }
+    );
 }
 
+sub build_parse_string_method {
+    my $self = shift;
+    return Moose::Meta::Method->wrap(
+        package_name => Scalar::Util::blessed $self,
+        name         => 'parse_string',
+        body         => sub {
+            my ($class, $string) = @_;
+            $class->new(dom_root =>  XML::LibXML->new->parse_string($string));
+        }
+    );
+}
+
+sub build_dom_findvalue_method {
+    my $self = shift;
+    return Moose::Meta::Method->wrap(
+        package_name => Scalar::Util::blessed $self,
+        name         => 'dom_findvalue',
+        body         => sub {
+            my ($self, $args) = @_;
+            if (! ref $args) {
+                $args = { xpath => $args };
+            }
+            $self->dom_root->findvalue($args->{xpath});
+        }
+    );
+}
+
+sub build_dom_findnodes_method {
+    my $self = shift;
+    return Moose::Meta::Method->wrap(
+        package_name => Scalar::Util::blessed $self,
+        name         => 'dom_findnodes',
+        body         => sub {
+            my ($self, $args) = @_;
+            if (! ref $args) {
+                $args = { xpath => $args };
+            }
+            $self->dom_root->findnodes($args->{xpath});
+        }
+    );
+}
 
 1;
-