webfontloader 1.0.5

data/src/google/fontapiparser.js

@@ -0,0 +1,94 @@
+/**
+ * @constructor
+ */
+webfont.FontApiParser = function(fontFamilies) {
+  this.fontFamilies_ = fontFamilies;
+  this.parsedFontFamilies_ = [];
+  this.variations_ = {};
+  this.fvd_ = new webfont.FontVariationDescription();
+};
+
+webfont.FontApiParser.VARIATIONS = {
+  'ultralight': 'n2',
+  'light': 'n3',
+  'regular': 'n4',
+  'bold': 'n7',
+  'italic': 'i4',
+  'bolditalic': 'i7',
+  'ul': 'n2',
+  'l': 'n3',
+  'r': 'n4',
+  'b': 'n7',
+  'i': 'i4',
+  'bi': 'i7'
+};
+
+webfont.FontApiParser.prototype.parse = function() {
+  var length = this.fontFamilies_.length;
+
+  for (var i = 0; i < length; i++) {
+    var pair = this.fontFamilies_[i].split(":");
+    var fontFamily = pair[0];
+    var variations = null;
+
+    if (pair.length == 2) {
+      var fvds = this.parseVariations_(pair[1]);
+
+      if (fvds.length > 0) {
+        variations = fvds;
+      }
+    } else {
+      variations = ['n4'];
+    }
+    this.parsedFontFamilies_.push(fontFamily);
+    this.variations_[fontFamily] = variations;
+  }
+};
+
+webfont.FontApiParser.prototype.generateFontVariationDescription_ = function(variation) {
+  if (!variation.match(/^[\w ]+$/)) {
+    return '';
+  }
+
+  var fvd = webfont.FontApiParser.VARIATIONS[variation];
+
+  if (fvd) {
+    return fvd;
+  } else {
+    var groups = variation.match(/^(\d*)(\w*)$/);
+    var numericMatch = groups[1];
+    var styleMatch = groups[2];
+    var s = styleMatch ? styleMatch : 'n';
+    var w = numericMatch ? numericMatch.substr(0, 1) : '4';
+    var css = this.fvd_.expand([s, w].join(''));
+    if (css) {
+      return this.fvd_.compact(css);
+    } else {
+      return null;
+    }
+  }
+};
+
+webfont.FontApiParser.prototype.parseVariations_ = function(variations) {
+  var finalVariations = [];
+  var providedVariations = variations.split(",");
+  var length = providedVariations.length;
+
+  for (var i = 0; i < length; i++) {
+    var variation = providedVariations[i];
+    var fvd = this.generateFontVariationDescription_(variation);
+
+    if (fvd) {
+      finalVariations.push(fvd);
+    }
+  }
+  return finalVariations;
+};
+
+webfont.FontApiParser.prototype.getFontFamilies = function() {
+  return this.parsedFontFamilies_;
+};
+
+webfont.FontApiParser.prototype.getVariations = function() {
+  return this.variations_;
+};

data/src/google/fontapiurlbuilder.js

@@ -0,0 +1,39 @@
+/**
+ * @constructor
+ */
+webfont.FontApiUrlBuilder = function(apiUrl) {
+  if (apiUrl) {
+    this.apiUrl_ = apiUrl;
+  } else {
+    var protocol = 'https:' == window.location.protocol ? 'https:' : 'http:';
+
+    this.apiUrl_ = protocol + webfont.FontApiUrlBuilder.DEFAULT_API_URL;
+  }  
+  this.fontFamilies_ = null;
+};
+
+webfont.FontApiUrlBuilder.DEFAULT_API_URL = '//fonts.googleapis.com/css';
+
+webfont.FontApiUrlBuilder.prototype.setFontFamilies = function(fontFamilies) {
+  // maybe clone?
+  this.fontFamilies_ = fontFamilies;
+};
+
+webfont.FontApiUrlBuilder.prototype.webSafe = function(string) {
+  return string.replace(/ /g, '+');
+};
+
+webfont.FontApiUrlBuilder.prototype.build = function() {
+  if (!this.fontFamilies_) {
+    throw new Error('No fonts to load !');
+  }
+  var length = this.fontFamilies_.length;
+  var sb = [];
+
+  for (var i = 0; i < length; i++) {
+    sb.push(this.webSafe(this.fontFamilies_[i]));
+  }
+  var url = this.apiUrl_ + '?family=' + sb.join('%7C'); // '|' escaped.
+
+  return url;
+};

