module AttParser

# File lib/attparser.rb, line 92
def self.infer(infer, val)
        # $tm.hrm
        
        # early exit: don't infer
        infer or return val
        
        # true
        if val.downcase == 'true'
                return true
        
        # false
        elsif val.downcase == 'false'
                return false
                        
        # null or nil
        elsif (val.downcase == 'null') or (val.downcase == 'nil')
                return nil
                
        # integer
        elsif rv = Integer(val) rescue false
                return rv
        
        # float
        elsif rv = Float(val) rescue false
                return rv
                
        # else return value as is
        else
                return val
        end
end

# File lib/attparser.rb, line 11
def self.parse(raw, opts={})
        # $tm.hrm
        raw = raw.strip
        state = 'none'
        name = nil
        val = nil
        atts = {}
        infer = opts['infer']
        
        # split
        tokens = raw.split(/(\\")|(")|(\=)|(\s+)/mu)
        tokens = tokens.grep(/./mu)
        
        # loop through tokens
        tokens.each do |token|
                # state: none
                if state == 'none'
                        if token.match(/\S/mu)
                                name = token.downcase
                                val = nil
                                state = 'after-name'
                        end
                
                # state: after-name
                elsif state == 'after-name'
                        if token.match(/./mu)
                                if token == '='
                                        state = 'after-equals'
                                elsif token.match(/\S/mu)
                                        atts[name] = nil
                                        name = token
                                        val = nil
                                        state = 'after-name'
                                end
                        end
                
                # state: after-equals
                elsif state == 'after-equals'
                        if token == '"'
                                val = ''
                                state = 'in-quote'
                        elsif token.match(/\S/mu)
                                atts[name] = self.infer(infer, token)
                                name = val = nil
                                state = 'none'
                        end
                
                # state: in-quote
                elsif state == 'in-quote'
                        if token == '"'
                                atts[name] = val
                                name = val = nil
                                state = 'none'
                        elsif token == '\\"'
                                val += '"'
                        else
                                val += token
                        end
                
                # else unknown state
                else
                        raise 'uknown-state: ' + state
                end
        end
        
        # if name, add to atts
        if name
                atts[name] = nil
        end
        
        # return
        return atts
end