Any-Renderer
5 results

 view release on metacpan or  search on metacpan

lib/Any/Renderer.pm  view on Meta::CPAN 


A renderer in this context is something that turns a data structure into a
string.  This includes templating engines, serialisers etc.

This module provides a consistent API to these services so that your
application can generate output in an extensible variety of formats.
Formats currently supported include:

	- XML (via XML::Simple)
	- XML+XSLT
	- Data::Dumper
	- Javascript, Javascript::Anon & JSON
	- UrlEncoded
	- The formats supported by Data::Serializer (e.g. Config::General and Config::Wrest)
	- Any templating language supported by Any::Template

The module will discover any backend modules and offer up their formats.
Once loaded, Any::Renderer will look for a module to handle any new formats it doesn't know about, so adding new formats in a persistent environment won't require the module to be reloaded.
However if you CHANGE which module provides a format you will need to reload Any::Renderer (e.g. send a SIGHUP to modperl).

=head1 METHODS

lib/Any/Renderer.pm  view on Meta::CPAN 


=head1 GLOBAL VARIABLES

=over 4

=item @Any::Renderer::LowPriProviders

A list of backend providers which have lower precedence (if there is more than one module which provides a given format).
The earlier things appear in this list, the lower the precedence.

Defaults to C<Data::Serializer> as this provides both XML::Simple and Data::Dumper (which have native Any::Renderer backends).

=back

=head1 WRITING A CUSTOM BACKEND

Back-end modules should have the same public interface as Any::Renderer itself:

=over 4

=item $o = new Any::Renderer::MyBackend($format, \%options);

lib/Any/Renderer/Data/Dumper.pm  view on Meta::CPAN 

package Any::Renderer::Data::Dumper;

# $Id: Dumper.pm,v 1.9 2006/08/23 19:41:16 johna Exp $

use strict;
use vars qw($VERSION);
use Data::Dumper;

$VERSION = sprintf"%d.%03d", q$Revision: 1.9 $ =~ /: (\d+)\.(\d+)/;

use constant FORMAT_NAME => 'Data::Dumper';

sub new
{
  my ( $class, $format, $options ) = @_;
  die("Invalid format $format") unless($format eq FORMAT_NAME);
  
  $options ||= {};
  my $self = {
    'options' => $options,
    'varname' => delete $options->{VariableName},
  };

  $options->{DumperOptions} ||= {};
  foreach my $opt(keys %{$options->{DumperOptions}}) {
    die("Data::Dumper does not support a $opt method") unless(Data::Dumper->can($opt));
  }

  bless $self, $class;

  return $self;
}

sub render
{
  my ( $self, $data ) = @_;

  TRACE ( "Rendering w/Data::Dumper" );
  DUMP ( $data );

  my $o = Data::Dumper->new([ $data ], [ $self->{ 'varname' } ]);
  $o->Sortkeys(1);
  foreach my $opt(keys %{$self->{options}{DumperOptions}}) {
    $o->$opt($self->{options}{DumperOptions}{$opt}); #Fire corresponding methods
  }
  return $o->Dump();
}

sub requires_template
{
  return 0;

lib/Any/Renderer/Data/Dumper.pm  view on Meta::CPAN 

  return [ FORMAT_NAME ];
}

sub TRACE {}
sub DUMP {}

1;

=head1 NAME

Any::Renderer::Data::Dumper - render data structures through Data::Dumper

=head1 SYNOPSIS

  use Any::Renderer;

  my %options = ('DumperOptions' => {'Indent' => 1});
  my $format = "Data::Dumper";
  my $r = new Any::Renderer ( $format, \%options );

  my $data_structure = [...]; # arbitrary structure
  my $string = $r->render ( $data_structure );

=head1 DESCRIPTION

Any::Renderer::Data::Dumper renders any Perl data structure passed to it into
a string representation via Data::Dumper.  For example:

  perl -MAny::Renderer -e "print Any::Renderer->new('Data::Dumper')->render({a => 1, b => [2,3]})"

results in:

  $VAR1 = {
            'a' => 1,
            'b' => [
                     2,
                     3
                   ]
          };

=head1 FORMATS

