Handel Framework

    sub delete {
        my ($self, $filter) = @_;
    
        # turn the hash filter into an xpath attribute query
        my $attributes = $self->filter_to_xpath($filter);
    
        # find all cart nodes matching the query
        my @nodes = $self->document_root->findnodes($self->child_node . $attributes);
    
        foreach my $node (@nodes) {
            $node->unbindNode;
        };
        $self->save_file;
    };

Item Actions

Now that we can create, search and delete carts, we need to do the same thing for cart items. Now would be a good time to review Handel::Manual::Storage/Items_As_Second_Class_Objects. Since carts and their items reside in the same file, we shall consider items and the Item class used later as second class objects. They will hold configuration information about items, but will do none of the work and the same storage instance will take care of reading/writing cart and cart items.

Adding Items

To create a new item record, we simply need to make sure on item doesn't already exist with the supplied id, then create a new node, populate it and insert it into the cart nodes child node collection.

    sub add_item {
        my ($self, $result, $data) = @_;
        my $item_storage = $self->item_storage;
        
        # get the cart node
        my $cart = $result->storage_result;
        
        # convert the data into a primary key filter
        my %filter = map {$_ => $data->{$_}} $item_storage->primary_columns;
        my $attributes = $self->filter_to_xpath(\%filter);
    
        # see if there is already an item in this cart matching the id
        if ($cart->find($item_storage->child_node . $attributes)) {
            throw Handel::Exception::Storage( -text => 'Cart item already exists with that id');
        # create a new item node and insert it into the cart node
        } else {
            my $item = $self->document->createElement($item_storage->child_node);
            map {$item->setAttribute($_ => $data->{$_})} keys %{$data};
    
            $cart->appendChild($item);
            $self->save_file;
    
            return $item_storage->result_class->create_instance($item, $self);
        };
    };

Searching Items

Now that we can add cart items, we need to be able to fetch them later.

    sub search_items {
        my ($self, $result, $filter) = @_;
        my $item_storage = $self->item_storage;
        
        # get the cart node
        my $cart = $result->storage_result;
        
        # convert the filter to a xpath statement
        my $attributes = $self->filter_to_xpath($filter);
        
        # get items in this cart matching the xpath
        my @nodes = $self->document_root->findnodes($item_storage->child_node . $attributes, $cart);
    
        my $iterator = $self->iterator_class->new({
            data         => \@nodes,
            result_class => $item_storage->result_class,
            storage      => $self
        });
    
        return wantarray ? $iterator->all : $iterator;
    };

Just like the cart search, we just need to create an XPath query from the supplied filter, and return any found nodes wrapped in storage results.

Counting Items

To make Cart::count happy, we also need a way to count the number of items in a cart. Again, we could just use search_items and count the number of results, but this is more efficient.

    sub count_items {
        my ($self, $result) = @_;
        my $item_storage = $self->item_storage;
        my $cart = $result->storage_result;
    
        # find all ./item nodes in the current cart
        return $cart->find($item_storage->child_node)->size;
    };

Deleting Items

Last on the list again, we need to be able to delete items. This should look pretty familiar by now.

    sub delete_items {
        my ($self, $result, $filter) = @_;
        my $item_storage = $self->item_storage;
        
        # get the cart node
        my $cart = $result->storage_result;
        
        # make an xpath wquery from the filter if we have one
        my $attributes = $self->filter_to_xpath($filter);
        my @nodes = $self->document_root->findnodes($item_storage->child_node . $attributes, $cart);
    
        foreach my $node (@nodes) {
            $node->unbindNode;
        };
        $self->save_file;
    };

Transaction Support

Each custom storage class should strive to support transactions if possible. If it is not possible, you need to override the base classes methods to keep them from throwing 'not implemented' exceptions.

    sub txn_begin {};
    sub txn_rollback {};
    sub txn_commit {};
    sub discard_changes {};

Storage Results

Mapping Methods to XML Attributes

Now that we have created the basic XML storage class, we need to create a results class that knows how to update individual xml nodes. The default Storage::Result class simply passes methods to the underlying storage result:

    $result->id;
    
    # the same as:
    $result->storage_result->id;

Since XML::Node objects only expose attributes using set/getAttribute, we need to write a custom AUTOLOAD method to redirect method calls.

    package Handel::Storage::XML::Result;
    use strict;
    use warnings;
    
    BEGIN {
        use base qw/Handel::Storage::Result/;
    };
    
    sub AUTOLOAD {
        my $self = shift;
    
        # leave DESTROY alone
        return if (our $AUTOLOAD) =~ /::DESTROY$/;
    
        $AUTOLOAD =~ s/^.*:://;
    
        return unless $self->storage->has_column($AUTOLOAD);
    
        # if we are setting, call setAttribute
        if (scalar @_) {
            $self->storage_result->setAttribute($AUTOLOAD, shift);
        };
    
        # return from getAttribute
        $self->storage_result->getAttribute($AUTOLOAD);
    };
    
    1;

This is the easiest way to make results and the underlying storage results talk to each other. Using this method, you can use the same result class for carts, order and cart/order items even if their fields differ.

If have a particular hatred for AUTOLOAD, you could just as well create two result classes: Handel::Storage::XML::Cart::Result and Handel::Storage::XML::Cart::Item::Result and assign them to the corresponding storage classes:

    package Handel::Storage::XML::Cart;
    use strict;
    use warnings;
    use base qw/Handel::Storage::XML/;
    __PACKAGE__->result_class('Handel::Storage::XML::Cart::Result');
    1;
    
    package Handel::Storage::XML::Cart::Item;
    use strict;
    use warnings;
    use base qw/Handel::Storage::XML/;
    __PACKAGE__->result_class('Handel::Storage::XML::Cart::Item::Result');
    1;

