File Coverage

blib/lib/DBIx/CSSQuery/Collection.pm

Criterion	Covered	Total	%
statement	7	9	77.7
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	10	12	83.3

package DBIx::CSSQuery::Collection;
use strict;
use DBI ":sql_types";
use DBIx::CSSQuery::DB;

use self;

sub new {
    return bless {
        db => DBIx::CSSQuery::DB->new(),
        selector => undef,
        sql_params => {
            order => "ORDER BY id ASC",
            limit => undef
        }
    }, $self;
}

sub get {
    my ($index) = @args;
    my $record;

    $self->each(
        sql_params => {
            limit => "$index,1"
        },
        callback => sub {
            $record = $_[0]
        }
    );

    return $record
}

sub insert {
    my %fields = @args;
    my $parsed = _parse_css_selector($self->{selector});
    my $p = $parsed->[0];

    my @fields = keys %fields;

    local $"= ",";
    my $sql = "INSERT INTO $p->{type} (@fields) VALUES (@{[ map {'?'} @fields ]})";
    my $dbh = $self->{db}->attr("dbh");
    my $sth = $dbh->prepare($sql);
    my $rv  = $sth->execute(map { $fields{$_} } @fields);

    return $self;
}

sub size {
    my $parsed = _parse_css_selector($self->{selector});
    my ($sql, $values) = _build_select_sql_statement($parsed, {
        select => "count(*)"
    });
    my $dbh = $self->{db}->attr("dbh");

    my $sth = $dbh->prepare( $sql );
    for my $i (0 .. $#{$values} ) {
        my $v = $values->[$i];
        $sth->bind_param($i+1, $v->[0], $v->[1]);
    }

    $sth->execute;
    my $record = $sth->fetchrow_hashref;
    return $record->{'count(*)'};
}

sub last {
    $self->{sql_params}{order} =~ s/ASC/DESC/;
    $self->{sql_params}{limit} = "0,1";
    return $self;
}

sub each {
    my %params;
    if (@args == 0) {
        return $self;
    }

    if (ref($args[0]) eq 'CODE') {
        $params{callback}= $args[0];
    }
    else {
        %params = @args;
    }

    my $cb = $params{callback};
    return $self unless defined $cb;

    my $parsed = _parse_css_selector($self->{selector});

    for(keys %{$self->{sql_params}}) {
        $params{sql_params}{$_} = $self->{sql_params}{$_};
    }

    my ($sql, $values) = _build_select_sql_statement($parsed, $params{sql_params});

    my $dbh = $self->{db}->attr("dbh");

    my $sth = $dbh->prepare( $sql );

    for my $i (0 .. $#{$values} ) {
        my $v = $values->[$i];
        $sth->bind_param($i+1, $v->[0], $v->[1]);
    }

    $sth->execute;
    while (my $record = $sth->fetchrow_hashref) {
        $cb->($record);
    }

    return $self;
}


sub _build_select_sql_statement {
    my ($parsed, $params) = @_;

    my $p = $parsed->[0];

    my @values = ();

    my $from  = " FROM $p->{type} ";
    my $where = "";
    if ($p->{attribute} =~ m/ \[ (.+) = (.+) \] /x ) {
        $where = " WHERE ";
        my $field = $1;
        my $val = $2;

        $where .= "$field = ?";
        my $type = SQL_INTEGER;
        if ($val =~ /^'(.+)'$/) {
            $val = $1;
            $type = SQL_VARCHAR;
        }
        push @values, [$val, SQL_INTEGER];
    }

    $params = {} if !defined($params);
    my $limit = defined($params->{limit}) ? " LIMIT $params->{limit}" : "";

    my $select = "SELECT * ";
    $select = "SELECT $params->{'select'} " if $params->{'select'};

    my $order = "ORDER BY id ASC";
    $order = " " . $params->{'order'} if $params->{'order'};

    return "${select}${from} ${where} ${order} ${limit}", \@values;
}

sub _parse_css_selector {
    my $selector = shift;
    my @sel =
        map { _parse_simple_css_selector($_) }
        split(/ /, $selector);
    return \@sel;
}

sub _parse_simple_css_selector {
    my $selector = shift;
    my $word = qr/[_a-z0-9]+/o;
    my $parsed = {
        type => "",
        class => "",
        id => "",
        attribute => "",
        special => ""
    };

    $selector =~ m{^(\*|$word)};
    $parsed->{type} = $1;

    while ( $selector =~ m{
                              \G
                              ( \#$word ) |                # ID
                              ( (?:\[ .+ \] )+ ) |         # attribute
                              ( (?:\.$word  )+ ) |         # class names
                              ( (?::$word(?: \(.+\))?)+ )  # special
                      }gx) {
        $parsed->{id} .= $1 ||"";
        $parsed->{attribute} .= $2 ||"";
        $parsed->{class} .= $3 ||"";
        $parsed->{special} .= $4 ||"";
    }

    return $parsed;
}

1;
__END__