webfontloader 1.0.5

data/src-test/google/fontapiurlbuildertest.js

@@ -0,0 +1,28 @@
+var FontApiUrlBuilderTest = TestCase('FontApiUrlBuilderTest');
+
+FontApiUrlBuilderTest.prototype.testThrowsExceptionIfNoFontFamilies =
+    function() {
+  var fontApiUrlBuilder = new webfont.FontApiUrlBuilder("http://moo");
+
+  try {
+    fontApiUrlBuilder.build();
+    fail('build should have thrown an exception.');
+  } catch (e) {
+    // success
+  }
+};
+
+FontApiUrlBuilderTest.prototype.testBuildProperUrl = function() {
+  var fontApiUrlBuilder = new webfont.FontApiUrlBuilder("http://moo");
+
+  fontApiUrlBuilder.setFontFamilies([ 'Font1', 'Font2' ]);
+  assertEquals('http://moo?family=Font1%7CFont2', fontApiUrlBuilder.build());
+};
+
+FontApiUrlBuilderTest.prototype.testBuildProperDefaultUrl = function() {
+  var fontApiUrlBuilder = new webfont.FontApiUrlBuilder();
+
+  fontApiUrlBuilder.setFontFamilies([ 'Font1', 'Font2' ]);
+  assertEquals("http:" + webfont.FontApiUrlBuilder.DEFAULT_API_URL +
+      '?family=Font1%7CFont2', fontApiUrlBuilder.build());
+};

data/src-test/google/googlefontapitest.js

