webfontloader 1.2.0 → 1.2.1

data/spec/fonts/sourcesansa.css

@@ -0,0 +1 @@
+@font-face{font-family:SourceSansA;src:url(sourcesans.eot?#iefix) format('embedded-opentype'),url(sourcesans.woff) format('woff'),url(sourcesans.otf) format('opentype'),url(sourcesans.ttf) format('truetype'),url(sourcesans.svg#source_sans_proregular) format('svg');}

data/spec/fonts/sourcesansb.css

@@ -0,0 +1 @@
+@font-face{font-family:SourceSansB;src:url(sourcesans.eot?#iefix) format('embedded-opentype'),url(sourcesans.woff) format('woff'),url(sourcesans.otf) format('opentype'),url(sourcesans.ttf) format('truetype'),url(sourcesans.svg#source_sans_proregular) format('svg');}

data/spec/google/fontapiparser_spec.js

@@ -0,0 +1,348 @@
+describe('FontApiParser', function () {
+  var FontApiParser = webfont.FontApiParser;
+
+  describe('parsed values are coherent', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Tangerine', 'Droid Serif:bi', 'Yanone Kaffeesatz:200,300,400,700', 'Cantarell:italic,b', 'Exo:100italic', 'Lobster:200n']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var fontFamilies = parser.getFontFamilies();
+
+      expect(fontFamilies.length).toEqual(6);
+      expect(fontFamilies).toEqual([
+        'Tangerine',
+        'Droid Serif',
+        'Yanone Kaffeesatz',
+        'Cantarell',
+        'Exo',
+        'Lobster'
+      ]);
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations();
+
+      var tangerine = variations['Tangerine'];
+      expect(tangerine).not.toBeNull();
+      expect(tangerine.length).toEqual(1);
+      expect(tangerine[0]).toEqual('n4');
+
+      var droidSerif = variations['Droid Serif'];
+      expect(droidSerif).not.toBeNull();
+      expect(droidSerif.length).toEqual(1);
+      expect(droidSerif[0]).toEqual('i7');
+
+      var yanoneKaffeesatz = variations['Yanone Kaffeesatz'];
+      expect(yanoneKaffeesatz).not.toBeNull();
+      expect(yanoneKaffeesatz.length).toEqual(4);
+      expect(yanoneKaffeesatz[0]).toEqual('n2');
+      expect(yanoneKaffeesatz[1]).toEqual('n3');
+      expect(yanoneKaffeesatz[2]).toEqual('n4');
+      expect(yanoneKaffeesatz[3]).toEqual('n7');
+
+      var cantarell = variations['Cantarell'];
+      expect(cantarell).not.toBeNull();
+      expect(cantarell.length).toEqual(2);
+      expect(cantarell[0]).toEqual('i4');
+      expect(cantarell[1]).toEqual('n7');
+
+      var exo = variations['Exo'];
+      expect(exo).not.toBeNull();
+      expect(exo.length).toEqual(1);
+      expect(exo[0]).toEqual('i1');
+
+      var lobster = variations['Lobster'];
+      expect(lobster).not.toBeNull();
+      expect(lobster.length).toEqual(1);
+      expect(lobster[0]).toEqual('n2');
+    });
+  });
+
+  describe('mix of numeric weight and style', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Nobile:700i,b,200i,r,i700']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var families = parser.getFontFamilies();
+
+      expect(families.length).toEqual(1);
+      expect(families[0]).toEqual('Nobile');
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations(),
+          nobile = variations['Nobile'];
+
+      expect(nobile).not.toBeNull();
+      expect(nobile.length).toEqual(4);
+      expect(nobile[0]).toEqual('i7');
+      expect(nobile[1]).toEqual('n7');
+      expect(nobile[2]).toEqual('i2');
+      expect(nobile[3]).toEqual('n4');
+    });
+  });
+
+  describe('typo bild instead of bold', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Nobile:bild']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var families = parser.getFontFamilies();
+
+      expect(families.length).toEqual(1);
+      expect(families[0]).toEqual('Nobile');
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations(),
+          nobile = variations['Nobile'];
+
+      expect(nobile).not.toBeNull();
+      expect(nobile.length).toEqual(1);
+      expect(nobile[0]).toEqual('n4');
+    });
+  });
+
+  describe('nonsense', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Nobile:dwe,^%^%fewf,$9940@#!@#$%^&*()_+}POIBJ{}{']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var families = parser.getFontFamilies();
+
+      expect(families.length).toEqual(1);
+      expect(families[0]).toEqual('Nobile');
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations(),
+          nobile = variations['Nobile'];
+
+      expect(nobile).not.toBeNull();
+      expect(nobile.length).toEqual(1);
+      expect(nobile[0]).toEqual('n4');
+    });
+  });
+
+  describe('no weight and one subset defined', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Cantarell::greek']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var families = parser.getFontFamilies();
+
+      expect(families.length).toEqual(1);
+      expect(families[0]).toEqual('Cantarell');
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations(),
+          cantarell = variations['Cantarell'];
+
+      expect(cantarell).not.toBeNull();
+      expect(cantarell.length).toEqual(1);
+      expect(cantarell[0]).toEqual('n4');
+    });
+
+    it('should parse pick test strings correctly', function () {
+      var testStrings = parser.getFontTestStrings(),
+          cantarell = testStrings['Cantarell'];
+
+      expect(cantarell).not.toBeNull();
+      expect(cantarell).toEqual(FontApiParser.INT_FONTS['greek']);
+    });
+  });
+
+  describe('no weight and multiple subsets defined', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Cantarell::cyrillic,greek,latin']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var families = parser.getFontFamilies();
+
+      expect(families.length).toEqual(1);
+      expect(families[0]).toEqual('Cantarell');
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations(),
+          cantarell = variations['Cantarell'];
+
+      expect(cantarell).not.toBeNull();
+      expect(cantarell.length).toEqual(1);
+      expect(cantarell[0]).toEqual('n4');
+    });
+
+    it('should parse pick test strings correctly', function () {
+      var testStrings = parser.getFontTestStrings(),
+          cantarell = testStrings['Cantarell'];
+
+      expect(cantarell).not.toBeNull();
+      expect(cantarell).toEqual(FontApiParser.INT_FONTS['cyrillic']);
+    });
+  });
+
+  describe('weight and multiple subsets defined', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Cantarell:regular,bold:cyrillic,greek,latin']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var families = parser.getFontFamilies();
+
+      expect(families.length).toEqual(1);
+      expect(families[0]).toEqual('Cantarell');
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations(),
+          cantarell = variations['Cantarell'];
+
+      expect(cantarell).not.toBeNull();
+      expect(cantarell.length).toEqual(2);
+      expect(cantarell[0]).toEqual('n4');
+      expect(cantarell[1]).toEqual('n7');
+    });
+
+    it('should parse pick test strings correctly', function () {
+      var testStrings = parser.getFontTestStrings(),
+          cantarell = testStrings['Cantarell'];
+
+      expect(cantarell).not.toBeNull();
+      expect(cantarell).toEqual(FontApiParser.INT_FONTS['cyrillic']);
+    });
+  });
+
+  describe('Hanuman is backward compatible', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Hanuman']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var families = parser.getFontFamilies();
+
+      expect(families.length).toEqual(1);
+      expect(families[0]).toEqual('Hanuman');
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations(),
+          hanuman = variations['Hanuman'];
+
+      expect(hanuman).not.toBeNull();
+      expect(hanuman.length).toEqual(1);
+      expect(hanuman[0]).toEqual('n4');
+    });
+
+    it('should parse pick test strings correctly', function () {
+      var testStrings = parser.getFontTestStrings(),
+          hanuman = testStrings['Hanuman'];
+
+      expect(hanuman).not.toBeNull();
+      expect(hanuman).toEqual(FontApiParser.INT_FONTS['Hanuman']);
+    });
+  });
+
+  describe('Hanuman is forward compatible', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Hanuman::khmer']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var families = parser.getFontFamilies();
+
+      expect(families.length).toEqual(1);
+      expect(families[0]).toEqual('Hanuman');
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations(),
+          hanuman = variations['Hanuman'];
+
+      expect(hanuman).not.toBeNull();
+      expect(hanuman.length).toEqual(1);
+      expect(hanuman[0]).toEqual('n4');
+    });
+
+    it('should parse pick test strings correctly', function () {
+      var testStrings = parser.getFontTestStrings(),
+          hanuman = testStrings['Hanuman'];
+
+      expect(hanuman).not.toBeNull();
+      expect(hanuman).toEqual(FontApiParser.INT_FONTS['khmer']);
+    });
+  });
+
+  describe('plus replaced with space', function () {
+    var parser = null;
+
+    beforeEach(function () {
+      parser = new FontApiParser(['Erica+One', 'Droid+Serif::latin', 'Yanone+Kaffeesatz:400,700:latin']);
+      parser.parse();
+    });
+
+    it('should parse families correctly', function () {
+      var fontFamilies = parser.getFontFamilies();
+
+      expect(fontFamilies.length).toEqual(3);
+      expect(fontFamilies).toEqual([
+        'Erica One',
+        'Droid Serif',
+        'Yanone Kaffeesatz'
+      ]);
+    });
+
+    it('should parse variations correctly', function () {
+      var variations = parser.getVariations();
+
+      var ericaOne = variations['Erica One'];
+      expect(ericaOne).not.toBeNull();
+      expect(ericaOne.length).toEqual(1);
+      expect(ericaOne[0]).toEqual('n4');
+
+      var droidSerif = variations['Droid Serif'];
+      expect(droidSerif).not.toBeNull();
+      expect(droidSerif.length).toEqual(1);
+      expect(droidSerif[0]).toEqual('n4');
+
+      var yanoneKaffeesatz = variations['Yanone Kaffeesatz'];
+      expect(yanoneKaffeesatz).not.toBeNull();
+      expect(yanoneKaffeesatz.length).toEqual(2);
+      expect(yanoneKaffeesatz[0]).toEqual('n4');
+      expect(yanoneKaffeesatz[1]).toEqual('n7');
+    });
+  });
+});