=over 4

=item Data::Dumper

=back

=head1 METHODS

=over 4

=item $r = new Any::Renderer::Data::Dumper($format, \%options)

C<$format> must be C<Data::Dumper>.
See L</OPTIONS> for a description of valid C<%options>.

=item $string = $r->render($data_structure)

The main method.

=item $bool = Any::Renderer::Data::Dumper::requires_template($format)

False in this case.

=item $list_ref = Any::Renderer::Data::Dumper::available_formats()

Just the one - C<Data::Dumper>.

=back

=head1 OPTIONS

=over 4

=item VariableName

Name of the perl variable the structure is assigned to.  Defaults to C<$VAR1>.

=item DumperOptions

This hashref of options is mapped to Data::Dumper methods (Indent, Purity, Useqq, etc.).  For example:

  perl -MAny::Renderer -e "print Any::Renderer->new('Data::Dumper', {DumperOptions => {Indent=>0}})->render({a => 1, b => [2,3]})"

results in:

  $VAR1 = {'a' => 1,'b' => [2,3]};

See L<Data::Dumper> for the list of I<Configuration Variables or Methods>.

=back

=head1 SEE ALSO

L<Data::Dumper>, L<Any::Renderer>

=head1 VERSION

$Revision: 1.9 $ on $Date: 2006/08/23 19:41:16 $ by $Author: johna $

=head1 AUTHOR

Matt Wilson and John Alden <cpan _at_ bbc _dot_ co _dot_ uk>

=head1 COPYRIGHT

t/Any_Renderer.t  view on Meta::CPAN 


use Any::Renderer;
ASSERT ( 1, 'Compilation' );

########################################################################
# Test available backends - this has to work whatever we have installed
########################################################################

# the known renderers and whether or not they require templates
my %known_renderers = (
    "Data::Dumper"      => 0,
    "JavaScript"        => 0,
    "JavaScript::Anon"  => 0,
    "Javascript"        => 0,
    "Javascript::Anon"  => 0,
    "JSON"              => 0,
    "UrlEncoded"        => 0,
    "XML"               => 0,
    "XSLT"              => 1,
);

t/Any_Renderer.t  view on Meta::CPAN 

};

#Ask what's available
my %d_renderers = map {$_ => Any::Renderer::requires_template ( $_ ) || 0} @{Any::Renderer::available_formats()};

DUMP ( "discovered renderers", \%d_renderers );
DUMP ( "known renderers", \%known_renderers );
ASSERT ( intersects( \%known_renderers, \%d_renderers ), "Check of available formats" );

##############################################################
# Use Data::Dumper to test the API as it's a core module
##############################################################

$format = "Data::Dumper";

#Test defaults (no options)
%options = ();
$renderer = new Any::Renderer ( $format, \%options );
ASSERT ( "\$VAR1 = [\n          1,\n          2,\n          3\n        ];\n" eq $renderer->render ( [ 1, 2, 3 ] ), "Render using defaults" );

#Test option passing
%options = ( VariableName => 'dd_var' );
$renderer = new Any::Renderer ( $format, \%options );
ASSERT ( "\$dd_var = [\n            1,\n            2,\n            3\n          ];\n" eq $renderer->render ( [ 1, 2, 3 ] ), "Using options" );

t/Any_Renderer_Data_Dumper.t  view on Meta::CPAN 

#!/usr/local/bin/perl

# Purpose : unit test for Any::Renderer::Data::Dumper
# Author  : Matt Wilson
# Created : 17th March 2006
# CVS     : $Header: /home/cvs/software/cvsroot/any_renderer/t/Any_Renderer_Data_Dumper.t,v 1.6 2006/08/29 12:40:48 andreww Exp $

use Test::Assertions::TestScript;
use Any::Renderer::Data::Dumper;

ASSERT ( 1, 'Compilation' );

# are we handling what we _think_ we're handling?
ASSERT ( EQUAL ( [ 'Data::Dumper' ], Any::Renderer::Data::Dumper::available_formats () ), "Handle expected formats" );

# do we require a template as expected (or not)?
ASSERT ( 0 == Any::Renderer::Data::Dumper::requires_template ( "Data::Dumper" ),  "Requires template?" );