@@ -0,0 +1,173 @@
+var GoogleFontApiTest = TestCase('GoogleFontApiTest');
+
+GoogleFontApiTest.prototype.testCallOnReadyWithFontFamilyLoading = function() {
+  var insert = '';
+  var link = '';
+  var fakeDomHelper = {
+      insertInto: function(tag, e) {
+        insert = tag;
+      },
+      createCssLink: function(csslink) {
+        link = csslink;
+      }
+  };
+  var userAgent = new webfont.UserAgent("Test", "1.0", true);
+  var googleFontApi = new webfont.GoogleFontApi(userAgent, fakeDomHelper,
+      { families: [ 'Font1', 'Font2' ] });
+
+  var families = null;
+  var descriptions = null;
+
+  googleFontApi.load(function(fontFamilies, fontDescriptions) {
+      families = fontFamilies;
+      descriptions = fontDescriptions;
+  });
+
+  assertEquals('head', insert);
+  assertEquals('http://fonts.googleapis.com/css?family=' +
+      'Font1%7CFont2', link);
+
+  assertNotNull(families);
+  assertEquals(2, families.length);
+  assertEquals('Font1', families[0]);
+  assertEquals('Font2', families[1]);
+
+  var font1Descriptions = descriptions['Font1'];
+  assertNotNull(font1Descriptions);
+  assertEquals(1, font1Descriptions.length);
+  assertEquals('n4', font1Descriptions[0]);
+
+  var font2Descriptions = descriptions['Font2'];
+  assertNotNull(font2Descriptions);
+  assertEquals(1, font2Descriptions.length);
+  assertEquals('n4', font2Descriptions[0]);
+};
+
+GoogleFontApiTest.prototype.testCallOnReadyWithFontFamilyLoadingApiUrlChanged =
+    function() {
+  var insert = '';
+  var link = '';
+  var fakeDomHelper = {
+      insertInto: function(tag, e) {
+        insert = tag;
+      },
+      createCssLink: function(csslink) {
+        link = csslink;
+      }
+  };
+  var userAgent = new webfont.UserAgent("Test", "1.0", true);
+  var googleFontApi = new webfont.GoogleFontApi(userAgent, fakeDomHelper,
+      { api: 'http://moo',  families: [ 'Font1', 'Font2' ] });
+
+  var families = null;
+  var descriptions = null;
+
+  googleFontApi.load(function(fontFamilies, fontDescriptions) {
+      families = fontFamilies;
+      descriptions = fontDescriptions;
+  });
+
+  assertEquals('head', insert);
+  assertEquals('http://moo?family=Font1%7CFont2', link);
+
+  assertNotNull(families);
+  assertEquals(2, families.length);
+  assertEquals('Font1', families[0]);
+  assertEquals('Font2', families[1]);
+
+  var font1Descriptions = descriptions['Font1'];
+  assertNotNull(font1Descriptions);
+  assertEquals(1, font1Descriptions.length);
+  assertEquals('n4', font1Descriptions[0]);
+
+  var font2Descriptions = descriptions['Font2'];
+  assertNotNull(font2Descriptions);
+  assertEquals(1, font2Descriptions.length);
+  assertEquals('n4', font2Descriptions[0]);
+};
+
+GoogleFontApiTest.prototype.testSpacesReplacedByPlus = function() {
+  var insert = '';
+  var link = '';
+  var fakeDomHelper = {
+      insertInto: function(tag, e) {
+        insert = tag;
+      },
+      createCssLink: function(csslink) {
+        link = csslink;
+      }
+  };
+  var userAgent = new webfont.UserAgent("Test", "1.0", true);
+  var googleFontApi = new webfont.GoogleFontApi(userAgent, fakeDomHelper,
+      { families: [ 'Font1 WithSpace', 'Font2 WithSpaceToo' ] });
+
+  var families = null;
+  var descriptions = null;
+
+  googleFontApi.load(function(fontFamilies, fontDescriptions) {
+      families = fontFamilies;
+      descriptions = fontDescriptions;
+  });
+
+  assertEquals('head', insert);
+  assertEquals('http://fonts.googleapis.com/css?family=Font1+WithSpace%7CFont2+WithSpaceToo', link);
+
+  assertNotNull(families);
+  assertEquals(2, families.length);
+  assertEquals('Font1 WithSpace', families[0]);
+  assertEquals('Font2 WithSpaceToo', families[1]);
+
+  var font1Descriptions = descriptions['Font1 WithSpace'];
+  assertNotNull(font1Descriptions);
+  assertEquals(1, font1Descriptions.length);
+  assertEquals('n4', font1Descriptions[0]);
+
+  var font2Descriptions = descriptions['Font2 WithSpaceToo'];
+  assertNotNull(font2Descriptions);
+  assertEquals(1, font2Descriptions.length);
+  assertEquals('n4', font2Descriptions[0]);
+};
+
+GoogleFontApiTest.prototype.testLoadWithVariations = function() {
+  var insert = '';
+  var link = '';
+  var fakeDomHelper = {
+      insertInto: function(tag, e) {
+        insert = tag;
+      },
+      createCssLink: function(csslink) {
+        link = csslink;
+      }
+  };
+  var userAgent = new webfont.UserAgent("Test", "1.0", true);
+  var googleFontApi = new webfont.GoogleFontApi(userAgent, fakeDomHelper,
+      { families: [ 'Font1 WithSpace:bi', 'Font2 WithSpaceToo:b,r' ] });
+
+  var families = null;
+  var descriptions = null;
+
+  googleFontApi.load(function(fontFamilies, fontDescriptions) {
+      families = fontFamilies;
+      descriptions = fontDescriptions;
+  });
+
+  assertEquals('head', insert);
+  assertEquals('http://fonts.googleapis.com/css?family=Font1+WithSpace:bi%7CFont2+WithSpaceToo:b,r', link);
+
+  assertNotNull(families);
+  assertEquals(2, families.length);
+  assertEquals('Font1 WithSpace', families[0]);
+  assertEquals('Font2 WithSpaceToo', families[1]);
+  assertNotNull(descriptions);
+
+  var font1Descriptions = descriptions['Font1 WithSpace'];
+  assertNotNull(font1Descriptions);
+  assertEquals(1, font1Descriptions.length);
+  assertEquals('i7', font1Descriptions[0]);
+
+  var font2Descriptions = descriptions['Font2 WithSpaceToo'];
+  assertNotNull(font2Descriptions);
+  assertEquals(2, font2Descriptions.length);
+  assertEquals('n7', font2Descriptions[0]);
+  assertEquals('n4', font2Descriptions[1]);
+};

data/src-test/typekit/typekit_script_test.js

