fontina 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1709e3c73ce8a624a911a47e6eb00f0648a690e3
+  data.tar.gz: 9d743b1f8a9fc918afccfca1c42cf21aaef3f561
+SHA512:
+  metadata.gz: 839971dac95f57ffb1a0ba3883ebbab127c03276f2d2bd2bebc78660ab63e8891dbb67f76e81418c1ee42b41c1b42727d2d2204a78583f11aea58d2116656850
+  data.tar.gz: 1dbab3c0e87be89f91a8a3adb403195100ec2b014af31507dbb49cdf273b4e11cec9e65b6fcd40d6b11187430e4a3c072f645a002f2c9e16769d29f9c4cbd21d

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Michael Petter
+
+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 NONINFRINGEMENT. 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,42 @@
+# Fontina
+
+[![Version](http://img.shields.io/gem/v/fontina.svg)                        ](https://rubygems.org/gems/fontina)
+[![Travis ](https://img.shields.io/travis/michaeljpetter/fontina/master.svg)](https://travis-ci.org/michaeljpetter/fontina)
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/fontina`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fontina'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fontina
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/fontina/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/fontina.gemspec

@@ -0,0 +1,29 @@
+require_relative 'lib/fontina/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'fontina'
+  gem.version       = Fontina::VERSION
+  gem.author        = 'Michael Petter'
+  gem.email         = 'michaeljpetter@gmail.com'
+
+  gem.summary       = 'A cheesy font utility'
+  gem.description   = <<-END
+    Fetches, parses, and describes font files.
+  END
+  gem.homepage      = 'http://github.com/michaeljpetter/fontina'
+  gem.license       = 'MIT'
+
+  gem.platform      = Gem::Platform::RUBY
+  gem.files         = Dir.glob %w(lib/**/* Gemfile *.gemspec LICENSE* README*)
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'bindata', '>=2.3.5'
+  gem.add_dependency 'faraday', '< 1.0'
+  gem.add_dependency 'faraday_middleware', '~> 0.10.0'
+  gem.add_dependency 'mores', '>=0.1.5'
+
+  gem.add_development_dependency 'bundler', '~> 1.7'
+  gem.add_development_dependency 'rake', '~> 10.0'
+  gem.add_development_dependency 'rspec', '~> 3.4'
+  gem.add_development_dependency 'rspec-its', '~> 1.2'
+end

data/lib/fontina/fetcher.rb

@@ -0,0 +1,34 @@
+module Fontina
+
+  module Fetcher
+    Result = Mores::ImmutableStruct.new(:content, :filename, :mime_type)
+
+    class << self
+      extend Forwardable
+
+      delegate :fetch => :succession
+
+      private
+
+      def succession
+        @succession ||= Mores::Succession.new do
+          line :fetch do |location|
+            raise "Location '#{location}' is not supported"
+          end
+        end
+      end
+
+      def included(base)
+        succession >> base.new
+      end
+    end
+  end
+
+end
+
+%w[
+  preprocessor
+  http
+  local_file_uri
+  local_file_path
+].each { |fetcher| require_relative "fetchers/#{fetcher}" }

data/lib/fontina/fetchers/http.rb

@@ -0,0 +1,43 @@
+require 'uri'
+
+module Fontina
+
+  class Fetchers::HTTP
+    include Fetcher
+
+    def fetch(location)
+      return super unless location.is_a? URI::HTTP
+
+      response = connection.get(location)
+
+      Result[response.body, get_filename(response), get_mime_type(response)]
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new do |c|
+        c.use FaradayMiddleware::FollowRedirects, limit: 2
+        c.use Faraday::Response::RaiseError
+        c.adapter Faraday.default_adapter
+      end
+    end
+
+    def get_filename(response)
+      get_attachment_filename(response) || File.basename(response.env.url.path)
+    end
+
+    def get_attachment_filename(response)
+      disposition = response.headers[:content_disposition] and
+      match = disposition.match(/^attachment; *filename=(?<q>"?)(?<filename>(\w| |\.|\\")*)\k<q>$/) and
+      match[:filename].gsub('\"', '"')
+    end
+
+    def get_mime_type(response)
+      type = response.headers[:content_type] and
+      match = type.match(/^(?<type>[\w-]+\/[\w-]+)(;.*)?$/) and
+      match[:type]
+    end
+  end
+
+end

data/lib/fontina/fetchers/local_file_path.rb

@@ -0,0 +1,15 @@
+require 'pathname'
+
+module Fontina
+
+  class Fetchers::LocalFilePath
+    include Fetcher
+
+    def fetch(location)
+      return super unless location.is_a? String
+
+      Result[Pathname.new(location).binread, File.basename(location)]
+    end
+  end
+
+end

data/lib/fontina/fetchers/local_file_uri.rb

@@ -0,0 +1,21 @@
+require 'uri'
+require 'pathname'
+
+module Fontina
+
+  class Fetchers::LocalFileURI
+    include Fetcher
+
+    def fetch(location)
+      return super unless
+        location.is_a?(URI::Generic) &&
+        location.scheme == 'file' &&
+        [nil, 'localhost'].include?(location.host)
+
+      path = URI.decode location.path
+
+      Result[Pathname.new(path).binread, File.basename(path)]
+    end
+  end
+
+end

data/lib/fontina/fetchers/preprocessor.rb

@@ -0,0 +1,18 @@
+require 'uri'
+
+module Fontina
+
+  class Fetchers::Preprocessor
+    include Fetcher
+
+    def fetch(location)
+      begin
+        uri = URI.parse location
+        location = uri if uri.scheme && !uri.opaque
+      rescue URI::Error; end
+
+      super
+    end
+  end
+
+end

data/lib/fontina/format.rb

@@ -0,0 +1,39 @@
+module Fontina
+
+  module Format
+    class << self
+      def for(criteria)
+        criteria.lazy
+          .map { |key, value| registry[key][value] }
+          .find(&:itself) or fail "no format matches #{criteria}"
+      end
+
+      private
+
+      def register(format, criteria)
+        criteria.each do |key, args|
+          args.each { |arg| registry[key][arg] = format }
+        end
+      end
+
+      def registry
+        @registry ||= %i[extension mime_type]
+          .reduce(Hash.new({}.freeze)) { |h, k| h[k] = {}; h }
+      end
+    end
+
+    private
+
+    registry.each_key do |key|
+      define_method key do |*args|
+        Format.send :register, self, key => args
+      end
+    end
+  end
+
+end
+
+%w[
+  fon
+  open_type
+].each { |format| require_relative "formats/#{format}" }

data/lib/fontina/formats/fon/constants.rb

@@ -0,0 +1,12 @@
+module Fontina::Formats::FON
+
+  IMAGE_DOS_SIGNATURE = 0x5a4d  # MZ
+  IMAGE_OS2_SIGNATURE = 0x454e  # NE
+
+  RT_FONTDIR = 7
+  RT_FONT = 8
+  RT_VERSION = 16
+
+  WORD_HIGHBIT = 0x8000
+
+end

data/lib/fontina/formats/fon/container.rb

@@ -0,0 +1,24 @@
+module Fontina::Formats::FON
+
+  class FON_Container < BinData::Record
+    search_prefix :fon
+
+    dos_header :dos
+
+    skip to_abs_offset: -> { dos.new_addr }
+    ne_header :ne
+
+    skip to_abs_offset: -> { ne.abs_offset + ne.restab_offs }
+    ne_exported_name_table :restab
+    virtual :restab_count, assert: -> { restab.count == 2 }
+
+    skip to_abs_offset: -> { ne.nrestab_addr }
+    ne_exported_name_table :nrestab
+    virtual :nrestab_num_bytes, assert: -> { nrestab.num_bytes == ne.nrestab_len }
+    virtual :nrestab_count, assert: -> { nrestab.count == 2 }
+    virtual :nrestab_first, assert: -> { nrestab.first.start_with?('FONTRES ') }
+
+    delayed_io :rsrctab, type: :ne_resource_table, read_abs_offset: -> { ne.abs_offset + ne.rsrctab_offs }
+  end
+
+end

data/lib/fontina/formats/fon/dos_header.rb

@@ -0,0 +1,14 @@
+module Fontina::Formats::FON
+
+  class FON_DOSHeader < BinData::Record
+    endian :little
+    hide :magic, :reloc_addr
+
+    uint16 :magic, assert: IMAGE_DOS_SIGNATURE
+    skip length: 22
+    uint16 :reloc_addr, assert: 0x40
+    skip length: 34
+    int32 :new_addr
+  end
+
+end

data/lib/fontina/formats/fon/ne_exported_name_table.rb

@@ -0,0 +1,24 @@
+module Fontina::Formats::FON
+
+  class FON_NEExportedName < BinData::Primitive
+    p_string :name
+    uint8 :enttab_idx, assert: 0
+
+    def get
+      name
+    end
+
+    def set(value)
+      name = value
+    end
+  end
+
+  class FON_NEExportedNameTable < BinData::Array
+    search_prefix :fon
+
+    default_parameter read_until: -> { element.empty? }
+
+    ne_exported_name
+  end
+
+end

data/lib/fontina/formats/fon/ne_font_dir.rb

@@ -0,0 +1,50 @@
+module Fontina::Formats::FON
+
+  class FON_NEFontDirEntry < BinData::Record
+    endian :little
+
+    uint16 :version
+    uint32 :len
+    string :copyright, length: 60, trim_padding: true
+    uint16 :font_type
+    uint16 :points
+    uint16 :vert_dpi
+    uint16 :horiz_dpi
+    uint16 :ascent 
+    uint16 :internal_leading
+    uint16 :external_leading
+    uint8 :italic
+    uint8 :underline
+    uint8 :strikeout
+    uint16 :weight
+    uint8 :char_set
+    uint16 :pix_width
+    uint16 :pix_height
+    uint8 :pitch_and_family
+    uint16 :avg_width
+    uint16 :max_width
+    uint8 :first_char
+    uint8 :last_char
+    uint8 :default_char
+    uint8 :break_char
+    uint16 :width_len
+    uint32 :device_addr
+    uint32 :face_addr
+    skip length: 4
+    stringz :device_name
+    stringz :face_name
+  end
+
+  class FON_NEFontDir < BinData::Record
+    endian :little
+    search_prefix :fon
+    hide :dir_count
+
+    uint16 :dir_count
+    array :dir, initial_length: :dir_count do
+      uint16 :ordinal
+      ne_font_dir_entry :entry
+    end
+  end
+
+end

data/lib/fontina/formats/fon/ne_header.rb

@@ -0,0 +1,25 @@
+module Fontina::Formats::FON
+
+  class FON_NEHeader < BinData::Record
+    FLAGS_MASK  = 0b1000100000000011
+    VALID_FLAGS = 0b1000000000000000
+
+    endian :little
+    hide :magic, :enttab_len, :flags
+
+    uint16 :magic, assert: IMAGE_OS2_SIGNATURE
+    skip length: 4
+    uint16 :enttab_len, assert: -> { value.between?(1, 2) }
+    skip length: 4
+    uint16 :flags, assert: -> { value & FLAGS_MASK == VALID_FLAGS }
+    skip length: 18
+    uint16 :nrestab_len
+    skip length: 2
+    uint16 :rsrctab_offs
+    uint16 :restab_offs
+    skip length: 4
+    int32 :nrestab_addr
+    skip length: 16
+  end
+
+end

data/lib/fontina/formats/fon/ne_resource.rb

@@ -0,0 +1,14 @@
+module Fontina::Formats::FON
+
+  class FON_NEResource < BinData::Choice
+    search_prefix :fon
+
+    default_parameter selection: -> { type_id & ~WORD_HIGHBIT }
+
+    ne_font_dir RT_FONTDIR
+    ne_vs_version_info RT_VERSION
+
+    virtual :default
+  end
+
+end

data/lib/fontina/formats/fon/ne_resource_name_info.rb

@@ -0,0 +1,18 @@
+module Fontina::Formats::FON
+
+  class FON_NEResourceNameInfo < BinData::Record
+    endian :little
+    search_prefix :fon
+
+    uint16 :data_blkaddr
+    uint16 :data_blklen
+    skip length: 2
+    uint16 :id
+    skip length: 4
+
+    delayed_io :data, read_abs_offset: -> { data_blkaddr << align_shift } do
+      buffer type: :ne_resource, length: -> { data_blklen << align_shift }
+    end
+  end
+
+end

data/lib/fontina/formats/fon/ne_resource_table.rb

@@ -0,0 +1,12 @@
+module Fontina::Formats::FON
+
+  class FON_NEResourceTable < BinData::Record
+    endian :little
+    search_prefix :fon
+
+    uint16 :align_shift, assert: -> { value > 1 }
+    array :types, type: :ne_resource_type_info, read_until: -> { element.type_id.zero? }
+    array :rsrc_names, type: :p_string, read_until: -> { element.empty? }
+  end
+
+end

data/lib/fontina/formats/fon/ne_resource_type_info.rb

@@ -0,0 +1,21 @@
+module Fontina::Formats::FON
+
+  class FON_NEResourceTypeInfo < BinData::Record
+    VALID_TYPE_IDS = ([0] + [
+      RT_FONTDIR,
+      RT_FONT,
+      RT_VERSION,
+      15  # unknown; occurs in some system fonts
+    ].map!(&WORD_HIGHBIT.method(:|))).freeze
+
+    endian :little
+    search_prefix :fon
+    hide :rsrc_count
+
+    uint16 :type_id, assert: -> { VALID_TYPE_IDS.include? value }
+    uint16 :rsrc_count, onlyif: -> { type_id.nonzero? } 
+    skip length: 4, onlyif: -> { type_id.nonzero? } 
+    array :name_info, type: :ne_resource_name_info, initial_length: :rsrc_count, onlyif: -> { type_id.nonzero? } 
+  end
+
+end

data/lib/fontina/formats/fon/ne_vs_version_info.rb

@@ -0,0 +1,70 @@
+module Fontina::Formats::FON
+
+  class FON_NEVersionData < BinData::Choice
+    endian :little
+
+    default_parameter selection: -> {
+      return STRINGZ if path[1...-2] == ['StringFileInfo']
+      return TRANSLATION if path[1..-1] == ['VarFileInfo', 'Translation']
+      :default
+    }
+
+    stringz STRINGZ = 1
+
+    array TRANSLATION = 2, read_until: :eof do
+      uint16 :locale
+      uint16 :codepage
+    end
+
+    virtual :default
+  end
+
+  class FON_NEVersionNode < BinData::Record
+    endian :little
+    search_prefix :fon
+    hide :node_len, :data_len, :children_len
+
+    uint16 :node_len
+    uint16 :data_len
+    stringz :name
+    virtual byte_align: 4
+
+    buffer :data, length: :data_len, type: :ne_version_data, onlyif: -> { data_len.nonzero? }
+    virtual :data_end
+    virtual byte_align: 4
+
+    virtual :children_len, initial_value: -> { node_len - data_end.rel_offset }
+
+    buffer :children, length: :children_len, onlyif: -> { children_len.nonzero? } do
+      array type: :ne_version_node, read_until: :eof
+    end
+    virtual byte_align: 4
+
+    def path
+      @path ||= (parent_node.path + [name]).freeze
+    end
+
+    private
+
+    def parent_node
+      @parent_node ||= begin
+        value = self
+        loop { value = value.parent; break if value.is_a? self.class }
+        value
+      end
+    end
+  end
+
+  class FON_NEVsVersionInfo < FON_NEVersionNode
+    virtual :root_name, assert: -> { name == 'VS_VERSION_INFO' }
+
+    virtual :root_num_bytes,
+      byte_align: -> { 1 << align_shift },
+      assert: -> { num_bytes == data_blklen << align_shift }
+
+    def path
+      @path ||= [name].freeze
+    end
+  end
+
+end

data/lib/fontina/formats/fon.rb

@@ -0,0 +1,79 @@
+module Fontina
+
+  module Formats::FON
+    extend Format
+    extension '.fon'
+
+    class << self
+      def read(io)
+        package container.read io
+      end
+
+      private
+
+      def container
+        @container ||= begin
+          %w[
+            shared/language_codes/windows
+            shared/p_string
+            fon/constants
+            fon/dos_header
+            fon/ne_header
+            fon/ne_exported_name_table
+            fon/ne_font_dir
+            fon/ne_vs_version_info
+            fon/ne_resource
+            fon/ne_resource_name_info
+            fon/ne_resource_type_info
+            fon/ne_resource_table
+            fon/container
+          ].each { |file| require_relative file }
+
+          Class.new(FON_Container) { auto_call_delayed_io }
+        end
+      end
+
+      def package(fon)
+        language = get_language(fon)
+
+        Package[
+          [QualifiedName[
+            fon.nrestab.first.name.sub(/^.*:\s*/, ''), :windows, language
+          ]],
+
+          get_rsrc_data(fon, RT_FONTDIR)
+            .flat_map(&:dir).map(&:entry)
+            .map do |e|
+              Font[
+                [QualifiedName[e.face_name, :windows, language]],
+                e.font_type[0] == 1 ? :vector : :raster,
+                e.points,
+                e.weight,
+                e.italic[0] == 1,
+                e.underline[0] == 1,
+                e.strikeout[0] == 1,
+              ]
+            end
+        ]
+      end
+
+      def get_language(fon)
+        language_id = get_rsrc_data(fon, RT_VERSION)
+          .flat_map(&:children).find_all { |c| c.name == 'VarFileInfo' }
+          .flat_map(&:children).find_all { |c| c.name == 'Translation' }
+          .flat_map(&:data).map(&:locale)
+          .first
+
+        Formats::Shared::LanguageCodes::WINDOWS[language_id]
+      end
+
+      def get_rsrc_data(fon, type)
+        fon.rsrctab
+          .types.find_all { |t| t.type_id == WORD_HIGHBIT | type }
+          .flat_map(&:name_info)
+          .map(&:data)
+      end
+    end
+  end
+
+end