Simple, powerful templates for Java

Q: Does the Java community really need yet another templating engine?

A: Not really, but back when I started Chunk, there wasn’t anything else out there like it. Now that it has matured, I am releasing it into the wild, and if somebody finds it useful, great!

Click below for an introduction to better code/layout separation:

http://www.x5software.com/chunk/wiki

Features:

• Macros, Includes and Conditional Includes.
• Flexible null-handling; template designer may specify default tag values.
• Library of powerful predefined in-tag filters, including regex (regular expressions), sprintf.
• Expose a subset of obj methods to template with a single line of code.
• Define multiple snippets per template file.
• Support for theme layers.
• Highly optimized codebase.
• Hooks for extending.
• Eclipse Template Editor plugin available with syntax highlighting & more.

Visit the Chunk project home on Google Code to download the Chunk Templates jar and get started.

I don’t know if Chunk is better than Velocity, I don’t know if Chunk is better than FreeMarker, but I’ve been using it for years and it’s gotten pretty cool.

Hackers are encouraged to contribute enhancements back to the community.  Google is hosting the code on its SVN server so it’s easy to check out a copy of the source and make whatever improvements you need.

But then it’s 500 (or 5,000!) lines of “little tweaks” later and you need to upgrade.  And you’re screwed.  And a couple extra xml files and a separate tree of folders and files doesn’t seem like such a bad idea anymore.

Well, okay, time to roll up your sleeves and learn this durn extension framework that the brainiacs at Varien/Magento have so lovingly constructed.

Layouts and Templates and Blocks, Oh My

classyllama.com has a great article on how to modify one or two things in a core layout without (1) modifying it directly in core or (2) having to make a copy of the whole layout file into your theme just to tweak one line:

http://classyllama.com/development/magento-development/the-better-way-to-modify-magento-layout/

Now that I understand this layout stuff, I’m doing a lot less messing around directly in theme templates.  By the way, if you are editing the factory-supplied Magento templates and layouts directly, for shame!  Set up a theme and make all your changes in the theme.

Update: another great article on navigating the Magento layout framework:
http://alanstorm.com/layouts_blocks_and_templates

OO PHP?  Isn’t that like oil and water?

The article linked below offers a lucid explanation of how to roll your own modules that extend the core Model, Controller, Resource, and Block classes (it’s a little different for each case) to override the core behavior in Magento. Not for beginners, you really need to have a handle on OO programming. Again, this is cool because you don’t have to edit a core file directly (where changes will get blown away in an upgrade) and you don’t have to copy the whole file just to tweak one function. The latter strategy prevents you from reaping the benefits of any bugfixes or new features in that file in the next upgrade, and could even cause serious problems/bugs as your copy gets out of sync with the core codebase.

http://prattski.com/2010/06/24/magento-overriding-core-files-blocks-models-resources-controllers/

For some reason that comprehensive article does not include instructions for overriding a function in a helper class (yet another special case). This article has an example for that:

http://blog.chapagain.com.np/magento-block-controller-model-helper-override/

Happy coding!

http://matthewjamestaylor.com/blog/centered-dropdown-menus

Thank goodness I found that article or I would still be pulling my hair out.

In my day, used to be you could stick this in one or two tables and you were done. We didn’t have no stinkin’ separation of content and layout and we liked it.

