http://beta-blog.net/2010/02/getting-rid-of-mts-permalink-file-extensions

/var/www/beta-blog.net/2010/02/getting-rid-of-mts-permalink-file-extensions.html

# DocumentRoot /var/www/beta-blog.net
RewriteEngine on
RewriteBase /
RewriteRule ^([^\.]+[^\/])$ $1.html [L]

That is, any request path not containing a dot and not ending with a trailing slash will be rewritten to the according HTML file. (Yes, that way I won't be able to serve permalinks containing dots, but I can live with that ;)

Now that's nice, but unfortunately, within MT you are not able to configure the looks of permalinks inedpendently from the file path. Nobody wants to remove the extension from the actual file, since the same directory might contain some .js, .jpg and other files mapped to their own content types as well. (And I have no idea how to set up an AddHandler directive exclusively respecting files without extension.) Therefore, the solution is to let MT add the configured extension to the actual file, but remove the extension from the permalink.

A blessing in disguise, one has to hack MT's source code itself, but it's a quite simple change to the archive_url method within MT's Entry module. Thus, applying the following patch to lib/MT/Entry.pm will remove .php/.html extensions from archive links:

--- MTOS-5.01-en.orig/lib/MT/Entry.pm   2010-02-14 01:17:24.000000000 +0100
+++ MTOS-5.01-en/lib/MT/Entry.pm        2010-02-14 01:58:58.000000000 +0100
@@ -541,7 +541,11 @@
     my $blog = $entry->blog() || return;
     my $url = $blog->archive_url || "";
     $url .= '/' unless $url =~ m!/$!;
-    $url . $entry->archive_file(@_);
+    #$url . $entry->archive_file(@_);
+    ## --> HACK: remove .php/.html extensions <-- ##
+    my $f = $entry->archive_file(@_);
+    $f =~ s/\.(php|html)$//;
+    $url . $f;
 }

 sub permalink {

Well, thats really a dirty hack and things will get more complicated with dynamic publishing. So, hopefully one day MT's developers will implement a cleaner solution and make it configurable through the webinterface. *hack*

Description

AutoSmileys is an easy to use and highly customizable macro environment for Movable Type. It will replace self-defined text abbreviations by image tags when your site is published or dynamically rendered, respectively. It may be applied either within entries, comments, pages, or any other part of your site.

AutoSmileys works with both static and dynamic publishing and has been tested with MT 4.2, MT 4.3, and MT 5.0 beta (Perl 5.8.8 / PHP 5.2.9). (Dynamic publishing with AutoSmileys requires PHP5 in either case.)

Download

http://source.beta-blog.net/autosmileys/0.9/AutoSmileys-0.9.zip

Installation

1. Download AutoSmileys-0.9.zip, unzip it and copy the AutoSmileys directory from the zip file into the plugins directory of your Movable Type installation.
2. Sign in to your Movable Type CMS.
3. For each blog you wish to use AutoSmileys in, select Design > Templates from the menu and open the desired template for editing.
4. Within each of these templates, enclose the desired parts with the <mt:AutoSmileys> ... </mt:AutoSmileys> block tag.
5. Republish your site.

So for instance, if you wish to have AutoSmileys replacement on your entry main body, edit the Entry template as follows:

Anyway you may also put the whole HTML body inside the AutoSmileys tag. This would also apply AutoSmileys to comments, since the Comments module template is included into the Entry template.

For general installation instructions concerning Movable Type, see http://www.movabletype.org/documentation/installation/.

Configuration

Once you have installed AutoSmileys, sign in to your Movable Type CMS and open the Tools > Plugins page. Whithin the AutoSmileys 0.9 panel, expand the Settings tab. By default, it will look as follows:

On the top of the form you may define HTML tag names whose content will be ignored in order to avoid inappropriate image tag placement. The list beneath consists of text abbreviations (tokens) and associated image source URLs.

Default smileys are taken from freesmileys.org. *thx*

You may change these entries as you like and you may also expand or shorten the list by clicking on the [+] and [-] links on the right hand side (JavaScript required).

The list may be expanded with up to 40 rows by default. You may increase the related parameter maxRows by editing AutoSmileys.pl. *hack*

Remarks

Remember that MT tags are applied after any text filter you may have set up for entries or comments. Hence, text filters such as Textile and Markdown would replace stuff like *lol* before AutoSmileys has a chance to see it.

Also, note that tokens are recognized only in the way you have defined them after standard HTML entity replacement has been applied. That is, &#58;&#45;&#41; will be displayed as :-) but not replaced.

How it works

The heart of AutoSmileys is a regular expression, dynamically created from the mappings of tokens to URLs defined as above. Once having these mappings collected within a Perl hash called %mappings, it's built as follows:

my $re_pattern = join '|',
  q/<(!)--(?:.|\n)*?-->/,          # markup comments
  q/<([^\s>]+)[^>]*?(\/)?\s*>/,    # markup tags
  map(quotemeta, keys %mappings);  # smileys

On a reasonably valid markup code this will replace any tokens outside markup tags, especially ignoring the content of specified tags inapplicable for containing image tags. Then,

s/($re_pattern)/&re_callback($1,$2,$3,$4)/eg;

does the job, using the following callback function:

my $expect;
sub re_callback
{
  my ($match, $comment, $tagname, $selfclosed) = @_;
  return $match if $comment || $selfclosed;
  if ( defined $tagname ) # non-self-closing markup tag
  {
    $tagname = lc $tagname; # ignore case
    if ( defined $expect )  # within ignorance state
    {
      undef $expect if $tagname eq $expect; # end ignorance state
      return $match;
    }
    $expect = qq</$tagname>
      if exists $ignoretags{$tagname}; # begin ignorance state
    return $match;
  }
  return $match if defined $expect || !(exists $mappings{$match});
  &{$Defaults->{image_tag}}($mappings{$match}, $match);
}

Here, $Defaults->{image_tag} is the actual image tag function. That's it 8-).

for, far, bar, foo, boofaz, boofar, boof, faz, foobaz, foobars, boofar

be your wordlist. Now, you may apply the according regualar expression:

(1) /\b(for|far|bar|foo|boofaz|boofar|boof|faz|foobaz|foobars|boofar)\b/

But which way a regex engine would implement the assignment? There are different options. The very worst algorithm would be surely to look up every word separately in the whole text. That would be the same as doing

foreach (qw( for far bar foo boofaz boofar boof faz foobaz foobars boofar ))
{
  return "matching!" if $text =~ m/\b$_\b/;
}
return "not matching.";

Assumed you would match m words against a text consisting of n letters, this peace of coding horror would have a runtime estimation of O(m*n).

Now, a better approach would be to run only once through the text, using a matching stack. Thus, assume " foobar " would appear somewhere in the text, the stack trace might look as follows then (read from bottom to top):

[7] ' ' => nothing matches.
[6] 'r' => "foobars" might match.
[5] 'a' => "foobaz" or "foobars" might match.
[4] 'b' => "foobaz" or "foobars" might match.
[3] 'o' => "foo", "foobaz", or "foobars" might match.
[2] 'o' => "for", "foo", "foobaz", or "foobars" might match.
[1] 'f' => "for", "far", "foo", "faz", "foobaz", or "foobars" might match.
[0] ' ' => "\b" matches.

So, but what if the wordlist is getting large? It seems that we should run nearly through the whole list each time a character is pushed onto the stack in order to find out whether the current stack contents still may be matched or not.

It's clear that a considerable optimization would be to sort the word list in advance. Moreover, instead of looking up one item after another, a really smart approach would be to walk downwards a search tree instead. As a tree, the wordlist above would appear like this:

          _____________|_____________
          |                         |
          b                         f
    ______|______        ___________|___________
    |           |        |                     |
   oof          ar       a                     o
    |                 ___|___            ______|______
    a ?               |     |            |           |
 ___|___              r     z            o           r
 |     |                                 |
 r     z                                 ba ?
                                     ____|____
                                     |       |
                                     rs      z

Here, the "?" denotes an optional node. Remember the length of the way downwards such a tree is in logarithmic relation to the number of nodes. Thus, loosely speeking, we have improved the worst algorithm above up to O(n*log(m)) at least.

Actually I'm not sure whether regex engines would apply optimizations like that when compiling. I guess they do, so it might be needless to replace the regex (1) above by the optimized version, implementing the sorted tree of alternative and optional nodes:

(2) /\b(b(?:ar|oof(?:a(?:r|z))?)|f(?:a(?:r|z)|o(?:o(?:ba(?:rs|z))?|r)))\b/

Nevertheless I couldn't help to create a little Perl routine that folds a wordlist into an optimized regex. Now, here it is:

sub foldWordsToRegex {

  local *toString = sub {
    ## node: [ prefix, [ nodes ], opt ]

    my ($prefix, $nodes, $opt) = ${$_[0]};
    my $rv = quotemeta $prefix;
    if ( ref $nodes eq q|ARRAY| && @$nodes )
    {
      $rv .= '(?:'.(join '|', map { toString($_) } @$nodes).')';
      $rv .= '?' if $opt;
    }
    $rv;
  };

  local *fold = sub(@_) {

    sub reduce($);
    local *reduce = sub {
      my ($prefix, $nodes, $opt) = ${$_[0]};

      return $_[0] unless ref $nodes eq q|ARRAY| && @$nodes > 1;

      ## 1st char of the prefix of 1st node in list
      my ($c, $qc);

      ## check whether 2nd prefix starts with same letter as the 1st
      if ( length $nodes->[0][0] )
      {
        $c = substr $nodes->[0][0], 0, 1;
        $qc = quotemeta $c;
        $nodes->[1][0] =~ m/^$qc/ or undef $c;
      }

      unless ( defined $c )
      {
        return $_[0] unless @$nodes > 2;

        ## try to reduce next list part
        my $first = shift @$nodes;
        my $next = reduce ['', $nodes, 0];
        return [ $prefix, [ $first, $next ], $opt] if length $next->[0];

        ## couldn't be reduced
        return [ $prefix, [ $first, ${$next->[1]} ], $opt ];
      }

      ## reduce any ensuing node whose prefix starts with $c
      my @new;
      my $newopt = 0;
      while ( @$nodes )
      {
        $nodes->[0][0] =~ s/^$qc// or last;

        ## reduce node or detect new optional node
        my $n = shift @$nodes;
        if ( length $n->[0] )
        {
          push @new, $n;
          next;
        }
        $newopt = 1;
      }

      if ( @$nodes || $opt )
      {
        my $new = reduce [ $c, [ @new ], $newopt ];
        if ( @$nodes )
        {
          ## reduce remaining nodes
          my $next = reduce ['', $nodes, 0];
          return [ $prefix, [ $new, $next ], $opt] if length $next->[0];

          ## couldn't be reduced
          return [ $prefix, [ $new, ${$next->[1]} ], $opt ];
        }

        ## current node is optional
        return [ $prefix, [ $new, @$nodes ], $opt ];
      }

      ## nothing left to reduce
      reduce [ $prefix.$c, [ @new ], $newopt ];
    };

    reduce [ '', [( map { [$_] } sort @_ )], 0];
  };

  toString(fold(@_));
};

Well, not so easy, but it works :)

Here, the inner recursion fold will create the actually tree, where nodes having the form of arrays consisting of prefix, subnodes and a flag denoting optional nodes. The second inner function toString then creates the actual regular expression string from that tree. So, for instance, calling

&foldWordsToRegex(qw( for far bar foo boofaz boofar boof faz foobaz foobars boofar ))

would return the regex (2).

"more than three words"

"more than three ..."

The solution is a simple regex, of course. In Perl style,

s/ˆ(\S+(?:\s+\S+){2})(\s+\S+)+/$1 .../

<$mt:EntryTitle regex_replace="/ˆ(\S+(?:\s+\S+){2})(\s+\S+)+/","$1&ensp;&hellip;"$>