drop given/when, too new

diff --git a/Build.PL b/Build.PL
index 1e24afc..84a88aa 100644 (file)
--- a/Build.PL
+++ b/Build.PL
@@ -7,7 +7,7 @@ my $build = Module::Build->new
      license     => "gpl",
      requires    =>
      {
-        'perl'        => '5.10.0',
+        'perl'        => 0,
         'Fuse'        => 0,
         'DBI'         => 0,
         'DBD::SQLite' => 0,

diff --git a/lib/ID3FS/Path.pm b/lib/ID3FS/Path.pm
index 68d94f1..2353b01 100644 (file)
--- a/lib/ID3FS/Path.pm
+++ b/lib/ID3FS/Path.pm
@@ -2,7 +2,6 @@ package ID3FS::Path;
 
 use strict;
 use warnings;
-use feature 'switch';
 use ID3FS::PathElement::Artist;
 use ID3FS::PathElement::Album;
 use ID3FS::PathElement::Boolean;
@@ -66,46 +65,44 @@ sub dirents
 {
     my($self)=@_;
     my @dents=();
-    print "DIRENTS: STATE: ",  $self->state(), "\n";
-    given($self->state())
+    my $state=$self->state();
+    print "DIRENTS: STATE: $state\n";
+    if($state==$STATE_TAG)
     {
-       when($STATE_TAG)
+       my $tag=$self->{elements}->[$#{$self->{elements}}];
+       if(defined($tag) && (ref($tag) eq "ID3FS::PathElement::Tag") &&
+          $self->{db}->tag_has_values($tag->{id}))
        {
-           my $tag=$self->{elements}->[$#{$self->{elements}}];
-           if(defined($tag) && (ref($tag) eq "ID3FS::PathElement::Tag") &&
-              $self->{db}->tag_has_values($tag->{id}))
-           {
-               print "DIRENTS: TAG: TAGVALUES\n";
-               @dents=$self->{db}->tag_values($tag->{id});
-           }
-           else
-           {
-               print "DIRENTS: TAG: ARTISTS\n";
-               @dents=(qw(AND ALLTRACKS), # FIXME: NOT and OR
-                       $self->{db}->artists(@{$self->{elements}}));
-           }
+           print "DIRENTS: TAG: TAGVALUES\n";
+           @dents=$self->{db}->tag_values($tag->{id});
        }
-       when($STATE_BOOLEAN)
+       else
        {
-           @dents=$self->{db}->tags(@{$self->{elements}});
-       }
-       when($STATE_ROOT)
-       {
-           @dents=("ALL", $self->{db}->tags(@{$self->{elements}}));
-       }
-       when($STATE_ALBUMS)
-       {
-           @dents=("TRACKS", $self->{db}->albums(@{$self->{elements}}));
-       }
-       when($STATE_TRACKLIST)
-       {
-           @dents=$self->{db}->tracks(@{$self->{elements}});
-       }
-       default
-       {
-           print "DIRENTS: UNHANDLED STATE: $_\n";
+           print "DIRENTS: TAG: ARTISTS\n";
+           @dents=(qw(AND ALLTRACKS), # FIXME: NOT and OR
+                   $self->{db}->artists(@{$self->{elements}}));
        }
     }
+    elsif($state==$STATE_BOOLEAN)
+    {
+       @dents=$self->{db}->tags(@{$self->{elements}});
+    }
+    elsif($state==$STATE_ROOT)
+    {
+       @dents=("ALL", $self->{db}->tags(@{$self->{elements}}));
+    }
+    elsif($state==$STATE_ALBUMS)
+    {
+       @dents=("TRACKS", $self->{db}->albums(@{$self->{elements}}));
+    }
+    elsif($state==$STATE_TRACKLIST)
+    {
+       @dents=$self->{db}->tracks(@{$self->{elements}});
+    }
+    else
+    {
+       print "DIRENTS: UNHANDLED STATE: $state\n";
+    }
     return(@dents);
 }
 
@@ -124,174 +121,150 @@ sub parse
     while(my $name=shift @parts)
     {
        print "NAME: $name\n";
-       given($self->state())
+       my $state=$self->state();
+       if($state==$STATE_INVALID)
+       {
+           print "SM: INVALID: $name\n";
+           return;
+       }
+       elsif($state==$STATE_ROOT)
        {
-           when($STATE_INVALID)
+           print "SM: ROOT: $name\n";
+           if($name eq "ALL")
            {
-               print "SM: INVALID: $name\n";
-               return;
+               $self->state($STATE_TAG);
            }
-           when($STATE_ROOT)
+           else
            {
-               print "SM: ROOT: $name\n";
-               if($name eq "ALL")
+               $tag=ID3FS::PathElement::Tag->new($self->{db}, $name);
+               if($tag)
                {
+                   push(@{$self->{elements}}, $tag);
                    $self->state($STATE_TAG);
                }
                else
                {
-                   $tag=ID3FS::PathElement::Tag->new($self->{db}, $name);
-                   if($tag)
-                   {
-                       push(@{$self->{elements}}, $tag);
-                       $self->state($STATE_TAG);
-                   }
-                   else
-                   {
-                       $self->state($STATE_INVALID);
-                   }
+                   $self->state($STATE_INVALID);
                }
            }
-           when($STATE_TAG)
+       }
+       elsif($state==$STATE_TAG)
+       {
+           print "SM: TAG: $name\n";
+           my $tag=$self->{elements}->[$#{$self->{elements}}];
+           if(defined($tag) &&
+              ref($tag) eq "ID3FS::PathElement::Tag" &&
+              $self->{db}->tag_has_values($tag->{id}))
            {
-               print "SM: TAG: $name\n";
-               my $tag=$self->{elements}->[$#{$self->{elements}}];
-               if(defined($tag) &&
-                  ref($tag) eq "ID3FS::PathElement::Tag" &&
-                  $self->{db}->tag_has_values($tag->{id}))
+               my $tagval=ID3FS::PathElement::Tagval->new($name);
+               if(defined($tagval))
                {
-                   my $tagval=ID3FS::PathElement::Tagval->new($name);
-                   if(defined($tagval))
-                   {
-                       $self->state($STATE_BOOLEAN);
-                       push(@{$self->{elements}}, $tagval);
-                   }
-                   else
-                   {
-                       $self->state($STATE_INVALID);
-                   }
+                   $self->state($STATE_BOOLEAN);
+                   push(@{$self->{elements}}, $tagval);
                }
                else
                {
-                   given($name)
-                   {
-                       when("AND")
-                       {
-                           $self->state($STATE_BOOLEAN);
-#                          push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($name));
-                       }
-                       when("ALLTRACKS")
-                       {
-                           $self->state($STATE_TRACKLIST);
-                       }
-                       when("OR")
-                       {
-                           $self->state($STATE_BOOLEAN);
-#                          push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($name));
-                       }
-                       when("NOT")
-                       {
-                           $self->state($STATE_TAG);
-#                      push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($name));
-                       }
-                       my $artist=ID3FS::PathElement::Artist->new($self->{db}, $name);
-                       if($artist)
-                       {
-                           push(@{$self->{elements}}, $artist);
-                           $self->state($STATE_ALBUMS);
-                       }
-                       else
-                       {
-                           $self->state($STATE_INVALID);
-                       }
-                   }
+                   $self->state($STATE_INVALID);
                }
            }
-
-#          when(255) #FIXME - dead code
-#          {
-#              my @valid_tagvals=$self->{db}->tag_values($tag);
-#              print "TAGVALUES: $name: ", join(', ', @valid_tagvals), "\n";
-#              if(@valid_tagvals)
-#              {
-#                  if(grep { $name eq $_; } @valid_tagvals)
-#                  {
-#                      print "TAGVAL VALID\n";
-#                      $self->state($STATE_TAGVAL);
-#                      push(@{$self->{elements}}, ID3FS::PathElement::Tagval($name));
-#                  }
-#                  else
-#                  {
-#                      print "ERROR: unknown tagval: $tagval\n";
-#                      $self->state($STATE_INVALID);
-#                  }
-#          }
-           when($STATE_TAGVAL)
+           elsif($name eq "ALLTRACKS")
            {
-               print "SM: TAGVAL: $name\n";
+               $self->state($STATE_TRACKLIST);
            }
-           when($STATE_BOOLEAN)
+           elsif($name eq "AND")
            {
-               print "SM: BOOLEAN: $name\n";
-               my $tag=ID3FS::PathElement::Tag->new($self->{db}, $name);
-               if($tag)
+               $self->state($STATE_BOOLEAN);
+#              push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($name));
+           }
+           elsif($name eq "OR")
+           {
+               $self->state($STATE_BOOLEAN);
+#              push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($name));
+           }
+           elsif($name eq "NOT")
+           {
+               $self->state($STATE_TAG);
+#              push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($name));
+           }
+           else
+           {
+               my $artist=ID3FS::PathElement::Artist->new($self->{db}, $name);
+               if($artist)
                {
-                   push(@{$self->{elements}}, $tag);
-                   $self->state($STATE_TAG);
+                   push(@{$self->{elements}}, $artist);
+                   $self->state($STATE_ALBUMS);
                }
                else
                {
                    $self->state($STATE_INVALID);
                }
            }
-           when($STATE_ALBUMS)
+       }
+       elsif($state==$STATE_TAGVAL)
+       {
+           print "SM: TAGVAL: $name\n";
+       }
+       elsif($state==$STATE_BOOLEAN)
+       {
+           print "SM: BOOLEAN: $name\n";
+           my $tag=ID3FS::PathElement::Tag->new($self->{db}, $name);
+           if($tag)
            {
-               print "SM: ALBUM: $name\n";
-               if($name eq "TRACKS")
-               {
-                   $self->state($STATE_TRACKLIST);
-               }
-               else
-               {
-                   my $album=ID3FS::PathElement::Album->new($self->{db}, $name);
-                   if($album)
-                   {
-                       push(@{$self->{elements}}, $album);
-                       $self->state($STATE_TRACKLIST);
-                   }
-                   else
-                   {
-                       $self->state($STATE_INVALID);
-                   }
+               push(@{$self->{elements}}, $tag);
+               $self->state($STATE_TAG);
                }
+           else
+           {
+               $self->state($STATE_INVALID);
            }
-           when($STATE_TRACKLIST)
+       }
+       elsif($state==$STATE_ALBUMS)
+       {
+           print "SM: ALBUM: $name\n";
+           if($name eq "TRACKS")
            {
-               print "SM: TRACKLIST: $name\n";
-               my $track=ID3FS::PathElement::File->new($self->{db}, $name);
-               push(@{$self->{elements}}, $track);
-               if($track)
+               $self->state($STATE_TRACKLIST);
+           }
+           else
+           {
+               my $album=ID3FS::PathElement::Album->new($self->{db}, $name);
+               if($album)
                {
-                   push(@{$self->{elements}}, $track);
-                   $self->state($STATE_FILE);
+                   push(@{$self->{elements}}, $album);
+                   $self->state($STATE_TRACKLIST);
                }
                else
                {
                    $self->state($STATE_INVALID);
                }
            }
-           when($STATE_FILE)
+       }
+       elsif($state==$STATE_TRACKLIST)
+       {
+           print "SM: TRACKLIST: $name\n";
+           my $track=ID3FS::PathElement::File->new($self->{db}, $name);
+           push(@{$self->{elements}}, $track);
+           if($track)
            {
-               print "SM: FILE: $name\n";
-               # Can't have anything after a filename
-               $self->state($STATE_INVALID);
+               push(@{$self->{elements}}, $track);
+               $self->state($STATE_FILE);
            }
-           default
+           else
            {
-               print "SM: ERROR: UNKNOWN STATE: $self->{state}\n";
                $self->state($STATE_INVALID);
            }
        }
+       elsif($state==$STATE_FILE)
+       {
+           print "SM: FILE: $name\n";
+           # Can't have anything after a filename
+           $self->state($STATE_INVALID);
+       }
+       else
+       {
+           print "SM: ERROR: UNKNOWN STATE: $self->{state}\n";
+           $self->state($STATE_INVALID);
+       }
     }
 }