Turns out the most popular CPAN module for doing SOAP in Perl (SOAP::Lite) is not particularly fun to use (see “State of the SOAP” at http://www.soaplite.com/ for a three-year-old call for volunteers to refactor).

Nevertheless, I did eventually emerge victorious. There may be a much easier way but after a lot of head-scratching and trial and error, this worked for me, YMMV.

The soapify routine was stolen from this page:
http://www.soaplite.com/2004/01/building_an_arr.html
Many thanks to soapify author Sandeep Satavlekar.

For passing the filter args to sales_order.list, I had to make the call in PHP first and then reverse-engineer the encoding of the nested array that actually got passed. There may be a way to get SOAP::Lite to encode nested arrays like this by default (or encode nested arrays in some other standard SOAPy way that Magento would also accept) but I chose not to waste any more time on this than I already had.

Enjoy!

UPDATE: Was getting sporadic “Access Denied” errors. Turns out you can fix this just by turning on cookies. Apparently this only affects you if Magento is using DB sessions. See new get_soap_session below for how to turn on cookies.

UPDATE TO THE UPDATE: Nah, that didn’t fix it. Still searching for a fix… runs fine in a session, fails about 80% of the time from cron.

#!/usr/bin/perl

# replace these values with the soap account you set up in the admin
my $user = 'username';
my $pass = 'password';

# replace with your domain and path (we installed magento at /shop/)
my $soap_url = 'http://YOURDOMAIN/MAGENTO_PATH/index.php/api/index/index/';

my ($soap,$session_id) = &get_soap_session($user,$pass,$soap_url);

# simple example (one arg of type string)
my $oid = '1000001';
my $order = &get_order($soap,$session_id,$oid);

# gnarly example (argument is nested arrays)
my $orders = &get_recent_invoiced_orders($soap,$session_id);

foreach my $ord (@$orders) {
    my $due = $ord->{grand_total};
    my $paid_or_authorized = $ord->{total_invoiced};
    my $owed = $due - $paid_or_authorized;
    # ignore if not yet paid
    next if ($owed > .02);
    &fulfill_order($ord);
}

exit 0;

# 
# subroutines... should do this more OO but this is
# some simple, readable example code to help you avoid
# exploring the dark cave that I went into...
# 
sub get_order {
    my $soap = shift;
    my $session_id = shift;
    my $oid = shift;

    # Yes, we're really calling a method named "call" -- confusing, no?
    #
    # For simple calls with no args or just one or two string args, this
    # straightforward code works fine.
    #
    # The first argument is always the session ID that was returned from the initial
    # login call.  The second argument is the requested API resource.
    # Third is a list of any arguments to pass to the resource that's being invoked.
    my $resp = $soap->call('call' => ($session_id, 'sales_order.info', ($oid)));
    return $resp->result;
}

sub get_recent_invoiced_orders {
    my $soap = shift;
    my $session_id = shift;

    # limit query to orders with activity in past 60 days
    my $sixty_days_back = &sixty_days_back();

    # If you can believe it, the crazy array below is really just this:
    #  my $filter_a, $filter_b;
    #  $filter_a->{status}->{eq} = 'processing';
    #  $filter_b->{updated_at}->{gt} = $sixty_days_back;
    #  my $filters = [ $filter_a, $filter_b ];

    # look up correct namespace prefixes for soapenc and xsi
    my $serializer = $soap->serializer();
    my $soapenc = $serializer->encprefix || 'soapenc';
    my $xsi = $serializer->find_prefix('http://www.w3.org/2001/XMLSchema-instance') || 'xsi';

    # There might be some way to automatically generate the mess
    # below from the simpler data structure above, but this works for now.
    my $ugly_args = ['item',
                     [
                      ['item',
                       [['key','status'],
                        ['value',
                         ['item',
                          [['key','eq'],['value','processing']]
                         ],
                         {"$xsi:type"=>'apache:Map'}
                        ]
                       ]
                      ],
                      ['item',
                       [['key','updated_at'],
                        ['value',
                         ['item',
                          [['key','gt'],['value',$sixty_days_back]]
                         ],
                         {"$xsi:type"=>'apache:Map'}
                        ]
                       ]
                      ]
                     ],
                     {"$xsi:type"=>'apache:Map'}
        ];

    my $ugly = ['args',$ugly_args,{"$soapenc:arrayType"=>'apache:Map[1]',"$xsi:type","$soapenc:Array"}];

    my @soap_args;
    $soap_args[0] = ['sessionId',$session_id];
    $soap_args[1] = ['resourcePath','sales_order.list'];
    $soap_args[2] = $ugly;

    my @data;
    foreach my $arg (@soap_args) {
        push @data, &soapify_args($arg);
    }

    my $resp = $soap->call('call' => @data);
    return $resp->result;
}

####################################################################
# soapify_args
#
# Description:
# Given an arrayref (infinite depth), constructs a valid SOAP Object
#
# Parameters:
# $args: Arrayref
#
# Format of the arrayref:
# [xml_element_name, value, attributes]
# xml_element_name must be a scalar, value could be a scalar or another arrayref of the same format and
# attributes must be a hashref. xml_element_name and attributes are optional.
#
# Examples:
# 1. ["ElemName1", "ElemValue1", { "xmlns" => "http://blah/blah"}]
# 2. ["ElemName2", [
# ["NameAtLevel1", "ValueAtLevel1", {}],
# ], {"attrname" => "attrvalue"}]
# 3. [
# ["name", "value"]
# ]
#
# Return Value:
# SOAP object
############################################################
sub soapify_args {
    my ($args) = (@_);

    die "The argument must be an arrayref!" if (ref($args) !~ /ARRAY/ );

    my @namevaluearray = @$args;
    my $soapobject = new SOAP::Data;

    if (defined ($namevaluearray[0]) && ref($namevaluearray[0]) !~ /ARRAY/) {

#------------------name------------------------# 
        $soapobject->name($namevaluearray[0]);

#------------------value-----------------------#
        if (defined $namevaluearray[1] && !ref($namevaluearray[1])) {
            $soapobject->value($namevaluearray[1]);
        }
        elsif (ref($namevaluearray[1]) =~ /ARRAY/) {
            my $soapvalue = soapify_args($namevaluearray[1]);
            my @pass = (ref($soapvalue) =~ /ARRAY/) ? @$soapvalue : ($soapvalue);
            $soapobject->value(SOAP::Data->value(@pass));
        }

#-------------------attribute------------------#
        my $attr = $namevaluearray[2];
        if (ref($attr) =~ /HASH/) {
            $soapobject->attr($attr);
        }
    }
    elsif (ref($namevaluearray[0]) =~ /ARRAY/) {
        my @valuesarray;
        foreach my $element (@namevaluearray) {
            my $reftoelement = (ref($element) =~ /ARRAY/) ? $element : [$element];
            push(@valuesarray, soapify_args($reftoelement));
        }
        return [@valuesarray];
    }

    return $soapobject;
}

sub get_soap_session {
    use HTTP::Cookies;
    use SOAP::Lite;
    on_fault => sub { my($soap, $res) = @_;
        die ref $res ? $res->faultstring : $soap->transport->status, "n";
    };
    #optional, uncomment this to debug xml going back and forth
    ##    SOAP::Lite->import(trace =>debug);

    my $user = shift;
    my $pass = shift;
    my $soap_url = shift;

    # need to turn cookies on, might get "Access Denied" errors otherwise
    my $soap = SOAP::Lite->new();
    $soap->proxy($soap_url, cookie_jar => HTTP::Cookies->new(ignore_discard => 1));

    # had to add this namespace to enable passing nested arrays as valid data
    my $serializer = $soap->serializer();
    $serializer->register_ns( 'http://xml.apache.org/xml-soap', 'apache' );

    my $session_id = $soap->login($user,$pass)->result;
    return ($soap,$session_id);
}

sub fulfill_order {
    my $ord = shift;

    # whatever you need to do, do it here... we pass the order to our SAP system
    # via a custom web service.  Maybe you transmit somewhere via EDI?

    # placeholder -- dump raw order data
    use Data::Dumper;
    print Dumper($ord);

    return;
}

sub sixty_days_back {
    my $sixty_days_in_secs = 60 * 24 * 60 * 60;
    my ($sec,$min,$hr,$mday,$mon0,$yr1900) = localtime(time - $sixty_days_in_secs);
    my $year = $yr1900 + 1900;
    my $mon = $mon0 + 1;
    # eg 2010-08-01 for august 1 2010
    return sprintf("%04d-%02d-%02d",$year,$mon,$mday);
}

Defining your own attributes is easy.  Getting them to display in a template is not.  Cheat sheet:

http://www.sharpdotinc.com/mdost/2009/04/06/magento-getting-product-attributes-values-and-labels/

http://www.exploremagento.com/magento/override-a-magento-core-block-class.php

http://snippi.net/taxonomy/term/10

http://www.sonassi.com/knowledge-base/magento-knowledge-base/mass-update-stock-levels-in-magento-fast/

http://www.magentocommerce.com/boards/viewthread/43928/

http://www.sonassi.com/knowledge-base/magento-knowledge-base/catalog-search-index-refresh-running-slow-or-haltingfreezing/

Y-Wing Fighter: the force is strong with this one.

Y-Wing can be a very handy shortcut in a tough sudoku puzzle and it may even be the only way forward in some harder ones. It’s named after an ugly rebel fighter craft from the Star Wars movies.  True to its namesake, it is not as elegant or as powerful as its X-Wing brother, but it can still do some damage.

Y-Wing can be hard to spot, so today I’ll describe a method for quickly teasing out the best ones. It boils down to this — the best Y-Wing sets are the ones where two of the three squares in the set are in the same 3×3 box!

Really, don’t bother looking for a set that’s super spread-out. It’s very rare that you’ll find one and even if you do, it’s the weakest kind: you’ll only be able to remove one candidate from one square, and that’s if you’re lucky.

Y-What?

First, let’s make sure we all know what we’re looking for. The basic idea is, you find three squares that each have two remaining candidates. The “pivot” square can see both of the end squares.  All three squares share candidates from a pool of just three total numbers, ABC. So one end of the “V” is AB, the pivot has BC, and the other end is AC.

Important detail - no two squares in the set have the same pair of candidates.  So, if you whittle down three squares to 78, 48 and 47, you’re well on your way to a Y-Wing.  If you’re looking at 47, 48 and 47, no deal.

How to spot Y-Wing / XY-Wing

Any square that can see both ends of the Y-Wing may eliminate candidate A from its own candidate pool. It’s an easy proof, just look at the pivot — when the puzzle is done, the pivot will either be B or C.

If the pivot is B, then the first end is not B, and must be A. In the other “reality,” if pivot is C, then the other end is not C, and must be A. Since the pivot must be either B or C, at least one of those end squares will have A.  Here’s the neat part: squares that can “see” both end squares can never be A; not in the first case, and not in the second case (and there are only two cases total).

The Claw

Some people like to think of Y-Wing as a claw.  A simple way to visualize it is, the claw’s pincers (end squares) “pinch” candidate A out of any square they can both see.  The pivot is the “hinge” of the claw.

There are two kinds of Y-Wing. One can be very helpful, and one is usually not. If the three squares in your Y-Wing are all in different boxes, you’ve found the less useful Y-Wing variant (your claw is wide open, pincers at 90 degrees).  Only one square can see both pincers - so even if we are lucky, we can only eliminate/pinch one candidate from one square.

The kind I like is when one claw pincer and the pivot share a box. Then you’ll always have more than one “pinchable” square (up to five, in fact). Fortunately, finding this second type is easier anyway.

The Method

Look at each group of 9 squares (the nine large 3×3 boxes).  In each big box, look for two squares in that box with only two candidates left each. They must share exactly one candidate.  It’s okay if they are in the same row/column but you’ll cast a wider net for the other claw if they aren’t. Found a pair like this? Good. Now look at the two candidates they don’t have in common. Let’s call them AB.  We are looking for a third square, from a different box, that has only AB left in its candidate pool. It must be able to “see” one of our original squares (yep, either one).  The square that it sees from our original box becomes the pivot.

So, we really just scan four potential zones outside our box:

• the squares in the same row as square 1

• the squares in the same row as square 2

• the squares in the same column as square 1, and finally,

• the squares in the same column as square 2

Didn’t pan out?  Move along, find another potential pivot/claw pair, maybe in this box or probably the next.  You’d be surprised how often you can track down a set of three once you focus your search like this.  See if you can find the Y-Wing below.  hint: start in box 7.

Y-Wing Example

Solution: Ignore the middle square and the lower right square, too many candidates. 39 and 35 share a candidate (3) but they are in the same row which reduces potential for success - we’ll come back to this pair only if other options don’t pan out.  45 and 35 share a candidate and they are located diagonally apart from each other so they are not in the same row or the same column.  Good.  The non-shared candidates are 3 and 4, so check around for a square with 34… R3C1!  Voila, here is our Y-Wing.  45 is the pivot, the other two are the claws.

Now think it through. When the pivot is 4, the left pincer can’t be 4 and must be 3.  Otherwise, the pivot is 5, and the right pincer can’t be 5 and must be 3.  So, either the left pincer is 3 or the right pincer is 3.  Either way, any square that sees them both will never be 3!

So, R2C3 and R3C3 get their 3’s pinched out by the claws, leaving a naked pair that solves R3C1 (3) and sets a whole chain of good things in motion.  Good times.

Followup quiz: What are the five “pinchable” squares in this Y-Wing?

Answer: R1C3 R2C3 R3C3 from box 1 and R7C1 R8C1 from box 7 can all “see” both claw pincers in this Y-Wing.

Visualize the Claw

Fishy Sudoku: Challenging puzzles. Great Interface.

Well, it’s about time I came clean.  I am a Sudoku addict.  I do two fairly difficult puzzles a day, at a site that offers free daily puzzles.  I’m getting a little tired of the puzzles on that site because they tend to block forward progress until you find one or two X-Wing sets and then you’re done.  A bit predictable after a while, and once you get good at spotting X-Wing it gets kinda boring.

So about a year ago I started making my own puzzles.  I wrote a java program that generates random puzzles, and another java program that solves the puzzles by applying various techniques in a loop, in order of difficulty.  The second program rates the puzzles made by the first program.  I wrote a third program that lets the first two programs fight it out until they come up with a tough puzzle.

Hard puzzles should have one or two X-Wing sets.  Really hard puzzles, in my opinion, need an XY-Wing or a swordfish or even a jellyfish.  Thus the name of my new daily puzzle website, www.fishysudoku.com.

I put together a nice little sudoku puzzle interface in Flash.  It addresses all the things I found really annoying about other online sudoku sites.  First of all, the pencilmarks come up automatically.  My wife insists that Sudoku is a big waste of time, and she’s right, to an extent.  The interesting parts of solving a sudoku puzzle tend to just punctuate long stretches of tedium. God forbid you make a mistake during the pencil-mark tedium.  Anyone who has tried Sudoku has made a mistake at some point that went undiscovered for the better part of an hour.  This is not a rewarding feeling.

So in my interface, autohelp is on by default.  Glaring mistakes are immediately circled until they are fixed.  Obvious pencilmarks are done for you.  But most interfaces that do this prevent additional edits to the pre-determined marks.  So in my interface, you can grey out any pencilmarks that you know to be impossible.

I have plenty of features still to add — puzzle archive, access to the solver for hints & more — but I figured it was time to do an alpha launch.

To reach a broader audience, I also boxed it up as a facebook app. Add it to your facebook apps! I need at least five people to add it before I can get listed in the app directory.

Spent $10 on Punch, Sketchup is free.  Sketchup rocks.  With no training and very little ramp-up on the interface, I had a working model of our master bath remodel and was able to mock up the custom shower stall that we want to build, found 3D models of toilets, sinks, vanities, clawfoot tubs, fixtures, you name it.

Caveats: Sketchup has no 2D view (although you can swing around to a bird’s-eye view and look through the ceiling without too much trouble once you get the hang of it).  Sketchup does require some patience when your toilet is 300 feet away from where you want it and you can’t quite get Sketchup to intuit what you are doing.  That said, nine times out of ten it is unbelievably good at intuiting what you want to do.  A lesser program would misinterpret most mouse movements, but there is some intelligent engine at work in Sketchup that seems to be aware of what you are seeing and almost always does what you mean.

Punch was infuriatingly dumb.  You had to tie everything you put into the space to a wall, and if something overlapped temporarily while you were adding something else or resizing a wall, the items on that wall just get deleted.  You couldn’t just grab things and move them with the mouse, and the 3D walkthrough was impossible to navigate.  Simple things like looking right or up or backing out, making walls temporarily see-through, etc. are SO easy in Sketchup and simply not possible in Punch.

A few tips to get you started in Sketchup — you definitely want to use a three button mouse with a mouse wheel.  Rolling the wheel zooms in and out, and holding down the wheel button while you move the mouse rotates/swings your 3D model around (this is a very powerful and satisfying feeling) no matter what tool is currently active.  Press H to get the “hand” cursor (grab and slide the model in any direction), Press space to select things, hold down shift to select multiple things.  Press M to grab things and move them.  Selecting and moving a face of a box will adjust the rest of the box as necessary to remain intact.

Hide walls, ceilings, whatever, by right clicking it and selecting ‘hide’ on the popup menu.  Sketch away!

Rabid sports fan that I am, I did not take the plunge until I discovered www.myp2p.eu and the wonders of p2p live streaming sports. So far this has turned out to be a mixed bag. When it’s good, it’s mid-to-low-res but you can follow the action. Veetle is pretty cool. When it’s bad it really stinks. The players and plays are fuzzy. The score is rarely legible. The keyframes drop out and for several seconds at a time blotchy pieces of the previous shot carry over for that “they’re playing in a vat of pea soup” effect. The best is when the feed stops for buffering just when Ray Allen has released the shot that will send the game into triple overtime.

But hey, the Bruins are in the playoffs (well, until they choked in OT last night), the Celtics are in the playoffs, and I have found that I will endure quite a lot of low quality picture to be connected to the hunt for a championship.

Some nights the only available feed is from Taiwan, with audio in Taiwanese Chinese (although I have to say, I don’t speak a word and the Taiwan commercials are still hilarious).

I find it ironic that in this age of higher and higher def, my own TV viewing quality experience is moving in the opposite direction. It’s consoling to think that a generation earlier I might be slapping the side of the TV fonzie-style before a big play to try to reduce the static from a bad over-the-air signal. Now I move around the room and adjust the angle of my laptop in the hopes that our wifi is the bottleneck.

However fuzzy the broadcast, last night proved to me that they can still break your heart, and that stings in hi-def. Bruins out of the hunt. Magic force game 7 on the Celts. Sox fall in the 12th. To cap it all off, the Yanks win. I guess we had it coming?

A new crop of talent is staking its ground in the children’s book landscape so long dominated by the likes of Dr. Seuss and Eric Carle.  It’s a good time to be a new dad.

Mo Willems is hit or miss, but when he’s on it’s pure gold. , for instance, is a clear winner.  Other pigeon books in the series don’t always measure up.  is one of a new Willems series featuring the new Piggie and Elephant duo (occasionally joined by a wise squirrel). This looks to be heavily in the rotation for some months to come.

The award, however, goes to Leslie Patricelli.  Nothing tops or except maybe her tour de force .  These board books are just the right length for the short toddler attention span, and just the right size for little hands and budding imaginations.  It’s only natural for our kids to imagine themselves as the baby protagonist in these juicy canvases with ultra saturated colors and friendly, thick black lines.

Honorable mention to Byron Barton.  I don’t know if girls would be quite so excited about the / / trilogy, but our two boys have a whole new appreciation for transportation thanks to Mr. Barton.