Changeset 1027


Ignore:
Timestamp:
Apr 28, 2007, 1:58:08 PM (15 years ago)
Author:
kake
Message:

Added category and locale parameters to action=random and made a new macro to go with it.

Location:
trunk
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Build.PL

    r1020 r1027  
    361361                      "openguides_information_boxes.tt",
    362362                      "preferences.tt",
     363                      "random_page_failure.tt",
    363364                      "rdf_index.tt",
    364365                      "recent_changes.tt",
  • trunk/Changes

    r1026 r1027  
    55
    660.60
     7        Added new parameters to action=random - you can now supply category
     8          and/or locale to get a random page chosen from that category/locale.
     9        To go with this, added a new macro:
     10          @RANDOM_PAGE_LINK [[Category Pubs|View a random pub]]
    711        Fixed bug in OpenGuides::Feed - HTML equivalent link now works even
    812          if your script_name isn't blank.
  • trunk/MANIFEST

    r1023 r1027  
    6868templates/plain_index.tt
    6969templates/preferences.tt
     70templates/random_page_failure.tt
    7071templates/rdf_index.tt
    7172templates/recent_changes.tt
  • trunk/lib/OpenGuides.pm

    r1015 r1027  
    335335  $guide->display_random_page;
    336336
    337 Display a random page.  As with other methods, the
    338 C<return_output> parameter can be used to return the output instead of
    339 printing it to STDOUT.
     337Display a random page.  As with other methods, the C<return_output>
     338parameter can be used to return the output instead of printing it to STDOUT.
     339You can also restrict it to a given category and/or locale by supplying
     340appropriate parameters:
     341
     342  $guide->display_random_page(
     343                               category => "pubs",
     344                               locale   => "bermondsey",
     345                             );
     346
     347The values of these parameters are case-insensitive.
     348
     349You can make sure this method never returns pages that are themselves
     350categories and/or locales by setting C<random_page_omits_categories>
     351and/or C<random_page_omits_locales> in your wiki.conf.
    340352
    341353=cut
     
    346358    my $config = $self->config;
    347359
    348     my @nodes = $wiki->list_all_nodes();
     360    my ( @catnodes, @locnodes, @nodes );
     361    if ( $args{category} ) {
     362        @catnodes = $wiki->list_nodes_by_metadata(
     363            metadata_type  => "category",
     364            metadata_value => $args{category},
     365            ignore_case    => 1,
     366        );
     367    }
     368    if ( $args{locale} ) {
     369        @locnodes = $wiki->list_nodes_by_metadata(
     370            metadata_type  => "locale",
     371            metadata_value => $args{locale},
     372            ignore_case    => 1,
     373        );
     374    }
     375
     376    if ( $args{category} && $args{locale} ) {
     377        # If we have both category and locale, return the intersection.
     378        my %count;
     379        foreach my $node ( @catnodes, @locnodes ) {
     380            $count{$node}++;
     381        }
     382        foreach my $node ( keys %count ) {
     383            push @nodes, $node if $count{$node} > 1;
     384        }
     385    } elsif ( $args{category} ) {
     386        @nodes = @catnodes;
     387    } elsif ( $args{locale} ) {
     388        @nodes = @locnodes;
     389    } else {
     390        @nodes = $wiki->list_all_nodes();
     391    }
    349392
    350393    my $omit_cats = $config->random_page_omits_categories;
     
    376419    }
    377420    my $node = $nodes[ rand @nodes ];
    378     my $output = $self->redirect_to_node( $node );
     421    my $output;
     422
     423    if ( $node ) {
     424        $output = $self->redirect_to_node( $node );
     425    } else {
     426        my %tt_vars = (
     427                        category => $args{category},
     428                        locale   => $args{locale},
     429                      );
     430        $output = OpenGuides::Template->output(
     431            wiki     => $wiki,
     432            config   => $config,
     433            template => "random_page_failure.tt",
     434            vars     => \%tt_vars,
     435        );
     436    }
    379437    return $output if $args{return_output};
    380438    print $output;
  • trunk/lib/OpenGuides/Utils.pm

    r992 r1027  
    169169                      return qq(<a href="$script_name?action=index;format=map;index_type=) . uri_escape(lc($_[0])) . qq(;index_value=) . uri_escape($_[1]) . qq(">$link_title</a>);
    170170                },
     171        qr/\@RANDOM_PAGE_LINK(?:\s+\[\[(Category|Locale)\s+([^\]|]+)\|?([^\]]+)?\]\])?/ =>
     172                sub {
     173                      if ( UNIVERSAL::isa( $_[0], "Wiki::Toolkit" ) ) {
     174                          shift; # don't need $wiki
     175                      }
     176                      my ( $type, $value, $link_title ) = @_;
     177                      my $link = "$script_name?action=random";
     178
     179                      if ( $type && $value ) {
     180                          $link .= ";" . lc( uri_escape( $type ) ) . "="
     181                                . lc( uri_escape( $value ) );
     182                          $link_title ||= "View a random page in $type $value";
     183                      } else {
     184                          $link_title ||= "View a random page on this guide";
     185                      }
     186                      return qq(<a href="$link">$link_title</a>);
     187                },
    171188        qr/\@INCLUDE_NODE\s+\[\[([^\]|]+)\]\]/ =>
    172189            sub {
  • trunk/t/12_macros.t

    r956 r1027  
    1212}
    1313
    14 plan tests => 10;
     14plan tests => 15;
    1515
    1616SKIP: {
     
    8989                                  node    => "Test 1",
    9090                                  content => "\@MAP_LINK [[Category Foo]]",
     91                                  return_output => 1,
    9192                                );
    9293    OpenGuides::Test->write_data(
     
    9495                                  node    => "Test 2",
    9596                                  content => "\@MAP_LINK [[Category Foo|Map]]",
     97                                  return_output => 1,
    9698                                );
    9799    $output = $guide->display_node(
     
    106108                                  );
    107109    like( $output, qr/>Map<\/a>/, "...and can be overridden" );
     110
     111    # Test @RANDOM_PAGE_LINK
     112    OpenGuides::Test->write_data(
     113                                  guide   => $guide,
     114                                  node    => "Test Random",
     115                                  content => "\@RANDOM_PAGE_LINK",
     116                                  return_output => 1,
     117                                );
     118    $output = $guide->display_node(
     119                                    return_output => 1,
     120                                    id            => "Test Random",
     121                                  );
     122    like( $output, qr/View a random page on this guide/,
     123          "\@RANDOM_PAGE_LINK has right default link text" );
     124
     125    # Not sure yet how to let people override link text in the above.  TODO.
     126
     127    OpenGuides::Test->write_data(
     128                                  guide   => $guide,
     129                                  node    => "Test Random",
     130                                  content => "\@RANDOM_PAGE_LINK "
     131                                             . "[[Category Pubs]]",
     132                                  return_output => 1,
     133                                );
     134    $output = $guide->display_node(
     135                                    return_output => 1,
     136                                    id            => "Test Random",
     137                                  );
     138    like( $output, qr/View a random page in Category Pubs/,
     139          "\@RANDOM_PAGE_LINK has right default link text for categories" );
     140    OpenGuides::Test->write_data(
     141                                  guide   => $guide,
     142                                  node    => "Test Random",
     143                                  content => "\@RANDOM_PAGE_LINK "
     144                                             . "[[Category Pubs|Random pub]]",
     145                                  return_output => 1,
     146                                );
     147    $output = $guide->display_node(
     148                                    return_output => 1,
     149                                    id            => "Test Random",
     150                                  );
     151    like( $output, qr/>Random pub<\/a>/, "...and can be overridden" );
     152
     153    OpenGuides::Test->write_data(
     154                                  guide   => $guide,
     155                                  node    => "Test Random",
     156                                  content => "\@RANDOM_PAGE_LINK "
     157                                             . "[[Locale Fulham]]",
     158                                  return_output => 1,
     159                                );
     160    $output = $guide->display_node(
     161                                    return_output => 1,
     162                                    id            => "Test Random",
     163                                  );
     164    like( $output, qr/View a random page in Locale Fulham/,
     165          "\@RANDOM_PAGE_LINK has right default link text for categories" );
     166    OpenGuides::Test->write_data(
     167                                  guide   => $guide,
     168                                  node    => "Test Random",
     169                                  content => "\@RANDOM_PAGE_LINK "
     170                                             . "[[Locale Fulham|"
     171                                             . "Random thing in Fulham]]",
     172                                  return_output => 1,
     173                                );
     174    $output = $guide->display_node(
     175                                    return_output => 1,
     176                                    id            => "Test Random",
     177                                  );
     178    like( $output, qr/>Random thing in Fulham<\/a>/,
     179          "...and can be overridden" );
    108180
    109181    # Test @INCLUDE_NODE
     
    113185                                  content => "Hello, I am Test 1!\r\n"
    114186                                             . "\@INCLUDE_NODE [[Test 2]]",
     187                                  return_output => 1,
    115188                                );
    116189    OpenGuides::Test->write_data(
     
    118191                                  node    => "Test 2",
    119192                                  content => "Hello, I am Test 2!",
     193                                  return_output => 1,
    120194                                );
    121195    $output = $guide->display_node(
  • trunk/t/57_random_page.t

    r1015 r1027  
    1111}
    1212
    13 plan tests => 4;
     13plan tests => 8;
    1414
    1515my ( $config, $guide, $wiki );
     
    8787                       . "(this test may sometimes pass when it shouldn't)" );
    8888
     89# Now make sure we can pick things up from specific categories/locales if asked
     90refresh_db();
     91$config = OpenGuides::Test->make_basic_config;
     92$guide = OpenGuides->new( config => $config );
     93
     94OpenGuides::Test->write_data(
     95                              guide         => $guide,
     96                              node          => "Red Lion",
     97                              locales       => "Hammersmith",
     98                              categories    => "Pubs",
     99                              return_output => 1,
     100                            );
     101OpenGuides::Test->write_data(
     102                              guide         => $guide,
     103                              node          => "Poppy Hana",
     104                              locales       => "Bermondsey",
     105                              categories    => "Restaurants",
     106                              return_output => 1,
     107                            );
     108$output = $guide->display_random_page( category => "Pubs",
     109                                       return_output => 1 );
     110$node = get_node_from_output( $output );
     111print "# Random node chosen: $node\n";
     112is( $node, "Red Lion", "can ask for a random pub "
     113                       . "(this test may sometimes pass when it shouldn't)" );
     114
     115$output = $guide->display_random_page( locale => "Bermondsey",
     116                                       return_output => 1 );
     117$node = get_node_from_output( $output );
     118print "# Random node chosen: $node\n";
     119is( $node, "Poppy Hana", "can ask for a random thing in Bermondsey "
     120                       . "(this test may sometimes pass when it shouldn't)" );
     121
     122OpenGuides::Test->write_data(
     123                              guide         => $guide,
     124                              node          => "Stanley Arms",
     125                              locales       => "Bermondsey",
     126                              categories    => "Pubs",
     127                              return_output => 1,
     128                            );
     129$output = $guide->display_random_page( locale => "Bermondsey",
     130                                       category => "Pubs",
     131                                       return_output => 1
     132                                      );
     133$node = get_node_from_output( $output );
     134print "# Random node chosen: $node\n";
     135is( $node, "Stanley Arms", "can ask for a random pub in Bermondsey "
     136                       . "(this test may sometimes pass when it shouldn't)" );
     137
     138
     139$output = $guide->display_random_page( locale => "Islington",
     140                                       category => "Cinemas",
     141                                       return_output => 1
     142                                     );
     143unlike( $output, qr/Status: 302/,
     144       "don't get a redirect if we ask for category/locale with no pages in" );
     145
    89146sub refresh_db {
    90147    unlink "t/node.db";
  • trunk/wiki.cgi

    r1014 r1027  
    8686                          );
    8787    } elsif ($action eq 'random') {
    88         print $guide->display_random_page;
     88        print $guide->display_random_page(
     89                            category => $q->param( "category" ) || "",
     90                            locale   => $q->param( "locale" ) || "",
     91                                         );
    8992    } elsif ($action eq 'find_within_distance') {
    9093        $guide->find_within_distance(
Note: See TracChangeset for help on using the changeset viewer.