This module is very useful for walking through a data structure. However, beware of certain quirks. This module does not behave quite the same between Perl versions, especially 5.8 to 5.10. If you work in a mixed environment, you might be surprised by this. Another quirk is that typeglobs are not handled very well, so if you need to walk over those values you might need a different tool for the job.

This module is very handy if you want to embed some spreadsheet functionality into an application. It's quick and easy to implement and easy to use. I can't speak to how well it performs as the task I'm using it for is pretty simple. I'm not sure I understand the need for the little execute statements instead of regular Perl API calls, but they work and get you access to everything. Only being able to fetch the whole document as a hash reference is a little strange, but workable. The documentation is incomplete and needs some TLC, but the code is readable enough that I was able to find the more advanced features I needed with just a little effort. Overall, great module that has some rough edges in the API and needs more documentation.

This is a decent module, but it's not as flexible or featureful as one might hope. However, it does the most important things. I hope to see this continue to expand, but work on improving it seems to be moving slowly.

Also, if you want to use it with uploads to a web page, you'll have to make sure and save the file first because it depends on Archive::Zip needs seekable file handles, which is not really the fault of this module.

Works well, so long as you have seen a presentation on the subject, read docs over at KiokuDB::Tutorial, and read the code to know the rest of how it works. I like it great other than the lack of documentation.

Indispensable if you want to parse dates entered by real people. The handling of relative dates with the ability of a custom context date (in case you need to treat some other day as today) is especially nice. The author is also responsive and helpful.

The big benefit from this module is it's ability to help understand the differences between various RSS versions. Other than, it does very little. The documentation covers the basics with the synopsis being the only valuable piece. The interface isn't much more than iterating through hashrefs, but it works.

All that said, it is still useful for casual RSS parsing or generation.

This is a very simple module, but very helpful. It does gives you the basic components to get you started with faking LWP::UserAgent, HTTP::Request, and HTTP::Response, but this minimum implementation does the majority of the Test::MockObject work you need to do web testing. Without this module, I'd have to do this work over and over again.

XML::Atom is a module that does a good job at the basics and appears to be pretty sound in implementation. However, if you want something extensible to handle more complicated Atom-based APIs, you're going to have some headaches.

Because of a lack of thorough documentation, you'll need to dig around the source once you move past fetching the parameters used by blogging software. If you need to access complex XML extensions to the API (e.g., Google GData), you'll have to dig deeper into XML::Atom::Utils and also try to figure out how you will need to cope with the fact that this library runs on top of either XML::XPath or XML::LibXML, which have slightly different DOM APIs. At which point, I'm not sure XML::Atom provides you any added value anymore.

I wouldn't say it deserves one star, but, as is, I wouldn't give it more than three.

This module looks like it will be cool someday, but the documentation index is a little misleading. As of this version, most of the actual parser/formatter classes are just stubs for future implementation.

Works well to convert POD into wiki-formatted text in the engine of your choice, but it doesn't provide any kind of link handling. If you need to handle links, you'll need to look into customizing this, do some pre-/post-processing of the text, or find another solution.

This module is great. It handles all of the OO support stuff that I used to delegate to a half-dozen modules for building accessors, validating parameters, etc. It takes the pain out of the mundane stuff.

Once you get passed the first layer of just using it to build basic accessors and assign defaults and such, you'll find a large goody bag of other features related to iterating over your the attributes you added, being able to add special attributes to the fields, managing types, using roles to flexibly tag your class' capabilities, etc.

The main downside is that it's a little hard to break into. I've not seen a really great intro to the module and some of the documentation is lacking... perhaps I'll contribute and remove this paragraph later... I'd say, though, don't let the lack of step-by-step instructions scare you off. It's worth the persistence.

The module is badly named. It ought to be in the Net:: namespace. The interface looks like OO, but it is not object-oriented. The names of the named parameters use hyphens instead of underscores, so you have to quote them. It's not even a very good wrapper around the API and I've had trouble getting it to work correctly. The final annoyance is that the documentation, while complete, does not wrap lines in the code blocks making the synopsis and other parts unreadable.

Very nice module for writing out XML. My original review of the module noted some deficiencies in the documentation that seem to be deficiencies in my eyeballs. Namespaces and prefix mapping as well as everything else seems to be well-documented for this stable module, and have been for some time.

This is a very well put together replacement for "grep -r" that works the way you always wished "grep -r" worked straight out of the box. The documentation describes how to tweak the configuration to make it even more what you want. This is becoming indispensable.

A superb module for handling IPC in a straightforward, easy-to-understand, and very easy to use way. However, the documentation is very weak. There's enough documentation just to use it. The docs don't help you at all if you need to know more about how the underlying caches are used, where pitfalls might lie, creating a custom cache, etc.

Archive::Tar is a must have for anyone who needs to automate or improve the management of your tar or gzip-tar files. It is well-documented, works nicely, and has all of the features I need when dealing with archives for most of my projects.

The documentation is off on another blog rather than in the POD, which is not ideal, but okay. The module itself works very well except for lacking wide character support. However, if you need wide character support, the patch in rt.cpan.org/Public/Bug/Display.html?i... works like a champ.

