• SSYWeblocGuy has new factored-out method to support parsing one file at a time, which is needed to preserve hierarchy when parsing folders of .webloc files.

jerrykrinock · jerrykrinock · commit 59454ffe586c · 2016-08-10T21:20:21.000-07:00
•  SSYWeblocGuy now does proper parsing of XML instead of cheesily grabbing the last string.
diff --git a/SSYWeblocGuy.h b/SSYWeblocGuy.h
@@ -3,21 +3,22 @@
 
 @interface SSYWeblocGuy : NSObject <NSXMLParserDelegate> {
     NSMutableString* m_xmlString ;
-    BOOL m_accumulatingUrl ;
 }
 
 /*!
- @brief    Returns an array of dictionaries, each containing the filename and
- URL extracted from any .webloc file found in a given array of file paths
+ @brief    Returns a dictionary containing the URL and name represented by
+ a .webloc file at a given path
  
- @details  Each element in the result is a dictionary which contains objects
- for two keys, "url" which is the url extracted from the .webloc file, and
- "filename" which is the base name of the .webloc file, without the path
- and without the .webloc extension.
+ @details  The returned dictionary contains objects for two keys, "url" which
+ is the url extracted from the .webloc file, and "filename" which is the base
+ name of the .webloc file, without the path and without the .webloc extension.
  
+ If the given file's name does not have the .webloc extension, or does not
+ XML containing a URL as expected for a .webloc file, returns nil.
+
  This method extracts the URL from XML in the data fork which is assumed to
  look like this example.
-
+ 
  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
  <plist version="1.0">
@@ -26,16 +27,20 @@
  <string>http://ancienthistory.about.com/od/cityofrome/ss/7hillsofRome.htm</string>
  </dict>
  </plist>
-
+ 
  It simply parses whatever is in the last <string>.  TODO: Do a proper parsing,
  looking for the <string> element of the <dict> element of the <plist> element.
-
+ 
  Although ancient versions of Safari created .webloc files with the target URL
  in the resource fork instead of the data fork, this method no longer supports
- that.
- */
-
+ that. */
++ (NSDictionary*)filenameAndUrlFromWeblocFileAtPath:(NSString*)path ;
 
+/*!
+ @brief    Returns an array of dictionaries, each containing the filename and
+ URL extracted from any .webloc file found in a given array of file paths by
+ -filenameAndUrlFromWeblocFileAtPath:.
+ */
 + (NSArray*)weblocFilenamesAndUrlsInPaths:(NSArray*)paths ;
 
 @end
diff --git a/SSYWeblocGuy.m b/SSYWeblocGuy.m
@@ -1,18 +1,41 @@
 #import "SSYWeblocGuy.h"
 
+/* Prior to 2016-08-10, this class did not have a proper state machine for
+ parsing the XML expected in a .webloc file.  I just took the last string that
+ was parsed.  This worked because there are only two strings in the file:
+    <key>URL</key>
+    <string>http://www.example.com</string>
+ and the second one was the one I wanted.  And so I marked a TODO to fix
+ this someday.
+ 
+ Now, it is fixed, but I'm no sure if it is better or worse.  The goal is to
+ future-proof in case Apple changes the .webloc format.  But after looking at
+ this state machine, I'm not sure it's really any more future proof.  It is
+ definitely less cheesy.  Oh, well, the old code is in git if I want to go back.
+ */
+
+typedef enum {
+    SSYWeblocParserStateZero,
+    SSYWeblocParserStateInPlist,
+    SSYWeblocParserStateInDict,
+    SSYWeblocParserStateParsingAKey,
+    SSYWeblocParserStateParsingUrlString,
+    SSYWeblocParserStateGotAllWeNeed
+} SSYWeblocParserState ;
+
+
 @interface SSYWeblocGuy ()
 
-@property (retain) NSMutableString* xmlString ;
+@property (retain) NSMutableString* stringBeingParsed ;
+@property (assign) SSYWeblocParserState parserState ;
 
 @end
 
 
 @implementation SSYWeblocGuy
 
-@synthesize xmlString = m_xmlString ;
-
 - (void)dealloc {
-    [m_xmlString release] ;
+    [_stringBeingParsed release] ;
     
     [super dealloc] ;
 }
