File Coverage

blib/lib/Rubric/Entry.pm

Criterion	Covered	Total	%
statement	62	62	100.0
branch	14	14	100.0
condition	4	6	66.6
subroutine	20	20	100.0
pod	8	9	88.8
total	108	111	97.3

use strict;
use warnings;
package Rubric::Entry;
# ABSTRACT: a single entry made by a user
$Rubric::Entry::VERSION = '0.156';
use parent qw(Rubric::DBI);

use Class::DBI::utf8;

#pod =head1 DESCRIPTION
#pod
#pod This class provides an interface to Rubric entries.  It inherits from
#pod Rubric::DBI, which is a Class::DBI class.
#pod
#pod =cut

use Encode 2 qw(_utf8_on);
use Rubric::Entry::Formatter;
use String::TagString;
use Time::Piece;

__PACKAGE__->table('entries');

#pod =head1 COLUMNS
#pod
#pod  id          - a unique identifier
#pod  link        - the link to which the entry refers
#pod  username    - the user who made the entry
#pod  title       - the title of the link's destination
#pod  description - a short description of the entry
#pod  body        - a long body of text for the entry
#pod  created     - the time when the entry was first created
#pod  modified    - the time when the entry was last modified
#pod
#pod =cut

__PACKAGE__->columns(
  All => qw(id link username title description body created modified)
);

__PACKAGE__->utf8_columns(qw( title description body ));

#pod =head1 RELATIONSHIPS
#pod
#pod =head2 link
#pod
#pod The link attribute returns a Rubric::Link.
#pod
#pod =cut

__PACKAGE__->has_a(link => 'Rubric::Link');

#pod =head2 uri
#pod
#pod The uri attribute returns the URI of the entry's link.
#pod
#pod =cut

sub uri { my ($self) = @_; return unless $self->link; $self->link->uri; }

#pod =head2 username
#pod
#pod The user attribute returns a Rubric::User.
#pod
#pod =cut

__PACKAGE__->has_a(username => 'Rubric::User');

#pod =head2 tags
#pod
#pod Every entry has_many tags that describe it.  The C method will return the
#pod tags, and the C method will return the Rubric::EntryTag objects that
#pod represent them.
#pod
#pod =cut

__PACKAGE__->has_many(entrytags => 'Rubric::EntryTag');
__PACKAGE__->has_many(tags => [ 'Rubric::EntryTag' => 'tag' ]);

#pod =head3 recent_tags_counted
#pod
#pod This method returns a reference to an array of arrayrefs, each a (tag, count)
#pod pair for tags used on the week's 50 most recent entries.
#pod
#pod =cut

__PACKAGE__->set_sql(recent_tags_counted => <<'');
SELECT tag, COUNT(*) as count
FROM   entrytags
WHERE entry IN (SELECT id FROM entries WHERE created > ? LIMIT 100)
  AND tag NOT LIKE '@%%'
  AND entry NOT IN (SELECT entry FROM entrytags WHERE tag = '@private')
GROUP BY tag
ORDER BY count DESC
LIMIT 50

sub recent_tags_counted {
  my ($class) = @_;
  my $sth = $class->sql_recent_tags_counted;
  $sth->execute(time - (86400 * 7));
  my $result = $sth->fetchall_arrayref;
  return $result;
}

#pod =head1 INFLATIONS
#pod
#pod =head2 created
#pod
#pod =head2 modified
#pod
#pod The created and modified columns are stored as seconds since epoch, but
#pod inflated to Time::Piece objects.
#pod
#pod =cut

__PACKAGE__->has_a(
  $_ => 'Time::Piece',
  deflate => 'epoch',
  inflate => Rubric::Config->display_localtime ? sub { localtime($_[0]) }
                                               : sub { gmtime($_[0]) }
) for qw(created modified);

__PACKAGE__->add_trigger(before_create => \&_default_title);

__PACKAGE__->add_trigger(before_create => \&_create_times);
__PACKAGE__->add_trigger(before_update => \&_update_times);