This is a useful module. However, the documentation is all in the synopsis, which is good, but sometimes details are nice. The interface itself provides a lot of extras that I don't need but they're not out of place. One thing is missing, though. It does not (as far as I can tell from the docs) unescape the actual URI elements. It would be nice if it had the ability to do that while it's ripping your form encoded/query strings apart.

Other than ALL THE OPTIONS BEING IN CAPS, the interface is pretty nice and works similar to the way POE::Component::IRC and POE::Component::Server::IRC work, if you're familiar with those. It has built-in SSL (experimental) support, which is also nice.

This would be a great module if it worked well. However, it's just extremely finicky. It doesn't handle even slightly unusual circumstances very well (for example, having non-Perl files or even temp files in the wrong place). I'd really like to see this module get some TLC and become useful.

I rarely give a distribution a full 5 rating across the board, but rarely is a tool so useful and well made as XML::Twig. This module is indispensable for ripping apart XML, particularly when dealing with extremely large XML files.

It makes processing XML a nearly tolerable process (I mean, it's still XML after all). So, whether you need to translate your XML from one format to another, or just iterate over pieces of tags to perform an action, I'd highly recommend this module.

I needed to see the contents of a huge XML file so I could figure out which elements and attributes to rip out to import the data into a database. The xmlpretty script that came with this module let me pipe this file into less and examine it progressively. It was quite helpful.

Excellent all around module for ripping feeds apart and then putting them back together again in whatever format you need. It takes very little work to setup and the examples get you 90% of what you need most of the time.

SVK is to Subversion what Subversion is to CVS, as far as I'm concerned. If you're familiar with Subversion, you can start using SVK with practically no extra knowledge. Once you become familiar with how SVK works, it will be difficult to impossible to go back.

This has worked very well at finding out basic information about several file types. The documentation has a few odd bugs that need to be fixed. Also, returning errors as an "error" key is not the way I prefer to handle errors (exceptions should generally be handled as exceptions, i.e., die/croak), but it is still a pretty nice little module.

If you come into this module looking for something "light" because it has "Lite" in the name, this isn't it. SOAP::Lite is comprehensive and I've found it to be very useful. The documentation is not as well organized as it could be, but check out the examples directory. I'm not a huge fan, but this module works pretty nicely.

I recently used this to build the Java::JCR interface. Excellent module all around. This module made just a few hours this weekend very productive. The only hiccups I experienced were resolved by learning more about the module rather than tearing my hair out and working around problems I found. It's very nice indeed.

I'd say this is a good start, but it's a little rough around the edges. The module is way too verbose when the page has validity errors. It prints them all out with every test. It also reports some erroneous validity errors, but that might not be this module's fault, but of HTML::Parser and the libraries it depends upon. (I.e., in this specific case, it seems to interpret the "name" attribute of form elements as having the same meaning as the "id" attribute, which doesn't appear as part of the HTML standard according to my reading.)

However, as for the module itself, the tests provided are really a good start, but it would be nice to see a few more. The no_tag() test should be able to make sure that no tag exists with certain attributes rather than just no_tag() named X exists. There's also no way to verify the textual contents of a specific tag, that I can find. Finally, the documentation for the module is sparse. The only way to figure out what the module is supposed to do is by reading the SYNOPSIS and then the source. There should be more.

Other than the installation, it's a pretty decent little add-on to Brian D Foy's release. As for the installation, need to add the "create_makefile_pl => 'passthrough'" to the Module::Build to keep the CPAN script happy.

This is a softening of my previous review as my first one was rather more scathing than deserved. After some experimentation, This module is a good idea, but needs some work. The documentation is incomplete. If you want to use this module you have to read the test cases to figure out what to do---test cases are not good docs, IMO. The module provides a lot of functionality that is all contained within the two packages of this distribution. There's quite a bit there if all you need is inheritance. The logger is underutilized so it's hard to pick out bugs and I had to read the module source itself to get even a vague idea of the semantics (how are IDs set? are saves atomic across the inherited tables? what's fetched when a fetch is made on a parent? etc.) The idea itself is very cool and it does work. You'll just have to dig for awhile to understand it enough to use it.

I like it. Some of the documentation is out of date or misleading and I think this tool is *really* hard to get into, compared to Class::DBI or Alzabo. However, I think it's overall the most flexible and powerful of that trio. The extensibility of the system is it's strongest point. With just a bit of code you can add whole new classes of generic functionality--a nifty feature, SPOPx::Ginsu, for example. It's documentation is it's weakest point, I had to read the code a few times to understand what was going on and found a couple sticky spots where it contradicts itself (particularly about "object rules").

I have to agree with the previous reviewer, ti, this module attempts to do something nice, but I think the execution is a little precarious. I have tried to use this module on several occassions and been bit by the deadlocking bug with MySQL each time and remembered why I then went and wrote my own session code. It's a reasonably good module, but there should be more clarity in the documentation of the possible pitfalls and more work needs to be done to ensure safety.