Add: node_modules

app/node_modules/font-manager/test/index.js

@@ -0,0 +1,580 @@
+var fontManager = require('../');
+var assert = require('assert');
+
+// some standard fonts that are likely to be installed on the platform the tests are running on
+var standardFont = process.platform === 'linux' ? 'Liberation Sans' : 'Arial';
+var postscriptName = process.platform === 'linux' ? 'LiberationSans' : 'ArialMT';
+
+describe('font-manager', function() {
+  it('should export some functions', function() {
+    assert.equal(typeof fontManager.getAvailableFonts, 'function');
+    assert.equal(typeof fontManager.getAvailableFontsSync, 'function');
+    assert.equal(typeof fontManager.findFonts, 'function');
+    assert.equal(typeof fontManager.findFontsSync, 'function');
+    assert.equal(typeof fontManager.findFont, 'function');
+    assert.equal(typeof fontManager.findFontSync, 'function');
+    assert.equal(typeof fontManager.substituteFont, 'function');
+    assert.equal(typeof fontManager.substituteFontSync, 'function');
+  });
+  
+  function assertFontDescriptor(font) {
+    assert.equal(typeof font, 'object');
+    assert.equal(typeof font.path, 'string');
+    assert.equal(typeof font.postscriptName, 'string');
+    assert.equal(typeof font.family, 'string');
+    assert.equal(typeof font.style, 'string');
+    assert.equal(typeof font.weight, 'number');
+    assert.equal(typeof font.width, 'number');
+    assert.equal(typeof font.italic, 'boolean');
+    assert.equal(typeof font.monospace, 'boolean');
+  }
+  
+  describe('getAvailableFonts', function() {
+    it('should throw if no callback is provided', function() {
+      assert.throws(function() {
+        fontManager.getAvailableFonts();
+      }, /Expected a callback/);
+    });
+    
+    it('should throw if callback is not a function', function() {
+      assert.throws(function() {
+        fontManager.getAvailableFonts(2);
+      }, /Expected a callback/);
+    });
+    
+    it('should getAvailableFonts asynchronously', function(done) {
+      var async = false;
+
+      fontManager.getAvailableFonts(function(fonts) {
+        assert(async); 
+        assert(Array.isArray(fonts));
+        assert(fonts.length > 0);
+        fonts.forEach(assertFontDescriptor);
+        done();
+      });
+
+      async = true;
+    });
+  });
+
+  describe('getAvailableFontsSync', function() {
+    it('should getAvailableFonts synchronously', function() {
+      var fonts = fontManager.getAvailableFontsSync();
+      assert(Array.isArray(fonts));
+      assert(fonts.length > 0);
+      fonts.forEach(assertFontDescriptor);
+    });
+  });
+  
+  describe('findFonts', function() {
+    it('should throw if no font descriptor is provided', function() {
+      assert.throws(function() {
+        fontManager.findFonts(function(fonts) {});
+      }, /Expected a font descriptor/);
+    });
+    
+    it('should throw if font descriptor is not an object', function() {
+      assert.throws(function() {
+        fontManager.findFonts(2, function(fonts) {});
+      }, /Expected a font descriptor/);
+    });
+    
+    it('should throw if no callback is provided', function() {
+      assert.throws(function() {
+        fontManager.findFonts({ family: standardFont });
+      }, /Expected a callback/);
+    });
+    
+    it('should throw if callback is not a function', function() {
+      assert.throws(function() {
+        fontManager.findFonts({ family: standardFont }, 2);
+      }, /Expected a callback/);
+    });
+    
+    it('should findFonts asynchronously', function(done) {
+      var async = false;
+    
+      fontManager.findFonts({ family: standardFont }, function(fonts) {
+        assert(async); 
+        assert(Array.isArray(fonts));
+        assert(fonts.length > 0);
+        fonts.forEach(assertFontDescriptor);
+        done();
+      });
+    
+      async = true;
+    });
+    
+    it('should find fonts by postscriptName', function(done) {
+      fontManager.findFonts({ postscriptName: postscriptName }, function(fonts) {
+        assert(Array.isArray(fonts));
+        assert.equal(fonts.length, 1);
+        fonts.forEach(assertFontDescriptor);
+        assert.equal(fonts[0].postscriptName, postscriptName);
+        assert.equal(fonts[0].family, standardFont);
+        done();
+      });
+    });
+    
+    it('should find fonts by family and style', function(done) {
+      fontManager.findFonts({ family: standardFont, style: 'Bold' }, function(fonts) {
+        assert(Array.isArray(fonts));
+        assert.equal(fonts.length, 1);
+        fonts.forEach(assertFontDescriptor);
+        assert.equal(fonts[0].family, standardFont);
+        assert.equal(fonts[0].style, 'Bold');
+        assert.equal(fonts[0].weight, 700);
+        done();
+      });
+    });
+    
+    it('should find fonts by weight', function(done) {
+      fontManager.findFonts({ family: standardFont, weight: 700 }, function(fonts) {
+        assert(Array.isArray(fonts));
+        assert(fonts.length > 0);
+        fonts.forEach(assertFontDescriptor);
+        fonts.forEach(function(font) {
+          assert.equal(font.weight, 700);
+        });
+        done();
+      });
+    });
+    
+    it('should find italic fonts', function(done) {
+      fontManager.findFonts({ family: standardFont, italic: true }, function(fonts) {
+        assert(Array.isArray(fonts));
+        assert(fonts.length > 0);
+        fonts.forEach(assertFontDescriptor);
+        fonts.forEach(function(font) {
+          assert.equal(font.italic, true);
+        });
+        done();
+      });
+    });
+    
+    it('should find italic and bold fonts', function(done) {
+      fontManager.findFonts({ family: standardFont, italic: true, weight: 700 }, function(fonts) {
+        assert(Array.isArray(fonts));
+        assert(fonts.length > 0);
+        fonts.forEach(assertFontDescriptor);
+        fonts.forEach(function(font) {
+          assert.equal(font.italic, true);
+          assert.equal(font.weight, 700);
+        });
+        done();
+      });
+    });
+    
+    it('should return an empty array for nonexistent family', function(done) {
+      fontManager.findFonts({ family: '' + Date.now() }, function(fonts) {
+        assert(Array.isArray(fonts));
+        assert.equal(fonts.length, 0);
+        done();
+      });
+    });
+    
+    it('should return an empty array for nonexistent postscriptName', function(done) {
+      fontManager.findFonts({ postscriptName: '' + Date.now() }, function(fonts) {
+        assert(Array.isArray(fonts));
+        assert.equal(fonts.length, 0);
+        done();
+      });
+    });
+    
+    it('should return many fonts for empty font descriptor', function(done) {
+      fontManager.findFonts({}, function(fonts) {
+        assert(Array.isArray(fonts));
+        assert(fonts.length > 0);
+        fonts.forEach(assertFontDescriptor);
+        done();
+      });
+    });
+  });
+  
+  describe('findFontsSync', function() {
+    it('should throw if no font descriptor is provided', function() {
+      assert.throws(function() {
+        fontManager.findFontsSync();
+      }, /Expected a font descriptor/);
+    });
+    
+    it('should throw if font descriptor is not an object', function() {
+      assert.throws(function() {
+        fontManager.findFontsSync(2);
+      }, /Expected a font descriptor/);
+    });
+    
+    it('should findFonts synchronously', function() {
+      var fonts = fontManager.findFontsSync({ family: standardFont });
+      assert(Array.isArray(fonts));
+      assert(fonts.length > 0);
+      fonts.forEach(assertFontDescriptor);
+    });
+    
+    it('should find fonts by postscriptName', function() {
+      var fonts = fontManager.findFontsSync({ postscriptName: postscriptName });
+      assert(Array.isArray(fonts));
+      assert.equal(fonts.length, 1);
+      fonts.forEach(assertFontDescriptor);
+      assert.equal(fonts[0].postscriptName, postscriptName);
+      assert.equal(fonts[0].family, standardFont);
+    });
+    
+    it('should find fonts by family and style', function() {
+      var fonts = fontManager.findFontsSync({ family: standardFont, style: 'Bold' });
+      assert(Array.isArray(fonts));
+      assert.equal(fonts.length, 1);
+      fonts.forEach(assertFontDescriptor);
+      assert.equal(fonts[0].family, standardFont);
+      assert.equal(fonts[0].style, 'Bold');
+      assert.equal(fonts[0].weight, 700);
+    });
+    
+    it('should find fonts by weight', function() {
+      var fonts = fontManager.findFontsSync({ family: standardFont, weight: 700 });
+      assert(Array.isArray(fonts));
+      assert(fonts.length > 0);
+      fonts.forEach(assertFontDescriptor);
+      assert.equal(fonts[0].weight, 700);
+    });
+    
+    it('should find italic fonts', function() {
+      var fonts = fontManager.findFontsSync({ family: standardFont, italic: true });
+      assert(Array.isArray(fonts));
+      assert(fonts.length > 0);
+      fonts.forEach(assertFontDescriptor);
+      assert.equal(fonts[0].italic, true);
+    });
+    
+    it('should find italic and bold fonts', function() {
+      var fonts = fontManager.findFontsSync({ family: standardFont, italic: true, weight: 700 });
+      assert(Array.isArray(fonts));
+      assert(fonts.length > 0);
+      fonts.forEach(assertFontDescriptor);
+      assert.equal(fonts[0].italic, true);
+      assert.equal(fonts[0].weight, 700);
+    });
+    
+    it('should return an empty array for nonexistent family', function() {
+      var fonts = fontManager.findFontsSync({ family: '' + Date.now() });
+      assert(Array.isArray(fonts));
+      assert.equal(fonts.length, 0);
+    });
+    
+    it('should return an empty array for nonexistent postscriptName', function() {
+      var fonts = fontManager.findFontsSync({ postscriptName: '' + Date.now() });
+      assert(Array.isArray(fonts));
+      assert.equal(fonts.length, 0);
+    });
+    
+    it('should return many fonts for empty font descriptor', function() {
+      var fonts = fontManager.findFontsSync({});
+      assert(Array.isArray(fonts));
+      assert(fonts.length > 0);
+      fonts.forEach(assertFontDescriptor);
+    });
+  });
+  
+  describe('findFont', function() {
+    it('should throw if no font descriptor is provided', function() {
+      assert.throws(function() {
+        fontManager.findFont(function(fonts) {});
+      }, /Expected a font descriptor/);
+    });
+    
+    it('should throw if font descriptor is not an object', function() {
+      assert.throws(function() {
+        fontManager.findFont(2, function(fonts) {});
+      }, /Expected a font descriptor/);
+    });
+    
+    it('should throw if no callback is provided', function() {
+      assert.throws(function() {
+        fontManager.findFont({ family: standardFont });
+      }, /Expected a callback/);
+    });
+    
+    it('should throw if callback is not a function', function() {
+      assert.throws(function() {
+        fontManager.findFont({ family: standardFont }, 2);
+      }, /Expected a callback/);
+    });
+    
+    it('should findFont asynchronously', function(done) {
+      var async = false;
+    
+      fontManager.findFont({ family: standardFont }, function(font) {
+        assert(async); 
+        assert.equal(typeof font, 'object');
+        assert(!Array.isArray(font));
+        assertFontDescriptor(font);
+        assert.equal(font.family, standardFont);
+        done();
+      });
+    
+      async = true;
+    });
+    
+    it('should find font by postscriptName', function(done) {
+      fontManager.findFont({ postscriptName: postscriptName }, function(font) {
+        assertFontDescriptor(font);
+        assert.equal(font.postscriptName, postscriptName);
+        assert.equal(font.family, standardFont);
+        done();
+      });
+    });
+    
+    it('should find font by family and style', function(done) {
+      fontManager.findFont({ family: standardFont, style: 'Bold' }, function(font) {
+        assertFontDescriptor(font);
+        assert.equal(font.family, standardFont);
+        assert.equal(font.style, 'Bold');
+        assert.equal(font.weight, 700);
+        done();
+      });
+    });
+    
+    it('should find font by weight', function(done) {
+      fontManager.findFont({ family: standardFont, weight: 700 }, function(font) {
+        assertFontDescriptor(font);
+        assert.equal(font.weight, 700);
+        done();
+      });
+    });
+    
+    it('should find italic font', function(done) {
+      fontManager.findFont({ family: standardFont, italic: true }, function(font) {
+        assertFontDescriptor(font);
+        assert.equal(font.italic, true);
+        done();
+      });
+    });
+    
+    it('should find bold italic font', function(done) {
+      fontManager.findFont({ family: standardFont, italic: true, weight: 700 }, function(font) {
+        assertFontDescriptor(font);
+        assert.equal(font.italic, true);
+        assert.equal(font.weight, 700);
+        done();
+      });
+    });
+    
+    it('should return a fallback font for nonexistent family', function(done) {
+      fontManager.findFont({ family: '' + Date.now() }, function(font) {
+        assertFontDescriptor(font);
+        done();
+      });
+    });
+    
+    it('should return a fallback font for nonexistent postscriptName', function(done) {
+      fontManager.findFont({ postscriptName: '' + Date.now() }, function(font) {
+        assertFontDescriptor(font);
+        done();
+      });
+    });
+    
+    it('should return a fallback font matching traits as best as possible', function(done) {
+      fontManager.findFont({ family: '' + Date.now(), weight: 700 }, function(font) {
+        assertFontDescriptor(font);
+        assert.equal(font.weight, 700);
+        done();
+      });
+    });
+    
+    it('should return a font for empty font descriptor', function(done) {
+      fontManager.findFont({}, function(font) {
+        assertFontDescriptor(font);
+        done();
+      });
+    });
+  });
+  
+  describe('findFontSync', function() {
+    it('should throw if no font descriptor is provided', function() {
+      assert.throws(function() {
+        fontManager.findFontSync();
+      }, /Expected a font descriptor/);
+    });
+    
+    it('should throw if font descriptor is not an object', function() {
+      assert.throws(function() {
+        fontManager.findFontSync(2);
+      }, /Expected a font descriptor/);
+    });
+    
+    it('should findFonts synchronously', function() {
+      var font = fontManager.findFontSync({ family: standardFont });
+      assert.equal(typeof font, 'object');
+      assert(!Array.isArray(font));
+      assertFontDescriptor(font);
+    });
+    
+    it('should find font by postscriptName', function() {
+      var font = fontManager.findFontSync({ postscriptName: postscriptName });
+      assertFontDescriptor(font);
+      assert.equal(font.postscriptName, postscriptName);
+      assert.equal(font.family, standardFont);
+    });
+    
+    it('should find font by family and style', function() {
+      var font = fontManager.findFontSync({ family: standardFont, style: 'Bold' });
+      assertFontDescriptor(font);
+      assert.equal(font.family, standardFont);
+      assert.equal(font.style, 'Bold');
+      assert.equal(font.weight, 700);
+    });
+    
+    it('should find font by weight', function() {
+      var font = fontManager.findFontSync({ family: standardFont, weight: 700 });
+      assertFontDescriptor(font);
+      assert.equal(font.weight, 700);
+    });
+    
+    it('should find italic font', function() {
+      var font = fontManager.findFontSync({ family: standardFont, italic: true });
+      assertFontDescriptor(font);
+      assert.equal(font.italic, true);
+    });
+    
+    it('should find bold italic font', function() {
+      var font = fontManager.findFontSync({ family: standardFont, italic: true, weight: 700 });
+      assertFontDescriptor(font);
+      assert.equal(font.italic, true);
+      assert.equal(font.weight, 700);
+    });
+    
+    it('should return a fallback font for nonexistent family', function() {
+      var font = fontManager.findFontSync({ family: '' + Date.now() });
+      assertFontDescriptor(font);
+    });
+    
+    it('should return a fallback font for nonexistent postscriptName', function() {
+      var font = fontManager.findFontSync({ postscriptName: '' + Date.now() });
+      assertFontDescriptor(font);
+    });
+    
+    it('should return a fallback font matching traits as best as possible', function() {
+      var font = fontManager.findFontSync({ family: '' + Date.now(), weight: 700 });
+      assertFontDescriptor(font);
+      assert.equal(font.weight, 700);
+    });
+    
+    it('should return a font for empty font descriptor', function() {
+      var font = fontManager.findFontSync({});
+      assertFontDescriptor(font);
+    });
+  });
+  
+  describe('substituteFont', function() {
+    it('should throw if no postscript name is provided', function() {
+      assert.throws(function() {
+        fontManager.substituteFont(function(font) {});
+      }, /Expected postscript name/);
+    });
+    
+    it('should throw if postscript name is not a string', function() {
+      assert.throws(function() {
+        fontManager.substituteFont(2, 'hi', function(font) {});
+      }, /Expected postscript name/);
+    });
+    
+    it('should throw if no substitution string is provided', function() {
+      assert.throws(function() {
+        fontManager.substituteFont(postscriptName, function(font) {});
+      }, /Expected substitution string/);
+    });
+    
+    it('should throw if substitution string is not a string', function() {
+      assert.throws(function() {
+        fontManager.substituteFont(postscriptName, 2, function(font) {});
+      }, /Expected substitution string/);
+    });
+    
+    it('should throw if no callback is provided', function() {
+      assert.throws(function() {
+        fontManager.substituteFont(postscriptName, '汉字');
+      }, /Expected a callback/);
+    });
+    
+    it('should throw if callback is not a function', function() {
+      assert.throws(function() {
+        fontManager.substituteFont(postscriptName, '汉字', 52);
+      }, /Expected a callback/);
+    });
+    
+    it('should substituteFont asynchronously', function(done) {
+      var async = false;
+    
+      fontManager.substituteFont(postscriptName, '汉字', function(font) {
+        assert(async); 
+        assert.equal(typeof font, 'object');
+        assert(!Array.isArray(font));
+        assertFontDescriptor(font);
+        assert.notEqual(font.postscriptName, postscriptName);
+        done();
+      });
+    
+      async = true;
+    });
+    
+    it('should return the same font if it already contains the requested characters', function(done) {
+      fontManager.substituteFont(postscriptName, 'hi', function(font) {
+        assertFontDescriptor(font);
+        assert.equal(font.postscriptName, postscriptName);
+        done();
+      });
+    });
+    
+    it('should return a default font if no font exists for the given postscriptName', function(done) {
+      fontManager.substituteFont('' + Date.now(), '汉字', function(font) {
+        assertFontDescriptor(font);
+        done();
+      });
+    });
+  });
+  
+  describe('substituteFontSync', function() {
+    it('should throw if no postscript name is provided', function() {
+      assert.throws(function() {
+        fontManager.substituteFontSync();
+      }, /Expected postscript name/);
+    });
+    
+    it('should throw if postscript name is not a string', function() {
+      assert.throws(function() {
+        fontManager.substituteFontSync(2, 'hi');
+      }, /Expected postscript name/);
+    });
+    
+    it('should throw if no substitution string is provided', function() {
+      assert.throws(function() {
+        fontManager.substituteFontSync(postscriptName);
+      }, /Expected substitution string/);
+    });
+    
+    it('should throw if substitution string is not a string', function() {
+      assert.throws(function() {
+        fontManager.substituteFontSync(postscriptName, 2);
+      }, /Expected substitution string/);
+    });
+    
+    it('should substituteFont synchronously', function() {
+      var font = fontManager.substituteFontSync(postscriptName, '汉字');
+      assert.equal(typeof font, 'object');
+      assert(!Array.isArray(font));
+      assertFontDescriptor(font);
+      assert.notEqual(font.postscriptName, postscriptName);
+    });
+    
+    it('should return the same font if it already contains the requested characters', function() {
+      var font = fontManager.substituteFontSync(postscriptName, 'hi');
+      assertFontDescriptor(font);
+      assert.equal(font.postscriptName, postscriptName);
+    });
+    
+    it('should return a default font if no font exists for the given postscriptName', function() {
+      var font = fontManager.substituteFontSync('' + Date.now(), '汉字');
+      assertFontDescriptor(font);
+    });
+  });
+});

app/node_modules/font-manager/test/mocha.opts

@@ -0,0 +1 @@
+--reporter spec