Acme-Web20-Validator

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

Changes
Makefile.PL
MANIFEST
README
t/00_compile.t
t/01_validate.t
lib/Acme/Web20/Validator.pm
lib/Acme/Web20/Validator/Rule.pm
lib/Acme/Web20/Validator/Rule/UsePrototype.pm
lib/Acme/Web20/Validator/Rule/UseCatalyst.pm
lib/Acme/Web20/Validator/Rule/UseRails.pm
lib/Acme/Web20/Validator/Rule/MentionsWeb20.pm
lib/Acme/Web20/Validator/Rule/UseLighttpd.pm
lib/Acme/Web20/Validator/Rule/HasAnyFeeds.pm
lib/Acme/Web20/Validator/Rule/ReferToDelicious.pm
lib/Acme/Web20/Validator/Rule/XHtmlStrict.pm

README  view on Meta::CPAN

        'Acme::Web20::Validator::Rule::UseCatalyst',
        ...
      );
      print $v->validation_report('http://web2.0validator.com/');
      printf "The score is %d out of %d", $validator->ok_count, $v->rule_size;

      ## OR

      my $v = Acme::Web20::Validator->new;
      $v->set_all_rules;
      $v->validate('http://web2.0validator.com/');
      print $v->validation_report;

      ## OR
      my $v = Acme::Web20::Validator->new;
      $v->set_all_rules;
      my @rules = $v->validate('http://web2.0validator.com/');
      print $_->name . "\t" . $_->is_ok for (@rules);

DESCRIPTION
    Acme::Web20::Validator is a Web 2.0 Validation module for your
    website. This module is inspired from Web 2.0 Validator
    (http://web2.0validator.com/).

    The definition of web 2.0 changes on a daily basis but currently
    supports are:

README  view on Meta::CPAN

    And the Rule is also pluggable with Module::Pluggable, so you can add
    any rules by yourself. For example:

      package Acme::Web20::Validator::Rule::MyRule;
      use strict;
      use warnings;
      use base qw (Acme::Web20::Validator::Rule);
      __PACKAGE__->name('Your rule's description');

      sub validate {
          my $self = shift;
          my $res = shift; ## HTTP::Response via LWP
          ...
          $self->is_ok(1) if ...;
      }

      1;

METHODS
  new

README  view on Meta::CPAN

        'Acme::Web20::Validator::Rule::UseCatalyst',
      )

    Adds validation rules to the validator.

  set_all_rules
      $v->set_all_rules;

    Adds Acme::Web20::Validator::Rule::* to the validator.

  validate
      my @rules = $v->validate($url);
      print $rules[0]->name;
      print $rules[0]->is_ok ? 'Yes!' : 'No';

    Validates the website and returns rules which know the result of each
    validation and rule's description.

  validation_report
      print $v->validation_report($url)

      ## OR
      $v->validate($url);
      print $v->validation_report;

    Returns a validation report formatted by Text::ASCIITable.

  rules_size
    Returns a number of rules validator has.

  ok_count
    Returns a number of OK after validation.

  clear
      $v->validation_report($url[0]);
      $v->clear;
      $v->validation_report($url[1]);
      $v->clear;
      ...

    Clears validation result in the instance for reusing. If you want to
    validate for other rules, create a new instance instead of reusing them.

SEE ALSO
    Module::Pluggable

AUTHOR
    Naoya Ito, <naoya@bloghackers.net>

    This library is free software; you can redistribute it and/or modify it
    under the same terms as Perl itself.

lib/Acme/Web20/Validator.pm  view on Meta::CPAN

use strict;
use warnings;
use base qw(Class::Accessor);
use Carp;
use LWP::UserAgent;
use Text::ASCIITable;
use Acme::Web20::Validator::Rule;

our $VERSION = 0.01;

__PACKAGE__->mk_accessors(qw(ua is_validated ok_count));

sub new {
    my $class = shift;
    my $self = bless {}, $class;
    $self->_init(@_);
    $self;
}

sub _init {
    my $self = shift;

lib/Acme/Web20/Validator.pm  view on Meta::CPAN

}

sub add_rule {
    my $self = shift;
    push @{$self->{_rules}}, @_;
}

sub clear {
    my $self = shift;
    $self->ok_count(0);
    $self->is_validated(0);
}

sub set_all_rules {
    shift->add_rule(Acme::Web20::Validator::Rule->new->plugins);
}

sub rules_size {
    my $self = shift;
    return scalar @{$self->{_rules}};
}

sub validate {
    my $self = shift;
    $self->is_validated and return @{$self->{_rules}};
    my $response = $self->_get_remote(@_);
    for my $rule (@{$self->{_rules}}) {
        unless (ref $rule) {
            eval "use $rule";
            if ($@) {
                warn $@;
                next;
            }
            $rule = $rule->new
        }
        $rule->validate($response);
        $self->ok_count($self->ok_count + 1) if $rule->is_ok;
    }
    $self->is_validated(1);
    return @{$self->{_rules}};
}

sub validation_report {
    my $self = shift;
    my @rules = $self->is_validated ? @{$self->{_rules}} : $self->validate(@_);
    my $t = Text::ASCIITable->new;
    $t->setCols('Rule', 'Result');
    $t->addRow($_->name, $_->is_ok ? 'Yes!' : 'No') for @rules;
    return $t->draw;
}

sub _get_remote {
    my $self = shift;
    my $url = shift or croak 'usage: $validator->validate($url)';
    my $response = $self->ua->get($url);
    croak "Could'nt get $url " . $response->status_line
        unless $response->is_success;
    return $response;
}

1;

__END__

lib/Acme/Web20/Validator.pm  view on Meta::CPAN

    'Acme::Web20::Validator::Rule::UseCatalyst',
    ...
  );
  print $v->validation_report('http://web2.0validator.com/');
  printf "The score is %d out of %d", $validator->ok_count, $v->rule_size;

  ## OR

  my $v = Acme::Web20::Validator->new;
  $v->set_all_rules;
  $v->validate('http://web2.0validator.com/');
  print $v->validation_report;

  ## OR
  my $v = Acme::Web20::Validator->new;
  $v->set_all_rules;
  my @rules = $v->validate('http://web2.0validator.com/');
  print $_->name . "\t" . $_->is_ok for (@rules);

