webfontloader 1.0.5

data/lib/webfontloader/demo/server.rb

@@ -0,0 +1,92 @@
+require 'sinatra/base'
+require 'open-uri'
+
+module WebFontLoader
+  module Demo
+    class Server < Sinatra::Base
+
+      DemoRoot = File.expand_path(File.join(File.dirname(__FILE__)))
+      ProjectRoot = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", ".."))
+
+      GoogleApi = "http://fonts.googleapis.com/css"
+      GoogleFontApi = "http://themes.googleusercontent.com/font"
+
+      set :app_file, __FILE__
+      set :sessions, false
+      set :static, true
+
+      set :modules, nil
+      set :compiled_js, nil
+
+      get '/' do
+        File.read(File.join(DemoRoot, "public", "index.html"))
+      end
+
+      get '/webfont.js' do
+        headers 'Content-Type' => "application/javascript"
+        headers 'Cache-Control' => 'max-age=300'
+        get_js_code
+      end
+
+      get '/fonts/api' do
+        url = "#{GoogleApi}?#{env['QUERY_STRING']}"
+        headers 'Content-Type' => 'text/css'
+        headers 'Cache-Control' => 'max-age=300'
+        response = open(url, 'User-Agent' => env['HTTP_USER_AGENT'])
+        source = response.read
+        source.gsub!(%r[http://themes.googleusercontent.com/font], '/fonts/font')
+        source
+      end
+
+      get '/fonts/font' do
+        sleep 1
+        url = "#{GoogleFontApi}?#{env['QUERY_STRING']}"
+        headers 'Cache-Control' => 'max-age=300'
+        headers 'Content-Encoding' => 'gzip'
+        response = open(url, 'User-Agent' => env['HTTP_USER_AGENT'])
+        response.read
+      end
+
+      get %r[/typekit/(\w+)\.js] do |kit_id|
+        headers 'Content-Type' => 'application/javascript'
+        headers 'Cache-Control' => 'max-age=300'
+        case kit_id
+        when "kitwitharialblack"
+          families = "['Arial Black']"
+          variations = "{}"
+        when "kitwithgeorgia"
+          families = "['Georgia']"
+          variations = "{ 'Georgia': ['i4', 'i7' ]}"
+        else
+          families = "[]"
+          variations = "{}"
+        end
+        <<-JS
+          if (window.__webfonttypekitmodule__) {
+            var module = window.__webfonttypekitmodule__['#{kit_id}'];
+            if (module) {
+              module(function(userAgent, configuration, init) {
+                // Here you may use the userAgent object to determine
+                // browser support.
+                init(true, #{families}, #{variations});
+              });
+            }
+          }
+        JS
+      end
+
+    protected
+
+      def get_js_code
+        if settings.compiled_js
+          settings.compiled_js
+        elsif settings.modules
+          settings.modules.all_source_files.map { |file| File.read(File.join(WebFontLoader::ProjectRoot, file)) }
+        else
+          "alert('No JavaScript has been configured in the demo server');"
+        end
+      end
+
+    end
+  end
+end

data/lib/webfontloader/modules.rb

@@ -0,0 +1,44 @@
+module WebFontLoader
+  class Modules
+
+    def initialize(*modules)
+      @project_root = WebFontLoader::ProjectRoot
+      @js_src = "src"
+      @js_test = "src-test"
+      @modules = modules.empty? ? config.keys : modules
+      # Make sure 'core' is first.
+      @modules.unshift "core"
+      @modules.uniq!
+    end
+
+    attr_reader :modules
+    attr_accessor :project_root, :js_src, :js_test
+
+    def all_source_files
+      @all_source_files ||= begin
+        modules.map { |mod| config[mod] }.compact.flatten.map { |f| File.join(js_src, f) }.push File.join(js_src, "async_load.js")
+      end
+    end
+
+    def all_test_globs
+      @all_test_globs ||= begin
+        js_test_dirs = Dir[File.join(project_root, js_test, "*")].map { |d| File.basename(d) }
+        js_test_dirs.map { |dir| File.join(js_test, dir, "*.js") if modules.include?(dir) }.compact
+      end
+    end
+
+    def js_output_wrapper(source)
+      File.read(File.join(js_src, "closure.js")).sub("{{source}}", source)
+    end
+
+  protected
+
+    def config
+      @config ||= begin
+        path = File.join(project_root, js_src)
+        YAML.load_file(File.join(path, "modules.yml"))
+      end
+    end
+
+  end
+end

data/src-test/ascender/ascender_script_test.js

@@ -0,0 +1,48 @@
+var AscenderScriptTest = TestCase('AscenderScriptTest');
+
+AscenderScriptTest.prototype.testLoadAndFamilyVariations = function(){
+
+  var insert, css, element;
+  var key = 'ec2de397-11ae-4c10-937f-bf94283a70c1';
+  var onReadyTriggered = false;
+
+  var fakeDomHelper = {
+      insertInto: function(tag, el) {
+        insert = tag;
+        element = el;
+      },
+      createCssLink: function(cssLink) {
+        css = cssLink;
+        return '<link href="' + css + '" type="text/css" />';
+      }
+  };
+
+  var configuration = {
+    key:key,
+    families: ['AndyBold','Arial:bold,regular']
+  };
+
+  var fakeOnReady = function(){
+    onReadyTriggered = true;
+  };
+
+  var as = new webfont.AscenderScript(fakeDomHelper, configuration);
+
+  assertFalse(onReadyTriggered);
+  as.load(fakeOnReady);
+
+  assertEquals('http://webfonts.fontslive.com/css/' + key + '.css', css);
+  assertEquals('<link href="http://webfonts.fontslive.com/css/' + key + '.css" type="text/css" />', element);
+  assertEquals('head', insert);
+  assertTrue(onReadyTriggered);
+
+  assertEquals(['n4'], as.parseVariations('regular'));
+  assertEquals(['n7'], as.parseVariations('bold'));
+  assertEquals(['i4'], as.parseVariations('italic'));
+  assertEquals(['i7'], as.parseVariations('bolditalic'));
+  assertEquals(['n4'], as.parseVariations('regular,'));
+  assertEquals(['n4','n7'], as.parseVariations('regular,bold'));
+  assertEquals(['n4','n7'], as.parseVariations('regular,,bold'));
+  assertEquals(['n4','n7'], as.parseVariations('n4,n7'));
+
+};

data/src-test/core/cssclassnametest.js

@@ -0,0 +1,42 @@
+var CssClassNameTest = TestCase('CssClassName');
+
+CssClassNameTest.prototype.setUp = function() {
+  this.sanitizer_ = new webfont.CssClassName();
+};
+
+CssClassNameTest.prototype.testSanitizeSpacesInName = function() {
+  var result = this.sanitizer_.sanitize(' My Family ');
+
+  assertEquals('myfamily', result);
+};
+
+CssClassNameTest.prototype.testSanitizeNumbersInName = function() {
+  var result = this.sanitizer_.sanitize('99 My Family 99');
+
+  assertEquals('99myfamily99', result);
+};
+
+CssClassNameTest.prototype.testSanitizeOtherChars = function() {
+  var result = this.sanitizer_.sanitize('_My+Family!-');
+
+  assertEquals('myfamily', result);
+};
+
+CssClassNameTest.prototype.testBuildManyParts = function() {
+  var result = this.sanitizer_.build('pre_', 'My Family', '_post');
+
+  assertEquals('pre-myfamily-post', result);
+};
+
+CssClassNameTest.prototype.testBuildSomeParts = function() {
+  var result = this.sanitizer_.build('pre!', 'My Family');
+
+  assertEquals('pre-myfamily', result);
+};
+
+CssClassNameTest.prototype.testBuildOtherJoinChar = function() {
+  this.sanitizer_ = new webfont.CssClassName('_');
+  var result = this.sanitizer_.build('pre', 'My Family');
+
+  assertEquals('pre_myfamily', result);
+};

data/src-test/core/cssfontfamilynametest.js

@@ -0,0 +1,54 @@
+var CssFontFamilyNameTest = TestCase('CssFontFamilyName');
+
+CssFontFamilyNameTest.prototype.setUp = function() {
+  this.sanitizer_ = new webfont.CssFontFamilyName();
+};
+
+CssFontFamilyNameTest.prototype.testSpaceNameWithoutQuotes = function() {
+  var result = this.sanitizer_.quote('My Family');
+
+  assertEquals('"My Family"', result);
+};
+
+CssFontFamilyNameTest.prototype.testSpaceNameWithDoubleQuotes = function() {
+  var result = this.sanitizer_.quote('"My Family"');
+
+  assertEquals('"My Family"', result);
+};
+
+CssFontFamilyNameTest.prototype.testSpaceNameWithSingleQuotes = function() {
+  var result = this.sanitizer_.quote('\'My Family\'');
+
+  assertEquals('"My Family"', result);
+};
+
+CssFontFamilyNameTest.prototype.testSpaceNameWithCommasAndQuotes = function() {
+  var result = this.sanitizer_.quote('\'family 1\',\'family 2\'');
+
+  assertEquals('\"family 1\",\"family 2\"', result);
+};
+
+CssFontFamilyNameTest.prototype.testSpaceNameWithCommaSpaceAndQuotes = function() {
+  var result = this.sanitizer_.quote('\'family 1\', \'family 2\'');
+
+  assertEquals('\"family 1\",\"family 2\"', result);
+};
+
+CssFontFamilyNameTest.prototype.testNoSpaceNameWithoutQuotes = function() {
+  var result = this.sanitizer_.quote('MyFamily');
+
+  assertEquals('MyFamily', result);
+};
+
+CssFontFamilyNameTest.prototype.testNoSpaceNameWithQuotes = function() {
+  var result = this.sanitizer_.quote('"MyFamily"');
+
+  assertEquals('MyFamily', result);
+};
+
+CssFontFamilyNameTest.prototype.testNoSpaceNameWithCommasAndQuotes = function() {
+  var result = this.sanitizer_.quote('\'family-1\', \'family-2\'');
+
+  assertEquals('family-1,family-2', result);
+};
+

data/src-test/core/domhelpertest.js

@@ -0,0 +1,81 @@
+var DomHelperTest = TestCase('DomHelperTest');
+
+DomHelperTest.prototype.setUp = function() {
+  this.domHelper_ = new webfont.DomHelper(document, new webfont.UserAgent("name", "version",
+      "engine", "engineVersion", "platform", "platformVersion", true));
+};
+
+DomHelperTest.prototype.testCreateElementNoAttr = function() {
+  var span = this.domHelper_.createElement('span');
+
+  assertNotNull(span);
+};
+
+DomHelperTest.prototype.testCreateElementEmptyAttrInnerHtml = function() {
+  var span = this.domHelper_.createElement('span', {}, 'moo');
+
+  assertNotNull(span);
+  assertEquals('moo', span.innerHTML);
+};
+
+DomHelperTest.prototype.testCreateElementWithAttrInnerHtml = function() {
+  var span = this.domHelper_.createElement('span', { style: 'font-size: 42px',
+      id: 'mySpan' }, 'hello');
+
+  assertNotNull(span);
+  assertEquals('mySpan', span.id);
+  assertEquals('42px', span.style.fontSize);
+  assertEquals('hello', span.innerHTML);
+};
+
+DomHelperTest.prototype.testCreateElementWithPrototypeAugments = function(){
+
+  Object.prototype.extrastuff = function(){ return 'I am a troublemaker.'; }
+
+  var span = this.domHelper_.createElement('span', { id : "augmented" });
+  var spanPar = this.domHelper_.createElement('div', { id : "augmentedpar" });
+  spanPar.appendChild(span);
+
+
+  assertNotNull(span);
+  assertSame(false,!!span.getAttribute('extrastuff'));
+  assertSame(-1,spanPar.innerHTML.indexOf('extrastuff'))
+
+
+  delete Object.prototype.extrastuff;
+  span = spanPar = undefined;
+}
+
+DomHelperTest.prototype.testCreateCssLink = function() {
+  var cssLink = this.domHelper_.createCssLink('http://moo/somecss.css');
+
+  assertEquals('stylesheet', cssLink.rel);
+  assertEquals('http://moo/somecss.css', cssLink.href);
+};
+
+DomHelperTest.prototype.testCreateScriptSrc = function() {
+  var cssLink = this.domHelper_.createScriptSrc('http://moo/somescript.js');
+
+  assertEquals('http://moo/somescript.js', cssLink.src);
+};
+
+DomHelperTest.prototype.testAppendAndRemoveClassNames = function() {
+  var div = this.domHelper_.createElement('div');
+
+  this.domHelper_.appendClassName(div, 'moo');
+  assertEquals('moo', div.className);
+  this.domHelper_.appendClassName(div, 'meuh');
+  assertEquals('moo meuh', div.className);
+  this.domHelper_.removeClassName(div, 'moo');
+  assertEquals('meuh', div.className);
+
+  this.domHelper_.removeClassName(div, 'meuh');
+  this.domHelper_.appendClassName(div, 'spaces and	tabs');
+
+  this.domHelper_.removeClassName(div, 'and');
+  assertEquals('spaces tabs', div.className);
+  this.domHelper_.removeClassName(div, 'spaces');
+  this.domHelper_.removeClassName(div, 'tabs');
+  assertEquals('', div.className);
+
+};

data/src-test/core/eventdispatchertest.js

@@ -0,0 +1,99 @@
+var EventDispatcherTest = TestCase('EventDispatcherTest');
+
+EventDispatcherTest.prototype.setUp = function() {
+  this.fakeHtmlElement_ = { className: '' };
+  this.loadingEventCalled_ = false;
+  this.fontLoadingEventCalled_ = false;
+  this.fontLoading_ = '';
+  this.fontActiveEventCalled_ = false;
+  this.fontActive_ = '';
+  this.fontInactvieEventCalled_ = false;
+  this.fontInactive_ = '';
+  this.activeEventCalled_ = false;
+  this.inactiveEventCalled_ = false;
+  var namespace = 'ns';
+  var self = this;
+
+  this.eventDispatcher_ = new webfont.EventDispatcher(new webfont.DomHelper(
+      document), this.fakeHtmlElement_, {
+        loading: function() {
+          self.loadingEventCalled_ = true;
+        },
+        active: function() {
+          self.activeEventCalled_ = true;
+        },
+        inactive: function() {
+          self.inactiveEventCalled_ = true;
+	      },
+        fontloading: function(fontFamily, fontDescription) {
+          self.fontLoadingEventCalled_ = true;
+          self.fontLoading_ = fontFamily + ' ' + fontDescription;
+        },
+        fontactive: function(fontFamily, fontDescription) {
+          self.fontActiveEventCalled_ = true;
+          self.fontActive_ = fontFamily + ' ' + fontDescription;
+        },
+        fontinactive: function(fontFamily, fontDescription) {
+          self.fontInactvieEventCalled_ = true;
+          self.fontInactive_ = fontFamily + ' ' + fontDescription;
+        }
+  }, namespace);
+};
+
+EventDispatcherTest.prototype.testClassNamesOnActiveLoad = function() {
+  this.eventDispatcher_.dispatchLoading();
+  assertEquals('ns-loading', this.fakeHtmlElement_.className);
+  this.eventDispatcher_.dispatchFontLoading('My Family', 'n4');
+  assertEquals('ns-loading ns-myfamily-n4-loading', this.fakeHtmlElement_.className);
+  this.eventDispatcher_.dispatchFontActive('My Family', 'n4');
+  assertEquals('ns-loading ns-myfamily-n4-active', this.fakeHtmlElement_.className);
+  this.eventDispatcher_.dispatchActive();
+  assertEquals('ns-myfamily-n4-active ns-active', this.fakeHtmlElement_.className);
+};
+
+EventDispatcherTest.prototype.testClassNamesOnInactiveLoad = function() {
+  this.eventDispatcher_.dispatchLoading();
+  assertEquals('ns-loading', this.fakeHtmlElement_.className);
+  this.eventDispatcher_.dispatchFontLoading('My Family', 'n4');
+  assertEquals('ns-loading ns-myfamily-n4-loading', this.fakeHtmlElement_.className);
+  this.eventDispatcher_.dispatchFontInactive('My Family', 'n4');
+  assertEquals('ns-loading ns-myfamily-n4-inactive', this.fakeHtmlElement_.className);
+  this.eventDispatcher_.dispatchActive();
+  assertEquals('ns-myfamily-n4-inactive ns-active', this.fakeHtmlElement_.className);
+};
+
+EventDispatcherTest.prototype.testEventsOnActiveLoad = function() {
+  this.eventDispatcher_.dispatchLoading();
+  assertTrue(this.loadingEventCalled_);
+  this.eventDispatcher_.dispatchFontLoading('fontFamilyLoading', 'n4');
+  assertTrue(this.fontLoadingEventCalled_);
+  assertEquals('fontFamilyLoading n4', this.fontLoading_);
+  this.eventDispatcher_.dispatchFontActive('fontFamilyActive', 'n4');
+  assertTrue(this.fontActiveEventCalled_);
+  assertEquals('fontFamilyActive n4', this.fontActive_);
+  this.eventDispatcher_.dispatchActive();
+  assertTrue(this.activeEventCalled_);
+};
+
+EventDispatcherTest.prototype.testEventsOnInactiveLoad = function() {
+  this.eventDispatcher_.dispatchLoading();
+  assertTrue(this.loadingEventCalled_);
+  this.eventDispatcher_.dispatchFontLoading('fontFamilyLoading', 'n4');
+  assertTrue(this.fontLoadingEventCalled_);
+  assertEquals('fontFamilyLoading n4', this.fontLoading_);
+  this.eventDispatcher_.dispatchFontInactive('fontFamilyInactive', 'n4');
+  assertTrue(this.fontInactvieEventCalled_);
+  assertEquals('fontFamilyInactive n4', this.fontInactive_);
+  this.eventDispatcher_.dispatchActive();
+  assertTrue(this.activeEventCalled_);
+};
+
+EventDispatcherTest.prototype.testClassNamesOnInactive = function() {
+  this.eventDispatcher_.dispatchInactive();
+  assertEquals('ns-inactive', this.fakeHtmlElement_.className);
+};
+
+EventDispatcherTest.prototype.testEventsOnInactive = function() {
+  this.eventDispatcher_.dispatchInactive();
+  assertTrue(this.inactiveEventCalled_);
+};