fontprocessor 27.1.3

data/spec/lib/fontprocessor/processed_font_iterator_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'tempfile'
+
+describe FontProcessor::ProcessedFontIterator do
+  before(:each) do
+    @fontbase_id = "a00000000000000000000001"
+    @charset_id = 1
+    @fpv = 20
+    @directory = File.join(Dir.tmpdir, "processed-font-iterator-#{Time.now.to_i}")
+  end
+  subject { FontProcessor::ProcessedFontIterator.new(@fontbase_id, @charset_id, @fpv, @directory, true) }
+
+  describe ".valid" do
+    before(:each) do
+      FileUtils.mkdir_p(@directory)
+    end
+    after(:each) do
+      FileUtils.rm_r(@directory)
+    end
+
+    it "is true when a truetype file is successfully processed" do
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-otf.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-dyna_base.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff2.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-inst.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff_raw.ttf"))
+      expect(subject.valid?).to be true
+    end
+    it "isn't true when a truetype file is missing a file" do
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-otf.ttf"))
+      expect(subject.valid?).to be false
+    end
+    it "is true when a postscript file is successfully processed" do
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-otf.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-inst.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-dyna_base.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff2.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff_raw.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-otf.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-inst.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-dyna_base.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff2.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff_raw.cff"))
+      expect(subject.valid?).to be true
+    end
+    it "isn't true when a postscript file is missing a postscript file" do
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-otf.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-otf.cff"))
+      expect(subject.valid?).to be false
+    end
+    it "isn't true when a postscript file is missing a truetype file" do
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff.ttf"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-otf.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff.cff"))
+      expect(subject.valid?).to be false
+    end
+    it "is true when a postscript file is not converting to a truetype file" do
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-dyna_base.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-otf.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-inst.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff2.cff"))
+      FileUtils.touch(File.join(@directory, "charset-#{@charset_id}-woff_raw.cff"))
+      no_ttf_iterator = FontProcessor::ProcessedFontIterator.new(@fontbase_id, @charset_id, @fpv, @directory, false)
+      expect(no_ttf_iterator.valid?).to be true
+    end
+  end
+
+  describe ".s3_key" do
+    it "can return a proper s3 key for a normal file" do
+      expect(subject.s3_key("otf", "ttf")).to eq "#{@fontbase_id}/#{@fpv}/#{@charset_id}/otf.ttf"
+    end
+  end
+
+  describe ".each" do
+    before(:each) do
+      FileUtils.mkdir_p(@directory)
+    end
+    after(:each) do
+      FileUtils.rm_r(@directory)
+    end
+
+    it "can successfully iterate" do
+      @file_1 = File.join(@directory, "charset-#{@charset_id}-otf.ttf")
+      @file_2 = File.join(@directory, "charset-#{@charset_id}-woff.ttf")
+      @file_3 = File.join(@directory, "charset-#{@charset_id}-woff2.ttf")
+      @file_4 = File.join(@directory, "charset-#{@charset_id}-woff_raw.ttf")
+      @file_5 = File.join(@directory, "charset-#{@charset_id}-inst.ttf")
+      @file_6 = File.join(@directory, "charset-#{@charset_id}-dyna_base.ttf")
+      @file_7 = File.join(@directory, "charset-#{@charset_id}-otf.otf")
+      @file_8 = File.join(@directory, "charset-#{@charset_id}-woff.otf")
+      @file_9 = File.join(@directory, "charset-#{@charset_id}-woff2.otf")
+      @file_10 = File.join(@directory, "charset-#{@charset_id}-woff_raw.otf")
+      @file_11 = File.join(@directory, "charset-#{@charset_id}-inst.otf")
+      @file_12 = File.join(@directory, "charset-#{@charset_id}-dyna_base.otf")
+      @file_13 = File.join(@directory, "source.otf")
+
+      [@file_1, @file_2, @file_3, @file_4, @file_5, @file_6, @file_7, @file_8, @file_9, @file_10, @file_11, @file_12, @file_13].each { |f| FileUtils.touch(f) }
+
+      results = []
+      subject.each { |file, s3_key| results << [s3_key, file] }
+      results.sort!
+
+      expect(results).to eq [
+        ["a00000000000000000000001/20/1/dyna_base.cff", @file_12],
+        ["a00000000000000000000001/20/1/dyna_base.ttf", @file_6],
+        ["a00000000000000000000001/20/1/inst.cff", @file_11],
+        ["a00000000000000000000001/20/1/inst.ttf", @file_5],
+        ["a00000000000000000000001/20/1/otf.cff", @file_7],
+        ["a00000000000000000000001/20/1/otf.ttf", @file_1],
+        ["a00000000000000000000001/20/1/woff.cff", @file_8],
+        ["a00000000000000000000001/20/1/woff.ttf", @file_2],
+        ["a00000000000000000000001/20/1/woff2.cff", @file_9],
+        ["a00000000000000000000001/20/1/woff2.ttf", @file_3],
+        ["a00000000000000000000001/20/1/woff_raw.cff", @file_10],
+        ["a00000000000000000000001/20/1/woff_raw.ttf", @file_4]
+      ]
+    end
+
+    it "won't iterate over missing files" do
+      expect { subject.each }.to raise_error(FontProcessor::MissingFilesException)
+    end
+  end
+end