@@ -0,0 +1,171 @@
+var TypekitScriptTest = TestCase('TypeKitScriptTest');
+
+TypekitScriptTest.prototype.testSupportAndLoadLifecycle = function() {
+  var configuration = {
+    'id': 'abc'
+  };
+  var insert = '';
+  var src = '';
+  var fakeDomHelper = {
+      insertInto: function(tag, e) {
+        insert = tag;
+      },
+      createScriptSrc: function(srcLink) {
+        src = srcLink;
+      }
+  };
+  var global = {};
+  var typeKit = new webfont.TypekitScript(global, fakeDomHelper, configuration);
+
+  // supportUserAgent
+  var userAgent = 'user agent';
+  var isSupport = null;
+
+  typeKit.supportUserAgent(userAgent, function(support) { isSupport = support; });
+  assertEquals('head', insert);
+  assertEquals('http://use.typekit.com/abc.js', src);
+  assertEquals(null, isSupport);
+
+  assertNotNull(global.__webfonttypekitmodule__);
+  assertNotNull(global.__webfonttypekitmodule__['abc']);
+
+  // Typekit script calls initializer.
+  global.__webfonttypekitmodule__['abc'](function(ua, config, init) {
+    assertEquals('user agent', ua);
+    assertEquals(config, configuration);
+    assertNotNull(init);
+    init(true, ['Font1', 'Font2'], {});
+  });
+  assertEquals(true, isSupport);
+
+  // load
+  var families = null;
+  var descriptions = null;
+
+  typeKit.load(function(fontFamilies, fontDescriptions) {
+      families = fontFamilies;
+      descriptions = fontDescriptions;
+  });
+
+  assertNotNull(families);
+  assertEquals(2, families.length);
+  assertEquals('Font1', families[0]);
+  assertEquals('Font2', families[1]);
+
+  var font1Descriptions = descriptions['Font1'];
+  assertUndefined(font1Descriptions);
+
+  var font2Descriptions = descriptions['Font2'];
+  assertUndefined(font2Descriptions);
+};
+
+TypekitScriptTest.prototype.testLoadWithVariations = function() {
+  var configuration = {
+    'id': 'abc'
+  };
+  var insert = '';
+  var src = '';
+  var fakeDomHelper = {
+      insertInto: function(tag, e) {
+        insert = tag;
+      },
+      createScriptSrc: function(srcLink) {
+        src = srcLink;
+      }
+  };
+  var global = {};
+  var typeKit = new webfont.TypekitScript(global, fakeDomHelper, configuration);
+
+  // supportUserAgent
+  var userAgent = 'user agent';
+  var isSupport = null;
+
+  typeKit.supportUserAgent(userAgent, function(support) { isSupport = support; });
+  assertEquals(null, isSupport);
+
+  assertNotNull(global.__webfonttypekitmodule__);
+  assertNotNull(global.__webfonttypekitmodule__['abc']);
+
+  // Typekit script calls initializer.
+  global.__webfonttypekitmodule__['abc'](function(ua, config, init) {
+    init(true, ['Font1', 'Font2'], {
+        'Font1': ['n7', 'i7']
+    });
+  });
+
+  // load
+  var families = null;
+  var descriptions = null;
+
+  typeKit.load(function(fontFamilies, fontDescriptions) {
+      families = fontFamilies;
+      descriptions = fontDescriptions;
+  });
+
+  assertNotNull(families);
+  assertEquals(2, families.length);
+  assertEquals('Font1', families[0]);
+  assertEquals('Font2', families[1]);
+
+  var font1Descriptions = descriptions['Font1'];
+  assertEquals(2, font1Descriptions.length);
+  assertEquals('n7', font1Descriptions[0]);
+  assertEquals('i7', font1Descriptions[1]);
+
+  var font2Descriptions = descriptions['Font2'];
+  assertUndefined(font2Descriptions);
+};
+
+TypekitScriptTest.prototype.testAlternateApi = function() {
+  var configuration = {
+    'id': 'abc',
+    'api': '/test'
+  };
+  var insert = '';
+  var src = '';
+  var fakeDomHelper = {
+      insertInto: function(tag, e) {
+        insert = tag;
+      },
+      createScriptSrc: function(srcLink) {
+        src = srcLink;
+      }
+  };
+  var typeKit = new webfont.TypekitScript({}, fakeDomHelper, configuration);
+  var userAgent = 'user agent';
+  var isSupport = null;
+
+  typeKit.supportUserAgent(userAgent, function(support) { isSupport = support; });
+  assertEquals('head', insert);
+  assertEquals('/test/abc.js', src);
+};
+
+TypekitScriptTest.prototype.testNoKitId = function() {
+  var configuration = {
+    'id': null,
+  };
+  var insert = null;
+  var src = null;
+  var fakeDomHelper = {
+      insertInto: function(tag, e) {
+        insert = tag;
+      },
+      createScriptSrc: function(srcLink) {
+        src = srcLink;
+      }
+  };
+  var typeKit = new webfont.TypekitScript({}, fakeDomHelper, configuration);
+  var userAgent = 'user agent';
+  var isSupport = null;
+
+  // supportUserAgent
+  typeKit.supportUserAgent(userAgent, function(support) { isSupport = support; });
+  assertNull(insert);
+  assertNull(src);
+  assertEquals(true, isSupport);
+
+  // load
+  typeKit.load(function(fontFamilies) { families = fontFamilies; });
+
+  assertEquals([], families);
+};