=head1 DESCRIPTION

Acme::Web20::Validator is a Web 2.0 Validation module for your website.
This module is inspired from Web 2.0 Validator (http://web2.0validator.com/).

The definition of web 2.0 changes on a daily basis but currently
supports are:

lib/Acme/Web20/Validator.pm  view on Meta::CPAN

And the Rule is also pluggable with Module::Pluggable, so you can add
any rules by yourself. For example:

  package Acme::Web20::Validator::Rule::MyRule;
  use strict;
  use warnings;
  use base qw (Acme::Web20::Validator::Rule);
  __PACKAGE__->name('Your rule's description');

  sub validate {
      my $self = shift;
      my $res = shift; ## HTTP::Response via LWP
      ...
      $self->is_ok(1) if ...;
  }

  1;

=head1 METHODS

lib/Acme/Web20/Validator.pm  view on Meta::CPAN

  )

Adds validation rules to the validator.

=head2 set_all_rules

  $v->set_all_rules;

Adds Acme::Web20::Validator::Rule::* to the validator.

=head2 validate

  my @rules = $v->validate($url);
  print $rules[0]->name;
  print $rules[0]->is_ok ? 'Yes!' : 'No';

Validates the website and returns rules which know the result of each
validation and rule's description.

=head2 validation_report

  print $v->validation_report($url)

  ## OR
  $v->validate($url);
  print $v->validation_report;

Returns a validation report formatted by Text::ASCIITable.

=head2 rules_size

Returns a number of rules validator has.

=head2 ok_count

lib/Acme/Web20/Validator.pm  view on Meta::CPAN

=head2 clear

  $v->validation_report($url[0]);
  $v->clear;
  $v->validation_report($url[1]);
  $v->clear;
  ...

Clears validation result in the instance for reusing. If you want to
validate for other rules, create a new instance instead of reusing
them.

=head1 SEE ALSO

L<Module::Pluggable>

=head1 TODO

Improve Catalyst, Rails checking logic.
Add more rules.

lib/Acme/Web20/Validator/Rule.pm  view on Meta::CPAN

use strict;
use warnings;
use base qw (Class::Data::Inheritable Class::Accessor);
use Carp;
use Module::Pluggable search_path => ['Acme::Web20::Validator::Rule'] ;

__PACKAGE__->mk_classdata('name');
__PACKAGE__->mk_accessors(qw(is_ok));
__PACKAGE__->name(__PACKAGE__);

sub validate {
    croak "this method is abstract";
}

1;

__END__

lib/Acme/Web20/Validator/Rule/HasAnyFeeds.pm  view on Meta::CPAN

#$Id: HasAnyFeeds.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::HasAnyFeeds;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);
use Feed::Find;

__PACKAGE__->name('Syndicate with RSS or Atom feeds?');

sub validate {
    my ($self, $res) = @_;
    my $html = $res->content;
    my @feeds = Feed::Find->find_in_html(\$html, $res->base);
    $self->is_ok(scalar @feeds);
}

1;

lib/Acme/Web20/Validator/Rule/HasTrackbackURI.pm  view on Meta::CPAN

#$Id: HasTrackbackURI.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::HasTrackbackURI;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Has auto-discoverable Trackback URI?');

sub validate {
    my ($self, $res) = @_;
    while ($res->content =~ m!(<rdf:RDF.*?</rdf:RDF>)!sg) {
        my $rdf = $1;
        my $ping_url;
        if ($rdf =~ m!trackback:ping="(.+?)"!) {
            $ping_url = $1;
        } elsif ($rdf =~ m!about="(.+?)"!) {
            $ping_url = $1;
        }
        return $self->is_ok(1) if $ping_url;

lib/Acme/Web20/Validator/Rule/MentionsWeb20.pm  view on Meta::CPAN

#$Id: MentionsWeb20.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::MentionsWeb20;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Actually mentions Web 2.0?');

sub validate {
    my ($self, $res) = @_;
    $self->is_ok($res->content =~ m!web\s*2.0!i);
}

1;

lib/Acme/Web20/Validator/Rule/ReferToDelicious.pm  view on Meta::CPAN

#$Id: ReferToDelicious.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::ReferToDelicious;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Refers to del.icio.us?');

sub validate {
    my ($self, $res) = @_;
    $self->is_ok($res->content =~ m/del\.icio\.us/);
}

1;

lib/Acme/Web20/Validator/Rule/UseCSS.pm  view on Meta::CPAN

#$Id: UseCSS.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::UseCSS;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Using Cascading Style Sheet?');

sub validate {
    my ($self, $res) = @_;
    $self->is_ok($res->content =~ m!<link.*?rel="stylesheet".*?>!);
}

1;

lib/Acme/Web20/Validator/Rule/UseCatalyst.pm  view on Meta::CPAN

#$Id: UseCatalyst.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::UseCatalyst;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Appears to be built using Catalyst?');

sub validate {
    my ($self, $res) = @_;
    my $bool = 0;
    $bool = 1 if ($res->headers->header('X-Catalyst'));
    $self->is_ok($bool);
}

1;

lib/Acme/Web20/Validator/Rule/UseFeedBurner.pm  view on Meta::CPAN

#$Id: UseFeedBurner.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::UseFeedBurner;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);
use Feed::Find;

__PACKAGE__->name('Burning the feed by FeedBurner?');

sub validate {
    my ($self, $res) = @_;
    my $html = $res->content;
    my @feeds = Feed::Find->find_in_html(\$html, $res->base) or return;
    for (@feeds) {
        $self->is_ok(1) if m!^http://feeds\.feedburner\.com/!;
    }
}

1;

lib/Acme/Web20/Validator/Rule/UseLighttpd.pm  view on Meta::CPAN

#$Id: UseLighttpd.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::UseLighttpd;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Served by lighttpd?');

sub validate {
    my ($self, $res) = @_;
    $self->is_ok(
        $res->headers->header('Server') &&
        $res->headers->header('Server') =~ m!lighttpd!
    );
}

1;

lib/Acme/Web20/Validator/Rule/UsePrototype.pm  view on Meta::CPAN

#$Id: UsePrototype.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::UsePrototype;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Has prototype.js?');

sub validate {
    my ($self, $res) = @_;
    $self->is_ok($res->content =~ m/prototype\.js/);
}

1;

lib/Acme/Web20/Validator/Rule/UseRails.pm  view on Meta::CPAN

#$Id: UseRails.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::UseRails;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Appears to be built using Ruby on Rails?');

sub validate {
    my ($self, $res) = @_;
    $self->is_ok($res->content =~ m/ruby on rails/i);
}

1;

lib/Acme/Web20/Validator/Rule/XHtmlStrict.pm  view on Meta::CPAN

#$Id: XHtmlStrict.pm,v 1.1 2005/11/14 03:39:09 naoya Exp $
package Acme::Web20::Validator::Rule::XHtmlStrict;
use strict;
use warnings;
use base qw (Acme::Web20::Validator::Rule);

__PACKAGE__->name('Attempts to be XHTML Strict?');

sub validate {
    my ($self, $res) = @_;
    $self->is_ok($res->content =~ m|<!DOCTYPE.*?-//W3C//DTD XHTML 1\.0 Strict//EN.*?>|i);
}

1;

t/01_validate.t  view on Meta::CPAN

#$Id: 01_validate.t,v 1.1 2005/11/14 03:39:09 naoya Exp $
use strict;
use Test::More tests => 9;
use Acme::Web20::Validator;
use Acme::Web20::Validator::Rule;

my $url = 'http://www.cpan.org/';

my $validator = Acme::Web20::Validator->new;
my $rule = Acme::Web20::Validator::Rule->new;
my @rules = $rule->plugins;
ok(@rules);

$validator->add_rule(@rules);
is (scalar @rules, $validator->rules_size);

my @result = $validator->validate($url);

ok(@result);
is(scalar @result, $validator->rules_size);
isa_ok($result[0], 'Acme::Web20::Validator::Rule');
ok($validator->validation_report);
ok($validator->ok_count >= 0);
ok($validator->ok_count <= $validator->rules_size);

my $v = Acme::Web20::Validator->new;
$v->set_all_rules;