data/src/google/googlefontapi.js

@@ -0,0 +1,49 @@
+/**
+ * @constructor
+ */
+webfont.GoogleFontApi = function(userAgent, domHelper, configuration) {
+  this.userAgent_ = userAgent;
+  this.domHelper_ = domHelper;
+  this.configuration_ = configuration;
+};
+
+webfont.GoogleFontApi.NAME = 'google';
+
+webfont.GoogleFontApi.prototype.supportUserAgent = function(userAgent, support) {
+  if (userAgent.getPlatform().match(/iPad|iPod|iPhone/) != null) {
+    support(false);
+  }
+  return support(userAgent.isSupportingWebFont());
+};
+
+webfont.GoogleFontApi.prototype.load = function(onReady) {
+  var fontApiUrlBuilder = new webfont.FontApiUrlBuilder(
+      this.configuration_['api']);
+  var fontFamilies = this.configuration_['families'];
+  var domHelper = this.domHelper_;
+  var nonBlockingIe = this.userAgent_.getName() == 'MSIE' &&
+      this.configuration_['blocking'] != true;
+
+  fontApiUrlBuilder.setFontFamilies(fontFamilies);
+
+  if (nonBlockingIe) {
+    domHelper.whenBodyExists(function() {
+      domHelper.insertInto('head', domHelper.createCssLink(
+          fontApiUrlBuilder.build()));
+    });
+  } else {
+    domHelper.insertInto('head', domHelper.createCssLink(
+        fontApiUrlBuilder.build()));
+  }
+  var fontApiParser = new webfont.FontApiParser(fontFamilies);
+
+  fontApiParser.parse();
+  onReady(fontApiParser.getFontFamilies(), fontApiParser.getVariations());
+};
+
+WebFont.addModule(webfont.GoogleFontApi.NAME, function(configuration) {
+  var userAgentParser = new webfont.UserAgentParser(navigator.userAgent);
+  var userAgent = userAgentParser.parse();
+  return new webfont.GoogleFontApi(userAgent,
+      new webfont.DomHelper(document), configuration);
+});

data/src/modules.yml

@@ -0,0 +1,27 @@
+core:
+  - core/namespace.js
+  - core/domhelper.js
+  - core/useragent.js
+  - core/useragentparser.js
+  - core/eventdispatcher.js
+  - core/fontmoduleloader.js
+  - core/fontwatcher.js
+  - core/font.js
+  - core/cssclassname.js
+  - core/cssfontfamilyname.js
+  - core/fontvariationdescription.js
+  - core/initialize.js
+
+ascender:
+  - ascender/ascender_script.js
+
+google:
+  - google/fontapiurlbuilder.js
+  - google/fontapiparser.js
+  - google/googlefontapi.js
+
+typekit:
+  - typekit/typekit_script.js
+
+custom:
+  - custom/customcss.js

data/src/typekit/typekit_script.js

@@ -0,0 +1,58 @@
+/**
+ * @constructor
+ */
+webfont.TypekitScript = function(global, domHelper, configuration) {
+  this.global_ = global;
+  this.domHelper_ = domHelper;
+  this.configuration_ = configuration;
+  this.fontFamilies_ = [];
+  this.fontVariations_ = {};
+};
+
+webfont.TypekitScript.NAME = 'typekit';
+webfont.TypekitScript.HOOK = '__webfonttypekitmodule__';
+
+webfont.TypekitScript.prototype.getScriptSrc = function(kitId) {
+  var api = this.configuration_['api'] || 'http://use.typekit.com';
+  return api + '/' + kitId + '.js';
+};
+
+webfont.TypekitScript.prototype.supportUserAgent = function(userAgent, support) {
+  var kitId = this.configuration_['id'];
+  var configuration = this.configuration_;
+  var self = this;
+
+  if (kitId) {
+    // Provide data to Typekit for processing.
+    if (!this.global_[webfont.TypekitScript.HOOK]) {
+      this.global_[webfont.TypekitScript.HOOK] = {};
+    }
+
+    // Typekit will call 'init' to indicate whether it supports fonts
+    // and what fonts will be provided.
+    this.global_[webfont.TypekitScript.HOOK][kitId] = function(callback) {
+      var init = function(typekitSupports, fontFamilies, fontVariations) {
+        self.fontFamilies_ = fontFamilies;
+        self.fontVariations_ = fontVariations;
+        support(typekitSupports);
+      };
+      callback(userAgent, configuration, init);
+    };
+
+    // Load the Typekit script.
+    var script = this.domHelper_.createScriptSrc(this.getScriptSrc(kitId))
+    this.domHelper_.insertInto('head', script);
+
+  } else {
+    support(true);
+  }
+};
+
+webfont.TypekitScript.prototype.load = function(onReady) {
+  onReady(this.fontFamilies_, this.fontVariations_);
+};
+
+WebFont.addModule(webfont.TypekitScript.NAME, function(configuration) {
+  return new webfont.TypekitScript(window, new webfont.DomHelper(document), configuration);
+});
+

