fontana 0.0.1.placeholder → 0.0.1.rc1

data/.gitignore

@@ -2,3 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
+.yardoc
+tmp

data/.irbrc

@@ -0,0 +1 @@
+puts "Loading the irb rc file from the current directory"

data/Guardfile

@@ -0,0 +1,19 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+end
+

data/README

@@ -0,0 +1,18 @@
+Fontana is a wrapper around several command line utilities for converting fonts to different formats.
+
+Install the required command line utilites if they do not alreay exist on your system.
+
+  brew install ttf2eot
+  brew install fontforge
+
+On Ubuntu the install is not so bad.
+
+  sudo apt-get install fontforge
+
+  wget https://raw.github.com/mdeering/fontana/master/vendor/ttf2eot-0.0.2-2.patched.tar.gz
+  tar xvfz ttf2eot-0.0.2-2.patched.tar.gz
+  cd  ttf2eot-0.0.2-2
+  make
+  sudo cp ttf2eot /usr/bin/.
+
+Much of the wrapper is based on the scripts found here https://github.com/zoltan-dulac/css3FontConverter

data/README.textile

@@ -0,0 +1,9 @@
+Fontana is a wrapper around several command line utilities for converting fonts to different formats.
+
+Install the required command line utilites if they do not alreay exist on your system.
+
+  brew update
+  brew install ttf2eot
+  brew install fontforge
+
+Much of the wrapper is based on the scripts found here https://github.com/zoltan-dulac/css3FontConverter

data/fontana.gemspec

@@ -14,10 +14,14 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "fontana"
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-rspec'
   s.add_development_dependency 'rspec'
-  s.add_runtime_dependency 'dragonfly'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'dragonfly'
+
 end

data/lib/fontana.rb

@@ -1,5 +1,7 @@
-require "fontana/version"
+require 'fontana/version'
+require 'fontana/fontforge'
+require 'fontana/ttf2eot'
+require 'fontana/font'
 
 module Fontana
-  # Your code goes here...
 end

data/lib/fontana/converter.rb

@@ -0,0 +1,16 @@
+module Fontana
+
+  module Converter
+
+    # Converts the font file into the new desired format
+    #
+    # @param [Tempfile] file a font file of one of the acceptd font formats
+    # @param [Symbol] format a symbol respresenting the expected font format you would like returned
+    # @return [Tempfile] a temperary file handle to a font in the format that was requested
+    def convert(file, format)
+      file
+    end
+
+  end
+
+end

data/lib/fontana/dragonfly.rb

@@ -0,0 +1,7 @@
+require 'dragonfly'
+require 'fontana/dragonfly/encoder'
+
+module Fontana
+  module Dragonfly
+  end
+end

data/lib/fontana/dragonfly/encoder.rb

@@ -0,0 +1,15 @@
+module Fontana
+
+  module Dragonfly
+
+    class Encoder
+
+      def encode(temp_object, format, encoding={})
+        Fontana::Font.new(temp_object.path).send("to_#{format}")
+      end
+
+    end
+
+  end
+
+end

data/lib/fontana/font.rb

