root/lu/LUBundle.lua

--------------------------------------------------------------------------------
-- Title:               LUBundle.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 LUFile = require( "LUFile" )
local LUList = require( "LUList" )
local LUMap = require( "LUMap" )
local LUString = require( "LUString" )
local debug = require( "debug" )

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

-- class variable(s)
local _bundles = LUMap()

-- initialization method
function self:init( anEntity, aName )
        self = super.init( self )
        
        self._entity = anEntity
        self._name = aName
        
        return self
end

-- method to access this bundle underlying entity
function self:entity()
        return self._entity
end

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

-- method to retrieve this bundle name
function self:name()
        if self._name == nil then
                self._name = self:entity():className()
        end
        
        return self._name
end

-- method to retrieve this bundle path
function self:path()
        if self._path == nil then
                self._path = self:pathWithObject( self:entity() )
        end
        
        return self._path
end

-- method to access a file with a given name
function self:fileWithName( aName, aType, aDirectory, aLocale )
        local  aPath = self:path()
        
        if aDirectory ~= nil then
                aPath = aPath .. LUFile:separator() .. aDirectory
        end
        
        if aName ~= nil then
                if aLocale ~= nil then
                        aName = aName .. "." .. aLocale
                end
                
                if aType ~= nil then
                        aName = aName .. "." .. aType
                end
        end
        
        return LUFile( aPath, aName )
end

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

-- method to access all the known bundle names
function self:bundleNames()
        local somePackages = package[ "loaded" ]
        local aList = LUList()

        for aName, anEntity in pairs( somePackages ) do
                if LUObject:isObject( anEntity ) == true then
                        aList:add( aName )
                end
        end
        
        return aList:sort()
end

-- method to access the cached bundles
function self:bundles()        
        return _bundles
end

-- method to access a known bundle
function self:bundleWithName( aName )
        local someBundles = self:bundles()
        local aBundle = someBundles:get( aName )
        
        if aBundle == nil then
                local anEntity = package[ "loaded" ][ aName ]
                
                if anEntity == nil then
                        local aStatus, anError = pcall( require, aName )
                        
                        if aStatus == true then
                                anEntity = package[ "loaded" ][ aName ] 
                        else
                                return nil, anError
                        end
                end
                
                if LUObject:isObject( anEntity ) == true then
                        aBundle = self:new( anEntity, aName )
                        
                        someBundles:put( aName, aBundle )
                end
        end
        
        return aBundle
end

-- method to return a bundle for a given object
function self:bundleWithObject( anObject )
        if anObject ~= nil then
                return self:bundleWithName( anObject:className() )
        end
        
        return  nil
end

function self:pathWithObject( anObject )
        local aClass = anObject:class()

        for aKey, aValue in pairs( aClass ) do
                if LUString:startsWith( aKey, "_" ) == false and type( aValue ) == "function" then
                        return self:pathWithMethod( aValue )
                end
        end
        
        return nil
end

function self:pathWithMethod( aMethod )
        local someInfo = debug.getinfo( aMethod, "S" )
        local aPath = someInfo[ "source" ]
        
        if aPath ~= nil and LUString:startsWith( aPath, "@" ) == true then
                local someComponents = LUFile:pathComponents( aPath )
                
                if someComponents:size() > 1 then
                        aPath = someComponents:removeLast():join( LUFile:separator() )
                end
                
                return aPath:sub( 2, aPath:len() )
        end
        
        return nil
end

return self