set aTargKey to "machine_name"
set aTargGenre to "SPHardwareDataType"

set macRes to getSystemProfileInAGenre(aTargGenre, aTargKey) of me
–>　　"MacBook Pro"

on getSystemProfileInAGenre(aTargGenre, aTargKey)
　　set sRes to do shell script ("/usr/sbin/system_profiler -xml " & aTargGenre)
　　set aSource to (my readPlistFromStr:sRes) as list
　　set aaList to contents of first item of aSource
　　
　　set aList to _items of aaList
　　repeat with i in aList
　　　　set aDict to (current application’s NSMutableDictionary’s dictionaryWithDictionary:(contents of i))
　　　　set aKeyList to (aDict’s allKeys()) as list
　　　　if aTargKey is in aKeyList then
　　　　　　set aRes to (aDict’s valueForKeyPath:aTargKey)
　　　　　　if aRes is not equal to missing value then
　　　　　　　　return aRes as string
　　　　　　end if
　　　　end if
　　end repeat
　　
　　return false
end getSystemProfileInAGenre

–stringのplistを読み込んでRecordに
on readPlistFromStr:theString
　　set aSource to current application’s NSString’s stringWithString:theString
　　set pListData to aSource’s dataUsingEncoding:(current application’s NSUTF8StringEncoding)
　　set aPlist to current application’s NSPropertyListSerialization’s propertyListFromData:pListData mutabilityOption:(current application’s NSPropertyListImmutable) |format|:(current application’s NSPropertyListFormat) errorDescription:(missing value)
　　return aPlist
end readPlistFromStr:

set rssURL to current application’s |NSURL|’s URLWithString:"http://piyocast.com/as/feed"
set xpathQuery to current application’s CGXPathQuery’s alloc()’s initWithContentsOfURL:rssURL

set theRecord to {firstName:"Saga", lastName:"Norén", city:"Malmö"}
makeXMLDocWithRecord(theRecord)
–>
(*
"<?xml version=＼"1.0＼" encoding=＼"UTF-8＼" standalone=＼"yes＼"?>＼n<character>＼n <firstName>Saga</firstName>＼n <city>Malmö</city>＼n <lastName>Norén</lastName>＼n</character>"
*)

set theRecord to {firstName:"Saga", lastName:"Norén", city:"Malmö", partner:{firstName:"Martin", lastName:"Rohde", city:"København"}}
makeXMLDocWithRecord(theRecord)
–>
(*
"<?xml version=＼"1.0＼" encoding=＼"UTF-8＼" standalone=＼"yes＼"?>＼n<character>＼n <firstName>Saga</firstName>＼n <lastName>Norén</lastName>＼n <city>Malmö</city>＼n <partner>＼n <firstName>Martin</firstName>＼n <city>København</city>＼n <lastName>Rohde</lastName>＼n </partner>＼n</character>"
*)

–Record –> XML (text)
on makeXMLDocWithRecord(theRecord)
　　— make root element
　　set rootElement to current application’s NSXMLNode’s elementWithName:"character"
　　
　　— make XML document
　　set theXMLDocument to current application’s NSXMLDocument’s alloc()’s initWithRootElement:rootElement
　　theXMLDocument’s setDocumentContentKind:(current application’s NSXMLDocumentXMLKind)
　　theXMLDocument’s setStandalone:true
　　theXMLDocument’s setCharacterEncoding:"UTF-8"
　　
　　— make dictionary from record
　　set anNSDictionary to current application’s NSDictionary’s dictionaryWithDictionary:theRecord
　　
　　— add children to root element
　　its addChildTo:rootElement withDictionary:anNSDictionary
　　
　　— return as string with whatever formatting options you want
　　return (theXMLDocument’s XMLStringWithOptions:(current application’s NSXMLNodePrettyPrint)) as text
end makeXMLDocWithRecord

property dictStack : missing value — stack to hold array of dictionaries
property textInProgress : "" — string to collect text as it is found
property anError : missing value — if we get an error, store it here

set xmlRes to my makeRecordWithXML:(returnData() of me)
–> {|character|:{firstName:{|contents|:"Saga"}, lastName:{|contents|:"Norén"}, city:{|contents|:"Malmö"}, partner:{firstName:{|contents|:"Martin"}, lastName:{|contents|:"Rohde"}, city:{|contents|:"København"}, attributes:{approach:"dogged"}}}}

on makeRecordWithXML:xmlString
　　— set up properties
　　set my dictStack to current application’s NSMutableArray’s array() — empty mutable array
　　set anEmpty to current application’s NSMutableDictionary’s |dictionary|()
　　(my dictStack)’s addObject:anEmpty — add empty mutable dictionary
　　set my textInProgress to current application’s NSMutableString’s |string|() — empty mutable string
　　
　　— convert XML from string to data
　　set anNSString to current application’s NSString’s stringWithString:xmlString
　　set theData to anNSString’s dataUsingEncoding:(current application’s NSUTF8StringEncoding)
　　
　　— initialize an XML parser with the data
　　set theNSXMLParser to current application’s NSXMLParser’s alloc()’s initWithData:theData
　　
　　— set this script to be the parser’s delegate
　　theNSXMLParser’s setDelegate:me
　　
　　— tell it to parse the XML
　　set theResult to theNSXMLParser’s parse()
　　if theResult then — went OK, get first item on stack
　　　　return ((my dictStack)’s firstObject()) –as record
　　else — error, so return error
　　　　error (my anError’s localizedDescription() as text)
　　end if
end makeRecordWithXML:

