cache sorted order per column

[MojoFacets.git] / lib / MojoFacets / Data.pm

diff --git a/lib/MojoFacets/Data.pm b/lib/MojoFacets/Data.pm
index 4811467..70d4d03 100644 (file)
--- a/lib/MojoFacets/Data.pm
+++ b/lib/MojoFacets/Data.pm
@@ -103,19 +103,21 @@ sub _load_path {
        foreach my $e ( @{ $data->{items} } ) {
                foreach my $n ( keys %$e ) {
                        $stats->{$n}->{count}++;
+                       my @v;
                        if ( ref $e->{$n} eq 'ARRAY' ) {
-
                                $stats->{$n}->{array} += $#{ $e->{$n} } + 1;
-
-                               foreach my $x ( @{$e->{$n}} ) {
-                                       $stats->{$n}->{numeric}++
-                                               if $x =~ m/^[-+]?([0-9]*\.[0-9]+|[0-9]+)$/;
-                               }
-
+                               @v = @{ $e->{$n} };
                        } else {
+                               @v = ( $e->{$n} );
+                       }
+
+                       foreach my $x ( @v ) {
                                $stats->{$n}->{numeric}++
-                                       if $e->{$n} =~ m/^[-+]?([0-9]*\.[0-9]+|[0-9]+)$/;
+                                       if $x =~ m/^[-+]?([0-9]*\.[0-9]+|[0-9]+)$/;
+                               $stats->{$n}->{empty}++
+                                       if $x =~ m/^\s*$/;
                        }
+
                }
        }
 
@@ -180,7 +182,7 @@ sub _checked {
        my $self = shift;
        my $checked;
        $checked->{$_}++ foreach @_;
-       warn "# _checked ",dump($checked);
+#      warn "# _checked ",dump($checked);
        return $checked;
 }
 
@@ -188,6 +190,11 @@ sub _checked {
 sub columns {
     my $self = shift;
 
+       if ( $self->param('columns') ) {
+               $self->_perm_array('columns');
+               $self->redirect_to('/data/items');
+       }
+
        my $stats = $self->_loaded( 'stats' ); # || $self->redirect_to( '/data/index' );
 
        my @columns;
@@ -242,7 +249,7 @@ sub _perm_scalar {
                $self->session($name => $scalar);
        }
 
-       warn "# $name ",dump $scalar;
+       warn "# _perm_scalar $name ",dump $scalar;
        return $scalar;
 }
 
@@ -256,7 +263,9 @@ sub filter {
 
        if ( @vals ) {
                $filters->{$name} = [ @vals ];
+               warn "# filter + $name $#vals\n";
        } else {
+               warn "# filter - $name\n";
                delete $filters->{$name};
        }
 
@@ -269,10 +278,11 @@ sub filter {
 
 
 sub _data_items {
-       my $self = shift;
-       my $path = $self->session('path') || $self->redirect_to( '/data/index' );
+       my ( $self, $all ) = @_;
        my $data = $self->_loaded( 'data' );
 
+       return @{ $data->{items} } if $all == 1;
+
        my $filters = $self->_current_filters;
        my $filter_value;
        foreach my $f ( keys %$filters ) {
@@ -322,6 +332,38 @@ sub _current_filters {
        return $current_filters;
 }
 
+sub _data_sorted_by {
+       my ( $self, $order ) = @_;
+
+       my $path = $self->session('path');
+
+       if ( defined $loaded->{$path}->{sorted}->{$order} ) {
+               return $loaded->{$path}->{sorted}->{$order};
+       }
+
+       my $data = $self->_loaded( 'data' );
+       my $numeric = $self->_is_numeric($order);
+       my $missing = $numeric ? 0 : '';
+       no warnings qw(numeric);
+       my $nr = 0;
+       my @sorted = map {
+               $_->[0]
+       } sort {
+               if ( $numeric ) {
+                       $a->[1] <=> $b->[1]
+               } else {
+                       $a->[1] cmp $b->[1]
+               }
+       } map {
+               [ $nr++, exists $_->{$order} ? join('', @{$_->{$order}}) : $missing ]
+       } @{ $data->{items} }
+       ;
+
+       warn "sorted $order"; # ,dump( @sorted );
+
+       $loaded->{$path}->{sorted}->{$order} = [ @sorted ];
+}
+
 
 sub items {
        my $self = shift;
@@ -340,26 +382,24 @@ sub items {
        # fix offset when changing limit
        $offset = int( $offset / $limit ) * $limit;
 
-       # FIXME - multi-level sort
-       my $numeric = $self->_is_numeric($order);
-       my $missing = $numeric ? 0 : '';
-       no warnings qw(numeric);
-       my @sorted = sort {
-               my $v1 = exists $a->{$order} ? join('', @{$a->{$order}}) : $missing;
-               my $v2 = exists $b->{$order} ? join('', @{$b->{$order}}) : $missing;
-               ($v1,$v2) = ($v2,$v1) if $sort eq 'd';
-               $numeric ? $v1 <=> $v2 : $v1 cmp $v2 ;
-       } $self->_data_items;
+       my $sorted = $self->_data_sorted_by( $order );
 
-#      warn "# sorted ", dump @sorted;
+       my $rows = $#$sorted + 1;
 
-       my $rows = $#sorted + 1;
+       my @sorted;
+       foreach my $i ( 0 .. $limit ) {
+               my $pos = $sort eq 'a' ? ( $i + $offset ) : ( $#$sorted - $i - $offset );
+               last unless defined $sorted->[$pos];
+               push @sorted, $loaded->{$path}->{data}->{items}->[ $sorted->[$pos] ];
+       }
+
+#      warn "# sorted ", dump $sorted;
 
        $self->render(
                order => $order,
                offset => $offset,
                limit => $limit,
-               sorted => [ splice @sorted, $offset, $limit ],
+               sorted => [ @sorted ],
                columns => [ @columns ],
                rows => $rows,
                numeric => { map { $_, $self->_is_numeric($_) } @columns },
@@ -382,8 +422,10 @@ sub _is_numeric {
        my $stats = $self->_loaded( 'stats' );
 
        # sort facet numerically if more >50% elements are numeric
+       my $count = $stats->{$name}->{count};
+       $count   -= $stats->{$name}->{empty} if defined $stats->{$name}->{empty};
        defined $stats->{$name}->{numeric} &&
-               $stats->{$name}->{numeric} > $stats->{$name}->{count} / 2;
+               $stats->{$name}->{numeric} > $count / 2;
 }
 
 sub facet {
@@ -399,7 +441,9 @@ sub facet {
        my $facet;
        my $name = $self->param('name') || die "no name";
 
-       foreach my $i ( $self->_data_items ) {
+       my $all = $self->_perm_scalar('all', 1);
+
+       foreach my $i ( $self->_data_items($all) ) {
                if ( ! exists $i->{$name} ) {
                        $facet->{ _missing }++;
                } elsif ( ref $i->{$name} eq 'ARRAY' ) {
@@ -412,16 +456,19 @@ sub facet {
 #      warn "# facet $name ",dump $facet;
 
        my $checked;
-       if ( defined $filters->{$name} ) {
-               $checked = $self->_checked( @{ $filters->{$name} } );
-       }
+       my @facet_names =
+                 $all                      ? keys %$facet
+               : defined $filters->{$name} ? @{ $filters->{$name} }
+               : keys %$facet;
+
+       $checked = $self->_checked( @{ $filters->{$name} } ) if defined $filters->{$name};
 
        my $sort = $self->param('sort') || 'c';
 
        # sort facet numerically if more >50% elements are numeric
        my $numeric = $self->_is_numeric($name);
 
-       my @facet_names = sort {
+       @facet_names = sort {
                if ( $sort =~ m/a/i ) {
                        $numeric ? $a <=> $b : lc $a cmp lc $b;
                } elsif ( $sort =~ m/d/i ) {
@@ -432,12 +479,20 @@ sub facet {
                        warn "unknown sort: $sort";
                        $a cmp $b;
                }
-       } keys %$facet;
+       } @facet_names;
 
        $self->render( name => $name, facet => $facet, checked => $checked,
                facet_names => \@facet_names, sort => $sort, numeric => $numeric,
        );
 }
 
+sub edit {
+       my $self = shift;
+       my $content = $self->param('content');
+
+       $self->render(
+               content => $content
+       );
+}
 
 1;