data/src/ascender/ascender_script.js

@@ -0,0 +1,84 @@
+/**
+ *
+ * WebFont.load({
+ *   ascender: {
+ *     key:'ec2de397-11ae-4c10-937f-bf94283a70c1',
+ *     families:['AyitaPro:regular,bold,bolditalic,italic']
+ *   }
+ * });
+ *
+ * @constructor
+ */
+webfont.AscenderScript = function(domHelper, configuration) {
+  this.domHelper_ = domHelper;
+  this.configuration_ = configuration;
+};
+
+webfont.AscenderScript.NAME = 'ascender';
+
+webfont.AscenderScript.VARIATIONS = {
+  'regular': 'n4',
+  'bold': 'n7',
+  'italic': 'i4',
+  'bolditalic': 'i7',
+  'r': 'n4',
+  'b': 'n7',
+  'i': 'i4',
+  'bi': 'i7'
+};
+
+webfont.AscenderScript.prototype.supportUserAgent = function(userAgent, support) {
+  return support(userAgent.isSupportingWebFont());
+};
+
+webfont.AscenderScript.prototype.load = function(onReady) {
+  var key = this.configuration_['key'];
+  var protocol = (('https:' == document.location.protocol) ? 'https:' : 'http:');
+  var url = protocol + '//webfonts.fontslive.com/css/' + key + '.css';
+  this.domHelper_.insertInto('head', this.domHelper_.createCssLink(url));
+  var fv = this.parseFamiliesAndVariations(this.configuration_['families']);
+  onReady(fv.families, fv.variations);
+};
+
+webfont.AscenderScript.prototype.parseFamiliesAndVariations = function(providedFamilies){
+  var families, variations, fv;
+  families = [];
+  variations = {};
+  for(var i = 0, len = providedFamilies.length; i < len; i++){
+    fv = this.parseFamilyAndVariations(providedFamilies[i]);
+    families.push(fv.family);
+    variations[fv.family] = fv.variations;
+  }
+  return { families:families, variations:variations };
+};
+
+webfont.AscenderScript.prototype.parseFamilyAndVariations = function(providedFamily){
+  var family, variations, parts;
+  parts = providedFamily.split(':');
+  family = parts[0];
+  variations = [];
+  if(parts[1]){
+    variations = this.parseVariations(parts[1]);
+  }else{
+    variations = ['n4'];
+  }
+  return { family:family, variations:variations };
+};
+
+webfont.AscenderScript.prototype.parseVariations = function(source){
+  var providedVariations = source.split(',');
+  var variations = [];
+  for(var i = 0, len = providedVariations.length; i < len; i++){
+    var pv = providedVariations[i];
+    if(pv){
+      var v = webfont.AscenderScript.VARIATIONS[pv];
+      variations.push(v ? v : pv);
+    }
+  }
+  return variations;
+};
+
+WebFont.addModule(webfont.AscenderScript.NAME, function(configuration) {
+  return new webfont.AscenderScript(new webfont.DomHelper(document),
+      configuration);
+});