Froody

 view release on metacpan or  search on metacpan

lib/Froody/API/XML.pm  view on Meta::CPAN

use strict;
use warnings;
use XML::LibXML;
use Froody::Method;
use Froody::ErrorType;
use Froody::Response::String;
use Froody::Logger;
my $logger = get_logger("froody.api.xml");

use base qw(Froody::API);
use Scalar::Util qw(weaken);

=head1 NAME

Froody::API::XML - Define a Froody API with xml

=head1 SYNOPSIS

  package MyAPI;
  use base qw{Froody::API::XML};
  

lib/Froody/API/XML.pm  view on Meta::CPAN

                  ->needslogin($class->_needslogin($method_element));
  my ($response_element) = $class->_extract_response($method_element, $full_name);
  if ($response_element) {
    my ($structure, $example_data) = $class->_extract_structure($response_element);
    $method->structure($structure);
    my $example = Froody::Response::String->new;
    $example->set_string("<rsp status='ok'>".$response_element->toString(1)."</rsp>");
    $example->structure($method);
    
    $method->example_response($example);
    weaken($example->{structure});
  } else {
    $method->structure({})
  }

  my $desc = $method_element->findvalue("./description");
  $desc =~ s/^\s+//;
  $desc =~ s/\s+$//;
  $method->description($desc);

  return $method;

lib/Froody/API/XML.pm  view on Meta::CPAN

  # enforce msg (code is already in here!)
  push @{ $spec->{err}{attr} }, "msg";
  
  $et->structure($spec);

  my $example = Froody::Response::String->new;
  $et_element->setNodeName("err");
  my $text = "<rsp status='fail'>".$et_element->toString(1)."</rsp>";
  $example->set_bytes($text);
  $example->structure($et);
  weaken($example->{structure});
  
  $et->example_response($example);

  return $et;
}

=item parser

This method returns the parser we're using.  It's an instance of XML::LibXML.

lib/Froody/ErrorType.pm  view on Meta::CPAN

package Froody::ErrorType;
use base qw(Froody::Structure);
use strict;
use warnings;

use Scalar::Util qw(blessed weaken);

our $VERSION = 0.01;

__PACKAGE__->mk_accessors( "name", "message" );
sub code { my $self = shift; $self->name( @_ ) }
sub full_name { my $self = shift; $self->name( @_ ) }

sub init {
  my $self = shift;

lib/Froody/Walker.pm  view on Meta::CPAN

use strict;
use warnings;

use base 'Class::Accessor::Chained::Fast';

__PACKAGE__->mk_accessors(qw{spec method});

use Froody::Logger;
use Froody::Error;

use Scalar::Util qw(weaken);

my $logger = get_logger("froody.walker");

=head2 METHODS

=over

=item $self->walk($spec, $data)

Walks the structure of data with the source C<Froody::Walker::Driver>,

lib/Froody/Walker.pm  view on Meta::CPAN

Sets the source driver.

=cut

sub from {
  my $self = shift;
  
  if (@_) {
    $self->{from} = shift;
    $self->{from}{walker} = $self;
    weaken( $self->{from}{walker} );
    return $self
  }
  return $self->{from};
}

=item to (Froody::Walker::Driver)

Sets the target driver.

=cut

sub to {
  my $self = shift;
  
  if (@_) {
    $self->{to} = shift;
    $self->{to}{walker} = $self;
    weaken( $self->{to}{walker} );
    return $self;
  }
  return $self->{to};
}

=back

=head2 Utility methods

Small methods that get called a lot from subclasses.