sub _default_title {
  my $self = shift;
  $self->title('(default)') unless $self->{title}
}

sub _create_times {
  my $self = shift;
  $self->created(scalar gmtime) unless defined $self->{created};
  $self->modified(scalar gmtime) unless defined $self->{modified};
}

sub _update_times {
  my $self = shift;
  $self->modified(scalar gmtime);
}

#pod =head1 METHODS
#pod
#pod =head2 query(\%arg)
#pod
#pod The arguments to C provide a set of abstract constraints for the query.
#pod These are sent to Rubric::Entry::Query, which builds an SQL query and returns
#pod the result of running it.  (Either a list or an Iterator is returned.)
#pod
#pod (The built-in Class::DBI search method can't handle this kind of search.)
#pod
#pod  user   - entries for this User
#pod  tags   - entries with these tags (arrayref)
#pod  link   - entries for this Link
#pod  urimd5 - entries for the Link with this md5 sum
#pod  has_body    - whether entries must have bodies (T, F, or undef)
#pod  has_link    - whether entries must have a link (T, F, or undef)
#pod  (time spec) - {created,modified}_{before,after,on}
#pod                limits entries by time; given as a complete or partial
#pod                time and date string in the form "YYYY-MM-DD HH:MM"
#pod
#pod =cut

sub query {
  my $self = shift;
  require Rubric::Entry::Query;
  Rubric::Entry::Query->query(@_);
}

#pod =head2 set_new_tags(\%tags)
#pod
#pod This method replaces all entry's current tags with the new set of tags.
#pod
#pod =cut

sub set_new_tags {
  my ($self, $tags) = @_;
  $self->entrytags->delete_all;
  $self->update;

  while (my ($tag, $value) = each %$tags) {
    $self->add_to_tags({ tag => $tag, tag_value => $value });
  }
}

#pod =head2 tags_from_string
#pod
#pod   my $tags = Rubric::Entry->tags_from_string($string);
#pod
#pod This (class) method takes a string of tags, delimited by whitespace, and
#pod returns an array of the tags, throwing an exception if it finds invalid tags.
#pod
#pod Valid tags (shouldn't this be documented somewhere else instead?) may contain
#pod letters, numbers, underscores, colons, dots, and asterisks.  Hyphens me be
#pod used, but not as the first character.
#pod
#pod =cut

sub tags_from_string {
  my ($class, $tagstring) = @_;

  return {} unless $tagstring and $tagstring =~ /\S/;

  String::TagString->tags_from_string($tagstring);
}

#pod =head2 C< markup >
#pod
#pod This method returns the value of the entry's @markup tag, or C<_default> if
#pod there is no such tag.
#pod
#pod =cut

sub markup {
  my ($self) = @_;

  my ($tag)
    = Rubric::EntryTag->search({ entry => $self->id, tag => '@markup' });

  return ($tag and $tag->tag_value) ? $tag->tag_value : '_default';
}


#pod =head2 C< body_as >
#pod
#pod   my $formatted_body = $entry->body_as("html");
#pod
#pod This method returns the body of the entry, formatted into the given format.  If
#pod the entry cannot be rendered into the given format, an exception is thrown.
#pod
#pod =cut

sub body_as {
  my ($self, $format) = @_;

  my $markup = $self->markup;

  Rubric::Entry::Formatter->format({
    text   => $self->body,
    markup => $markup,
    format => $format
  });
}

sub accessor_name_for {
  my ($class, $field) = @_;

  return 'user' if $field eq 'username';

  return $field;
}

## return retrieve_all'd objects in recent-to-older order

__PACKAGE__->set_sql(RetrieveAll => <<'');
SELECT __ESSENTIAL__
FROM   __TABLE__
ORDER BY created DESC

sub tagstring {
  my ($self) = @_;
  String::TagString->string_from_tags({
    map {; $_->tag => $_->tag_value } $self->entrytags
  });
}

1;

__END__