root/lu/LUFile.lua

--------------------------------------------------------------------------------
-- Title:               LUFile.lua
-- Description:         Like a square peg in a round hole
-- Author:              Raphaël Szwarc http://alt.textdrive.com/lua/
-- Creation Date:       February 1, 2005
-- Legal:               Copyright (C) 2005 Raphaël Szwarc
--------------------------------------------------------------------------------

-- import dependencies
local LUObject = require( "LUObject" )
local LUList = require( "LUList" )
local LUString = require( "LUString" )
local io = require( "io" )
local math = require( "math" )
local os = require( "os" )

-- define the class
local super = LUObject
local self = super()

-- class variable(s)
local _separator = nil
local _tmpDir = nil

-- initialization method
function self:init( aDirectory, aFile )
        self = super.init( self )

        if aDirectory ~= nil then
                aDirectory = tostring( aDirectory )
        end

        if aFile ~= nil then
                aFile = tostring( aFile )
        end
        
        self._directory = aDirectory
        self._file = aFile
        
        return self
end
        
-- method to access this file content as a "lua chunck"
function self:chunk()
        local aContent, aStatus = self:content()
        
        if aContent ~= nil then
                local aChunk, aStatus = loadstring( aContent )

                if aChunk ~= nil then
                        return aChunk
                else
                        return nil, aStatus
                end
        end
        
        return nil, aStatus
end

-- method to access this file content
function self:content()
        local aPath = self:path()
        local aFile, aStatus = io.open( aPath, "rb" )

        if aFile ~= nil then
                local aContent = aFile:read( "*all" )
                
                aFile:close()
                
                return aContent
        end
        
        return nil, aStatus
end

-- method to set this file content
function self:setContent( aContent )
        local aPath = self:path()
        local aFile, aStatus = io.open( aPath, "wb" )

        if aFile ~= nil then
                aFile:write( aContent or "" )
                aFile:close()
                
                return self
        end
        
        return nil, aStatus
end

-- method to copy this file
function self:copy( aFile, shouldDelete )
        if aFile ~= nil and self ~= aFile then
                local aContent, aStatus = self:content()
                
                if aContent ~= nil then
                        local aFile, aStatus = aFile:setContent( aContent )
                        
                        if aFile ~= nil and aFile:exists() == true then
                                if shouldDelete == true then
                                        return self:delete()
                                end
                        
                                return true
                        end

                        return false, aStatus
                end
                
                return false, aStatus
        end
        
        return false, "nil file"
end

-- method to delete this file
function self:delete()
        local aPath = self:path()
        local aValue, aStatus = os.remove( aPath )
        
        if aStatus == nil then
                return true
        end
        
        return false, aStatus
end

-- method to access the directory of this file
function self:directory()
        if self._directory == nil then
                self._directory = "."
        end

        return self._directory
end

-- method to compare the given object with this object for equality
function self:equals( anObject )
        if self:isKindOf( anObject ) == true then
                if self:path() == anObject:path() then
                        return true
                end
        end
        
        return false
end

-- method to check if this file exists
function self:exists()
        local aPath = self:path()
        local aFile, aStatus = io.open( aPath, "r" )
        
        if aFile ~= nil then
                aFile:close()
                
                return true
        end
        
        return false, aStatus
end

-- method to access this file extension
function self:extension()
        local aName = self:pathComponents():last()
        local anExtension = aName:match( "^.+%.(%w+)$" )

        return anExtension
end

-- method to check if this file path is absolute
function self:isAbsolute()
        if LUString:startsWith( self:directory(), "." ) == false then
                return true
        end
        
        return false
end

 -- method to check if this file is a directory
function self:isDirectory()
        if self._file == nil then
                return true
        end
        
        return false
end

-- method to check if this file is a file
function self:isFile()
        if self._file ~= nil then
                return true
        end
        
        return false
end

-- method to move this file
function self:move( aFile )
        return self:copy( aFile, true )
end

        
-- method to access the name of this file
function self:name()
        if self._name == nil then
                if self._file ~= nil then
                        self._name = self._file
                else
                        self._name = self:pathComponents():last()
                end
        end
        
        return self._name
end

-- method to access this directory parent 
function self:parentDirectory()
        local aSeparator = self:separator()
        local aPath = self:path()
        
        if aPath ~= aSeparator then
                local anIndex = aPath:reverse():find( aSeparator, 1, true )
                
                if anIndex ~= nil then
                        aPath = aPath:sub( 1, aPath:len() - anIndex )
                        
                        if aPath:len() == 0 then
                                aPath = aSeparator
                        end
                        
                        return aPath
                end
        end
        
        return nil
end

-- method to access the path of this file
function self:path()
        local aSeparator = self:separator()
        local aPath = self:directory()
                
        if self._file ~= nil then
                aPath = aPath .. aSeparator
                aPath = aPath .. self._file
        end
        
        aPath = aPath:gsub( "%.%.", "" )
        aPath = aPath:gsub( "%" .. aSeparator .. "%" .. aSeparator, aSeparator )
        
        return aPath
end

-- method to access the path components of this file
function self:pathComponents( aPath, aSeparator )
        aPath = aPath or self:path()
        aSeparator = aSeparator or self:separator()

        return LUString:components( aPath, aSeparator )
end

-- method to rename this file
function self:rename( aFile )
        local aPath = tostring( aFile )
        local aValue, aStatus = os.rename( self:path(), aPath )
        
        if aStatus == nil then
                return true
        end
        
        return false, aStatus
end

-- method to compute this file size
function self:size()
        local aFile, aStatus = io.open ( self:path(), "rb" )
        
        if aFile ~= nil then
                local aSize = aFile:seek( "end" )
                
                aFile:close()
                
                if aSize ~= nil then
                        return aSize
                end
        end
        
        return -1, aStatus
end

-- method for string representation
function self:toString()
        return self:path()
end

-- method for URI representation
function self:toURI()
        local LUURI = require( "LUURI" )
        local aPath = LUURI:pathWithComponents( self:pathComponents(), true, self:isDirectory() )
        
        return LUURI( "file://" .. aPath )
end

-- method to access the system dependent name separator
function self:separator()
        if _separator == nil then
                _separator = package.path:match( "(%p)%?%." ) or "/"
        end
        
        return _separator
end

-- method to access the system dependent temporary directory
function self:tmpDir()
        if _tmpDir == nil then
                _tmpDir = self:new( os.tmpname() ):parentDirectory()
        end
        
        return _tmpDir
end

-- method to generate a temporary file name
function self:tmpName( aPrefix, aSuffix )
        local aComponent = self:pathComponents( os.tmpname() ):last()
        local aBuffer = LUList()
        
        math.random( math.pi )
        
        if aPrefix ~= nil then
                aBuffer:add( aPrefix )
        end
        
        aBuffer:add( aComponent )
        aBuffer:add( ( "%x" ):format( math.random( ( os.clock() + 1 ) * math.pi ) ) )
        aBuffer:add( ( "%x" ):format( math.random( os.time() + 1 ) ) )

        if aSuffix ~= nil then
                aBuffer:add( aSuffix )
        end
        
        return aBuffer:join( "." )
end

-- method to access a temporary file
function self:tmpFile( aPrefix, aSuffix )
        return self:new( self:tmpDir(), self:tmpName( aPrefix, aSuffix ) )
end

return self