reot 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.o
+*.so
+*.eot
+Makefile

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in reot.gemspec
+gemspec

data/README.md

@@ -0,0 +1,13 @@
+Reot
+====
+
+Simple library for converting [ttf](http://en.wikipedia.org/wiki/TrueType) to [eot](http://en.wikipedia.org/wiki/Embedded_OpenType) format. It is using [ttf2eot](http://code.google.com/p/ttf2eot/), just instead of using console, you can use simple ruby module.
+
+Example
+-------
+
+```ruby
+  Reot.convert!('awesome_webfont.ttf', 'awesome_webfont.eot') #=> true
+```
+
+Generates ```awesome_webfont.eot```!

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rake/extensiontask'
+
+Bundler::GemHelper.install_tasks
+Rake::ExtensionTask.new('reot')
+
+desc "Build eventmachine, then run tests."
+task :default => [:clean,:compile, :test]
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+

data/ext/reot/OpenTypeUtilities.cpp

@@ -0,0 +1,334 @@
+/* Modified for use with ttf2eot, originally from WebKit. */
+
+/*
+ * Copyright (C) 2008 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <string.h>
+#include <vector>
+
+#ifndef _MSC_VER
+# include <stdint.h>
+#else
+typedef unsigned char uint8_t;
+#endif
+
+#include "OpenTypeUtilities.h"
+
+
+using std::vector;
+
+typedef unsigned Fixed;
+
+#define DEFAULT_CHARSET 1
+
+struct BigEndianUShort { 
+    operator unsigned short() const { return (v & 0x00ff) << 8 | v >> 8; }
+    BigEndianUShort(unsigned short u) : v((u & 0x00ff) << 8 | u >> 8) { }
+    unsigned short v;
+};
+
+struct BigEndianULong { 
+    operator unsigned() const { return (v & 0xff) << 24 | (v & 0xff00) << 8 | (v & 0xff0000) >> 8 | v >> 24; }
+    BigEndianULong(unsigned u) : v((u & 0xff) << 24 | (u & 0xff00) << 8 | (u & 0xff0000) >> 8 | u >> 24) { }
+    unsigned v;
+};
+
+#pragma pack(1)
+
+struct EOTPrefix {
+    unsigned eotSize;
+    unsigned fontDataSize;
+    unsigned version;
+    unsigned flags;
+    uint8_t fontPANOSE[10];
+    uint8_t charset;
+    uint8_t italic;
+    unsigned weight;
+    unsigned short fsType;
+    unsigned short magicNumber;
+    unsigned unicodeRange[4];
+    unsigned codePageRange[2];
+    unsigned checkSumAdjustment;
+    unsigned reserved[4];
+    unsigned short padding1;
+};
+
+struct TableDirectoryEntry {
+    BigEndianULong tag;
+    BigEndianULong checkSum;
+    BigEndianULong offset;
+    BigEndianULong length;
+};
+
+struct sfntHeader {
+    Fixed version;
+    BigEndianUShort numTables;
+    BigEndianUShort searchRange;
+    BigEndianUShort entrySelector;
+    BigEndianUShort rangeShift;
+    TableDirectoryEntry tables[1];
+};
+
+struct OS2Table {
+    BigEndianUShort version;
+    BigEndianUShort avgCharWidth;
+    BigEndianUShort weightClass;
+    BigEndianUShort widthClass;
+    BigEndianUShort fsType;
+    BigEndianUShort subscriptXSize;
+    BigEndianUShort subscriptYSize;
+    BigEndianUShort subscriptXOffset;
+    BigEndianUShort subscriptYOffset;
+    BigEndianUShort superscriptXSize;
+    BigEndianUShort superscriptYSize;
+    BigEndianUShort superscriptXOffset;
+    BigEndianUShort superscriptYOffset;
+    BigEndianUShort strikeoutSize;
+    BigEndianUShort strikeoutPosition;
+    BigEndianUShort familyClass;
+    uint8_t panose[10];
+    BigEndianULong unicodeRange[4];
+    uint8_t vendID[4];
+    BigEndianUShort fsSelection;
+    BigEndianUShort firstCharIndex;
+    BigEndianUShort lastCharIndex;
+    BigEndianUShort typoAscender;
+    BigEndianUShort typoDescender;
+    BigEndianUShort typoLineGap;
+    BigEndianUShort winAscent;
+    BigEndianUShort winDescent;
+    BigEndianULong codePageRange[2];
+    BigEndianUShort xHeight;
+    BigEndianUShort capHeight;
+    BigEndianUShort defaultChar;
+    BigEndianUShort breakChar;
+    BigEndianUShort maxContext;
+};
+
+struct headTable {
+    Fixed version;
+    Fixed fontRevision;
+    BigEndianULong checkSumAdjustment;
+    BigEndianULong magicNumber;
+    BigEndianUShort flags;
+    BigEndianUShort unitsPerEm;
+    long long created;
+    long long modified;
+    BigEndianUShort xMin;
+    BigEndianUShort xMax;
+    BigEndianUShort yMin;
+    BigEndianUShort yMax;
+    BigEndianUShort macStyle;
+    BigEndianUShort lowestRectPPEM;
+    BigEndianUShort fontDirectionHint;
+    BigEndianUShort indexToLocFormat;
+    BigEndianUShort glyphDataFormat;
+};
+
+struct nameRecord {
+    BigEndianUShort platformID;
+    BigEndianUShort encodingID;
+    BigEndianUShort languageID;
+    BigEndianUShort nameID;
+    BigEndianUShort length;
+    BigEndianUShort offset;
+};
+
+struct nameTable {
+    BigEndianUShort format;
+    BigEndianUShort count;
+    BigEndianUShort stringOffset;
+    nameRecord nameRecords[1];
+};
+
+#pragma pack()
+
+static void appendBigEndianStringToEOTHeader(vector<uint8_t>&eotHeader, const BigEndianUShort* string, unsigned short length)
+{
+    size_t size = eotHeader.size();
+    eotHeader.resize(size + length + 2 * sizeof(unsigned short));
+    unsigned short* dst = reinterpret_cast<unsigned short*>(&eotHeader[0] + size);
+    unsigned i = 0;
+    dst[i++] = length;
+    unsigned numCharacters = length / 2;
+    for (unsigned j = 0; j < numCharacters; j++)
+        dst[i++] = string[j];
+    dst[i] = 0;
+}
+
+bool getEOTHeader(unsigned char* fontData, size_t fontSize, vector<uint8_t>& eotHeader, size_t& overlayDst, size_t& overlaySrc, size_t& overlayLength)
+{
+    overlayDst = 0;
+    overlaySrc = 0;
+    overlayLength = 0;
+
+    size_t dataLength = fontSize;
+    const char* data = (const char *) fontData;
+
+    eotHeader.resize(sizeof(EOTPrefix));
+    EOTPrefix* prefix = reinterpret_cast<EOTPrefix*>(&eotHeader[0]);
+
+    prefix->fontDataSize = dataLength;
+    prefix->version = 0x00020001;
+    prefix->flags = 0;
+
+    if (dataLength < offsetof(sfntHeader, tables))
+        return false;
+
+    const sfntHeader* sfnt = reinterpret_cast<const sfntHeader*>(data);
+
+    if (dataLength < offsetof(sfntHeader, tables) + sfnt->numTables * sizeof(TableDirectoryEntry))
+        return false;
+
+    bool haveOS2 = false;
+    bool haveHead = false;
+    bool haveName = false;
+
+    const BigEndianUShort* familyName = 0;
+    unsigned short familyNameLength = 0;
+    const BigEndianUShort* subfamilyName = 0;
+    unsigned short subfamilyNameLength = 0;
+    const BigEndianUShort* fullName = 0;
+    unsigned short fullNameLength = 0;
+    const BigEndianUShort* versionString = 0;
+    unsigned short versionStringLength = 0;
+
+    for (unsigned i = 0; i < sfnt->numTables; i++) {
+        unsigned tableOffset = sfnt->tables[i].offset;
+        unsigned tableLength = sfnt->tables[i].length;
+
+        if (dataLength < tableOffset || dataLength < tableLength || dataLength < tableOffset + tableLength)
+            return false;
+
+        unsigned tableTag = sfnt->tables[i].tag;
+        switch (tableTag) {
+            case 'OS/2':
+                {
+                    if (dataLength < tableOffset + sizeof(OS2Table))
+                        return false;
+
+                    haveOS2 = true;
+                    const OS2Table* OS2 = reinterpret_cast<const OS2Table*>(data + tableOffset);
+                    for (unsigned j = 0; j < 10; j++)
+                        prefix->fontPANOSE[j] = OS2->panose[j];
+                    prefix->italic = OS2->fsSelection & 0x01;
+                    prefix->weight = OS2->weightClass;
+                    // FIXME: Should use OS2->fsType, but some TrueType fonts set it to an over-restrictive value.
+                    // Since ATS does not enforce this on Mac OS X, we do not enforce it either.
+                    prefix->fsType = 0;            
+                    for (unsigned j = 0; j < 4; j++)
+                        prefix->unicodeRange[j] = OS2->unicodeRange[j];
+                    for (unsigned j = 0; j < 2; j++)
+                        prefix->codePageRange[j] = OS2->codePageRange[j];
+                    break;
+                }
+            case 'head':
+                {
+                    if (dataLength < tableOffset + sizeof(headTable))
+                        return false;
+
+                    haveHead = true;
+                    const headTable* head = reinterpret_cast<const headTable*>(data + tableOffset);
+                    prefix->checkSumAdjustment = head->checkSumAdjustment;
+                    break;
+                }
+            case 'name':
+                {
+                    if (dataLength < tableOffset + offsetof(nameTable, nameRecords))
+                        return false;
+
+                    haveName = true;
+                    const nameTable* name = reinterpret_cast<const nameTable*>(data + tableOffset);
+                    for (int j = 0; j < name->count; j++) {
+                        if (dataLength < tableOffset + offsetof(nameTable, nameRecords) + (j + 1) * sizeof(nameRecord))
+                            return false;
+                        if (name->nameRecords[j].platformID == 3 && name->nameRecords[j].encodingID == 1 && name->nameRecords[j].languageID == 0x0409) {
+                            if (dataLength < tableOffset + name->stringOffset + name->nameRecords[j].offset + name->nameRecords[j].length)
+                                return false;
+
+                            unsigned short nameLength = name->nameRecords[j].length;
+                            const BigEndianUShort* nameString = reinterpret_cast<const BigEndianUShort*>(data + tableOffset + name->stringOffset + name->nameRecords[j].offset);
+                            
+                            switch (name->nameRecords[j].nameID) {
+                                case 1:
+                                    familyNameLength = nameLength;
+                                    familyName = nameString;
+                                    break;
+                                case 2:
+                                    subfamilyNameLength = nameLength;
+                                    subfamilyName = nameString;
+                                    break;
+                                case 4:
+                                    fullNameLength = nameLength;
+                                    fullName = nameString;
+                                    break;
+                                case 5:
+                                    versionStringLength = nameLength;
+                                    versionString = nameString;
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    }
+                    break;
+                }
+            default:
+                break;
+        }
+        if (haveOS2 && haveHead && haveName)
+            break;
+    }
+
+    prefix->charset = DEFAULT_CHARSET;
+    prefix->magicNumber = 0x504c;
+    prefix->reserved[0] = 0;
+    prefix->reserved[1] = 0;
+    prefix->reserved[2] = 0;
+    prefix->reserved[3] = 0;
+    prefix->padding1 = 0;
+
+    appendBigEndianStringToEOTHeader(eotHeader, familyName, familyNameLength);
+    appendBigEndianStringToEOTHeader(eotHeader, subfamilyName, subfamilyNameLength);
+    appendBigEndianStringToEOTHeader(eotHeader, versionString, versionStringLength);
+
+    // If possible, ensure that the family name is a prefix of the full name.
+    if (fullNameLength >= familyNameLength && memcmp(familyName, fullName, familyNameLength)) {
+        overlaySrc = reinterpret_cast<const char*>(fullName) - data;
+        overlayDst = reinterpret_cast<const char*>(familyName) - data;
+        overlayLength = familyNameLength;
+    }
+
+    appendBigEndianStringToEOTHeader(eotHeader, fullName, fullNameLength);
+
+    unsigned short padding = 0;
+    eotHeader.push_back(padding);
+    eotHeader.push_back(padding);
+
+    prefix = reinterpret_cast<EOTPrefix*>(&eotHeader[0]);
+    prefix->eotSize = eotHeader.size() + fontSize;
+
+    return true;
+}

data/ext/reot/OpenTypeUtilities.h

@@ -0,0 +1,38 @@
+/* Modified for use with ttf2eot, originally from WebKit. */
+
+/*
+ * Copyright (C) 2008 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef OpenTypeUtilities_h
+#define OpenTypeUtilities_h
+
+#include <cstddef>
+#include <vector>
+using std::vector;
+
+bool getEOTHeader(unsigned char * fontData, size_t fontSize, vector<uint8_t>& eotHeader, size_t& overlayDst, size_t& overlaySrc, size_t& overlayLength);
+
+
+#endif // OpenTypeUtilities_h

data/ext/reot/extconf.rb

@@ -0,0 +1,13 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+$CFLAGS = "-Wall -Wno-multichar"
+
+# Give it a name
+extension_name = 'reot'
+
+# The destination
+dir_config(extension_name)
+
+# Do the work
+create_makefile(extension_name)

data/ext/reot/reot.cpp

@@ -0,0 +1,70 @@
+// ttf2eot for ruby
+// just using ruby Module with singleton method instead of cli
+// Orignial code:
+// http://code.google.com/p/ttf2eot/
+
+// Include the Ruby headers and goodies
+#include "ruby.h"
+#include "OpenTypeUtilities.h"
+
+VALUE Reot = Qnil;
+
+extern "C" void Init_reot();
+
+extern "C" VALUE method_convert(VALUE self, VALUE filepath, VALUE destination);
+
+extern "C" void Init_reot() {
+  Reot = rb_define_module("Reot");
+  rb_define_singleton_method(Reot, "convert!", (VALUE(*)(...))&method_convert, 2);
+}
+
+extern "C" VALUE method_convert(VALUE self, VALUE filepath, VALUE destination) {
+  const size_t kFontInitSize = 8192;
+  vector<uint8_t> eotHeader(512);
+  size_t overlayDst = 0;
+  size_t overlaySrc = 0;
+  size_t overlayLength = 0;
+  size_t fontSize = kFontInitSize;
+  size_t fontOff = 0;
+  FILE *input, *output;
+  unsigned char *fontData;
+
+  char *input_file, *output_file;
+  input_file = StringValuePtr(filepath);
+  output_file = StringValuePtr(destination);
+
+
+  input = fopen(input_file, "rb");
+  output = fopen(output_file, "wb");
+
+  if ((fontData = (unsigned char *) malloc(fontSize)) == NULL) {
+    return Qfalse;
+  }
+
+  if(!input && !output) {
+    return Qfalse;
+  }
+
+  do {
+    size_t ret = fread(fontData + fontOff, 1, fontSize - fontOff, input);
+    if (ret && fontSize <= SIZE_MAX / 2) {
+      fontOff += ret;
+      if ((fontData = (unsigned char *) realloc(fontData, fontSize *= 2)) == NULL) {
+        return Qfalse;
+      }
+    } else if (ret) {
+      return Qfalse;
+    } else {
+      fontData = (unsigned char *) realloc(fontData, fontSize = fontOff);
+      break;
+    }
+  } while (true);
+
+  if (getEOTHeader(fontData, fontSize, eotHeader, overlayDst, overlaySrc, overlayLength)) {
+    fwrite(&eotHeader[0], eotHeader.size(), 1, output);
+    fwrite(fontData, fontSize, 1, output);
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}

data/lib/reot/version.rb

@@ -0,0 +1,3 @@
+module Reot
+  VERSION = "0.0.1"
+end

data/reot.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "reot/version"
+
+Gem::Specification.new do |s|
+  s.name        = "reot"
+  s.version     = Reot::VERSION
+  s.authors     = ["Josef Šimánek"]
+  s.email       = ["retro@ballgag.cz"]
+  s.homepage    = ""
+  s.summary     = %q{ttf2eot ruby wrapper}
+  s.description = %q{Simple ttf2eot convertor}
+  s.extensions  = ["ext/reot/extconf.rb"]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rake-compiler"
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+require 'bundler'
+require 'minitest/autorun'
+
+Bundler.setup
+require 'reot'

data/test/reot_test.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class TestReot < MiniTest::Unit::TestCase
+  def setup
+    File.delete('test/fonts/Metalista.ttf.eot') if File.exists?("test/fonts/Metalista.ttf.eot")
+  end
+
+  def test_reot_converts_ttf_to_eot
+    assert Reot.convert!("test/fonts/Metalista.ttf", "test/fonts/Metalista.eot")
+    assert_equal 28672, File.size("test/fonts/Metalista.eot")
+  end
+
+  def test_returns_false_for_bad_file_path
+    assert !Reot.convert!("un/ex/isting/path.ttf", "please/here.eot")
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: reot
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Josef Šimánek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &4034600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *4034600
+description: Simple ttf2eot convertor
+email:
+- retro@ballgag.cz
+executables: []
+extensions:
+- ext/reot/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- ext/reot/OpenTypeUtilities.cpp
+- ext/reot/OpenTypeUtilities.h
+- ext/reot/extconf.rb
+- ext/reot/reot.cpp
+- lib/reot/version.rb
+- reot.gemspec
+- test/fonts/Metalista.ttf
+- test/helper.rb
+- test/reot_test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: ttf2eot ruby wrapper
+test_files:
+- test/fonts/Metalista.ttf
+- test/helper.rb
+- test/reot_test.rb