data/spec/lib/fontprocessor/processor_spec.rb

@@ -0,0 +1,466 @@
+require 'set'
+require 'spec_helper'
+require 'fixtures/fixtures'
+
+describe FontProcessor do
+  def self.setup_fonts(fixture)
+  before(:all) do
+      @char_set = JSON.parse('{"charset_id":"1","features":"ALL","unicode":""}')
+      @formats = JSON.parse('{"process_original":true,"convert":true,"derivatives":["woff","svg","swf","inst"]}')
+      @mini_char_set = JSON.parse('{"charset_id":"a","features":"ALL","unicode":"65..120"}')
+      @char_set_uni_vals = [0x20..0x7e,0xa0..0xffff]
+      @mini_char_set_uni_vals = 65..120
+      @fixture = FontProcessor::Specs::Fixture.new(fixture)
+      @naming_strategy = @fixture.naming_strategy
+      @license_url = "http://custom-url"
+    end
+
+    subject { FontProcessor::Processor.new(@naming_strategy, @license_url, "01") }
+
+    after(:all) do
+      @fixture.destroy if @fixture
+    end
+  end
+
+  context "with a bad PostScript file" do
+    describe "ots failure" do
+      setup_fonts(:ots_failure_font)
+      it "will raise an exception when subsetting the font" do
+        expect {
+          subject.generate_char_set(@char_set, @formats)
+        }.to raise_error(Exception)
+      end
+    end
+  end
+
+  context "with a bad PostScript file" do
+    describe "ots failure" do
+      setup_fonts(:ots_failure_font)
+      it "will raise an exception when trying to wrap the font as WOFF" do
+        expect {
+          subject.wrap_woff(@char_set, FontProcessor::FontFormat.new(:cff, :otf))
+        }.to raise_error
+      end
+    end
+  end
+
+  context "with a font with a STAT table" do
+    describe "stripping" do
+      setup_fonts(:stat_font)
+
+      it "will retain STAT referenced strings" do
+        path = File.join(@fixture.temp_directory, "stripped.otf")
+        fm = Skytype::FontManipulator.new(File.binread(@naming_strategy.source))
+        fm.save(path)
+        subject.strip(path)
+
+        #reload the fm, make sure it's name table has a STAT string, ID 256
+        fm = Skytype::FontManipulator.new(File.binread(path))
+        name_table = Skytype::NameTable.new(fm.get_table("name"))
+        expect(name_table.get_string(256, Skytype::NameTable::EN_LANGUAGE_ID).nil?).to be_falsey
+      end
+    end
+  end
+  context "with a PostScript file" do
+    describe ".file_metadata" do
+      setup_fonts(:postscript)
+
+      it "can detect outlines" do
+        expect(subject.file_metadata(@formats)).to have_postscript_outlines
+        expect(subject.file_metadata(@formats)).not_to have_truetype_outlines
+      end
+    end
+
+
+    describe ".generate_char_set" do
+      setup_fonts(:postscript)
+
+      it "can generate all font files for a given character set" do
+        subject.generate_char_set(@char_set, @formats)
+
+        expect(File.exist?(File.join(@fixture.temp_directory, "source.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "source.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff_raw.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff_raw.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-inst.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-inst.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-dyna_base.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-dyna_base.otf"))).to be true
+
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-eot.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-eot.ttf"))).to be false
+      end
+
+      it "verifies that PUA glyphs are present" do
+        subject.generate_char_set(@char_set, @formats)
+        all_cs = File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf")
+        fm = Skytype::FontManipulator.new(File.binread(all_cs))
+        FontProcessor::Processor::PUA_PAIRS.each do | pair |
+          expect(fm.get_glyph_for_unicode( pair[0] )).not_to eq 0
+        end
+      end
+
+      it "verifies that dyna_base has proper CFF NameDict entries for dyna_base and inst" do
+        subject.generate_char_set(@char_set, @formats)
+        dyna_base_font = File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-dyna_base.otf")
+        fm = Skytype::FontManipulator.new(File.binread(dyna_base_font))
+        name_table = Skytype::NameTable.new(fm.get_table("name"))
+        expect(fm.get_cff_name).to eq name_table.get_string(Skytype::NameTable::POSTSCRIPT_NAME_ID, Skytype::NameTable::EN_LANGUAGE_ID)
+
+        inst_font = File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-inst.otf")
+        fm = Skytype::FontManipulator.new(File.binread(inst_font))
+        name_table = Skytype::NameTable.new(fm.get_table("name"))
+        expect(fm.get_cff_name).to eq name_table.get_string(Skytype::NameTable::POSTSCRIPT_NAME_ID, Skytype::NameTable::EN_LANGUAGE_ID)
+      end
+
+      context "with a temporarily unlocked subset" do
+        before(:all) do
+          @filename = File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf")
+        end
+
+        it "contains only the unicode in the character set" do
+          subject.generate_char_set(@char_set, @formats)
+          subject.unlock(@filename)
+          orig = FontProcessor::FontFile.new(File.join(@fixture.temp_directory, "source.otf"))
+          orig_characters = Set.new(orig.unicode)
+          orig_characters.add(FontProcessor::Processor::NON_BREAKING_SPACE)
+          expanded_set = Array.new()
+          @char_set_uni_vals.each { |range| expanded_set += range.entries }
+          expected_characters = (orig_characters & expanded_set).to_a.sort
+
+          subset = FontProcessor::FontFile.new(@filename)
+          expect(subset.unicode).to eq expected_characters
+          subject.lock(@filename)
+        end
+      end
+
+      it "can convert to TrueType outlines" do
+        subject.generate_char_set(@char_set, @formats)
+        font_file = FontProcessor::FontFile.new(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.ttf"))
+        expect(font_file.has_truetype_outlines?).to be true
+        expect(font_file.has_postscript_outlines?).to be false
+      end
+
+      it "adds license urls to ttf character set files" do
+        subject.generate_char_set(@char_set, @formats)
+        metadata = FontProcessor::FontFile.new(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))
+        expect(metadata.names['en']['License URL']).to eq @license_url
+      end
+
+      it "obfuscates the name table" do
+        subject.generate_char_set(@char_set, @formats)
+        metadata = FontProcessor::FontFile.new(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))
+        expect(metadata.names['en']['Family']).to be_nil
+        expect(metadata.names['en']['Full name']).to eq "-"
+        expect(metadata.names['en']['PostScript name']).to eq "-"
+        expect(metadata.names['en']['Unique ID']).not_to eq "Fontin"
+      end
+
+    end
+
+    describe " .generate_char_set with invalid data" do
+      setup_fonts(:postscript)
+
+      it "raises an exception" do
+        File.open(File.join(@fixture.temp_directory, "postscript.otf"), "w") { |f| f.puts "I am not a font" }
+        expect { subject.generate_char_set(@char_set, @formats) }.to raise_error(FontProcessor::Processor::UnknownFontFormat)
+      end
+    end
+
+    context "internally" do
+      setup_fonts(:postscript)
+
+      it "does not automatically generate a non-breaking space when missing" do
+        min_char_set = { "charset_id" => "min", "unicode" => "32..65", "features" => "NONE" }
+        max_char_set = { "charset_id" => "max", "unicode" => "32..160", "features" => "NONE" }
+        cff = FontProcessor::FontFormat.new(:cff, :otf)
+
+        subject.subset(min_char_set,
+                       @naming_strategy.source,
+                       @naming_strategy.source,
+                       @naming_strategy.char_set(min_char_set['charset_id'], cff))
+        subject.subset(max_char_set,
+                       @naming_strategy.source,
+                       @naming_strategy.char_set(min_char_set['charset_id'], cff),
+                       @naming_strategy.char_set(max_char_set['charset_id'], cff))
+
+        font_file = FontProcessor::FontFile.new(@naming_strategy.char_set(max_char_set['charset_id'], cff))
+        expect(font_file.unicode).not_to include(0xA0)
+      end
+
+      it "automatically generates a non-breaking space when missing" do
+        max_char_set = { "charset_id" => "max", "unicode" => "32..160", "features" => "NONE" }
+        cff = FontProcessor::FontFormat.new(:cff, :otf)
+
+        subject.generate_char_set(max_char_set, @formats)
+
+        font_file = FontProcessor::FontFile.new(@naming_strategy.char_set(max_char_set['charset_id'], cff))
+        expect(font_file.unicode).to include(0xA0)
+        expect(font_file.unicode).to include(0xAD)
+      end
+
+      it "can copy a name entry over another" do
+        char_set = { "charset_id" => "copy", "unicode" => "32..65", "features" => "NONE" }
+        cff = FontProcessor::FontFormat.new(:cff, :otf)
+        filename = @naming_strategy.char_set(char_set['charset_id'], cff)
+        subject.subset(char_set,
+                       @naming_strategy.source,
+                       @naming_strategy.source,
+                       filename)
+        unique_string = "asdfasdfasdfsa"
+
+        subject.obfuscate_names(filename, unique_string)
+        subject.copy_name_record(filename,
+                                 FontProcessor::Processor::UNIQUE_ID,
+                                 FontProcessor::Processor::FAMILY_ID)
+
+        file = FontProcessor::FontFile.new(filename)
+        expect(file.names["en"]["Family"]).to eq unique_string
+        expect(file.names["en"]["Full name"]).to eq "-"
+        expect(file.names["en"]["PostScript name"]).to eq "-"
+        expect(file.names["en"]["Unique ID"]).to eq unique_string
+      end
+
+    end
+  end
+
+  context "with a TrueType file" do
+    describe ".file_metadata" do
+      setup_fonts(:truetype)
+
+      it "can detect outlines" do
+        expect(subject.file_metadata(@formats)).not_to have_postscript_outlines
+        expect(subject.file_metadata(@formats)).to have_truetype_outlines
+      end
+    end
+
+    describe " .generate_char_set" do
+      setup_fonts(:truetype)
+
+      it "can generate all font files for a given character set" do
+        subject.generate_char_set(@mini_char_set, @formats)
+        expect(File.exist?(File.join(@fixture.temp_directory, "source.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-otf.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-woff.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-woff_raw.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-svg.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-inst.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-eot.ttf"))).to be false
+      end
+
+      context "with a temporarily unlocked subset" do
+        before(:all) do
+          @filename = File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-otf.ttf")
+        end
+
+        it "contains only the unicode in the character set" do
+          subject.generate_char_set(@mini_char_set, @formats)
+          subject.unlock(@filename)
+          orig = FontProcessor::FontFile.new(File.join(@fixture.temp_directory, "source.ttf"))
+          orig_characters = Set.new(orig.unicode)
+
+          expected_characters = (orig_characters & @mini_char_set_uni_vals.entries).to_a.sort
+
+          subset = FontProcessor::FontFile.new(@filename)
+          expect(subset.unicode).to eq expected_characters
+          subject.lock(@filename)
+        end
+      end
+
+      it "adds license urls to raw fonts" do
+        subject.generate_char_set(@mini_char_set, @formats)
+        metadata = FontProcessor::FontFile.new(File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-otf.ttf"))
+        expect(metadata.names['en']['License URL']).to eq @license_url
+      end
+
+      it "obfuscates the name table" do
+        subject.generate_char_set(@mini_char_set, @formats)
+        metadata = FontProcessor::FontFile.new(File.join(@fixture.temp_directory, "charset-#{@mini_char_set['charset_id']}-otf.ttf"))
+        expect(metadata.names['en']['Family']).to be_nil
+        expect(metadata.names['en']['Full name']).to eq "-"
+        expect(metadata.names['en']['PostScript name']).to eq "-"
+        expect(metadata.names['en']['Unique ID']).not_to include "Bleeding Cowboys"
+      end
+
+    end
+
+    describe " .generate_char_set with limited formats" do
+      setup_fonts(:postscript)
+      it "produces just the original CFF format and no others" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":true,"convert":false,"derivatives":[]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.otf"))).to be false
+      end
+            
+      it "produces just the original CFF format and a WOFF" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":true,"convert":false,"derivatives":["woff"]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.otf"))).to be false
+      end
+
+      it "produces the original CFF format and a WOFF, but no SVF because the PS original is not converted" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":true,"convert":false,"derivatives":["woff", "svg"]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.otf"))).to be false
+      end
+
+      it "produces the original CFF format, a WOFF and a SWF" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":true,"convert":false,"derivatives":["woff", "swf"]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.otf"))).to be true
+      end
+
+      it "produces the a WOFF and a SWF, but not original format file" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":false,"convert":false,"derivatives":["woff", "swf", "svg"]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.otf"))).to be false
+      end
+
+      it "to throw an error if an invalid format is supplied, even if the JSON is valid" do
+        format_data = '{"process_original":false,"convert":false,"derivatives":[]}'
+        expect {
+          subject.generate_char_set(@char_set, JSON.parse(format_data))
+        }.to raise_error "Invalid format data {\"process_original\"=>false, \"convert\"=>false, \"derivatives\"=>[]}"
+      end
+      
+      it "to throw an error if an invalid format is supplied, even if the JSON is valid" do
+        format_data = '{"process_original":false,"convert":false,"derivatives":["svg"]}'
+        expect {
+        subject.generate_char_set(@char_set, JSON.parse(format_data))
+        }.to raise_error "Invalid format data {\"process_original\"=>false, \"convert\"=>false, \"derivatives\"=>[\"svg\"]}"
+      end
+    end
+
+    describe " .generate_char_set with conversion and derivative specifiers" do
+      setup_fonts(:postscript)
+      it "produces just the original CFF format and only the converted file" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":true,"convert":true,"derivatives":[]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.otf"))).to be false
+      end
+      it "produces only the converted file" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":false,"convert":true,"derivatives":[]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.otf"))).to be false
+      end
+      it "produces only the converted file formats" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":false,"convert":true,"derivatives":["woff", "swf", "svg"]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.ttf"))).to be true
+      end
+    end
+
+    describe " .generate_char_set from TrueType with limited formats" do
+      setup_fonts(:truetype)
+                                                                                                                    
+      it "ignores a SVG derivtive from a TrueType font" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":false,"convert":false,"derivatives":["svg"]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.ttf"))).to be false
+      end
+
+      it "produces just the derivatives from a TrueType font" do
+        subject.generate_char_set(@char_set, JSON.parse('{"process_original":false,"convert":false,"derivatives":["woff", "swf", "svg"]}'))
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.otf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.ttf"))).to be true
+      end
+    end
+
+    
+    describe " .generate_char_set with invalid data" do
+      setup_fonts(:truetype)
+
+      it "raises an exception" do
+        File.open(File.join(@fixture.temp_directory, "truetype.otf"), "w") { |f| f.puts "I am not a font" }
+        expect { subject.generate_char_set(@char_set, @formats) }.to raise_error(FontProcessor::Processor::UnknownFontFormat)
+      end
+    end
+
+    describe " .generate_char_set" do
+      setup_fonts(:locked)
+
+      it "can generate all font files for a given character set" do
+        subject.generate_char_set(@char_set, @formats)
+        expect(File.exist?(File.join(@fixture.temp_directory, "source.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-otf.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-woff.ttf"))).to be true
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-eot.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-svg.ttf"))).to be false
+        expect(File.exist?(File.join(@fixture.temp_directory, "charset-#{@char_set['charset_id']}-swf.ttf"))).to be true
+      end
+    end
+
+    context "internally" do
+      setup_fonts(:truetype)
+
+      it "can copy a name entry over another" do
+        char_set = { "charset_id" => "copy", "unicode" => "32..65", "features" => "NONE" }
+        ttf = FontProcessor::FontFormat.new(:ttf, :otf)
+        filename = @naming_strategy.char_set(char_set['charset_id'], ttf)
+        subject.subset(char_set,
+                       @naming_strategy.source,
+                       @naming_strategy.source,
+                       filename)
+        unique_string = "asdfasdfasdfsa"
+
+        subject.obfuscate_names(filename, unique_string)
+        subject.copy_name_record(filename,
+                                 FontProcessor::Processor::UNIQUE_ID,
+                                 FontProcessor::Processor::FAMILY_ID)
+
+        file = FontProcessor::FontFile.new(filename)
+        expect(file.names["en"]["Family"]).to eq unique_string
+        expect(file.names["en"]["Full name"]).to eq "-"
+        expect(file.names["en"]["PostScript name"]).to eq "-"
+        expect(file.names["en"]["Unique ID"]).to eq unique_string
+      end
+
+      context "with a file containing bad os2 width values" do
+        setup_fonts(:bad_os2_width_class)
+
+        it "corrects the values" do
+          filename = @naming_strategy.source
+          subject.fix_os2_weight_and_width(filename)
+
+          fm = Skytype::FontManipulator.new(File.binread(filename))
+          os2_data = fm.get_table("OS/2")
+          os2_table = Skytype::OS2Table.new(os2_data)
+          
+          expect(os2_table.get_width).to eq 1
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'bundler'
+Bundler.require
+
+ENV['RACK'] = 'test'

