root/lu/LUXMLInputStream.lua

--------------------------------------------------------------------------------
-- Title:               LUXMLInputStream.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 LUInputStream = require( "LUInputStream" )
local LUBundle = require( "LUBundle" )
local LUMap = require( "LUMap" )
local LUString = require( "LUString" )
local string = require( "string" )

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

-- class variable(s)
local _entities = nil

-- constant(s)
self.Tag = 1
self.EndTag = 2
self.Text = 3

-- initialization method
function self:init( aContent, anIndex, aLength )
        self = super.init( self, aContent, anIndex, aLength )
        
        self._type = self.Tag
        
        return self
end

-- method to read a tag
function self:read()
        local aContent = self:content()
        local anIndex = self:index()
        
        if self._type ~= self.Text then
                local aStart = aContent:find( "%b<>", anIndex )
                
                if aStart == nil then
                        aStart = self:length() + 1
                end
                
                if aStart ~= nil then
                        local aText = aContent:sub( anIndex, aStart - 1 )
                        
                        aText = LUString:trim( aText )
                        
                        if aText:len() > 0 then
                                aText = self:decode( aText )
                        
                                self:setIndex( aStart - 1 )
                                
                                self._type = self.Text
                                
                                return self.Text, aText
                        end
                end
        end

        do
                local aStart, anEnd = aContent:find( "%b<>", anIndex )
                
                if aStart ~= nil then
                        local aTag = aContent:sub( aStart, anEnd )
                        local someAttributes = nil
                        local aFunction = function ( aKey, _, aValue ) 
                                someAttributes = someAttributes or LUMap()
                                someAttributes:put( aKey:lower(), self:decode( aValue ) )
                        end
                        local aNameIndex = aTag:find( "[%c%s]+" ) or aTag:len() - 1
                        local aName = aTag:sub( 2, aNameIndex ):lower()

                        aName = LUString:trim( aName )
                        aName = aName:gsub( "/+$", "" )

                        self:setIndex( anEnd + 1 )
                        
                        -- as per http://lua-users.org/wiki/LuaXml
                        aTag:gsub( "(%w+)=([\"'])(.-)%2", aFunction )

                        if aName:sub( 1, 1 ) == "/" then
                                aName = aName:sub( 2, aName:len() )
                                
                                self._type = self.EndTag

                                return self.EndTag, aTag, aName, someAttributes
                        else
                                self._type = self.Tag

                                return self.Tag, aTag, aName, someAttributes
                        end
                end
        end

        return nil
end

-- method to read a text
function self:readChar()
        while true do
                local aType, aContent, aName, someAttributes = self:read()
                
                if aType == self.Text then
                        return aContent
                elseif aType == nil then
                        break
                end
        end
        
        return nil
end

-- private method to decode a given entity
local function CharWithEntity( aSymbol, anEntity )
        if aSymbol == "#" then
                local aCode = tonumber( ( anEntity:gsub( "^x", "0x" ) ) )

                if aCode ~= nil and aCode < 256 then
                        return string.char( aCode )
                end
        else
                local aValue = self:entities():get( anEntity )

                if aValue ~= nil then
                        return aValue
                end
        end
        
        return ( "&%s%s;" ):format( aSymbol, anEntity )
end

-- method to decode a given string
function self:decode( aString )
        if aString ~= nil then
                aString = aString:gsub( "&(#?)(%w+);", CharWithEntity )  
        end
        
        return aString
end

-- method to access the entities
function self:entities()
        if _entities == nil then
                local aBundle = LUBundle:bundleWithName( "LUXMLInputStream" )
                local aFile = aBundle:fileWithName( "LUXMLInputStream", "txt" )

                _entities = LUMap():load( aFile )
        end
        
        return _entities
end

return self