In each result class, you could map actual attributes to real methods instead of using autoload:

    package Handel::Storage::XML::Cart::Result;
    use strict
    use warnings;
    use base qw/Handel::Storage::Result/;
    
    sub id {
        my ($self, $value) = @_;
        
        if ($value) {
            $self->storage_result->setAttribute('id', $value);
        };
    
        return $self->storage_result->getAttribute('id');
    };

Updating Results

When autoupdates are off, one has to call update manually to save the changes made to cart and item nodes. When autoupdates are enabled, update will be called automatically on each result. To support updates we need to create an update method on the custom result class:

    sub update {
        my ($self, $data) = @_;
    
        if ($data) {
            foreach my $key (keys %{$data}) {
                $self->storage_result->setAttribute($key, $data->{$key});
            };
        };
    
        $self->storage->save_file;
    };

When update is called, the xml file is saved. If a hashref of data is supplied, it will set the appropriate attributes and then save the changes to the xml file.

Deleting Results

Each result needs to be able to remove itself from storage. To do so, we simply need to add a delete method to the result that removes itself and updates the file:

    sub delete {
        my $self = shift;
    
        $self->storage_result->unbindNode;
        $self->update;
    };

Using Your New Storage Class

Now that we have a shiny new XML storage class, we need to use it. There are two ways we can go about using our new storage class. The easiest way would be to load and configure them directly in the Cart and Item interface classes:

    package My::Cart;
    use strict;
    use warnings;
    use base qw/Handel::Cart/;
    __PACKAGE__->item_class('My::Cart::Item');
    __PACKAGE__->storage_class('Handel::Storage::XML');
    __PACKAGE__->storage({
        add_columns     => [qw/id shopper name description type/],
        primary_columns => [qw/id/],
        file_name       => 'carts.xml',
        parent_node     => 'carts',
        child_node      => 'cart',
    });
    
    1;

While this way works, it has one problem. If you decide to change storage classes later, it may not take the same options that this storage class does.

Create Cart and Item Storage Classes

In order to make changing storage classes less painful, it is recommended that you make subclasses of your custom storage class to set storage options, and then use those subclasses within your Cart and Item interface classes:

    package My::Storage::Cart;
    use strict;
    use warnings;
    use base qw/Handel::Storage::XML/;
    
    __PACKAGE__->item_storage_class('My::Storage::Cart::Item');
    
    __PACKAGE__->setup({
        file_name       => 'carts.xml',
        parent_node     => 'carts',
        child_node      => 'cart',
        add_columns     => [qw/id shopper name description type/],
        primary_columns => [qw/id/],
    });
    
    1;
    
    package My::Storage::Cart::Item;
    use strict;
    use warnings;
    use base qw/Handel::Storage::XML/;
    
    __PACKAGE__->setup({
        parent_node     => 'items',
        child_node      => 'item',
        add_columns     => [qw/id sku quantity price description/],
        primary_columns => [qw/id/]
    });
    
    1;

Create Cart and Item Classes

Now that we have custom storage subclasses for Carts and Items, we just need to tell our cart and item classes to use them:

    package My::Cart;
    use strict;
    use warnings;
    use base qw/Handel::Cart/;
    
    __PACKAGE__->item_class('My::Cart::Item');
    __PACKAGE__->storage_class('My::Storage::Cart');
    
    1;
    
    package My::Cart::Item;
    use strict;
    use warnings;
    use base qw/Handel::Cart::Item/;
    
    __PACKAGE__->storage_class('My::Storage::Cart::Item');
    
    1;

Now that we have some separation between the Cart/Items classes and the storage classes, changing storage classes in the future just means changing My::Storage::Cart and My::Storage::Cart::Item.

All Hands on Deck

That's all there is to it. Using the same techniques above, you should be able to write a custom storage class for just about anything; LDAP, INI files, SOAP/XMLRPC, etc.

Caveats

The example above is by no means complete. It makes no effort to deal with constraints, default values or data validation. It also does not make any attempt to support transactions in any meaningful way nor does it deal with concurrency issues with xml file reading and writing.

Given more time, I may work on making this example into a supported Storage::XML class.

Posted by: Christopher H. Laco on Sep 10, 2006 6:27 PM | Permalink

Handel 0.99_11 Released

Look out Ned, it's coming right for us!

• Fix examples code in AddingColumns.pod
• Fixed pod references after DBIC Storage rearrangement
• Added item_storage_class/item_storage to Storage so item related methods could get item storage config from item storage without being tied to top level item class
• Moved item_class/cart_class back into Handel::Base. They don't belong in storage
• Moved checkout_class back into Handel::Order. That doesn't belong in storage either
• Added WritingCustomStorage to Cookbook
• Added has_column to Storage

Posted by: Christopher H. Laco on Sep 10, 2006 2:43 PM | Permalink

Cookbook: Adding Columns in 1.0

Tags: articles (2) : columns (1) : cookbook (2) : customizing (2)

Introduction

I've updated this to reflect changes made in 0.99_11, which should be available on CPAN shortly.

As 1.0 draws near, it was about time I started on the ever popular Cookbook/Tutorial stuffs. I decided to tackle something everyone asks: how to add columns.

The methods below outline the steps necessary to add columns to the default install of Handel 1.x. The steps below generally apply to customizing most storage options, including removing columns, adding constraints, etc.

This article is broken down into three solutions: Good, Better, and Best.

Good

