root/lu/LUModule.lua

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

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

-- initialization method
function self:init( anEntity, aName )
        self = super.init( self )

        self._entity = anEntity
        self._name = aName
        
        return self
end

-- method to retrieve all the attribute names define by this module
function self:attributeNames()
        local aList = LUList()
        local anEntity = self:entity()
        
        for aName, anAttribute in pairs( anEntity ) do
                local aType = type( anAttribute )
                
                if aType ~= "function" and aType ~= "table" then
                        aList:add( aName )
                end
        end

        return aList:sort()
end

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

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

-- method to retrieve all the function names define by this module
function self:functionNames()
        local aList = LUList()
        local anEntity = self:entity()
        
        for aName, aFunction in pairs( anEntity ) do
                if type( aFunction ) == "function" then
                        aList:add( aName )
                end
        end

        return aList:sort()
end

-- method to retrieve this module name
function self:name()
        return self._name
end

-- method to check if this is a native module
function self:isNative()
        local aPath = self:path()
        
        if aPath ~= nil then
                if LUString:endsWith( aPath:lower(), ".lua" ) == true then
                        return false
                end
        end
        
        return true
end

-- method to retrieve this module path
function self:path()
        return nil
end

-- method to retrieve this module version
function self:version()
        local anEntity = self:entity()
        local aVersion = anEntity[ "_VERSION" ]
        
        if aVersion == nil then
                aVersion = anEntity[ "version" ]
        end
        
        return aVersion
end

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

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

        for aName, anEntity in pairs( somePackages ) do
                if aName == aName:lower() and type( anEntity ) == "table" then
                        aList:add( aName )
                end
        end
        
        return aList:sort()
end

-- method to access a known module
function self:moduleWithName( aName )
        local anEntity = package[ "loaded" ][ aName ]
        
        if aName == "_G" then
                anEntity = _G
        end
        
        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 type( anEntity ) == "table" then
                return self:new( anEntity, aName )
        end
        
        return nil
end

return self