data/tasks/fonts.rake

@@ -0,0 +1,30 @@
+namespace :fonts do
+  desc "Convert a font to SVG"
+  task :convert_svg => :merb_env do
+    TMP_DIR = "/tmp/font-convert"
+    TRUETYPE = FontFormat.new(:ttf, :otf)
+    POSTSCRIPT = FontFormat.new(:cff, :otf)
+    SVG = FontFormat.new(:ttf, :svg)
+
+    file = ARGV[1]
+    filename = File.basename(file)
+    output_filename = filename.split('.')[0] + ".svg"
+
+    FileUtils.mkdir(TMP_DIR) unless File.exist? TMP_DIR
+    FileUtils.cp(file, TMP_DIR)
+
+    naming_strategy = FontFileNamingStrategy.new(filename, TMP_DIR)
+    converter = FontProcessing::FontConverter.new(naming_strategy)
+
+    original_font_format = filename =~ /\.ttf$/ ? TRUETYPE : POSTSCRIPT
+    FileUtils.cp(naming_strategy.source, naming_strategy.source(original_font_format))
+
+    converter.convert(TRUETYPE) if original_font_format.outline_format != :ttf
+
+    FileUtils.cp(naming_strategy.source(TRUETYPE), naming_strategy.char_set(CharSet.default, TRUETYPE))
+    converter.convert_char_set(CharSet.default, TRUETYPE, SVG)
+
+    FileUtils.cp(naming_strategy.char_set(CharSet.default, SVG), File.join(File.dirname(file), output_filename))
+    FileUtils.rmdir(TMP_DIR)
+  end
+end

data/worker.rb

@@ -0,0 +1,23 @@
+require 'bundler'
+Bundler.require(:default)
+Resque.redis = FontProcessor::Config.redis_server
+
+require 'resque/failure/airbrake'
+Resque::Failure::Airbrake.configure do |config|
+  config.api_key = FontProcessor::Config.airbrake_api_key
+  config.secure = true
+end
+Resque::Failure.backend = Resque::Failure::Airbrake
+
+queues = ["27"]
+
+worker = Resque::Worker.new(*queues)
+Resque.logger.level = Logger::DEBUG
+
+if ENV['PIDFILE']
+  File.open(ENV['PIDFILE'], 'w') { |f| f << Process.pid.to_s }
+end
+
+worker.log "Starting worker #{worker}"
+
+worker.work(5)