If you need a quick fix in a script or want to alter all instances of Handel objects within the same process, you can simple add a column to the desired classes storage using Handel::Storage::add_columns.

    #!/usr/bin/perl -w
    use strict;
    use warnings;
    use Handel::Cart;
    
    Handel::Cart->storage->add_columns('custom');
    Handel::Cart->create_accessors;
    
    my $carts = Handel::Cart->search;
    print $carts->count;
    
    while (my $cart = $carts->next) {
        print $cart->custom, "\n";
    };

Better

The example above gets the job done with a minimal amount of code. But if you're on shared server with other people using Handel, you're going to get a nasty phone call when every one discovers their stuff has an extra field in it.

The better, more polite approach is to make your own custom classes and use [ab]use them instead.

    package My::Cart;
    use strict;
    use warnings;
    use base qw/Handel::Cart/;
    
    __PACKAGE__->item_class('My::Cart::Item');    
    __PACKAGE__->storage->add_columns('custom');
    __PACKAGE__->create_accessors;
    
    1;

You don't have to subclass both the cart and items classes, but for the sake of good practice, there's no reason not to if you've gone this far.

    package My::Cart::Item;
    use strict;
    use warnings;
    use base qw/Handel::Cart::Item/;
    
    1;

Then in your script, use you're cart instead.

    #!/usr/bin/perl -w
    use strict;
    use warnings;
    use My::Cart;
    
    my $carts = My::Cart->search;
    print $carts->count;
    
    while (my $cart = $carts->next) {
        print $cart->custom, "\n";
    };

Best

The two approaches above have one potential issue: they assume that the current classes will always use the default storage. If you add columns using only the column name, that won't be an issue. If you add columns using the DBIx::Class C<\%column_info> syntax, you will have a problem if the new storage class doesn't understand the syntax.

    package My::Cart;
    use strict;
    use warnings;
    
    use base qw/Handel::Cart/;
    __PACKAGE__->storage_class('Future::Storage::XML');
    
    # this line goes boom!
    # don't know how to add column 'HASH(0x2254b8)'
    __PACKAGE__->storage->add_columns('foo' => {
        data_type   => 'varchar',
        size        => 50,
        is_nullable => 1
    });
    
    1;

This is a potential problem when setting any storage class option from within the interface classes that uses it. To help abstract the storage specifics away from the interface classes that use them, you should go the extra mile and declare custom storage classes. I did mention that it's a 'framework' right? :-)

Create Cart and Item Storage Classes

First we need to create custom storage classes for the Cart and Item interface classes.

    package My::Storage::Cart;
    use strict;
    use warnings;
    use base qw/Handel::Storage::DBIC::Cart/;
    
    __PACKAGE__->item_storage_class('My::Storage::Cart::Item');
    
    __PACKAGE__->add_columns('foo' => {
        data_type   => 'varchar',
        size        => 50,
        is_nullable => 1
    });
    
    1;
	
    package My::Storage::Cart::Item;
    use strict;
    use warnings;
    use base qw/Handel::Storage::DBIC::Cart::Item/;
    
    1;

Create Cart and Item Classes

    package My::Cart;
    use strict;
    use warnings;
    use base qw/Handel::Cart/;
    
    __PACKAGE__->item_class('My::Cart::Item');
    
    # No storage changes in here
    # The storage class takes care of adding the column
    __PACKAGE__->storage_class('My::Storage::Cart');
    __PACKAGE__->create_accessors;
    
    1;
	
    package My::Cart::Item;
    use strict;
    use warnings;
    use base qw/Handel::Cart::Item/;
    
    __PACKAGE__->storage_class('My::Storage::Cart::Item');
    __PACKAGE__->create_accessors;
    
    1;

Code Away Merrill

    #!/usr/bin/perl -w
    use strict;
    use warnings;
    use My::Cart;    
    
    my $carts = My::Cart->search;
    print $carts->count;
    
    while (my $cart = $carts->next) {
        print $cart->custom, "\n";
    };

Now that we've pushed the add column magic down into the storage class, My::Cart is blissfully unaware of any changes that storage class needs to make in order to add a column:

    package My::Storage::Cart;
    use strict;
    use warnings;
    use base qw/Handel::Storage::DBIC::Cart/;
    
    __PACKAGE__->item_storage_class('My::Storage::Cart::Item');
    __PACKAGE__->add_columns([qw/foo varchar 50 nullable/]);
    
    1;

Conclusion

That's all there is to it! Like most of Handel, you can pick your level of magic based on your needs.

Posted by: Christopher H. Laco on Sep 06, 2006 10:05 PM | Permalink

Handel 0.99_10 Released

Tags: changes (26) : development release (16)

The coding monkeys are on crack, and they can't be stopped!

• Added start of Cookbook and Cookbook/AddColumns
• Moved DBIC specific Storage classes into DBIC namespace
• Changed process to get items->all instead of (items)

Posted by: Christopher H. Laco on Sep 06, 2006 9:09 PM | Permalink

Handel 0.99_09 Released

Tags: changes (26) : development release (16)

Fresh out of the monkey pit.

• Catalyst Helpers now require FormValidator::Simple 0.17 (Woohoo!)
• Validation component now requires DBIx::Class::Validation 0.01001 which uses new FV::S for profile/instance/messages fixes
• Filled in pod generated by Catalyst Helpers in a moment of weakness

Posted by: Christopher H. Laco on Sep 05, 2006 9:53 PM | Permalink

Handel 0.99_08 Released

Tags: changes (26) : development release (16)

Another quick release before I lose my energy today and forget what I was thinking about this morning.

• Added txn_begin/commit/rollback to Storage and Storage::DBIC to help abstract Checkout::process from Storage.
• Added Storage::DBIC::Result to get DBIC specific things out of Storage::Result
• Minor pod fixes

