plist 0.2.0 → 0.2.1

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010-2011- Nathan Rajlich
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/lib/plist.js

@@ -1,177 +1,214 @@
-var sax = require('sax');
-var fs = require('fs');
-var util = require('util');
+;(function (exports, sax) {
+ //Checks if running in a non-browser environment
+  var inNode = typeof window === 'undefined' ? true : false;
 
-function Parser() {
+  function Parser() {
     sax.SAXParser.call(this, false, { lowercasetags: true, trim: false });
-}
+  }
 
-util.inherits(Parser, sax.SAXParser);
+  var inherits = null;
+  if (inNode) {
+    var fs = require('fs');
+    inherits = require('util').inherits; //use node provided function
+  } else { //use in browser
+    if ("create" in Object) {
+      inherits = function(ctor, superCtor) {
+        ctor.super_ = superCtor;
+        ctor.prototype = Object.create(superCtor.prototype, {
+          constructor: {
+            value: ctor,
+            enumerable: false,
+            writable: true,
+            configurable: true
+          }
+        });
+      };
+    } else {
+      var klass = function() {};
+      inherits = function(ctor, superCtor) {
+        klass.prototype = superCtor.prototype;
+        ctor.prototype = new klass;
+        ctor.prototype['constructor'] = ctor;
+      }
+    }
+  }
+  inherits(Parser, sax.SAXParser); //inherit from sax (browser-style or node-style)
 
-Parser.prototype.getInteger = function (string) {
+  Parser.prototype.getInteger = function (string) {
     this.value = parseInt(string, 10);
-}
-Parser.prototype.getString = function (string) {
+  }
+  Parser.prototype.getReal = function (string) {
+    this.value = parseFloat(string);
+  }
+  Parser.prototype.getString = function (string) {
     this.value += string;
-}
-Parser.prototype.getData = function(string) {
+  }
+  Parser.prototype.getData = function(string) {
     // todo: parse base64 encoded data
     this.value += string;
-}
-Parser.prototype.getDate = function (string) {
+  }
+  Parser.prototype.getDate = function (string) {
     this.value = new Date(string);
-}
+  }
 
-Parser.prototype.addToDict = function (value) {
+  Parser.prototype.addToDict = function (value) {
     this.dict[this.key] = value;
-}
-Parser.prototype.addToArray = function (value) {
+  }
+  Parser.prototype.addToArray = function (value) {
     this.array.push(value);
-}
+  }
 
-Parser.prototype.onopentag = function (tag) {
+  Parser.prototype.onopentag = function (tag) {
     switch (tag.name) {
-    case 'dict':
+      case 'dict':
         this.stack.push(this.context);
         this.context = {
-            value: function() {
-                return this.dict;
-            },
-            dict: {},
-            setKey: function(key) {
-                this.key = key;
-            },
-            setValue: function(value) {
-                this.dict[this.key] = value;
-            }
+          value: function() {
+            return this.dict;
+          },
+          dict: {},
+          setKey: function(key) {
+            this.key = key;
+          },
+          setValue: function(value) {
+            this.dict[this.key] = value;
+          }
         }
         break;
-    case 'plist':
-    case 'array':
+      case 'plist':
+      case 'array':
         this.stack.push(this.context);
         this.context = {
-            value: function() {
-                return this.array;
-            },
-            array: [],
-            setKey: function(key) {
-                console.log('unexpected <key> element in array');
-            },
-            setValue: function(value) {
-                this.array.push(value);
-            }
+          value: function() {
+            return this.array;
+          },
+          array: [],
+          setKey: function(key) {
+            console.log('unexpected <key> element in array');
+          },
+          setValue: function(value) {
+            this.array.push(value);
+          }
         }
         break;
-    case 'key':
+      case 'key':
         this.ontext = function (text) {
-            this.context.setKey(text);
+          this.context.setKey(text);
         }
         break;
-    case 'integer':
+      case 'integer':
         this.ontext = this.getInteger;
         break;
-    case 'string':
+      case 'real':
+        this.ontext = this.getReal;
+        break;
+      case 'string':
         this.value = '';
         this.ontext = this.getString;
         this.oncdata = this.getString;
         break;
-    case 'data':
+      case 'data':
         this.value = '';
         this.ontext = this.getData;
         this.oncdata = this.getData;
         break;
-    case 'true':
+      case 'true':
         this.value = true;
         break;
-    case 'false':
+      case 'false':
         this.value = false;
         break;
-    case 'date':
+      case 'date':
         this.ontext = this.getDate;
         break;
-    default:
+      default:
         console.log('ignored tag', tag.name);
         break;
     }
-}
-Parser.prototype.onclosetag = function (tag) {
+  }
+  Parser.prototype.onclosetag = function (tag) {
     var value;
     switch (tag) {
-    case 'dict':
-    case 'array':
-    case 'plist':
+      case 'dict':
+      case 'array':
+      case 'plist':
         var value = this.context.value();
         this.context = this.stack.pop();
         this.context.setValue(value);
         break;
-    case 'true':
-    case 'false':
-    case 'string':
-    case 'integer':
-    case 'date':
-    case 'data':
+      case 'true':
+      case 'false':
+      case 'string':
+      case 'integer':
+      case 'real':
+      case 'date':
+      case 'data':
         this.context.setValue(this.value);
         break;
-    case 'key':
+      case 'key':
         break;
-    default:
+      default:
         console.log('closing', tag, 'tag ignored');
     }
     this.oncdata = this.ontext = this.checkWhitespace;
-}
-Parser.prototype.checkWhitespace = function (data) {
+  }
+  Parser.prototype.checkWhitespace = function (data) {
     if (!data.match(/^[ \t\r\n]*$/)) {
-        console.log('unexpected non-whitespace data', data);
+      console.log('unexpected non-whitespace data', data);
     }
-}
-Parser.prototype.oncomment = function (comment) {
-}
-Parser.prototype.onerror = function (error) {
+  }
+  Parser.prototype.oncomment = function (comment) {
+  }
+  Parser.prototype.onerror = function (error) {
     console.log('sax parser error:', error);
     throw error;
-}
+  }
 
-Parser.prototype.parseFile = function (xmlfile, callback) {
+  if (inNode) Parser.prototype.parseFile = function (xmlfile, callback) { //browsers aren't capable of opening files, instead use AJAX
     var parser = this;
     parser.stack = [ ];
     parser.context = {
-        callback: callback,
-        value: function() {},
-        setKey: function(key) {},
-        setValue: function(value) {
-            callback(null, value);
-        },
+      callback: callback,
+      value: function() {},
+      setKey: function(key) {},
+      setValue: function(value) {
+        callback(null, value);
+      },
     }
     var rs = fs.createReadStream(xmlfile, {
       encoding: 'utf8'
     });
     rs.on('data', function(data) { parser.write(data); });
     rs.on('end', function() { parser.close(); });
-}
+  }
 
-Parser.prototype.parseString = function (xml, callback) {
+  Parser.prototype.parseString = function (xml, callback) {
     var parser = this;
     parser.stack = [ ];
     parser.context = {
-        callback: callback,
-        value: function() {},
-        setKey: function(key) {},
-        setValue: function(value) {
-            this.callback(null, value);
-        },
+      callback: callback,
+      value: function() {},
+      setKey: function(key) {},
+      setValue: function(value) {
+        this.callback(null, value);
+      },
     };
     parser.write(xml);
     parser.close();
-}
+  }
 
-exports.Parser = Parser;
+  exports.Parser = Parser;
 
-exports.parseString = function (xml, callback) {
+  exports.parseString = function (xml, callback) {
     var parser = new Parser();
     parser.parseString(xml, callback);
-}
+  }
 
-exports.parseFile = function (filename, callback) {
+  if (inNode) exports.parseFile = function (filename, callback) { //Do not expose no created method
     var parser = new Parser();
     parser.parseFile(filename, callback);
-}
+  }
+})(typeof exports === 'undefined' ? plist = {} : exports, typeof window === "undefined" ? require('sax') : sax)
+//the above line checks for exports (defined in node) and uses it, or creates a global variable and exports to that.
+//also, if in node, require sax node-style, in browser the developer must use a <script> tag to import sax
+// TODO: Implement detection of 'sax' in the Browser environment

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "plist",
   "description": "Mac OS X Plist parser for NodeJS. Convert a Plist file or string into a native JS object",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "author": "Nathan Rajlich <nathan@tootallnate.net>",
   "contributors": [ "Hans Huebner <hans.huebner@gmail.com>" ],
   "repository": {

package/tests/airplay.xml

@@ -0,0 +1,38 @@
+<?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">
+<dict>
+  <key>duration</key>
+  <real>5555.0495000000001</real>
+  <key>loadedTimeRanges</key>
+  <array>
+    <dict>
+      <key>duration</key>
+      <real>5555.0495000000001</real>
+      <key>start</key>
+      <real>0.0</real>
+    </dict>
+  </array>
+  <key>playbackBufferEmpty</key>
+  <true/>
+  <key>playbackBufferFull</key>
+  <false/>
+  <key>playbackLikelyToKeepUp</key>
+  <true/>
+  <key>position</key>
+  <real>4.6269989039999997</real>
+  <key>rate</key>
+  <real>1</real>
+  <key>readyToPlay</key>
+  <true/>
+  <key>seekableTimeRanges</key>
+  <array>
+    <dict>
+      <key>duration</key>
+      <real>5555.0495000000001</real>
+      <key>start</key>
+      <real>0.0</real>
+    </dict>
+  </array>
+</dict>
+</plist>

package/tests/test.js

@@ -37,3 +37,22 @@ plist.parseFile(file2, function(err, dicts) {
   assert.equal(dict['PopupMenu'][2]['Key'], "\n        \n        #import <Cocoa/Cocoa.h>\n\n#import <MacRuby/MacRuby.h>\n\nint main(int argc, char *argv[])\n{\n  return macruby_main(\"rb_main.rb\", argc, argv);\n}\n\n");
 
 });
+
+
+// Third test...
+var file3 = path.join(__dirname, "airplay.xml");
+var startTime3 = new Date();
+
+plist.parseFile(file3, function(err, dicts) {
+  if (err) {
+    throw err;
+  }
+
+  var endTime = new Date();
+  console.log('Parsed "' + file3 + '" in ' + (endTime - startTime3) + 'ms');
+
+  var dict = dicts[0];
+  assert.equal(dict['duration'], 5555.0495000000001);
+  assert.equal(dict['position'], 4.6269989039999997);
+
+});