@@ -0,0 +1,85 @@
+module Fontana
+
+  class Font
+
+    def initialize(original_font_path)
+      raise Errno::ENOENT.new("No such file #{original_font_path}") unless File.file?(original_font_path)
+
+      @original_font_path = original_font_path
+      @original_font_type = File.extname(@original_font_path)
+      File.open(@original_font_path) { |file| @original_font_file_contents = file.read }
+
+      self
+    end
+
+    def to_eot
+      return @eot_string unless @eot_string.nil?
+
+      case @original_font_type
+      when '.eot'
+        @eot_string = @original_font_file_contents
+      when '.ttf'
+        @eot_string = TTF2EOT.convert(@original_font_file_contents)
+      else
+        @eot_string = TTF2EOT.convert(to_ttf)
+      end
+
+      @eot_string
+    end
+
+    def to_otf
+      return @otf_string unless @otf_string.nil?
+
+      case @original_font_type
+      when '.otf'
+        @otf_string = @original_font_file_contents
+      else
+        @otf_string = Fontforge.convert(@original_font_type, @original_font_file_contents, '.otf')
+      end
+
+      @otf_string
+    end
+
+    def to_svg
+      return @svg_string unless @svg_string.nil?
+
+      case @original_font_type
+      when '.svg'
+        @svg_string = @original_font_file_contents
+      else
+        @svg_string = Fontforge.convert(@original_font_type, @original_font_file_contents, '.svg')
+      end
+
+      @svg_string
+    end
+
+
+    def to_ttf
+      return @ttf_string unless @ttf_string.nil?
+
+      case @original_font_type
+      when '.ttf'
+        @ttf_string = @original_font_file_contents
+      else
+        @ttf_string = Fontforge.convert(@original_font_type, @original_font_file_contents, '.ttf')
+      end
+
+      @ttf_string
+    end
+
+    def to_woff
+      return @woff_string unless @woff_string.nil?
+
+      case @original_font_type
+      when '.woff'
+        @woff_string = @original_font_file_contents
+      else
+        @woff_string = Fontforge.convert(@original_font_type, @original_font_file_contents, '.woff')
+      end
+
+      @woff_string
+    end
+
+  end
+
+end

data/lib/fontana/fontforge.rb

@@ -0,0 +1,58 @@
+require 'tempfile'
+
+module Fontana
+
+  class Fontforge
+
+    def self.convert(input_ext, input_string, output_ext)
+      input_file  = create_input_file(input_ext, input_string)
+      output_file = setup_output_file output_ext
+      run_conversion_command(input_file, output_file, output_ext.split('.').last)
+      return_string = readback_output_file(output_file)
+      cleanup(input_file)
+      cleanup(output_file)
+      return_string
+    end
+
+    def self.information(font_path)
+      run_information_command(font_path).strip
+    end
+
+
+    private
+
+      def self.cleanup(tempfile)
+        tempfile.unlink
+      end
+
+      def self.create_input_file(ext, content, filename = 'fontana-fontforge-input')
+        tempfile = Tempfile.new([filename, ext])
+        tempfile.binmode
+        tempfile.write content
+        tempfile.close
+        tempfile
+      end
+
+      def self.setup_output_file(extension, filename = 'fontana-fontforge-output')
+        tempfile = Tempfile.new([filename, extension])
+        tempfile.close
+        tempfile
+      end
+
+      def self.readback_output_file(output_file)
+        output = nil
+        File.open(output_file.path, 'rb') { |file| output = file.read }
+        output
+      end
+
+      def self.run_conversion_command(input_file, output_file, ext)
+        puts "fontforge -script #{File.join(File.dirname(__FILE__), 'fontforge', "2#{ext}.pe")} #{input_file.path} #{output_file.path}"
+        puts `fontforge -script #{File.join(File.dirname(__FILE__), 'fontforge', "2#{ext}.pe")} #{input_file.path} #{output_file.path}`
+      end
+
+      def self.run_information_command(input_file_path)
+        puts "fontforge -script #{File.join(File.dirname(__FILE__), 'fontforge', "info.pe")} '#{input_file_path}'"
+        `fontforge -script #{File.join(File.dirname(__FILE__), 'fontforge', "info.pe")} '#{input_file_path}'`
+      end
+  end
+end

data/lib/fontana/fontforge/2otf.pe

@@ -0,0 +1,2 @@
+Open($1)
+Generate($2)

data/lib/fontana/fontforge/2svg.pe

@@ -0,0 +1,2 @@
+Open($1)
+Generate($2)

data/lib/fontana/fontforge/2ttf.pe

@@ -0,0 +1,2 @@
+Open($1)
+Generate($2)

data/lib/fontana/fontforge/2woff.pe

@@ -0,0 +1,2 @@
+Open($1)
+Generate($2)

data/lib/fontana/fontforge/info.pe