Posted by: Christopher H. Laco on Sep 04, 2006 5:13 PM | Permalink

Handel 0.99_07 Released

Tags: catalyst (5) : changes (26) : development release (16) : helpers (1) : scaffold (2)

I can see light at the end of the tunnel. It could always be the train though. The Catalyst helpers have been reworked. They still need some tweaking, but what doesn't. Maybe I'll feel generous and fill in the auto generated pod. :-)

WARNING: The auto generated Catalyst helper code requires FormValidator::Simple changes/fixes that have yet to be commited or accepted until the author responds. Contact me if you need a copy of the modified version. Keep your fingers crossed that I don't have to do a hostile takeover of the module just to fix a few bugs.

• Moved perl_critic.t to style_perl_critic.t
• Added style_no_tabs.t
• Style tests now enabled via TEST_PRIVATE
• Reworked Catalyst Helpers for Controllers and their tests.
• Fixed issue where add_handler wasn't assigning unique pref ids when non were specified in the plugins themselves.
• Moved requirements to Requirements.pod
• Cart destroy now works on a blessed object under Catalyst
• AssignOrderNumber checkout plugin no longer sets the updated field. This will be rolled into the Order class in the next release.

Posted by: Christopher H. Laco on Sep 03, 2006 9:12 PM | Permalink

Handel 0.99_06 Released

Tags: changes (26) : development release (16)

Close, but no Bob Seger. We're getting close. I'm done futzing with storage I think, and the Catalyst Models/Model Helpers have been reworked. All tests pass (except for perl_critic.t). Tomorrow I start on the rest of the Cat code.

• Simplified Storage->setup and removed clear/reset nonsense
• Added Spanish lexion provided by Diego Kuperman
• Abstracted Iterator and added subclasses for lists, DBIC resultsets and storage results
• Added result_iterator_class to Base using default of Handel::Iterator::Results
• Storage now leaves DBIC result_class alone and returns Handel::Iterator::DBIC iterators for search/search_items
• Cart/Order now use Handel::Iterator::Results iterator
• Split DBIC specific storage into Storage::DBIC w/ massive tests
• Started moving news tests to Handel::Test w/ better db deploy/var directory
• Split Manual Storage into Storage/Storage::DBIC
• Added param checks to many Storage methods
• Replaced old Makefile warnings w/ mention of Test::More and DateTime compares
• Added Perl::Critic tests for my personal gratification. None pass yet. :-)
• currency_columns gets/sets list instead of arrayrefs to better match generic columns/primary_columns
• Bumped DBIC requirement to 0.08 (use -current for now)
• Reworked Catalyst Helpers for Models (Controllers are still broken)

Posted by: Christopher H. Laco on Aug 25, 2006 9:52 PM | Permalink

A Personal Note About Handel/Mango

Tags: mango (3)

I may moderate this off topic, but I felt it important that my statements below be made public for the sake of posterity given recent events.

<begin long brain spew>

As anyone who has read the pod or Changes file knows, I started working on Handel at the end of 2004. Handel started as a hobby project, born out of the need to convert an ASP site to LAMP and out of frustration have having to write Yet Another Damn Shopping Cart without many modules to support it [on CPAN]. In the year and a half since then, Handel 0.33 has become pretty stable with the help of a lot of tests, some kind patch submitters and TDD goodness; and we're on the cusp of 1.0, which I hope will prove to be the best release yet.

But I digress. You knew that already. The purpose of this email is to hopefully clarify my intentions with Handel and Mango as well as ward off any future problems that may arise due to my [maybe not so] unique personality traits. :-)

As I suspect most true 'geeks coders' are, I take my projects to a personal level. They're not just bits of code to put me on the fast path to CPANTS fame but instead, are obsessions. If I can't figure something out, something is broken or tests don't pass, I can't sleep; literally. I've had dreams about code I'm working one. (*cough*loser*cough*).

I liken Handel to an earwig of that tune you can get out of your head (Ring,Ring,Ring,Ring,Ring,Ring,Ring: Banana Phone!). The only way to get rid of it is to sing the tune over and over until your brain loses interest. The same is true for this project for me. I'm pushing to get everything in my head out into 1.0 so I can set it free and move on. If that makes me a control freak, then so be it. You caught me.

Since Handel is a 'personal obsession' for me, I've purposefully kept it a one man show where I can make all of the decisions and ultimately, all of the mistakes as well. I do appreciate the interest in Handel so far, as well as the patches submitted by various guilty parties. So, if you feel like I have ignored you, or spurned your offers of patches for rewrites and such, my apologies. It's not personal. It's just men battling my control-freak-obsession demons. But have no fear. Once I finish my 1.0 obsession, I fully intended to start handing out commit bits on the repo and finding a victim or two to start taking on special godlike powers. I do acknowledge that is what is needed for Handel to grow and succeed and live on.

With the recent approval of the Mango grant by The Perl Foundation, I now find myself on the cusp of another 'personal obsession'. I've made my promises for a price bed, and now have to lay in it and frankly, it scares me. Mango is a project born out of my desire to help bring Catalyst/Handel/Perl to the forefront of this Web 2.0 RoR age we live in rather than playing the bystander role. I think Catalyst is better, and I want to prove it.

So, as I work to put one personal obsession to rest, and embark on new one, I will undoubtedly piss someone off, make someone feel like their help, opinions, patches or help aren't wanted or welcome. You've been warned. It isn't personal, usually not intentional, and it's definitely not permanent.

Game on.

-=Chris

Posted by: Christopher H. Laco on Aug 22, 2006 3:59 PM | Permalink

