typekit 0.2.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Corey Ward
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,165 @@
+Typekit API Client
+==================
+
+This is a Ruby client for the [Typekit API](http://typekit.com/docs/api). **It is still in development**. Feel free to help out, 
+or just watch the project and check it out when it gets closer to completion. Any tips/pointers are much appreciated.
+
+You can get in touch with me at `corey.atx.at.gmail.com`.
+
+Example
+-------
+
+A quick example of how to use the client. 
+
+    # Add FF Meta Web Pro to a Kit with Normal and Bold weights
+    typekit = Typekit::Client.new(token)
+    kit = typekit.kit('abcdef')
+    kit.add_family(typekit.family_by_name('FF Meta Web Pro').id, :variations => ['n4', 'n7'])
+    kit.publish
+    
+    # Change the name of a kit and add a domain
+    kit.name = 'Example'
+    kit.domains << 'localhost'
+    kit.save
+    
+    # Get the web address to Droid Sans
+    typekit.family_by_slug('droid-sans').web_link
+
+Usage
+-----
+
+You'll need a Typekit account and a Typekit API token to use the Typekit API. You can generate a new token 
+[here](https://typekit.com/account/tokens). You should also familiarize yourself with the 
+[terminology](http://typekit.com/docs/api/terminology) that the Typekit API uses and the way [changes are published](http://typekit.com/docs/api/kits).
+
+There are two ways you can work with the Typekit API client: directly through the class variables, or via an
+instance of the `Typekit::Client` object. Either way, beware that the token you provide will be assigned to
+a class variable (ie. it'll be shared across instances of Typekit::Client). This is due to the way HTTParty works.
+
+### Getting Started
+
+    # Getting down to business...
+    typekit = Typekit::Client.new(token)
+  
+    # Get a list of kits in your account
+    kits = typekit.kits    #=> [<Typekit::Kit @id='abcdef'>, <Typekit::Kit @id='ghijkl', ...]
+
+    # Get detailed information for a kit by ID
+    typekit.kit('abcdef')
+    #=> <Typekit::Kit @id='abcdef', @name='Test', @analytics=false, @badge=false, @domains=['localhost'], @families=[...]>
+
+### Using the API without an instance of Typekit::Client
+
+    # If you prefer using the class methods directly, the following is identical to the above methods...
+    Typekit::Client.set_token(token)
+    Typekit::Kit.all             #=> [<Typekit::Kit @id='abcdef'>, <Typekit::Kit @id='ghijkl', ...]
+    Typekit::Kit.find('abcdef')  #=> <Typekit::Kit @id='abcdef', @name="Test", ...>
+
+### Lazy Loaded Detailed Attributes    
+
+Detailed information for kits gets loaded lazily when you use `Typekit::Kit.all`. This allows us to create instances
+of `Typekit::Kit` without the full set of attributes and without requiring you to manually load that data.
+
+    kits = typekits.all   #=> [...]
+    kits.first            #=> <Typekit::Kit @id='abcdef'>
+    kits.first.name       #=> "Test"
+    kits.first            #=> <Typekit::Kit @id='abcdef', @name='Test', @analytics=false, @badge=false, @domains=['localhost'], @families=[]>
+
+### Updating a Kit
+
+You can make changes to a Kit by altering the attributes and calling `save`:
+
+    kit = typekit.kit('abcdef')
+    kit.name = 'Derezzed'
+    kit.domains << 'localhost'
+    kit.save
+
+#### Publishing Manually
+
+When you call `Typekit::Kit#save`, the kit is also published. If you don't want this to happen, pass `false` as the only argument. You can also manually publish a Kit after making changes.
+
+    kit.name = 'Fashion Nugget'
+    kit.save(false)
+    # ... later in your application, possibly even in another request
+    kit = Typekit::Client.kit('abcdef')
+    kit.publish     #=> Finally, changes are published to the Typekit CDN
+
+### Getting Font Family Information
+
+The Typekit API also allows you to find detailed information about any Family in their library, including all available
+validations, CSS font names, etc. **If you are not familiar with the terminology Typekit uses throughout their API, you 
+really should [give it a read](http://typekit.com/docs/api/terminology) before continuing.**
+
+    # Get a family by ID
+    family = typekit.family('brwr')
+    
+    # Get a family by slug
+    family = typekit.family_by_slug('ff-meta-web-pro')
+    
+    # Get a family by name (gets converted to a slug automatically)
+    family = typekit.family_by_name('FF Meta Web Pro')
+    
+    # List variations available for a given family
+    family.variations       #=> [<Typekit::Variation ...>, <Typekit::Variation ...>, ...]
+    
+    # Get a particular variation (details lazy-loaded)
+    variation = typekit.family('brwr').variation('n4') #=> <Typekit::Variation @id="brwr:n4", @name="FF Meta Web Pro Normal">
+    
+    # View details about a variation
+    variation.font_weight    #=> "400"
+    variation.to_fvd         #=> "n4"
+    variation                #=> <Typekit::Variation @id="brwr:n4", @name="FF Meta Web Pro Normal", @font_weight="400", ...>
+    
+**Note**: Variations, like Kits, have detailed information loaded lazily. If you would like to load data for a Variation 
+without accessing an individual attribute you can simply call `Typekit::Variation#fetch`.
+
+### Adding a Family to a Kit
+
+You can add Families to a kit by specifying the Family ID (which can be found through the `Typekit::Family` methods) and 
+which you want to have included in the Kit. These methods *make changes to the "working" copy* of your Kit. In order for them 
+to take effect, **you must publish your Kit after adding/updating/removing Families**.
+    
+    # Add a new Family with the full character subset
+    kit = typekit.kit('abcdef')
+    kit.add_family('brwr', :variations => ['n4'], :subset => 'all')
+    
+    # Changing a Family that is already a part of a Kit
+    kit.update_family('brwr') do |f|
+      f['subset'] = 'default'
+      f['variations'] << 'i7'
+    end
+    
+    # Removing a Variation from a Family in your a Kit
+    kit.update_family('brwr') do |f|
+      f['variations'].delete_if { |v| v == 'n4' }
+    end
+    
+    # Remove a Family from a Kit
+    kit.delete_family('brwr')
+    
+    # Publishing your changes
+    kit.publish
+    
+**Important Note**: Families and Variations that are a part of Kits are passed around as Hashes, not instances of `Typekit::Family` or 
+`Typekit::Variation`, which are used solely browse the available Families and their details.
+    
+Documentation
+-------------
+
+Full documentation for the latest version can be found at [RubyDoc](http://rubydoc.info/github/coreyward/typekit).
+
+Contributing
+------------
+
+* Fork the project
+* Start a feature/bugfix branch
+* Add [yard](http://yardoc.org/)-compatible documentation for your changes, where relevant. Follow the existing styles.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+---------
+
+Copyright (c) 2011 Corey Ward. Licensed under the "MIT" license. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "typekit"
+  gem.homepage = "http://github.com/coreyward/typekit"
+  gem.license = "MIT"
+  gem.summary = %{Ruby library for accessing the Typekit REST API.}
+  gem.description = %{Ruby library for accessing the Typekit REST API.}
+  gem.email = "corey.atx@gmail.com"
+  gem.authors = ["Corey Ward"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_dependency 'httparty', '~> 0.7.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "typekit #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/typekit/base.rb

@@ -0,0 +1,15 @@
+module Typekit
+  # Contains mass assignment functionality for building objects out of hashes.
+  # @abstract
+  module MassAssignment
+    def initialize(attributes = {})
+      mass_assign(attributes)
+    end
+    
+    def mass_assign(attributes)
+      attributes.each do |attribute, value|
+        respond_to?(:"#{attribute}=") && send(:"#{attribute}=", value)
+      end
+    end
+  end
+end

data/lib/typekit/client.rb

@@ -0,0 +1,119 @@
+module Typekit
+  class Client
+    include HTTParty
+    base_uri 'https://typekit.com/api/v1/json'
+
+    # @param token [String] Your Typekit API token
+    def initialize(token)
+      set_token token
+    end
+
+    # Rather than making laborious calls to `Typekit::Client.kits` you can create an instance
+    # of the {Typekit::Client} and call methods on it. Instance methods will be defined for 
+    # class methods on their first utilization.
+    # @example
+    #   typekit = Typekit::Client.new('your token here')
+    #   typekit.kits    #=> [...]
+    def method_missing(method, *args, &block)
+      super unless self.class.respond_to? method
+      self.class.class_eval do
+        define_method method do |*args, &block|
+          self.class.send(method, *args, &block)
+        end
+      end
+      self.class.send(method, *args, &block)
+    end
+
+    class << self
+      # Handle responses from HTTParty calls to the Typekit API with
+      # some generic response interpretation and manipulation. 
+      # @todo Add individual errors for various HTTP Status codes
+      def handle_response(response)
+        status = response.headers['status'].to_i
+        
+        case status
+          when 404 then raise ResourceDoesNotExistError, response
+          when 400..499 then raise APIError, response
+          when 500..599 then raise ServiceError, response
+        end
+
+        response.values.first if response.values.any?
+      end
+      private :handle_response
+      
+      # Handle all HTTParty responses with some error handling so that our
+      # individual methods don't have to worry about it at all (although they)
+      # can (and should where relevant) rescue from errors when they are able to.
+      [:get, :head, :post, :put, :delete].each do |http_verb|
+        define_method http_verb do |*args|
+          handle_response super(*args)
+        end
+      end
+      
+      # Set the Typekit API token to be used for subsequent calls.
+      # @note This is set to a class variable, so all instances of Typekit::Client
+      #   will use the same API token. This is due to the way HTTParty works.
+      # @param token [String] Your Typekit API token
+      # @todo Work around the class variable limitation of HTTParty to allow use of 
+      #   the API with multiple tokens.
+      def set_token(token)
+        headers 'X-Typekit-Token' => token
+      end
+      
+      # List kits available for this account
+      # @see Typekit::Kit.all
+      def kits
+        Kit.all
+      end
+
+      # Retrieve a specific kit
+      # @see Typekit::Kit.find
+      def kit(id)
+        Kit.find id
+      end
+      
+      # Create a new kit
+      # @see Typekit::Kit.create
+      def create_kit(params)
+        Kit.create(params)
+      end
+      
+      # Retrieve a specific Family
+      # @see Typekit::Family.find
+      # @param id [String] The Typekit Family id (e.g. 'brwr' or 'gkmg')
+      def family(id)
+        Family.find(id)
+      end
+      
+      # Retrieve a Family by Typekit slug
+      # @see Typekit::Family.find_by_slug
+      # @param slug [String] The Typekit Family slug for the font family (e.g. 'ff-meta-web-pro' or 'droid-sans')
+      def family_by_slug(slug)
+        Family.find_by_slug(slug)
+      end
+      
+      # Retrieve a Family by font family name
+      # @see Typekit::Family.find_by_name
+      # @param name [String] The name of the font family without variation (e.g. 'FF Meta Web Pro' or 'Droid Sans')
+      def family_by_name(name)
+        Family.find_by_name(name)
+      end
+    end
+
+    # @todo Put this somewhere better than Typekit::Client
+    class APIError < ArgumentError
+      attr_reader :response
+      
+      def initialize(response)
+        @response = response
+      end
+      
+      def to_s
+        @response['errors'].first if @response['errors'].any?
+      end
+    end
+    
+    class ResourceDoesNotExistError < APIError; end
+    class ServiceError < APIError; end
+  end
+end

data/lib/typekit/family.rb

@@ -0,0 +1,37 @@
+module Typekit
+  class Family
+    include MassAssignment
+    attr_accessor :id, :name, :slug, :web_link, :description, :foundry, :variations, :libraries
+    # Typekit::Family.new isn't expected usage
+    private :initialize
+    
+    # Find a variation in this Family by the Font Variation Description
+    # @param id [String] Family/Font variation ID/Description (e.g. n4 or i7)
+    def variation(id)
+      variations.select { |v| v.id.split(':').last == id }.first
+    end
+    
+    class << self
+      # Retrieve a specific Family
+      # @param id [String] The Typekit Family id (e.g. 'brwr' or 'gkmg')
+      def find(id)
+        family = Family.new Client.get("/families/#{id}")
+        family.variations.map! { |v| Variation.send(:new, v) }
+        family
+      end
+      
+      # Retrieve a Family by Typekit slug
+      # @param slug [String] The Typekit Family slug for the font family (e.g. 'ff-meta-web-pro' or 'droid-sans')
+      # @todo Add error handling
+      def find_by_slug(slug)
+        find(Client.get("/families/#{slug}")['id'])
+      end
+      
+      # Retrieve a Family by font family name
+      # @param name [String] The name of the font family without variation (e.g. 'FF Meta Web Pro' or 'Droid Sans')
+      def find_by_name(name)
+        find_by_slug name.downcase.gsub(/[^a-z]+/, '-')
+      end
+    end
+  end
+end

data/lib/typekit/kit.rb

@@ -0,0 +1,147 @@
+module Typekit
+  # @todo Get information for a specific family in the kit (/kits/:kit/families/:family)
+  class Kit
+    include MassAssignment
+    
+    # Detailed information about a kit. Lazy loaded when accessed unless
+    # the data already exists.
+    # @see Kit#fetch
+    attr_accessor :name, :domains, :families, :analytics, :badge
+    
+    # Typekit-defined kit id
+    attr_accessor :id
+    protected :id=
+    
+    # Typekit::Kit.new isn't expected usage
+    private :initialize
+    
+    # @todo Allow users to change defaults easily
+    @@defaults = { :analytics => false, :badge => false }
+    
+    class << self
+      # Find a kit by id (*not* by name)
+      # @param id [String] Typekit Kit ID (can be found via {Kit.all})
+      def find(id)
+        kit = Kit.new(:id => id)
+        kit.reload
+        kit
+      end
+      
+      # Get a list of all of the kits available for this Typekit account
+      # @todo Support pagination
+      def all
+        Client.get('/kits').inject([]) do |kits, attributes|
+          kits << Kit.new(attributes)
+        end
+      end
+      
+      # Create a new kit
+      # @param params [Hash] Attributes for the newly create kit
+      # @option params [String] :name Required: The name of the kit
+      # @option params [Array] :domains Required: An array of the domains that this kit will be used on
+      # @option params [Boolean] :analytics (false) Allow Typekit to collect kit-usage data via Google Analytics
+      # @option params [Boolean] :badge (false) Show the Typekit colophon badge on websites using this kit
+      def create(params)
+        params = @@defaults.merge(params)
+        response = Client.post("/kits", :query => params)
+        Kit.new(response)
+      end
+      
+      private
+      def lazy_load(*attributes)
+        attributes.each do |attribute|
+          define_method :"#{attribute}" do
+            instance_variable_defined?("@#{attribute}") ? instance_variable_get("@#{attribute}") : fetch(attribute)
+          end
+        end
+      end
+    end
+    
+    # Lazy load extended information only when it's accessed
+    lazy_load :name, :analytics, :badge, :domains, :families
+  
+    # Get detailed information about this kit from Typekit
+    # @note This is called lazily when you access any non-loaded attribute
+    #   and doesn't need to be called manually unless you want to reload the
+    #   data. This means we can return an array of Kit objects for {Kit.all}
+    #   without making N+1 requests to the API.
+    # @param attribute [Symbol] Optionally return a single attribute after data is loaded
+    # @return Returns @attribute if attribute argument is specified; otherwise returns self
+    def fetch(attribute = nil)
+      mass_assign Client.get("/kits/#{@id}")
+      attribute ? instance_variable_get("@#{attribute}") : self
+    end
+    alias :reload :fetch
+    
+    # Save kit attributes like name and domains. This does *not* alter the families
+    # added to the kit. 
+    # @param publish_after_save [Boolean] Commit changes saved to the published kit. See {#publish}.
+    # @return [Boolean] Status of the operation (including the publishing, if it is called)
+    def save(publish_after_save = true)
+      attributes = [:name, :analytics, :badge, :domains].inject({}) { |attributes, x| attributes[x] = instance_variable_get("@#{x}"); attributes }
+      result = mass_assign Client.post("/kits/#{@id}", :query => attributes)
+      published = publish if publish_after_save
+      
+      # For the parenthesized statement, true && true or false && false are acceptable.
+      # but xor does the exact opposite, so we negate it.
+      result && !(publish_after_save ^ published)
+    end
+    
+    # Typekit maintains the changes you have made to a Kit in a "working" state 
+    # until you specify that it is ready to be published. After the state has been
+    # changed to "published" your kit will be queued to be pushed out to their CDN
+    # and served to new requests. This can take up to 5 minutes when they are under
+    # heavy load.
+    # @return [Time] The date & time that the kit was last published
+    def publish
+      Client.post("/kits/#{@id}/publish")
+    end
+    
+    # Delete a kit from Typekit
+    # @note Typekit does not have this functionality in their API at this time. When they do,
+    #   the `raise` call in this method can be removed, along with this warning.
+    # @raise An error, always, telling you this doesn't work.
+    def delete
+      raise "The Typekit API does not support deleting a kit at this time."
+      Client.delete("/kits/#{@id}")
+    end
+    alias :destroy :delete
+    
+    # Add a family to this kit (does not publish changes)
+    # @param id [String] Typekit Font Family id (e.g. 'brwr')
+    # @param params [Hash] Attributes for the family to be added
+    # @option params [Array] :variations ([]) Font Variation Descriptions ('n4', 'i7', etc.) for the variations to be included
+    # @option params [String] :subset ('default') Character subset to be served ('all' or 'default')
+    # @return [Boolean] True on success; error raised on failure
+    def add_family(id, params = {})
+      params = { :variations => [], :subset => 'default' }.merge(params)
+      !!Client.post("/kits/#{@id}/families/#{id}", :query => params)
+    end
+    
+    # Update a family on this kit (does not publish changes)
+    # @param id [String] Typekit Font Family id (e.g. 'brwr')
+    # @param [Block] A block manipulating the family attributes
+    # @yieldparam [Hash] family The existing definition for this family
+    # @example Updating a font family
+    #   Typekit::Kit.update_family('abcdef') do |family|
+    #     family['subset'] = 'all'
+    #     family['variations'] << 'i3'
+    #   end
+    # @return [Boolean] True on success; error raised on failure
+    def update_family(id)
+      raise 'Block required' unless block_given?
+      family = Client.get("/kits/#{@id}/families/#{id}")
+      yield family
+      family.keep_if { |k,v| %w{variations subset}.include? k }
+      !!Client.post("/kits/#{@id}/families/#{id}", :query => family)
+    end
+    
+    # Delete a family from this kit (does not publish changes)
+    # @param id [String] Typekit Font Family id (e.g. 'brwr')
+    # @return [Boolean] True on success; error raised on failure
+    def delete_family(id)
+      !!Client.delete("/kits/#{@id}/families/#{id}")
+    end
+    alias :remove_family :delete_family
+  end
+end

data/lib/typekit/variation.rb

@@ -0,0 +1,43 @@
+module Typekit
+  # @todo Move lazy loading into a module
+  class Variation
+    include MassAssignment
+    attr_accessor :id, :name, :font_style, :font_variant, :font_weight, :foundry, :libraries, :postscript_name
+    
+    # Typekit::Variation.new isn't expected usage
+    private :initialize
+    
+    class << self
+      private
+      def lazy_load(*attributes)
+        attributes.each do |attribute|
+          define_method :"#{attribute}" do
+            instance_variable_defined?("@#{attribute}") ? instance_variable_get("@#{attribute}") : fetch(attribute)
+          end
+        end
+      end
+    end
+    
+    lazy_load :font_style, :font_variant, :font_weight, :foundry, :libraries, :postscript_name
+    
+    # Get detailed information about this Family Variation from Typekit
+    # @note This is called lazily when you access any non-loaded attribute
+    #   and doesn't need to be called manually unless you want to reload the
+    #   data. This means we can return an array of Variation objects for {Family#variations}
+    #   without making N+1 requests to the API.
+    # @param attribute [Symbol] Optionally return a single attribute after data is loaded
+    # @return Returns @attribute if attribute argument is specified; otherwise returns self
+    def fetch(attribute)
+      family_id, variation_id = @id.split(':')
+      mass_assign Client.get("/families/#{family_id}/#{variation_id}")
+      attribute ? instance_variable_get("@#{attribute}") : self
+    end
+    alias :reload :fetch
+    
+    # Convert the variation name to the Font Variation Description for adding it to a Kit
+    # @return [String] Font Variation ID (e.g. 'n4' or 'i7')
+    def to_fvd
+      name.split(':').last
+    end
+  end
+end

data/lib/typekit.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'httparty'
+
+require 'typekit/base'
+require 'typekit/client'
+require 'typekit/variation'
+require 'typekit/family'
+require 'typekit/kit'

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'typekit'
+
+class Test::Unit::TestCase
+end

data/test/test_typekit.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestTypekit < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: typekit
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Corey Ward
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-12 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *id005
+description: Ruby library for accessing the Typekit REST API.
+email: corey.atx@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/typekit.rb
+- lib/typekit/base.rb
+- lib/typekit/client.rb
+- lib/typekit/family.rb
+- lib/typekit/kit.rb
+- lib/typekit/variation.rb
+- test/helper.rb
+- test/test_typekit.rb
+has_rdoc: true
+homepage: http://github.com/coreyward/typekit
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 1490713961465430856
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Ruby library for accessing the Typekit REST API.
+test_files: 
+- test/helper.rb
+- test/test_typekit.rb