data/webfontloader.gemspec

@@ -0,0 +1,144 @@
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'webfontloader'
+  s.version           = '1.0.5'
+  s.date              = '2010-07-12'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "WebFont Loader gives you added control when using linked fonts via @font-face."
+  s.description = <<-DESC
+WebFont Loader gives you added control when using linked fonts via
+`@font-face`. It provides a common interface to loading fonts regardless of
+the source, then adds a standard set of events you may use to control the
+loading experience.
+DESC
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["Ryan Carver", "Jeremie Lenfant-engelmann"]
+  s.email    = 'ryan@typekit.com'
+  s.homepage = 'http://github.com/typekit/webfontloader'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  ## This sections is only necessary if you have C extensions.
+  # s.require_paths << 'ext'
+  # s.extensions = %w[ext/extconf.rb]
+
+  ## If your gem includes any executables, list them here.
+  # s.executables = []
+  # s.default_executable = 'name'
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md] + Dir["docs/*.md"]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  # s.add_dependency('DEPNAME', [">= 1.1.0", "< 2.0.0"])
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  s.add_development_dependency('rack', ["~>1.2.1"])
+  s.add_development_dependency('sinatra', ["~>1.0"])
+  s.add_development_dependency('vegas', ["~>0.1.6"])
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    LICENSE
+    README.md
+    Rakefile
+    bin/webfontloader-demos
+    docs/EVENTS.md
+    docs/MODULES.md
+    docs/TRANSITIONS.md
+    lib/webfontloader.rb
+    lib/webfontloader/demo/public/ascender.html
+    lib/webfontloader/demo/public/basic.css
+    lib/webfontloader/demo/public/custom.html
+    lib/webfontloader/demo/public/event-css-active-multiple.html
+    lib/webfontloader/demo/public/event-css-active.html
+    lib/webfontloader/demo/public/event-css-inactive.html
+    lib/webfontloader/demo/public/event-css-loading.html
+    lib/webfontloader/demo/public/event-js-active.html
+    lib/webfontloader/demo/public/event-js-font-active.html
+    lib/webfontloader/demo/public/event-js-loading.html
+    lib/webfontloader/demo/public/events-variations.html
+    lib/webfontloader/demo/public/events.html
+    lib/webfontloader/demo/public/google-css.html
+    lib/webfontloader/demo/public/google.html
+    lib/webfontloader/demo/public/ie-fast-js.html
+    lib/webfontloader/demo/public/ie-slow-js.html
+    lib/webfontloader/demo/public/ie-slow-link.html
+    lib/webfontloader/demo/public/index.html
+    lib/webfontloader/demo/public/typekit-variations.html
+    lib/webfontloader/demo/public/typekit.html
+    lib/webfontloader/demo/server.rb
+    lib/webfontloader/modules.rb
+    src-test/ascender/ascender_script_test.js
+    src-test/core/cssclassnametest.js
+    src-test/core/cssfontfamilynametest.js
+    src-test/core/domhelpertest.js
+    src-test/core/eventdispatchertest.js
+    src-test/core/fontmoduleloadertest.js
+    src-test/core/fonttest.js
+    src-test/core/fontvariationdescriptiontest.js
+    src-test/core/fontwatchertest.js
+    src-test/core/useragenttest.js
+    src-test/custom/customcsstest.js
+    src-test/google/fontapiparsertest.js
+    src-test/google/fontapiurlbuildertest.js
+    src-test/google/googlefontapitest.js
+    src-test/typekit/typekit_script_test.js
+    src/ascender/ascender_script.js
+    src/async_load.js
+    src/closure.js
+    src/core/cssclassname.js
+    src/core/cssfontfamilyname.js
+    src/core/domhelper.js
+    src/core/eventdispatcher.js
+    src/core/font.js
+    src/core/fontmoduleloader.js
+    src/core/fontvariationdescription.js
+    src/core/fontwatcher.js
+    src/core/initialize.js
+    src/core/namespace.js
+    src/core/useragent.js
+    src/core/useragentparser.js
+    src/custom/customcss.js
+    src/google/fontapiparser.js
+    src/google/fontapiurlbuilder.js
+    src/google/googlefontapi.js
+    src/modules.yml
+    src/typekit/typekit_script.js
+    tools/compiler/compiler.jar
+    tools/jstestdriver/JsTestDriver-1.2.1.jar
+    webfontloader.gemspec
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ /^spec\/.*_spec\.rb/ }
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification 
+name: webfontloader
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 5
+  version: 1.0.5
+platform: ruby
+authors: 
+- Ryan Carver
+- Jeremie Lenfant-engelmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 1
+        - 2
+        - 1
+        version: 1.2.1
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: vegas
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 1
+        - 6
+        version: 0.1.6
+  type: :development
+  version_requirements: *id003
+description: |
+  WebFont Loader gives you added control when using linked fonts via
+  `@font-face`. It provides a common interface to loading fonts regardless of
+  the source, then adds a standard set of events you may use to control the
+  loading experience.
+
+email: ryan@typekit.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- docs/EVENTS.md
+- docs/MODULES.md
+- docs/TRANSITIONS.md
+files: 
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/webfontloader-demos
+- docs/EVENTS.md
+- docs/MODULES.md
+- docs/TRANSITIONS.md
+- lib/webfontloader.rb
+- lib/webfontloader/demo/public/ascender.html
+- lib/webfontloader/demo/public/basic.css
+- lib/webfontloader/demo/public/custom.html
+- lib/webfontloader/demo/public/event-css-active-multiple.html
+- lib/webfontloader/demo/public/event-css-active.html
+- lib/webfontloader/demo/public/event-css-inactive.html
+- lib/webfontloader/demo/public/event-css-loading.html
+- lib/webfontloader/demo/public/event-js-active.html
+- lib/webfontloader/demo/public/event-js-font-active.html
+- lib/webfontloader/demo/public/event-js-loading.html
+- lib/webfontloader/demo/public/events-variations.html
+- lib/webfontloader/demo/public/events.html
+- lib/webfontloader/demo/public/google-css.html
+- lib/webfontloader/demo/public/google.html
+- lib/webfontloader/demo/public/ie-fast-js.html
+- lib/webfontloader/demo/public/ie-slow-js.html
+- lib/webfontloader/demo/public/ie-slow-link.html
+- lib/webfontloader/demo/public/index.html
+- lib/webfontloader/demo/public/typekit-variations.html
+- lib/webfontloader/demo/public/typekit.html
+- lib/webfontloader/demo/server.rb
+- lib/webfontloader/modules.rb
+- src-test/ascender/ascender_script_test.js
+- src-test/core/cssclassnametest.js
+- src-test/core/cssfontfamilynametest.js
+- src-test/core/domhelpertest.js
+- src-test/core/eventdispatchertest.js
+- src-test/core/fontmoduleloadertest.js
+- src-test/core/fonttest.js
+- src-test/core/fontvariationdescriptiontest.js
+- src-test/core/fontwatchertest.js
+- src-test/core/useragenttest.js
+- src-test/custom/customcsstest.js
+- src-test/google/fontapiparsertest.js
+- src-test/google/fontapiurlbuildertest.js
+- src-test/google/googlefontapitest.js
+- src-test/typekit/typekit_script_test.js
+- src/ascender/ascender_script.js
+- src/async_load.js
+- src/closure.js
+- src/core/cssclassname.js
+- src/core/cssfontfamilyname.js
+- src/core/domhelper.js
+- src/core/eventdispatcher.js
+- src/core/font.js
+- src/core/fontmoduleloader.js
+- src/core/fontvariationdescription.js
+- src/core/fontwatcher.js
+- src/core/initialize.js
+- src/core/namespace.js
+- src/core/useragent.js
+- src/core/useragentparser.js
+- src/custom/customcss.js
+- src/google/fontapiparser.js
+- src/google/fontapiurlbuilder.js
+- src/google/googlefontapi.js
+- src/modules.yml
+- src/typekit/typekit_script.js
+- tools/compiler/compiler.jar
+- tools/jstestdriver/JsTestDriver-1.2.1.jar
+- webfontloader.gemspec
+has_rdoc: true
+homepage: http://github.com/typekit/webfontloader
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: WebFont Loader gives you added control when using linked fonts via @font-face.
+test_files: []
+