TPF Grant Proposal Approved: Mango

Tags: catalyst (5) : mango (3)

Much to my surprise, The Perl Foundation has approved the grant proposal for Mango. For those who hadn't heard about Mango yet, it is going to be an "ecommerce solution" built using Catalyst+Handel. The main goal of Mango is to be one of those 'Web 2.0' buzzword applications [but better] to help promote Catalyst outside of the circle of us who already know its virtues.

Please feel free to add any comments, thoughts, concerns, requirements etc to the Mango wiki space.

Right now, I'm still pushing hard to get Handel 1.0 done so I can dole out maint bits and concentrate on Mango. I'm also a bit in shock about the grant. I'm a little bit hyped, a whole lot scared, and quite a bit rock and roll. Here's hoping that I can live up to the promises I've made and not make us all look bad in the process. :-)

-=Chris

Posted by: Christopher H. Laco on Aug 22, 2006 9:35 AM | Permalink

Handel 0.99_05 Released

Tags: changes (26) : development release (16)

It's that time of the month again. Another round of bits and bytes has escaping from the coding monkeys. These new bits and bytes formed:

• Changed create_result in Base to create_instance
• Added create/search/uuid_maker/copyable_item_columns to Storage
• Storage->clone now clones even with an active schema instance
• Schema configuration in Storage now uses a clone of the item_classes storage instead of the original, and redirects result->storage
• Cart/Order/Items now use storage create/search
• Cart/Order add() now use copyable_item_columns when passed objects
• Cart/Order add() now look for source columns and methods to fill destination column values
• Various pod fixes
• Added more tests for create_instance/clone changes
• Cart/Order/Item new/load/destroy now take \%options, specifically $options{storage}
• Order->new $process argument moved into \%options
• Order->copy_cart_items now just uses add
• Added checkout_class to Storage
• Storage now uses exception_action rather than dbh->{HandleError}
• Storage process_error now creates a Storage Exception for unknown errors
• Moved storage settings in Cart/Order Item into Storage::Cart/Order::Item
• Applied Catalyst Helper test patch from Todd W.
• Added Storage::Result, which is now returned by storage actions
• Handel::Currency convert now returns a new currency object
• Cart/Order/Item now use generic result objects
• Cart/Order clear now returns result of action like delete does
• Renamed Cart/Order/Item new() to create()
• Renamed Cart/Order/Item load() to search()
• Added load/new/items to Compat.t w/subclass tests

At this point, I think I'm close to being done rearranging the API and there's even a good bit of compat tests for those -4 people using the old API in subclasses. Now that the big stuff is out of the way, it's time to get busy reworking the Catalyst helpers and I still need to fix the demo code and get some good Cookbook stuff in place.

Posted by: Christopher H. Laco on Aug 09, 2006 9:13 PM | Permalink

CatInABox Update

Tags: catalyst (5)

With a little prompting on #catalyst, I've updated CatInABox to use Catalyst 5.7001. I've also updated a few of the plugins including View::TT, Template-Toolkit and Authentication. As always, you can download a copy from the downloads directory.

For the brave Win32 users out there, I've also posted the CatInABox directory I use on my USB thumb drive that includes just about everything plus the kitchen sink compiled for Perl 5.8.x on win32.

Happy coding.

Posted by: Christopher H. Laco on Aug 07, 2006 8:20 PM | Permalink

Handel 0.99_04 Released

Tags: changes (26) : development release (16)

Just because I can't seem to stop, here's another development release which includes the following changes:

• Schema configuration now finally uses load_components without the Class::C3 recalc slowdown
• Validation component now uses throw_exception/next::method now that load_components is used
• Major pod cleanup
• Excised all forms of RETURN_AS
• TEST_SPELLING is now TEST_POD, which all pod tests now use
• Order created/updated fields now return DateTime objects using DBIx::Class::InflateColumn::DateTime
• Excised remaining UNIVERSAL::isa mistakes. Blessed is your friend
• Order created/updated fields now default to DateTime->now

Posted by: Christopher H. Laco on Jul 15, 2006 5:55 PM | Permalink

Handel 0.99_03 Released

Tags: changes (26) : development release (16)

Once again, the well trained monkey servants have put forth a new development version of Handel. Their master coding includes:

