root/lang/perl/Google-Chart-DBIC/trunk/lib/Google/Chart/DBIC.pm @ 17834

package Google::Chart::DBIC;
use Moose;
use Google::Chart;
use Google::Chart::Types;
use Google::Chart::DBIC::Types;
use Data::Dumper ();
use POSIX ();
use Scalar::Util ();
our $VERSION = '0.01';

has 'size' => (
    is => 'rw',
    isa => 'Google::Chart::Size',
    coerce => 1,
    required => 1,
    default => sub {
        Class::MOP::load_class('Google::Chart::Size');
        Google::Chart::Size->new( width => 400, height => 400 );
    },
);
has 'type' => (
    is => 'rw',
    isa => 'Google::Chart::Type',
    coerce => 1,
    required => 1,
    default => sub { 
        Class::MOP::load_class('Google::Chart::Type::Line');
        Google::Chart::Type::Line->new;
    },
);
has 'color' => (
    is => 'rw',
    isa => 'Google::Chart::Color',
    coerce => 1,
    required => 1,
    default => sub {
        Class::MOP::load_class('Google::Chart::Color');
        my @default;
        for (1 .. 10) {
            push @default, (sprintf "%06X", rand() * 0xffffff);
        }
        Google::Chart::Color->new(values => \@default);
    },
);
has 'resultset' => (
    is => 'rw',
    isa => 'DBIx::Class::ResultSet',
    required => 1,
);
has 'min_value' => (
    is => 'rw',
    isa => 'Num',
);
has 'max_value' => (
    is => 'rw',
    isa => 'Num',
);
has 'axis_column' => (
    is => 'rw',
    isa => 'Str',
);
has 'key_column' => (
    is => 'rw',
    coerce => 1,
    isa => 'Google::Chart::DBIC::KeyColumn'
);

__PACKAGE__->meta->make_immutable;

no Moose;


sub __find_axis_column {
    my ($self, $row) = @_;

    my @primary = $self->resultset->result_source->primary_columns;
    my $axis_column = $self->axis_column || 'axis_x';

    if ( $row->has_column_loaded($axis_column))
    {
        # no op. we're fine
    } elsif (scalar @primary == 1) {
        # either we don't have a axis_column defined, or the
        # selected query did not use axis_column... but we have a
        # primary key
        $axis_column = $primary[0];
    } else {
        # In this case, as_uri() will Do The Right Thing
        $axis_column = undef;
    }

    return $axis_column;
}

sub as_uri {
    my $self = shift;
    my $dataset = {};
    my $axis_x = [];
    my $max_value = 0;
    my $min_value = 0;

    my $resultset = $self->resultset;
                      
    my $axis_column; # this will be calculated only once
    while (my $row = $resultset->next) {
        my $axis = '';

        $axis_column ||= $self->__find_axis_column( $row );
        $axis = $row->get_column($axis_column) if $axis_column;
        push @$axis_x, $axis unless grep {$_ eq $axis} @$axis_x;

#        if ($axis_column && scalar @primary > 1 && 
        for my $col ($row->columns) {
            next unless $row->has_column_loaded($col);
            next if $axis_column && $col eq $axis_column;
            my $v = $row->$col;
            next unless Scalar::Util::looks_like_number $v;
            my $k = $col;
            $k = join(':', map( {$row->get_column($_)} sort @{$self->key_column} ), $k) if $self->key_column;
            push @{$dataset->{$k}}, Scalar::Util::looks_like_number $v ? $v : undef;
            $max_value = $v if $v >= $max_value;
            $min_value = $v if $v < $min_value;
        }
    }
    $max_value = $self->max_value || $max_value;
    $min_value = $self->min_value || $min_value;
    my $chart = Google::Chart->new(
        size => $self->size,
        type => $self->type,
        axis => [
            {
                location => 'x',
                labels   => $axis_x ? $self->_roughen($axis_x, 5) : [],
            },
            {
                location => 'y',
                labels   => [ map { ($_ * ($max_value - $min_value)) + $min_value } map { 0.2 * $_ } (0 .. 5) ],
            }
        ],
        data => {
            module => 'Extended',
            args => {
                dataset => [values %$dataset],
                max_value => $max_value,
                min_value => $min_value,
            },
        },
#        color => [@{$self->color}[0 .. (scalar values %$dataset) - 1]],
        color => $self->color,
        legend => [keys %$dataset],
    );
    return $chart->as_uri;
}

sub _roughen {
    my ($self, $arr, $count) = @_;

    return $arr if scalar @$arr < ($count - 1);
    my $gap = POSIX::ceil($#{$arr}/ ($count - 1));
    my $ret = [];
    for my $i (0 .. $#{$arr}) {
        push @$ret, ($i % $#{$arr} && $i % $gap) ? '' : $arr->[$i];
    }
    return $ret;
}

1;
__END__

=head1 NAME

Google::Chart::DBIC - glue class for Google::Chart and DIBC

=head1 SYNOPSIS

  use TestApp::Schema;
  use Google::Chart::DBIC;

  my $schema = TestApp::Schema->connect(
      "dbi:SQLite:$dbfile"
  );
  my @list = TestApp::Schema->resultset('Climate')->search({
      place => 'Tokyo',
  }{
      select => ['high','low','month'],
      as => ['high','low','axis_x'],
  });
  my $chart = Google::Chart::DBIC->new({
      resultset => \@list,
      size => '300x400',
      type => 'line',
  });
  my $uri = $chart->as_uri;    

  
=head1 DESCRIPTION

Google::Chart::DBIC is glue class for Google::Chart and DBIC.

=head1 METHODS

=head2 new(%args)

Constructor.

=over 4

=item type

will be passed to Google::Chart constructor.

=item size

will be passed to Google::Chart constructor.

=item resultset

'looks_like_number' value in the resultset will be plotted on the chart. 
If there is a column named 'axis_x', it will be assigned as bottom axis of the chart.

=item max_value

specify max_value of the chart. defaults max value of the resultset.

=item color

specify color if you don't like default colors.

=item axis_column

specify column name to use as bottom axis of the chart.

=item key_column

specify column name to use as hash key.

=item value_column

specify column name to use as hash value.

=back

=head2 as_uri

Returns google chart uri.

=head1 AUTHOR

Author E<lt>nobuo.danjou@gmail.comE<gt>

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

=head1 SEE ALSO

L<Google::Chart>

=cut