# initiate an object with a specific variable name
my %options = ( VariableName => 'dd_var' );
my $dd = new Any::Renderer::Data::Dumper ( "Data::Dumper", \%options );

# rendering a list into Data::Dumper
ASSERT ( "\$dd_var = [\n            1,\n            2,\n            3\n          ];\n" eq $dd->render ( [ 1, 2, 3 ] ), "Render a list (with specific variable name)" );

# rendering of a hash into Data::Dumper
ASSERT ( "\$dd_var = {\n            '1' => 2\n          };\n" eq $dd->render ( { 1 => 2 } ), "Render a hash (with specific variable name)" );

# rendering of a singular value
ASSERT ( "\$dd_var = 1;\n" eq $dd->render ( 1 ), "Render a single value (with specific variable name)" );

# rendering of a singular string value
ASSERT ( "\$dd_var = 'string';\n" eq $dd->render ( "string" ), "Render a single value (with specific variable name)" );

# initiate an object
%options = ();
$dd = new Any::Renderer::Data::Dumper ( "Data::Dumper", \%options );

# rendering a list into Data::Dumper
ASSERT ( "\$VAR1 = [\n          1,\n          2,\n          3\n        ];\n" eq $dd->render ( [ 1, 2, 3 ] ), "Render a list" );

# rendering of a hash into Data::Dumper
ASSERT ( "\$VAR1 = {\n          '1' => 2\n        };\n" eq $dd->render ( { 1 => 2 } ), "Render a hash" );

# rendering of a singular value
ASSERT ( "\$VAR1 = 1;\n" eq $dd->render ( 1 ), "Render a single value" );

# rendering of a singular string value
ASSERT ( "\$VAR1 = 'string';\n" eq $dd->render ( "string" ), "Render a single value" );

# Test passing options to Data::Dumper
$dd = new Any::Renderer::Data::Dumper ( "Data::Dumper", {'DumperOptions' => {'Indent' => 0}} );
my $rv = $dd->render ( { 1 => 2 } );
ASSERT ( "\$VAR1 = {'1' => 2};" eq $rv, "Set Indent" );

# Test Data::Dumper method name checking
ASSERT(DIED(sub{ new Any::Renderer::Data::Dumper ( "Data::Dumper", {'DumperOptions' => {'Nonsense' => 1}} ) }) && $@ =~ /does not support a Nonsense method/,"Trapped dodgy method name");

# Trap invalid formats
ASSERT(DIED(sub {new Any::Renderer::Data::Dumper( "Nonsense", {} )}) && $@=~/Invalid format Nonsense/,"Trap invalid format");  

# vim: ft=perl

t/Any_Renderer_Data_Serializer.t  view on Meta::CPAN 

}

use Test::Assertions::TestScript tests => $NumTests, auto_import_trace => 1;
ASSERT ( 1, 'Check if Data::Serializer is available' );

if($HaveDataSerializer) {
  require Any::Renderer::Data::Serializer;
  ASSERT ( 1, 'Compilation' );
  
  # are we handling what we _think_ we're handling?
  ASSERT ( scalar (grep { $_ eq 'Data::Dumper' } @{Any::Renderer::Data::Serializer::available_formats ()}), "Handle expected formats" );
  
  # do we require a template as expected (or not)?
  ASSERT ( 0 == Any::Renderer::Data::Serializer::requires_template ( "Data::Dumper" ), "Requires template?" );
  
  # initiate an object
  %options = ();
  $dd = new Any::Renderer::Data::Serializer ( "Data::Dumper", \%options );
  
  # rendering a list into Data::Serializer
  ASSERT ( "[1,2,3]" eq $dd->render ( [ 1, 2, 3 ] ), "Render a list" );
  
  # rendering of a hash into Data::Serializer
  ASSERT ( "{'1' => 2}" eq $dd->render ( { 1 => 2 } ), "Render a hash" );
  
  # rendering of a integer value
  ASSERT ( "1" eq $dd->render ( 1 ), "Render an integer" );



( run in 0.507 second using v1.01-cache-2.11-cpan-a5abf4f5562 )