view release on metacpan or  search on metacpan

lib/Boulder/Util.pm  view on Meta::CPAN

    local ($,) = '';
    local ($\) = '';
    $data = [$data] if ( ref($data) eq 'HASH' );
    foreach my $rec (@$data) {
        my $param;
        foreach $param ( keys %$rec ) {
            my ($escaped_param) = escape($param);
            my @vals =
              ref( $rec->{$param} ) eq 'ARRAY'
              ? @{ $rec->{$param} }
              : ( $rec->{$param} );
            my $v;
            foreach $v (@vals) {
                print $filehandle "$escaped_param=", escape("$v"), "\n";
            }
        }
        print $filehandle "=\n";
    }
}

sub boulder_load {
    my ( $filehandle, $mode ) = @_;
    my @lines;
    if ( defined($filehandle) && ( $filehandle ne '' ) ) {
        while (<$filehandle>) {
            chomp;
            last if /^=/;
            push( @lines, $_ );
        }
    }
    return undef unless @lines;
    return "@lines" =~ /=/ ? join( "&", @lines ) : join( "+", @lines )
      if $mode == QUERY;
    my %hash;
    foreach (@lines) {
        my ( $key, $value ) = split /=/, $_, 2;
        next unless $key;
        $value = unescape($value);
        unless ( exists( $hash{$key} ) ) {
            $hash{$key} = $value;
            next;
        }
        if ( ref( $hash{$key} ) eq 'ARRAY' ) {
            push( @{ $hash{$key} }, $value );
        } else {
            $hash{$key} = [ $hash{$key}, $value ];
        }
    }
    \%hash;
}

# Borrowed from CGI so we don't have to load that package if
# we don't need to. Turns a string into a filehandle.
sub to_filehandle {
    my $thingy = shift;
    return undef unless $thingy;
    return $thingy if UNIVERSAL::isa( $thingy, 'GLOB' );
    return $thingy if UNIVERSAL::isa( $thingy, 'FileHandle' );
    if ( !ref($thingy) ) {
        my $caller = 1;
        while ( my $package = caller( $caller++ ) ) {
            my ($tmp) =
                $thingy =~ /[\':]/
              ? $thingy
              : "$package\:\:$thingy";
            return $tmp if defined( fileno($tmp) );
        }
    }
    return undef;
}

1;

__END__

=begin

=head1 NAME

Boulder::Util - Utility methods for simple Boulder IO interactions.

=head1 SYNOPSIS
 
 #!/usr/bin/perl -w
 use strict;
 
 use Boulder::Util qw( boulder_save boulder_load );
 
 my $file ='pixies.txt';
 
 my $data = { 
     vocals => ['frank', 'kim'],
     guitar => ['frank', 'joey'],
     bass => 'kim',
     drums => 'david'
 };
 
 my $fh;
 open ($fh,">$file");
 boulder_save($fh,$data);
 close $fh;
 
 my $fh2;
 open ($fh2,"$file");
 while(my $q = boulder_load($fh2,Boulder::Util::QUERY)) {
     print "$q\n";
 }
 close $fh2;

=head1 DESCRIPTION

Boulder::Util is a utility package for manipulating simple Boulder IO
records in a lightweight fashion.

Boulder IO is the native format output by the CGI package's C<save>
method. While working on a project I used that method to serialize
the state of a query for later use. That later use did not involve
a CGI request though. I wanted to avoid loading up the CGI package
just to read in the file memory and the L<Boulder> package itself
seemed like a bit much. What I wished I had was a quick way of
reading those records without incurring the overhead of either