— this is an XML parser delegate method. Called when new element found
on parser:anNSXMLParser didStartElement:elementName namespaceURI:aString qualifiedName:qName attributes:aRecord
　　— store reference to last item on the stack
　　set parentDict to my dictStack’s lastObject()
　　
　　— make new child
　　set childDict to current application’s NSMutableDictionary’s |dictionary|()
　　
　　— if there are attributes, add them as a record with key "attributes"
　　if aRecord’s |count|() > 0 then
　　　　childDict’s setValue:aRecord forKey:"attributes"
　　end if
　　
　　— see if there’s already an item for this key
　　set existingValue to parentDict’s objectForKey:elementName
　　
　　if existingValue is not missing value then
　　　　— there is, so if it’s an array, store it…
　　　　if (existingValue’s isKindOfClass:(current application’s NSMutableArray)) as boolean then
　　　　　　set theArray to existingValue
　　　　else
　　　　　　— otherwise create an array and add it
　　　　　　set theArray to current application’s NSMutableArray’s arrayWithObject:existingValue
　　　　　　parentDict’s setObject:theArray forKey:elementName
　　　　end if
　　　　
　　　　— then add the new dictionary to the array
　　　　theArray’s addObject:childDict
　　else
　　　　— add new dictionary directly to the parent
　　　　parentDict’s setObject:childDict forKey:elementName
　　end if
　　
　　— also add the new dictionary to the end of the stack
　　(my dictStack)’s addObject:childDict
end parser:didStartElement:namespaceURI:qualifiedName:attributes:

— this is an XML parser delegate method. Called at the end of an element
on parser:anNSXMLParser didEndElement:elementName namespaceURI:aString qualifiedName:qName
　　— if any text has been stored, add it as a record with key "contents"
　　if my textInProgress’s |length|() > 0 then
　　　　set dictInProgress to my dictStack’s lastObject()
　　　　dictInProgress’s setObject:textInProgress forKey:"contents"
　　　　
　　　　— reset textInProgress property for next element
　　　　set my textInProgress to current application’s NSMutableString’s |string|()
　　end if
　　
　　— remove last item from the stack
　　my dictStack’s removeLastObject()
end parser:didEndElement:namespaceURI:qualifiedName:

— this is an XML parser delegate method. Called when string is found. May be called repeatedly
on parser:anNSXMLParser foundCharacters:aString
　　— only append string if it’s not solely made of space characters (which should be, but aren’t, caught by another delegate method)
　　if (aString’s stringByTrimmingCharactersInSet:(current application’s NSCharacterSet’s whitespaceAndNewlineCharacterSet()))’s |length|() > 0 then
　　　　(my textInProgress)’s appendString:aString
　　end if
end parser:foundCharacters:

— this is an XML parser delegate method. Called when there’s an error
on parser:anNSXMLParser parseErrorOccurred:anNSError
　　set my anError to anNSError
end parser:parseErrorOccurred:

set aRec to {abc:"test", bcd:"test2", cde:"test3"}
set aJson to convRecToJson(aRec) of me as string
–>　　 "{"abc":"test","bcd":"test2","cde":"test3"}"

set bundleList to {"com.apple.filemerge", "com.barebones.bbedit", "com.barebones.textwrangler"}
set dummyList to {"fdummy", "bbedummy", "twdummy"}

set aDict to current application’s NSMutableDictionary’s dictionaryWithObjects:dummyList forKeys:bundleList
–>　　(NSDictionary) {​​​​​com.apple.filemerge:"fdummy", ​​​​​com.barebones.textwrangler:"twdummy", ​​​​​com.barebones.bbedit:"bbedummy"​​​}

set labelList to {"Address", "Names"}
set valueList to {"ここらへん", "ぴよまるさん"}

set theResult to current application’s NSDictionary’s dictionaryWithObjects:(valueList) forKeys:(labelList)
set aRec to theResult as record

set cRec to aRec & bRec
–> {fullName:"abc", anAge:46, aInfo:10}

–Case: same label (fullName) and different value ("abc", "def")
set dRec to {fullName:"abc", anAge:46}
set eRec to {fullName:"def", aInfo:10}

set fRec to dRec & eRec
–> {fullName:"abc", anAge:46, aInfo:10}

set aRec to {f1:"1", f2:"2", f3:"3"}
set bRec to addValueForKey(aRec, "100", "f10") of me
–>　　{​​​​​f1:"1", ​​​​​f3:"3", ​​​​​f10:"100", ​​​​​f2:"2"​​​}