@@ -22,29 +45,41 @@ - (void)    parser:(NSXMLParser*)parser
 	  namespaceURI:(NSString*)namespaceURI
 	 qualifiedName:(NSString*)qualifiedName
 		attributes:(NSDictionary*)attributeDict {
-	if ([elementName isEqualToString:@"string"]) {
-		// The contents are collected in parser:foundCharacters:.
-		m_accumulatingUrl = YES ;
-		// The mutable string needs to be reset to empty.
-		[[self xmlString] setString:@""] ;
-	}
+    if ((_parserState == SSYWeblocParserStateZero) && [elementName isEqualToString:@"plist"]) {
+        _parserState = SSYWeblocParserStateInPlist ;
+    }
+    else if ((_parserState == SSYWeblocParserStateInPlist) && [elementName isEqualToString:@"dict"]) {
+        _parserState = SSYWeblocParserStateInDict ;
+    }
+    else if ((_parserState == SSYWeblocParserStateInDict) && [elementName isEqualToString:@"key"]) {
+        _parserState = SSYWeblocParserStateParsingAKey ;
+    }
+    else if ((_parserState == SSYWeblocParserStateParsingUrlString) && [elementName isEqualToString:@"string"]) {
+        if ([self.stringBeingParsed isEqualToString:@"URL"]) {
+            _parserState = SSYWeblocParserStateParsingUrlString ;
+            [self.stringBeingParsed setString:@""] ;
+        }
+    }
 }
 
 - (void)parser:(NSXMLParser *)parser
  didEndElement:(NSString *)elementName
   namespaceURI:(NSString *)namespaceURI
  qualifiedName:(NSString *)qName {
-    m_accumulatingUrl = NO ;
+    if ((_parserState == SSYWeblocParserStateParsingAKey) && [elementName isEqualToString:@"key"]) {
+        _parserState = SSYWeblocParserStateParsingUrlString ;
+    }
+    if ((_parserState == SSYWeblocParserStateParsingUrlString) && [elementName isEqualToString:@"string"]) {
+        _parserState = SSYWeblocParserStateGotAllWeNeed ;
+    }
 }
 
 - (void)  parser:(NSXMLParser*)parser
  foundCharacters:(NSString*)string {
-
-    if (m_accumulatingUrl) {
-        // If the current element is one whose content we care about, append 'string'
-        // to the property that holds the content of the current element.
-        //
-        [[self xmlString] appendString:string] ;
+    if ((_parserState ==SSYWeblocParserStateParsingAKey) || (_parserState == SSYWeblocParserStateParsingUrlString)) {
+        /* I have not investigated why this method gets invoked with 
+         string = @"\n" in between the real strings.  I just filter them out… */
+        [[self stringBeingParsed] appendString:[string stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]] ;
     }
 }
 
@@ -53,50 +88,73 @@ - (void)     parser:(NSXMLParser*)parser
     NSLog(@"Found error in XML: %@", error) ;
 }
 
-- (NSArray*)weblocFilenamesAndUrlsInPaths:(NSArray*)paths {
-	NSMutableArray* filenamesAndURLs = [NSMutableArray array] ;
-	
-	for (NSString* path in paths) {
-		NSString* url = nil ;
-        
+- (NSDictionary*)filenameAndUrlFromWeblocFileAtPath:(NSString*)path {
+    NSString* url = nil ;
+    if ([path.pathExtension isEqualToString:@"webloc"]) {
         NSData* data = [NSData dataWithContentsOfFile:path] ;
+        
+        /* The .webloc files produced by Safari 9.0 (macOS 10.11) or later
+         are .plist files.  Look for that first. */
         NSDictionary* dic = [NSPropertyListSerialization propertyListWithData:data
                                                                       options:0
                                                                        format:NULL
                                                                         error:NULL] ;
         url = [dic objectForKey:@"URL"] ;
+
         if (!url) {
-            if (data) {
+            /* We are parsing a .webloc file produced by Safari 5 - 8, which
+             uses XML format. */
+            if (data.length > 0) {
                 NSXMLParser* parser = [[NSXMLParser alloc] initWithData:data] ;
                 [parser setDelegate:self] ;
-                NSMutableString* xmlString = [[NSMutableString alloc] init] ;
-                [self setXmlString:xmlString] ;
-                [xmlString release] ;
-                
+                self.parserState = SSYWeblocParserStateZero ;
+                NSMutableString* stringBeingParsed = [NSMutableString new] ;
+                self.stringBeingParsed = stringBeingParsed ;
+                [stringBeingParsed release] ;
                 [parser parse] ;
-                // Note that -parse is synchronous and will not return until the parsing
-                // is done or aborted.
+                /* Note: -parse is synchronous and will not return until the parsing
+                 is done or aborted. */
                 [parser release] ;
                 
-                url = [self xmlString] ;
-                
-                // Not really necessary, but for resource usage efficiency we
-                // release xmlString here instead of in -dealloc…
-                [self setXmlString:nil] ;
+                url = [self.stringBeingParsed copy] ;
+                [url autorelease] ;
+                self.stringBeingParsed = nil ;
             }
         }
-        
-        if (url) {
-			NSString* filename = [[path lastPathComponent] stringByDeletingPathExtension] ;
-			
-			NSDictionary* filenameAndURL = [NSDictionary dictionaryWithObjectsAndKeys:
-											filename, @"filename",
-											url, @"url",
-											nil] ;
-			
-			[filenamesAndURLs addObject:filenameAndURL] ;
+    }
+    
+    NSDictionary* answer ;
+    if (url.length > 0) {
+        NSString* filename = [[path lastPathComponent] stringByDeletingPathExtension] ;
+        answer = [NSDictionary dictionaryWithObjectsAndKeys:
+                  [filename stringByDeletingPathExtension], @"filename",
+                  url, @"url",
+                  nil] ;
+    }
+    else {
+        answer = nil ;
+    }
+    
+    return answer ;
+}
+
++ (NSDictionary*)filenameAndUrlFromWeblocFileAtPath:(NSString*)path {
+    SSYWeblocGuy* instance = [[SSYWeblocGuy alloc] init] ;
+    NSDictionary* answer = [instance filenameAndUrlFromWeblocFileAtPath:path] ;
+    [instance release] ;
+    
+    return answer ;
+}
+
+- (NSArray*)weblocFilenamesAndUrlsInPaths:(NSArray*)paths {
+	NSMutableArray* filenamesAndURLs = [NSMutableArray array] ;
+	
+	for (NSString* path in paths) {
+        NSDictionary* filenameAndUrl = [self filenameAndUrlFromWeblocFileAtPath:path] ;
+        if (filenameAndUrl) {
+            [filenamesAndURLs addObject:filenameAndUrl] ;
         }
-	}
+    }
 	
 	if ([filenamesAndURLs count])
 		return [[[NSArray alloc] initWithArray:filenamesAndURLs] autorelease] ;
