jakewilliami/hiddenfiles.jl

A cross-platform tool to determine if a file or directory is hidden

---

^{I have omitted shell and typescript in the above list of "Most Used Languages".}

hiddenfiles.jl's Issues

Consider storing stat results in a struct

Consider storing stat results in a struct rather than indexing the st_flags attribute directly.

Something like this (untested):

struct BSDStatStruct
    st_dev::UInt64
    st_mode::UInt64
    st_nlink::UInt64
    st_uid::UInt64
    st_gid::UInt64
    st_rdev::UInt64
    st_ino::UInt64
    st_size::UInt64
    st_blksize::UInt64
    st_blocks::UInt64
    st_flags::UInt64
    st_gen::UInt64
    st_atime::Int
    st_mtim::Int
    st_ctim::Int
    st_birthtim::Int
end

function _st_flags(f::AbstractString)
    stat_t = Ref{BSDStatStruct}()
    ccall(:jl_lstat, Cvoid, (Cstring, Ref{BSDStatStruct}), f, stat_t)
    return stat_t.x.st_flags
end

Write docstrings/documentation

Research/write BSD implementation of ishidden

I read somewhere that BSD, like macOS, is another UNIX system that needs a unique ishidden method. Ensure this is well-researched and implemented if needed.

Write macOS implementation of ishidden

macOS implementation is difficult, because it follows UNIX conventions whilst also having some other information.

As far as I can tell, the only other thing that determines whether a file is hidden in macOS is a certain attribute in finder flags. Once I finish this implementation, I should confirm with Stefan, as he may know about some other file attributes that we need to check (in his comment he mentions there are three, on top of the UNIX standard).

Related:

• GitHub - JuliaLang/julia: Issue #38841
• GitHub - JuliaLang/julia: stat.jl
• GitHub - JuliaLang/julia: sys.c
• Apple Developer Documentation - Hidden Files and Directories: Simplifying the User Experience
• StackOverflow - Is the file hidden?
• Apple Developer Documentation - kLSItemInfoIsInvisible
• Apple Developer Documentation - LSItemInfoRecord
• Apple Developer Documentation - LSItemInfoFlags
• Open Source Apple - hfs_format.h
• Apple Developer Documentation - fstat
• Apple Developer Documentation - chflags

Check if Windows implementation is correct

Despite finding resources to calculate the Windows implementation of is_hidden, I have found resources that may indicate we do not need to check for the existence of FILE_ATTRIBUTE_SYSTEM in the file's attributes.^{[1], [2]} We should investigate this to make sure the way we do it is correct.

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Write tests/implement CI/CD

Write tests for these functions! I think I will have to create files and make them hidden or not hidden, which might mean that I have to create whole functions to change file attributes. I should also test on directories and files.

Include option for checking if file is ignored

It might be out of scope of the current repo, but might be nice to include this functionality, similar to Rust's ignore crate.

Implement ishidden on ZFS for Linux

See also: #3, #12.

Refactor helper methods into subdirectory

Currently the main module is very messy. I would like to keep only the business logic in this file, and any helper methods tucked away in some subdirectory.

Prospective directory structure:

src
├── utils
│  └── darwin.jl
└── HiddenFiles.jl

Ensure directory references (. and ..) are hidden

I thought . and .. are symbolic links or something like that, but they actually exist in the file system, so I shouldn’t follow them/expand them! Therefore, anything whose base name is . or .. are actually hidden.

Enchancement: use CFStringGetCharacters over iteration and CFStringGetCharacterAtIndex

Currently we use CFStringGetCharacterAtIndex and iterate over the CF String to construct the String. This is obviously inefficient, and we should use CFStringGetCharacters instead.

Some example code which I haven't quite got working yet:

mutable struct CFRange
    length::Int
    location::Int
end
function _cfstring_get_characters(cfstr::Cstring, range::CFRange)
    charbuf = Vector{UInt8}(undef, range.length)
    ccall(:CFStringGetCharacters, Ptr{UInt32}, (Cstring, Ptr{Cvoid}, Ptr{Cvoid}), cfstr, pointer_from_objref(range), charbuf)
    return charbuf
end
function _string_from_cfstring(cfstr::Cstring, encoding::Unsigned = K_CFSTRING_ENCODING_MACROMAN)
    strlen = _cfstring_get_length(cfstr)
    maxsz = _cfstring_get_maximum_size_for_encoding(strlen, encoding)
    return _cfstring_get_characters(cfstr, CFRange(maxsz, 0))
end

Then, we will simple be able to write

function _string_from_cf_string(cfstr::Cstring)
    charbuf = _string_from_cfstring(cfstr)
    return String(charbuf)
end

Better error handling in inner functions

We should handle errors better in internal functions. E.g., see SystemError and Base.IOError. See also how realpath handles non-existent paths.

The worst case scenario is that we seg fault, as we are passing around pointers within C calls. Let's try to avoid this (at the very least) at all costs.

Implement ishidden on ZFS for BSD

See also: #3, #13.

Consider using ObjectiveC.jl

Currently I have implemented CF* structures and functions within Julia. It would be ideal if I could call Objective-C directly (using ObjectiveC.jl), however currently it appears this project has been abandoned.

Ensure string encoding for CFStrings work with non-UTF-8 pathnames

Unfortunately on macOS, to check for whether a path is a package or bundle, the MDItem* functions necessitate the use of CFStrings, and all of the joys that come with them. As I have had to implement these myself, they are probably not very robust.

In the interest of everyone who doesn't use the Latin alphabet, I should ensure the string interface with Apple's Core Foundation works robustly.

Determine whether children of hidden directories or bundles should be hidden

Some hidden files may be directories containing normal files. Are these normal files hidden, as their parent is?