data/spec/google/fontapiurlbuilder_spec.js

@@ -0,0 +1,40 @@
+describe('FontApiUrlBuilder', function () {
+  var FontApiUrlBuilder = webfont.FontApiUrlBuilder;
+
+  it('should throw an exception if there are no font families', function () {
+    var builder = new FontApiUrlBuilder('http://moo', 'http:');
+    expect(builder.build).toThrow();
+  });
+
+  it('should build a proper url', function () {
+    var builder = new FontApiUrlBuilder('http://moo', 'http:');
+    builder.setFontFamilies(['Font1', 'Font2']);
+    expect(builder.build()).toEqual('http://moo?family=Font1%7CFont2');
+  });
+
+  it('should build a proper url', function () {
+    var builder = new FontApiUrlBuilder(undefined, 'http:');
+    builder.setFontFamilies(['Font1', 'Font2']);
+    expect(builder.build()).toEqual('http:' +
+      FontApiUrlBuilder.DEFAULT_API_URL +
+      '?family=Font1%7CFont2');
+  });
+
+  it('should build a proper url', function () {
+    var builder = new FontApiUrlBuilder(undefined, 'http:');
+    builder.setFontFamilies(['Font1:bold:greek,cyrillic', 'Font2:italic', 'Font3']);
+    expect(builder.build()).toEqual('http:' +
+      FontApiUrlBuilder.DEFAULT_API_URL +
+      '?family=Font1:bold%7CFont2:italic%7CFont3' +
+      '&subset=greek,cyrillic');
+  });
+
+  it('should build a proper url', function () {
+    var builder = new FontApiUrlBuilder(undefined, 'http:');
+    builder.setFontFamilies(['Font1:bold,italic:greek,cyrillic', 'Font2:italic', 'Font3::latin']);
+    expect(builder.build()).toEqual('http:' +
+      FontApiUrlBuilder.DEFAULT_API_URL +
+      '?family=Font1:bold,italic%7CFont2:italic%7CFont3' +
+      '&subset=greek,cyrillic,latin');
+  });
+});