• Fixed AxKit Exception Error (RT#19707,TKP)
• Added start of Handel::Manual
• uuid is now new_uuid, and now in Storage
• Removed setup_columns_accessors in favor or create_accessors in Base
• Cart/Order/Item classes now have a instance of storage instead of subclassing it
• Added Handel::Base as super class for Cart/Order/Item classes
• Added Handel::Storage tests
• Handel::Storage now does all schema configurate during first schema_instance call
• Added Handel::Storage::new/setup
• Cart/Order/Item classes now delegate direct schema access to Storage
• Added validation/constraint/default_value_class to Storage
• Converted Storage from Class::Data::Accessor to Class::Accesssor::Grouped
• Refactored injection of components into schema source classes
• schema_instance now creates a clone using compose_namespace and does its component injection into the clone instead
• Added currency_class/currency_columns to Storage
• Added value() to Handel::Currency
• Added autoupdate to results that inherits from storage->autoupdate
• Added basic compatibility layer for older subclasses

If you are one of the brave souls that is using 0.99_01/02, I apologize now. There has been a major rewrite of the storage layer, and you will have to change code. But hey, that's why they call it a development release right? :-)

Posted by: Christopher H. Laco on Jul 10, 2006 9:23 PM | Permalink

Handel 0.99_02 Released

Tags: changes (26) : development release (16)

Fresh from the assembly line, I present Handel 0.99_02:

• Fixed test counts in t/order_new.t (RT#19700,TKP)
• Moved _error_handler in Storage to process_error and set dbh->{HandelError} using $self->can
• Use blessed when setting schema_instance in Storage
• Abstracted schema setup when setting Storage->schema_instance($schema)

Posted by: Christopher H. Laco on Jun 05, 2006 10:12 PM | Permalink

Handel 0.99_01 Released

Tags: changes (26) : development release (16)

After what seems like an eternity, the first dev version of the upcoming Handel 1.0 is now available. It should be available on CPAN shortly, or you can get the latest version from SVN here.

Changes in the release include:

• RETURN_AS has been removed from the API
• Data filters now take SQL::Abstract syntax for wildcards
• Converted from Class::DBI to DBIx::Class schemas
• Handel::ConfigReader is now a singleton via instance()
• Handel::DBI is deprecated in favor if Handel::Storage
• Moved column defaults into Handel::Components::DefaultValues
• Added constraint_cart_name

Note: Handel 1.0 is not API compatible with Handel 0.32 and older. One of the major goals of 1.0 was to correct some bad API decisions I shouldn't have made to begin with. I've tried to keep the incompatible changes down to a minimum. The main change is that new/load/item now always returns an interator in scalar context, and a list in list context. New/load/items no longer returns a cart/item object if there is only one result. That was bad magic that I shouldn't have ever done.

Posted by: Christopher H. Laco on Jun 04, 2006 3:16 PM | Permalink

Handel IRC Channel

Tags: irc (1)

For those of you who need help, or just want to abuse me [claco] on IRC, feel free to join the #handel channel on irc.perl.org. Beware or purl. She's a saucy little infobot. :-)

Posted by: Christopher H. Laco on Apr 12, 2006 9:10 PM | Permalink

Subversion Repository Relocated

Due to some issues that forced me to move the site from mod_perl to mod_fastcgi, the Subversion repository is no longer available at /svn. The repository is now located at http://svn.handelframework.com/CPAN/Handel/.

Nevermind. The subversion repository is right where it's always been. Pay no attention to the man behind the curtain.

Scratch that. Reverse it. I had to remove the repository again. While it appeared to work properly, it didn't really work completely.

Posted by: Christopher H. Laco on Mar 23, 2006 10:21 PM | Permalink

Catalyst Powered Site

Tags: catalyst (5)

Rather than updating Handel or working on a Catalyst/Handel powered ecommerce solution, I decided to spend some time and make the site a little easier to work with. Up until this week, it's been a mish mosh of MovableType templates, Apache handlers, MediaWiki, static pages, and the Catalyst powered demo. I've now 'fixed the glitch'.

The site now shares the same templates and rendering tech (Template Toolkit) running on top of Catalyst. Browing the source now uses a Catalyst SVN model. The wiki is now Catalyst powered using Textile, with no logins required.

Posted by: Christopher H. Laco on Mar 19, 2006 8:30 PM | Permalink

Handel 0.32 Released

Tags: changes (26) : release (11)

Just because I can...

• Added order_reconcile.t tests
• Order::reconcile now uses copy_cart/copy_cart_items

Posted by: Christopher H. Laco on Jan 23, 2006 8:19 AM | Permalink

Handel 0.31 Released

Tags: changes (26) : release (11)

Live from the monkey pit, Handel version 0.31 had been scrape from the
programming mouldes and set free against the world. Changes in 0.31 include:

• Fixed order creation from cart uuid to use cart_class
• Fixed order reconcile to use cart_class
• Added ccissuenumber, ccstartdate and ccenddate temp fieds to orders
• Use version to property compare CDBI versions (3.0.1 doesn't use version)
• Added clear_messages to Handel::Checkout
• Checkout plugin handlers are now run in the order of their declared preference number
• Fixed Carts item_class to return a default
• Fixed Carts items(), delete(), destroy() and restore() to use item_class
• Fixed Orders item_class to return a default
• Fixed Orders items(), delete() to use item_class
• PRAGMA synchronous = OFF and temp_store = MEMORY for SQLite tests to reduce disk trashing during testing
• Handel::Exception::Taglib subclasses Apache::AxKit::Exception if available to play nice with AxKits exception handling
• Added destroy() to Handel::Order
• Added subclassing tests to current cart/order/checkout tests
• Checkout::process now clears the stash before the call to plugin init, so plugins can set stash data
• Added Handel::Checkout::Stash to checkout process
• Added Checkout->stash_class to allow the use of a custom stash class in Checkout subclasses
• Checkout::new how takes the stash option, which should contain a instance of a Handel::Checkout::Stash subclass
• Added t/checkout_stash,t tests
• Class setter methods (order_class, item_class, stash_class, cart_class) now try to require the specified class

Happy coding.

Posted by: Christopher H. Laco on Jan 18, 2006 9:21 PM | Permalink

Handel 0.30 Released

Tags: changes (26) : release (11)

Back by popular demand, I present to thee Handel 0.30. It includes the following coding mistakes:

0.30 Fri Dec 23 22:52:23 2005

• Constraint constraint_price now accepts 0 as a valid value
• Added order_class to Handel::Checkout to allow Checkout->order to create subclassed versions of Order objects
• Added cart_class to Handel::Order to allow Order->new to create subclassed versions of Cart objects
• Added copy_cart/copy_cart_items in Handel::Order so subclasses can customize order creation from custom carts
• When copying cart items into a new order, only columns in Handel::Cart::Item instead of all columns found

Posted by: Christopher H. Laco on Dec 28, 2005 6:00 PM | Permalink

Handel 0.29 Released

Direct from the monkey pit, Handel 0.29 is out with the following changes:

0.29 Thu Dec 8 20:12:38 2005

• Constraint constraint_checkout_phase now checks CHECKOUT_ALL_PHASES
• Added add_phase to Handel::Checkout to add custom phases
• Removed APR::UUID usage under OpenBSD
• Disabled Apache-Tests tests by default and added TEST_HTTP to enable them
• Added pod to Handel::Order about temporary fields

0.28 Fri Nov 25 15:09:25 2005

• Added pod_spelling.t tests which don't run by default
• Corrected a boatload of spelling errors :-)
• Catalyst Helpers now require Catalyst 5.56 to deal with short vs. long M/V/C modules names.

Posted by: Christopher H. Laco on Dec 08, 2005 8:49 PM | Permalink

DBIx::Class Powered Handel

Tags: dbic (1)

After some tinkering and constantly bothering #dbix-class with questions, there is a development version of Handel running on DBIx::Class.

0.28_01 Sun Nov 27 15:13:25 2005

• Converted from Class::DBI to DBIx::Class
• constraint_price now accepts 0 as a valid value
• price fields are now set to 0 by default
• shopper constraint is now working can't be empty during new

Beware! There be dragons!

Even though DBIx::Class 0.04 is the prereq, please use the latest from the DBIC trunk. This fixes problems with inflated columns not being updated during Checkout::process().

There is currently a 'feature' when updating item columns that causes changes to be lost. For now, please always retrieve items using array context and not the iterator in scalar context for now.

You can download the dist here:
http://handelframework.com/downloads/Handel-0.28_01.tar.gz

You can also get the latest from the DBIC branch here:
http://handelframework.com/svn/CPAN/Handel/branches/DBIC/

-=Chris

Posted by: Christopher H. Laco on Nov 27, 2005 2:33 PM | Permalink

Handel Article on Perl.com

Tags: articles (2)

There's a new article this week on Perl.com entitled Building E-Commerce Sites with Handel. It's a basic introduction to Handel and how to use Handel and Catalyst to quick start your ecommerce site. Check it out!

Posted by: Christopher H. Laco on Nov 18, 2005 9:54 AM | Permalink

Handel 0.27 Released

Tags: changes (26) : release (11)

Fresh from the coding monkey pit, Handel 0.27 is out.

• Tested with Class::DBI 3.0.12
• Require Apache-Test 1.27
• Added IfDefine APACHE1 block to ignore AxKit under Apache2
• Catalyst helper tests now use short => 1 under Catalyst 5.5
• Added Traditional Chinese L10N by Kang-min Liu

Posted by: Christopher H. Laco on Nov 13, 2005 2:48 PM | Permalink

Handel 0.26 Released

Tags: changes (26) : release (11)

Yet another one from the monkey factory.

0.26 Wed Oct 5 21:12:56 2005

• Tested with Class::DBI 3.0.9
• Fixed Exception creation after triggers under Class::DBI 3.0.9
• Handel::DBI now uses Class::DBI->insert in Class::DBI 3.0.9+
• Added subclassing tests
• Changed item_class to use class name instead of __PACKAGE__ See README for known issues

If you're making extensive use of subclassing of the cart, specifically Handel::Cart::Item and setting the ->item_class() method, this is a must upgrade. You will need to upgrade your Class::DBI install to 3.0.8 or greater to take advantage of the has_many fix for for subclasses.

Posted by: Christopher H. Laco on Oct 05, 2005 9:49 PM | Permalink

Handel 0.25 Released

Tags: changes (26) : release (11)

From the bowls of the SVN server, I'm pleased to announce the release of Handel 0.25. It should be available on CPAN shortly.

0.25 Sun Oct 3 20:15:35 2005

• Removed -T from Catalyst helpers tests to keep older versions of File::Path/IO::File happy
• Fixed Catalyst helper test failures due to setting $FindBin::Bin
• Fixed mod_perl detection and code to deal with MP2 and PerlModule/PerlLoadModule
• Fixed Catalyst checkout/order helpers error when trying to get the value of a cookie that didn't already exist
• Fixed obscure bug with Data::UUID crashing in the first call only under MP2
• Added support to create uuids form APR::UUID if it's available

0.24 Mon Sep 26 20:28:13 2005

• Added Catalyst Helper tests
• Added pod notes about Data::FormValidator/HTML::FillInForm in helpers

Posted by: Christopher H. Laco on Oct 03, 2005 8:26 PM | Permalink

Handel 0.23 Released

Tags: changes (26) : release (11)

Rinse. Lather. Repeat.

Because I'm an idiot, here is Handel 0.23. It fixes a problem where Catalyst helpers weren't replacing :: globally when creating uri in templates.

Posted by: Christopher H. Laco on Sep 20, 2005 9:35 PM | Permalink

Handel 0.22 Released

Tags: changes (26) : release (11)

Handel 0.22 has been released and it's on its way to a CPAN mirror nearest you. This is a bugfix release fixing some Catalyst helper problems including:

• Removed leftover hardcoded MyApp::M calls in Catalyst controllers
• Catalyst controller helpers now require Data::FormValidator 4.00+
• Tested with Class::DBI 3.0.8
• Catalyst helpers are smarter about doing the right thing with MyApp::M(odel)::Cart vs. Cart in arguments

Posted by: Christopher H. Laco on Sep 20, 2005 8:53 PM | Permalink

Handel 0.21 Released

Tags: changes (26) : release (11)

The Catalyst helpers in Handel versions before 0.21 have a problem creating files from within the __DATA__ sections on *nix. This is due to a bug in Catalyst::Helper in addition to the fact that the CPAN dist was made on my machine using XP;causing LF/CRLF issues. :-)

A fix has been commited to the Catalyst trunk. To make things easier for the common man, I've also set the svn:eol-style to LF for all of the Catalyst helpers in the Handel svn repository and uploaded Handel version 0.21 to CPAN. This version contains updated Catalyst helpers with Unix line endings that should work on Catalyst 5.33 and below.

A big thanks to Andy Grundman and Bernard FRIT for the help tracking this problem down.

Posted by: Christopher H. Laco on Sep 19, 2005 7:26 PM | Permalink

Handel 0.20 Released

Tags: changes (26) : release (11)

Handel 0.20 has been released and should be available on a CPAN mirror nearest you shorty. Among the change are:

• Catalyst controllers now use Data::FormValidator along with better error handling
• Catalyst Checkout contoller now uses HTML::FillInForm to maintain form state after a POST when there are Data::FormValidator/other errors
• Tested with Class::DBI 3.0.7
• Added add_columns to Handel::DBI to add custom columns to Cart/Items/Order/Items
• Added item_class to Cart/Order classes to specify the item class to be returned from add/items
• Added HandelDBIDSN config variable

Posted by: Christopher H. Laco on Sep 17, 2005 8:56 PM | Permalink

Handel 0.19 Released

Tags: changes (26) : release (11)

After a few late weeks of Catalyst hacking and prodding on #catalyst, I'm pleased to announce the release of Handel 0.19 to the world. The most notable changes are:

• Added Catalyst Helpers/Scaffold support
• Added handel.sqlite.sql SQL Create Script
• Updated French lexicon with more human-friendly translations sent from Bernard FRIT
• Various README fixes patched by Uwe Voelker
• Added Cart::destroy method to actually delete cart record
• Order::new now copies shopper id from cart when creating a new order from an existing shopping cart when no order shopper is specified
• Added temp credit card fields to orders: ccn cctype ccm ccy ccvn ccname
• Added CHECKOUT_PHASE_FINALIZE to checkout phases
• Added MarkOrderSaved and AssignOrderNumber checkout plugins
• Added Order::reconcile to keep cart items and order items synced

It should be available on a CPAN mirror nearest you by morning.

Posted by: Christopher H. Laco on Sep 12, 2005 9:58 PM | Permalink

Browse Module Documentation Online

With a little bit of tinkering, you can now browse the module documentaton (POD) online. The html version of the module docs are built every hour from the latest code in the HEAD revision of the Handel repository trunk.

Posted by: Christopher H. Laco on Sep 05, 2005 1:20 AM | Permalink

Source Browsing Completed. Respository Moved.

Tags: repository (1) : source (1) : subversion (1)

After another fit of tinkering, I have finished the changes to allow styled browsing of the Handel source online. You can browse the Handel source tree at /source/. In the past, this was also the url of the Subversion respository. Access to the Subversion repository has been relocated to http://svn.handelframework.com/CPAN/Handel/.

Happy browsing!

Posted by: Christopher H. Laco on Sep 03, 2005 11:23 AM | Permalink

YAPC::EU, Catalyst and Handel

Tags: catalyst (5) : demo (1) : scaffold (2) : yapc (1)

Close, but no Bob Seger.

Last week, Marcus Ramberg, one of the Catalyst core developers, expressed interest in demoing Handel integration into Catalyst at his presentation at YAPC::EU. After a few furious days of hacking, I managed to toss together a scaffold for Catalyst that created all of the necessary Handel->Catalyst naughty bits.

Unfortunately, he ran out of time and didn't get around to Handel, or the demo before it. Such is life. At least we're mentioned in the slides. :-)

