Project

General

Profile

Feature #12843

Updated by nobu (Nobuyoshi Nakada) almost 5 years ago

We currently have `File.basename()` File.basename() and `File.dirname()`, File.dirname(), both of which 
 work very well and are quite useful when working with files and 
 directories. 

 When you want to get the filename without extension, you can use 
 something like this: 

 ```ruby 
 

     File.basename('foo/bar/test.rb', '.rb') 
 
     File.basename('foo/bar/test.rb', '.*') 
 ``` 

 While this works very well, I was wondering if it would be possible 
 to add a method that does precisely that for you but which requires 
 only one argument - the path. That would allow us to omit the ',' 
 and the second argument, which I think would be nice to have. 

 Resulting ruby code may be a tiny bit shorter: 

 ```ruby 
 

     File.basename('foo/bar/test.rb', '.*') 
 
     File.methodXY('foo/bar/test.rb') 
 ``` 

 Where `.methodXY()` .methodXY() should be the name of the new method added. 

 I would thus like to suggest a way for a new method addition, on the 
 class `File` File namespace, just like `.basename()` .basename() and `.dirname()`, .dirname(), that will 
 return the filename of a given path/file, but without any suffix and 
 without any path - so, similar to `File.basename()` File.basename() but to additionally 
 already chop away all extname suffixes. 

 Giving things a proper, meaningful name is often difficult. In 
 particular when method names should ideally be short; both 
 `.dirname` .dirname and `.basename` .basename are quite short too. 

 My obvious choice would be: 

 ```ruby 
 

     File.filename() 
 ``` 

 But I am not sure if this is a good name. A problem is that I 
 can not come up with a better name. 

 We also already have `File.extname()` File.extname() in order to determine the 
 "extension name" of the file. 

     https://ruby-doc.org/core-2.2.0/File.html#method-c-extname 

 So we essentially have 3 behaviours - obtain the name of the 
 directory via `.dirname`; .dirname; obtain the name of the file/entry itself, 
 via `.basename`; .basename; and being able to obtain the name of the extension 
 via `.extname`. .extname. 

 What we actually appear to be missing is to obtain the part 
 of the name of a path/file/directory WITHOUT the extension 
 and WITHOUT the leading    dirname part. 

 If `File.filename()` File.filename() is not a good name then perhaps any of the 
 following may serve as better alternatives; some are obviously 
 not really great names though, I add them mostly for comparison: 

 ```ruby 
 

     File.no_suffix() 
 
     File.corename() 
 
     File.corefile() 
 
     File.shortname() 
 
     File.short_name() 
 
     File.sname() 
 
     File.filename_without_extension() # Probably too verbose but 
    
       # probably more descriptive than the other names 
 ``` 

 Anyway, I guess the name of the method is one thing - if the 
 functionality itself would be approved, then I am sure a good 
 name can be found for the functionality anyway if none of 
  
 the above are very good choices. I just thought that it should 
 fit towards `.dirname` `.basename` .dirname .basename and `.extname`, .extname, hence why I put 
 `.filename` .filename first. 

 Thanks for reading! 

Back