data/spec/google/googlefontapi_spec.js

@@ -0,0 +1,123 @@
+describe('GoogleFontApi', function () {
+  var GoogleFontApi = webfont.GoogleFontApi,
+      UserAgent = webfont.UserAgent,
+      userAgent = null,
+      link = '',
+      insert = '',
+      fakeDomHelper =  {
+        insertInto: function (tag, e) {
+          insert = tag;
+        },
+        createCssLink: function (cssLink) {
+          link = cssLink;
+        },
+        getProtocol: function () {
+          return 'http:';
+        }
+      };
+
+
+  beforeEach(function () {
+    insert = '';
+    link = '';
+    userAgent = new UserAgent('Test', '1.0', true);
+  });
+
+  describe('call onReady with font family loading', function () {
+    var googleFontApi = null,
+        families = null,
+        descriptions = null;
+
+    beforeEach(function () {
+      googleFontApi = new GoogleFontApi(userAgent, fakeDomHelper, { families: ['Font1', 'Font2'] });
+      googleFontApi.load(function (fontFamilies, fontDescriptions) {
+        families = fontFamilies;
+        descriptions = fontDescriptions;
+      });
+    });
+
+    it('has inserted the link element correctly', function () {
+      expect(insert).toEqual('head');
+      expect(link).toEqual('http://fonts.googleapis.com/css?family=Font1%7CFont2');
+    });
+
+    it('has the correct families', function () {
+      expect(families).not.toBeNull();
+      expect(families.length).toEqual(2);
+      expect(families[0]).toEqual('Font1');
+      expect(families[1]).toEqual('Font2');
+    });
+
+    it('has the correct font descriptions', function () {
+      var font1 = descriptions['Font1'];
+      expect(font1).not.toBeNull();
+      expect(font1.length).toEqual(1);
+      expect(font1[0]).toEqual('n4');
+
+      var font2 = descriptions['Font2'];
+      expect(font2).not.toBeNull();
+      expect(font2.length).toEqual(1);
+      expect(font1[0]).toEqual('n4');
+    });
+  });
+
+  describe('call onReady with font family loading and custom API url', function () {
+    var googleFontApi = null,
+        families = null,
+        descriptions = null;
+
+    beforeEach(function () {
+      googleFontApi = new GoogleFontApi(userAgent, fakeDomHelper, {
+        api: 'http://moo',
+        families: ['Font1', 'Font2']
+      });
+      googleFontApi.load(function (fontFamilies, fontDescriptions) {
+        families = fontFamilies;
+        descriptions = fontDescriptions;
+      });
+    });
+
+    it('has inserted the link element correctly', function () {
+      expect(insert).toEqual('head');
+      expect(link).toEqual('http://moo?family=Font1%7CFont2');
+    });
+  });
+
+  describe('spaces replaced by plus', function () {
+    var googleFontApi = null,
+        families = null,
+        descriptions = null;
+
+    beforeEach(function () {
+      googleFontApi = new GoogleFontApi(userAgent, fakeDomHelper, { families: ['Font1 WithSpace', 'Font2 WithSpaceToo'] });
+      googleFontApi.load(function (fontFamilies, fontDescriptions) {
+        families = fontFamilies;
+        descriptions = fontDescriptions;
+      });
+    });
+
+    it('has inserted the link element correctly', function () {
+      expect(insert).toEqual('head');
+      expect(link).toEqual('http://fonts.googleapis.com/css?family=Font1+WithSpace%7CFont2+WithSpaceToo');
+    });
+ });
+
+  describe('load with variations', function () {
+    var googleFontApi = null,
+        families = null,
+        descriptions = null;
+
+    beforeEach(function () {
+      googleFontApi = new GoogleFontApi(userAgent, fakeDomHelper, { families: ['Font1 WithSpace:bi', 'Font2 WithSpaceToo:b,r'] });
+      googleFontApi.load(function (fontFamilies, fontDescriptions) {
+        families = fontFamilies;
+        descriptions = fontDescriptions;
+      });
+    });
+
+    it('has inserted the link element correctly', function () {
+      expect(insert).toEqual('head');
+      expect(link).toEqual('http://fonts.googleapis.com/css?family=Font1+WithSpace:bi%7CFont2+WithSpaceToo:b,r');
+    });
+ });
+});