Many thanks to the Catalyst folk for all the help so far and answering the silly questions time and time again. I'm flattered that they took the time to even consider Handel, let alone put it into their YAPC presentation.

Posted by: Christopher H. Laco on Aug 31, 2005 10:48 PM | Permalink

Wiki Logins Opened

Tags: wiki (2)

When I installed the wiki, I made the decision to turn on white-list edits (edit requires login) and disable account creation by non sysops. This was intentionally tight to keep out spam until I had more time to finish setting up the server and the website.

Today, presumably after posting this sites url on #catalyst, I got this comment about someone wanting to help but didn't want to be bother with waiting on me to create a login. Fair enough.

Not being one to look a gift horse in the mouth, I've changed the wiki configuration. Anyone can now create account and edit wiki content. Anonymous editing is still forbidden. IF things get out of hand, I'll probably reverse this decision.

Posted by: Christopher H. Laco on Aug 31, 2005 10:35 PM | Permalink

Handel Wiki Available

Tags: wiki (2)

Sure it's empty. Sure it's read-only unless you have a Sysop approved account. Either way, the Handel Wiki is now online. Hopefully it can become all things how-to over time.

Want to get started adding to the wiki? Just request an account and get started today!

Posted by: Christopher H. Laco on Aug 29, 2005 10:48 PM | Permalink | Comments (2)

Subversion Repository Now Available!

Why stop with a blog right? I've moved the subversion repository to the new web server. You may now browse the Handel source at your leasure and checkout code until the cows come home.

Rather split out Handel and create a no repo, including trying to keep the property history, I decided it was better just to move my entire repository. Now people can access or stuff I'm tinkering with as well.

Posted by: Christopher H. Laco on Aug 26, 2005 11:26 PM | Permalink

Handel Blog

Welcome to the Handel website. Hopefully this will be one of many posts on the Handel blog. I'm still working on getting the wiki and the rest of the site in place as well as getting the Subversion repository online.

Stay tuned.

Posted by: Christopher H. Laco on Aug 26, 2005 10:23 PM | Permalink