lib/ID3FS/Path.pm

   1 package ID3FS::Path;
   2
   3 use strict;
   4 use warnings;
   5 use ID3FS::PathElement::Artist;
   6 use ID3FS::PathElement::Album;
   7 use ID3FS::PathElement::Boolean;
   8 use ID3FS::PathElement::File;
   9 use ID3FS::PathElement::Tag;
  10 use ID3FS::PathElement::Tagval;
  11
  12 our ($STATE_INVALID, $STATE_ROOT, $STATE_TAG, $STATE_TAGVAL,
  13      $STATE_BOOLEAN, $STATE_ALBUMS, $STATE_TRACKLIST,
  14      $STATE_FILE)=(0..7);
  15
  16 sub new
  17 {
  18     my $proto=shift;
  19     my $class=ref($proto) || $proto;
  20     my $self={};
  21     bless($self,$class);
  22
  23     $self->{db}=shift;
  24     $self->{path}=shift;
  25     $self->parse();
  26 #    print "STATE: ", $self->state(), "\n";
  27     return $self;
  28 }
  29
  30 sub isdir
  31 {
  32     my($self)=@_;
  33     if(($self->state() == $STATE_FILE) ||
  34        ($self->state() == $STATE_INVALID))
  35     {
  36         return 0;
  37     }
  38     return 1;
  39 }
  40
  41 sub isfile
  42 {
  43     my($self)=@_;
  44     return 1 if($self->state() == $STATE_FILE);
  45     return 0;
  46 }
  47
  48 sub isvalid
  49 {
  50     my($self)=@_;
  51     return($self->state() != $STATE_INVALID);
  52 }
  53
  54 sub dest
  55 {
  56     my($self, $mountpoint)=@_;
  57     if($self->state() == $STATE_FILE)
  58     {
  59         return $self->{db}->filename($mountpoint, @{$self->{elements}});
  60     }
  61     return "ERROR"; #should never happen?
  62 }
  63
  64 sub dirents
  65 {
  66     my($self)=@_;
  67     my @dents=();
  68     my $state=$self->state();
  69 #    print "DIRENTS: STATE: $state\n";
  70 #    print "DIRENTS: FILE: $self->{path}\n";
  71     if($state==$STATE_TAG || $state==$STATE_TAGVAL)
  72     {
  73         my $tag=$self->{elements}->[$#{$self->{elements}}];
  74         if($state==$STATE_TAG &&
  75            defined($tag) &&
  76            ref($tag) eq "ID3FS::PathElement::Tag" &&
  77            $self->{db}->tag_has_values($tag->{id}))
  78         {
  79             @dents=$self->{db}->tag_values($tag->{id});
  80         }
  81         else
  82         {
  83             @dents=(qw(AND OR TRACKS NOARTIST),
  84                     $self->{db}->artists(@{$self->{elements}}));
  85         }
  86     }
  87     elsif($state==$STATE_BOOLEAN)
  88     {
  89         my $parent=$self->{elements}->[$#{$self->{elements}}];
  90         unless(defined($parent) &&
  91                ref($parent) eq "ID3FS::PathElement::Boolean" &&
  92                $parent->{name} eq "NOT")
  93         {
  94             push(@dents, "NOT");
  95         }
  96         push(@dents, $self->{db}->tags(@{$self->{elements}}));
  97     }
  98     elsif($state==$STATE_ROOT)
  99     {
 100         @dents=(qw(ALL NOT), $self->{db}->tags(@{$self->{elements}}));
 101     }
 102     elsif($state==$STATE_ALBUMS)
 103     {
 104         @dents=(qw(TRACKS NOALBUM),$self->{db}->albums(@{$self->{elements}}));
 105     }
 106     elsif($state==$STATE_TRACKLIST)
 107     {
 108         @dents=$self->{db}->tracks(@{$self->{elements}});
 109     }
 110     else
 111     {
 112         print "DIRENTS: UNHANDLED STATE: $state\n";
 113     }
 114     return(@dents);
 115 }
 116
 117 sub parse
 118 {
 119     my($self)=@_;
 120     @{$self->{components}}=split(/\//, $self->{path});
 121     shift @{$self->{components}}; # drop empty field before leading /
 122 #    print "PATH: $self->{path}\n";
 123     $self->state($STATE_ROOT);
 124     return if($self->{path} eq "/");
 125     my @parts=@{$self->{components}};
 126     my($tag, $tagval);
 127     $self->{elements}=[];
 128     while(my $name=shift @parts)
 129     {
 130 #       print "NAME: $name\n";
 131         my $state=$self->state();
 132         if($state==$STATE_INVALID)
 133         {
 134 #           print "SM: INVALID: $name\n";
 135             return;
 136         }
 137         elsif($state==$STATE_ROOT)
 138         {
 139 #           print "SM: ROOT: $name\n";
 140             if($name eq "ALL")
 141             {
 142                 $self->state($STATE_TAG);
 143             }
 144             elsif($name eq "NOT")
 145             {
 146                 push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($self->{db}, $name));
 147                 $self->state($STATE_BOOLEAN);
 148             }
 149             else
 150             {
 151                 $tag=ID3FS::PathElement::Tag->new($self->{db}, $name);
 152                 if($tag)
 153                 {
 154                     push(@{$self->{elements}}, $tag);
 155                     $self->state($STATE_TAG);
 156                 }
 157                 else
 158                 {
 159                     $self->state($STATE_INVALID);
 160                 }
 161             }
 162         }
 163         elsif($state==$STATE_TAG || $state==$STATE_TAGVAL)
 164         {
 165 #           print "SM: TAG/TAGVAL($state): $name\n";
 166             my $tag=$self->{elements}->[$#{$self->{elements}}];
 167             if($state==$STATE_TAG &&
 168                defined($tag) &&
 169                ref($tag) eq "ID3FS::PathElement::Tag" &&
 170                $self->{db}->tag_has_values($tag->{id}))
 171             {
 172                 my $tagval=ID3FS::PathElement::Tag->new($self->{db}, $name, $tag->{id});
 173                 if(defined($tagval))
 174                 {
 175                     $self->state($STATE_TAGVAL);
 176                     # stay in tag state
 177                     push(@{$self->{elements}}, $tagval);
 178                 }
 179                 else
 180                 {
 181                     $self->state($STATE_INVALID);
 182                 }
 183             }
 184             elsif($name eq "TRACKS")
 185             {
 186                 $self->state($STATE_TRACKLIST);
 187             }
 188             elsif($name eq "NOARTIST")
 189             {
 190                 $self->state($STATE_TRACKLIST);
 191             }
 192             elsif($name eq "AND")
 193             {
 194                 $self->state($STATE_BOOLEAN);
 195                 push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($self->{db}, $name));
 196             }
 197             elsif($name eq "OR")
 198             {
 199                 $self->state($STATE_BOOLEAN);
 200                 push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($self->{db}, $name));
 201             }
 202             else
 203             {
 204                 my $artist=ID3FS::PathElement::Artist->new($self->{db}, $name);
 205                 if($artist)
 206                 {
 207                     push(@{$self->{elements}}, $artist);
 208                     $self->state($STATE_ALBUMS);
 209                 }
 210                 else
 211                 {
 212                     $self->state($STATE_INVALID);
 213                 }
 214             }
 215         }
 216         elsif($state==$STATE_BOOLEAN)
 217         {
 218 #           print "SM: BOOLEAN: $name\n";
 219             my $parent=$self->{elements}->[$#{$self->{elements}}];
 220             my $allownot=1;
 221             if(defined($parent) &&
 222                ref($parent) eq "ID3FS::PathElement::Boolean" &&
 223                $parent->{name} eq "NOT")
 224             {
 225                 $allownot=0;
 226             }
 227             if($allownot && $name eq "NOT")
 228             {
 229                 $self->state($STATE_BOOLEAN);
 230                 push(@{$self->{elements}}, ID3FS::PathElement::Boolean->new($self->{db}, $name));
 231             }
 232             else
 233             {
 234                 my $tag=ID3FS::PathElement::Tag->new($self->{db}, $name);
 235                 if($tag)
 236                 {
 237                     push(@{$self->{elements}}, $tag);
 238                     $self->state($STATE_TAG);
 239                 }
 240                 else
 241                 {
 242                     $self->state($STATE_INVALID);
 243                 }
 244             }
 245         }
 246         elsif($state==$STATE_ALBUMS)
 247         {
 248 #           print "SM: ALBUM: $name\n";
 249             if($name eq "TRACKS")
 250             {
 251                 $self->state($STATE_TRACKLIST);
 252             }
 253             elsif($name eq "NOALBUM")
 254             {
 255                 $self->state($STATE_TRACKLIST);
 256             }
 257             else
 258             {
 259                 my $album=ID3FS::PathElement::Album->new($self->{db}, $name);
 260                 if($album)
 261                 {
 262                     push(@{$self->{elements}}, $album);
 263                     $self->state($STATE_TRACKLIST);
 264                 }
 265                 else
 266                 {
 267                     $self->state($STATE_INVALID);
 268                 }
 269             }
 270         }
 271         elsif($state==$STATE_TRACKLIST)
 272         {
 273 #           print "SM: TRACKLIST: $name\n";
 274             my $track=ID3FS::PathElement::File->new($self->{db}, $name);
 275             if($track)
 276             {
 277                 push(@{$self->{elements}}, $track);
 278                 $self->state($STATE_FILE);
 279             }
 280             else
 281             {
 282                 $self->state($STATE_INVALID);
 283             }
 284         }
 285         elsif($state==$STATE_FILE)
 286         {
 287 #           print "SM: FILE: $name\n";
 288             # Can't have anything after a filename
 289             $self->state($STATE_INVALID);
 290         }
 291         else
 292         {
 293             print "SM: ERROR: UNKNOWN STATE: $self->{state}\n";
 294             $self->state($STATE_INVALID);
 295         }
 296     }
 297 }
 298
 299 sub state
 300 {
 301     my($self, $newstate)=@_;
 302     $self->{state}=$newstate if(defined($newstate));
 303     return $self->{state};
 304 }
 305
 306 1;