@@ -0,0 +1,25 @@
+Open($1)
+Print($fullname, ' ', $weight)
+#Print('firstfont')
+#Print($firstfont)
+#Print('curfont')
+#Print($curfont)
+#Print('fontname')
+#Print($fontname)
+#Print('familyname')
+#Print($familyname)
+#Print('fullname')
+#Print($fullname)
+#Print('weight')
+#Print($weight)
+#Print('copyright')
+#Print($copyright)
+#Print('filename')
+#Print($filename)
+#Print('fontversion')
+#Print($fontversion)
+#Print('iscid')
+#Print($iscid)
+#Print('mmcount')
+#Print($mmcount)
+

data/lib/fontana/fontforge/scripting.txt

@@ -0,0 +1,8 @@
+http://fontforge.sourceforge.net/scripting-tutorial.html
+
+STDIN
+If you wish FontForge to read a script from stdin then you can use "-" as a "filename" for stdin. (If you build FontForge without X11 then fontforge will attempt to read a script file from stdin if none is given on the command line.)
+
+STDOUT
+FONTFORGE_VERBOSE
+If you set the environment variable FONTFORGE_VERBOSE (it doesn't need a value, just needs to be set) then FontForge will print scripts to stdout as it executes them.

data/lib/fontana/rails.rb

@@ -0,0 +1,45 @@
+require 'uri'
+require 'dragonfly'
+require 'fontana/dragonfly'
+begin
+  require 'rack/cache'
+rescue LoadError => e
+  puts "Couldn't find rack-cache - make sure you have it in your Gemfile:"
+  puts "  gem 'rack-cache', :require => 'rack/cache'"
+  puts " or configure dragonfly manually instead of using 'fontana/rails/fonts'"
+  raise e
+end
+
+### The dragonfly app ###
+app = Dragonfly[:fonts]
+
+app.configure do |c|
+  c.encoder.register(Fontana::Dragonfly::Encoder)
+  c.register_mime_type(:eot,  'application/vnd.ms-fontobject')
+  c.register_mime_type(:otf,  'font/opentype')
+  c.register_mime_type(:svg,  'image/svg+xml')
+  c.register_mime_type(:ttf,  'font/ttf')
+  c.register_mime_type(:woff, 'application/x-font-woff')
+  c.url_format = '/media-fonts/:job/:basename.:format'
+  c.log        = ::Rails.logger
+  c.datastore.root_path   = ::Rails.root.join('public/system/dragonfly', ::Rails.env).to_s
+  c.datastore.server_root = ::Rails.root.join('public').to_s
+end
+
+# app.configure_with(:rails)
+
+### Extend active record ###
+if defined?(ActiveRecord::Base)
+  app.define_macro(ActiveRecord::Base, :font_accessor)
+end
+
+### Insert the middleware ###
+rack_cache_already_inserted = Rails.application.config.action_controller.perform_caching && Rails.application.config.action_dispatch.rack_cache
+
+Rails.application.middleware.insert 0, Rack::Cache, {
+  :verbose     => true,
+  :metastore   => URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/meta"), # URI encoded in case of spaces
+  :entitystore => URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/body")
+} unless rack_cache_already_inserted
+
+Rails.application.middleware.insert_after Rack::Cache, Dragonfly::Middleware, :fonts

data/lib/fontana/ttf2eot.rb

@@ -0,0 +1,34 @@
+require 'tempfile'
+
+module Fontana
+
+  class TTF2EOT
+
+    def self.convert(input_string)
+      input_file  = create_input_file(input_string)
+      return_string = run_command(input_file)
+      cleanup(input_file)
+      return_string
+    end
+
+
+    private
+
+      def self.cleanup(tempfile)
+        tempfile.unlink
+      end
+
+      def self.create_input_file(content, filename = 'fontana-ttf2eot-input')
+        tempfile = Tempfile.new([filename, '.ttf'])
+        tempfile.write content
+        tempfile.close
+        tempfile
+      end
+
+      def self.run_command(input_file)
+        puts "ttf2eot #{input_file.path}"
+        `ttf2eot #{input_file.path}`
+      end
+  end
+end
+

data/lib/fontana/version.rb

@@ -1,3 +1,3 @@
 module Fontana
-  VERSION = "0.0.1.placeholder"
+  VERSION = "0.0.1.rc1"
 end

data/spec/dragonfly/encoder_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Fontana::Dragonfly::Encoder do
+
+  describe '#encode' do
+
+    it 'should do nothing if the font is already in the correct format' do
+      sample_ttf   = font_assets('/Consola Mono/ConsolaMono.ttf')
+      temp_ttf     = Dragonfly::TempObject.new(File.new(sample_ttf))
+      returned_ttf = Fontana::Dragonfly::Encoder.new.encode(temp_ttf, :ttf)
+      Digest::MD5.hexdigest(returned_ttf) ==  Digest::MD5.file( font_assets('/Consola Mono/ConsolaMono.ttf'))
+    end
+
+  end
+
+end

data/spec/fontana_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Fontana::Font do
+
+  def eot_md5
+    @eot_md5 ||= Digest::MD5.file(font_assets('Consola Mono/ConsolaMono.eot'))
+  end
+
+  def otf_md5
+    @otf_md5 ||= Digest::MD5.file(font_assets('Consola Mono/ConsolaMono.otf'))
+  end
+
+  def svg_md5
+    @svg_md5 ||= Digest::MD5.file(font_assets('Consola Mono/ConsolaMono.svg'))
+  end
+
+  def ttf_md5
+    @ttf_md5 ||= Digest::MD5.file(font_assets('Consola Mono/ConsolaMono.ttf'))
+  end
+
+  def woff_md5
+    @woff_md5 ||= Digest::MD5.file(font_assets('Consola Mono/ConsolaMono.woff'))
+  end
+
+  context '#initialize' do
+
+    it 'should require the path to font file' do
+      lambda { Fontana::Font.new() }.should raise_error(ArgumentError)
+    end
+
+    it 'will assume a string is a path to file and attempt to open it' do
+      lambda { Fontana::Font.new('/bad/file/path') }.should raise_error(Errno::ENOENT)
+    end
+
+  end
+
+  pending 'font conversions' do
+
+    [ :eot, :otf, :svg, :ttf, :woff ].each do |file_extension|
+
+      context "with a #{file_extension} as an original font #to_eot" do
+
+        it 'will return a string representing the embedded open type font' do
+          font = Fontana::Font.new(font_assets("Consola Mono/ConsolaMono.#{file_extension}"))
+          Digest::MD5.hexdigest(font.to_eot).should == eot_md5.to_s
+        end
+
+      end
+
+      context "with a #{file_extension} as an original font #to_otf" do
+
+        it 'will return a string representing the open type font' do
+          pending 'No utility found to convert from eot => otf' if file_extension == :eot
+          font = Fontana::Font.new(font_assets("Consola Mono/ConsolaMono.#{file_extension}"))
+          Digest::MD5.hexdigest(font.to_otf).should == otf_md5.to_s
+        end
+
+      end
+
+
+      context "with a #{file_extension} as an original font #to_svg" do
+
+        it 'will return a string representing the scalable vector graphic font' do
+          pending 'No utility found to convert from eot => svg' if file_extension == :eot
+          font = Fontana::Font.new(font_assets("Consola Mono/ConsolaMono.#{file_extension}"))
+          Digest::MD5.hexdigest(font.to_svg).should == svg_md5.to_s
+        end
+
+      end
+
+
+      context "with a #{file_extension} as an original font #to_ttf" do
+
+        it 'will return a string representing the true type font' do
+          pending 'No utility found to convert from eot => ttf' if file_extension == :eot
+          font = Fontana::Font.new(font_assets("Consola Mono/ConsolaMono.#{file_extension}"))
+          Digest::MD5.hexdigest(font.to_ttf).should == ttf_md5.to_s
+        end
+
+      end
+
+      context "with a #{file_extension} as an original font #to_woff" do
+
+        it 'will return a string representing the web open font format font' do
+          pending 'No utility found to convert from eot => woff' if file_extension == :eot
+          font = Fontana::Font.new(font_assets("Consola Mono/ConsolaMono.#{file_extension}"))
+          Digest::MD5.hexdigest(font.to_woff).should == woff_md5.to_s
+        end
+
+      end
+
+    end
+
+  end
+
+end