harfbuzz 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 88bd6dee65ceba054a1ff2ba5b4329bfea310689
+  data.tar.gz: fc6e012e4e25a3f579cea5946f9e6a7afcd963e4
+SHA512:
+  metadata.gz: 4ddabd5869af1957fbe68864b1bba1f0dba915b0392f6c66549645b5d3f34ae1c6c2bffd473d104443cdd383aabcfc763dba1a1b2ffd0c2ebe28fa19fc058b7c
+  data.tar.gz: 1d5ed18e405ae2c595d31403898facdc1722f28d268176799042cfb8f9aeb18b505bbf2dfb6eac83f0e86225472cdec2613199660dde863f1e4cb3c7d3014f9f

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+Gemfile.lock

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 John Labovitz
+
+MIT License
+
+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,58 @@
+The Harfbuzz gem is a Ruby interface to the Harfbuzz text shaping engine. By using this gem, some input text, a font file, and a list of features, you can convert Unicode text to glyph descriptions that are ready to be rendered.
+
+For more information about Harfbuzz itself, see [harfbuzz.org](http://harfbuzz.org).
+
+For an example of use, see [example.rb](harfbuzz/examples/example.rb). From the base directory of this gem, you can run this example:
+
+    ruby examples/example.rb
+
+
+## Installation
+
+You must have the Harfbuzz library available on your system. OS X users can use Homebrew to install it:
+
+    brew install harfbuzz
+
+Once you've installed the Harfbuzz library, install this gem by the usual:
+
+    sudo gem install harfbuzz
+
+or if you're using a Ruby installed in Homebrew, as a normal user:
+
+    gem install harfbuzz
+
+
+## Design philosophy
+
+The Harfbuzz gem is composed of two layers: a low-level direct interface to Harfbuzz itself, and a high-level abstract interface that uses traditional Ruby objects and idioms.
+
+The low-level interface is a one-to-one mapping of Harfbuzz C functions to Ruby methods, implemented using the [FFI](https://github.com/ffi/ffi) library. For example, the Harfbuzz C function `hb_version_string()`  is available in Ruby as `Harfbuzz.hb_version_string`. However, as the low-level methods return C pointers wrapped in FFI objects, this layer is generally not useful to a Ruby programmer.
+
+The high-level interface abstracts the C functions, structures, and pointers into Ruby objects. For example, the aftermentioned `hb_version_string()` function is more usefully available via `Harfbuzz.version_string`, which returns a Ruby string containing with the version of the Harfbuzz library.
+
+Where appropriate, Ruby classes have been constructed to map to the concepts in Harfbuzz. Hence:
+
+| C           | Ruby
+| ----------- | ----
+| hb_blob_t   | Harfbuzz::Blob
+| hb_buffer_t | Harfbuzz::Buffer
+| hb_face_t   | Harfbuzz::Face
+| hb_font_t   | Harfbuzz::Font
+
+The shaping method itself is in the base Harfbuzz module, as `Harfbuzz.shape(...)`.
+
+
+## Caveats & bugs
+
+Only a small number of basic Harfbuzz functions are mapped to Ruby methods. More will be added as needed.
+
+There is no documentation except this file and the example script.
+
+There are no tests or specs.
+
+Memory management may not be correct.
+
+
+## Feedback
+
+As this is a new project, I'd love to hear your feedback. Email me at [johnl@johnlabovitz.com](mailto:johnl@johnlabovitz.com).

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+Bundler.require
+require 'bundler/gem_tasks'

data/examples/example.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift 'lib'
+require 'harfbuzz'
+
+#
+# Show some information about Harfbuzz
+#
+
+puts "Harfbuzz version: #{Harfbuzz.version_string}"
+puts "Shapers: #{Harfbuzz.shapers.join(', ')}"
+
+#
+# Create a font to be used for shaping. To get the most of out this example, use an OpenType font.
+#
+
+face = Harfbuzz::Face.new(File.open('/Library/Fonts/ACaslonPro-Regular.otf', 'rb'))
+font = Harfbuzz::Font.new(face)
+
+#
+# Create a buffer to hold the text and the resulting glyphs/positions.
+#
+
+buffer = Harfbuzz::Buffer.new
+
+#
+# Add some text to the buffer.
+#
+
+buffer.add_utf8('WAVE first.')
+
+#
+# Guess direction, script, & language from the text.
+#
+
+if true
+  buffer.guess_segment_properties
+else
+  #FIXME: these functions are not yet bound
+  # hb_buffer_set_direction(buffer, hb_direction_from_string(direction, -1))
+  # hb_buffer_set_script(buffer, hb_script_from_string(script, -1))
+  # hb_buffer_set_language(buffer, hb_language_from_string(language, -1))
+  # hb_buffer_set_flags(buffer, shape_flags)
+end
+
+#
+# Shape the text in the buffer using some interesting features.
+#
+
+Harfbuzz.shape(font, buffer, %w{+dlig +hlig})
+
+#
+# Normalize glyph clusters (FIXME: why?).
+#
+
+buffer.normalize_glyphs
+
+#
+# Iterate through the buffer, examining the glyphs & related positions.
+#
+
+glyph_infos = buffer.get_glyph_infos
+glyph_positions = buffer.get_glyph_positions
+buffer.length.times do |i|
+  info, position = glyph_infos[i], glyph_positions[i]
+  glyph_name = font.glyph_to_string(info[:codepoint])
+  puts "/%-10.10s %5u | mask: %04X | cluster: %2u | advance: %4u,%4u | offset: %4u,%4u" % [
+    glyph_name,
+    info[:codepoint],
+    info[:mask],
+    info[:cluster],
+    position[:x_advance], position[:y_advance],
+    position[:x_offset], position[:y_offset],
+  ]
+end

data/harfbuzz.gemspec

@@ -0,0 +1,27 @@
+#encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'harfbuzz/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'harfbuzz'
+  s.version       = Harfbuzz::VERSION
+  s.summary       = 'Ruby interface to the Harfbuzz text shaping engine'
+  s.author        = 'John Labovitz'
+  s.email         = 'johnl@johnlabovitz.com'
+  s.description   = %q{
+    Harfbuzz is a Ruby interface to the Harfbuzz text shaping engine.
+  }
+  s.homepage      = 'http://github.com/jslabovitz/harfbuzz-gem'
+  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_path  = 'lib'
+
+  s.add_dependency 'ffi'
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+end

data/lib/harfbuzz.rb

@@ -0,0 +1,40 @@
+require 'ffi'
+
+require 'harfbuzz/ffi_additions'
+
+module Harfbuzz
+
+  extend FFI::Library
+
+  ffi_lib 'harfbuzz'
+
+  typedef :pointer, :hb_destroy_func_t
+  typedef :uint32, :hb_codepoint_t
+
+  attach_function :hb_version_string, [], :string
+  attach_function :hb_version, [:pointer, :pointer, :pointer], :void
+
+  def self.version_string
+    hb_version_string
+  end
+
+  def self.version
+    major_ptr = FFI::MemoryPointer.new(:uint, 1)
+    minor_ptr = FFI::MemoryPointer.new(:uint, 1)
+    micro_ptr = FFI::MemoryPointer.new(:uint, 1)
+    hb_version(major_ptr, minor_ptr, micro_ptr)
+    [
+      major_ptr.read_uint,
+      minor_ptr.read_uint,
+      micro_ptr.read_uint,
+    ]
+  end
+
+end
+
+require 'harfbuzz/base'
+require 'harfbuzz/blob'
+require 'harfbuzz/face'
+require 'harfbuzz/font'
+require 'harfbuzz/buffer'
+require 'harfbuzz/shaping'

data/lib/harfbuzz/base.rb

@@ -0,0 +1,17 @@
+module Harfbuzz
+
+  class Base
+
+    def self.finalize(method, ptr)
+      proc {
+        Harfbuzz.send(method, ptr) unless ptr == 0
+      }
+    end
+
+    def define_finalizer(method, ptr)
+      ObjectSpace.define_finalizer(self, self.class.finalize(method, ptr))
+    end
+
+  end
+
+end

data/lib/harfbuzz/blob.rb

@@ -0,0 +1,41 @@
+module Harfbuzz
+
+  typedef :pointer, :hb_blob_t
+
+  enum :hb_memory_mode_t, [
+    :HB_MEMORY_MODE_DUPLICATE,
+    :HB_MEMORY_MODE_READONLY,
+    :HB_MEMORY_MODE_WRITABLE,
+    :HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE,
+  ]
+
+  attach_function :hb_blob_create, [
+    :pointer,           # data
+    :uint,              # length
+    :hb_memory_mode_t,  # mode,
+    :pointer,           # user_data,
+    :hb_destroy_func_t, # destroy
+  ], :hb_blob_t
+  attach_function :hb_blob_get_length, [
+    :hb_blob_t,         # blob
+  ], :uint
+  attach_function :hb_blob_destroy, [:hb_blob_t], :void
+
+  class Blob < Base
+
+    attr_reader :hb_blob
+
+    def initialize(data, mode=0, user_data=nil)
+      data_ptr = FFI::MemoryPointer.new(:char, data.size)
+      data_ptr.put_bytes(0, data)
+      @hb_blob = Harfbuzz.hb_blob_create(data_ptr, data.size, mode, user_data, nil)
+      define_finalizer(:hb_blob_destroy, @hb_blob)
+    end
+
+    def length
+      Harfbuzz.hb_blob_get_length(@hb_blob)
+    end
+
+  end
+
+end

data/lib/harfbuzz/buffer.rb

@@ -0,0 +1,103 @@
+module Harfbuzz
+
+  typedef :pointer, :hb_buffer_t
+  typedef :uint32, :hb_mask_t
+  typedef :int32, :hb_position_t
+
+  class GlyphInfo < FFI::Struct
+
+    layout \
+      :codepoint, :hb_codepoint_t,
+      :mask,      :hb_mask_t,
+      :cluster,   :uint32,
+      :var1,      :uint32,  # private
+      :var2,      :uint32   # private
+
+  end
+
+  class GlyphPosition < FFI::Struct
+
+    layout \
+      :x_advance, :hb_position_t,
+      :y_advance, :hb_position_t,
+      :x_offset,  :hb_position_t,
+      :y_offset,  :hb_position_t,
+      :var,       :uint32  # private
+
+    def inspect
+      "<#{self} %s>" % [
+        %w{x_advance y_advance x_offset y_offset}.map { |k|
+          "#{k} = #{self[k.to_sym].inspect}"
+        }.join(', ')
+      ]
+    end
+
+  end
+
+  attach_function :hb_buffer_create, [], :hb_buffer_t
+  attach_function :hb_buffer_add_utf8, [
+    :hb_buffer_t,   # buffer
+    :pointer,       # text
+    :int,           # text_length
+    :uint,          # item_offset
+    :int,           # item_length
+  ], :void
+  attach_function :hb_buffer_guess_segment_properties, [:hb_buffer_t], :void
+  attach_function :hb_buffer_get_length, [:hb_buffer_t], :uint
+  attach_function :hb_buffer_get_glyph_infos, [
+    :hb_buffer_t,   # buffer
+    :pointer,       # length
+  ], GlyphInfo
+  attach_function :hb_buffer_get_glyph_positions, [
+    :hb_buffer_t,   # buffer
+    :pointer,       # length
+  ], GlyphPosition
+  attach_function :hb_buffer_normalize_glyphs, [:hb_buffer_t], :void
+
+  class Buffer < Base
+
+    attr_reader :hb_buffer
+
+    def initialize
+      @hb_buffer = Harfbuzz.hb_buffer_create
+      define_finalizer(:hb_buffer_destroy, @hb_buffer)
+    end
+
+    def add_utf8(text, offset=0, length=-1)
+      text_ptr = FFI::MemoryPointer.new(:char, text.bytesize)
+      text_ptr.put_bytes(0, text)
+      Harfbuzz.hb_buffer_add_utf8(@hb_buffer, text_ptr, text.bytesize, offset, length)
+    end
+
+    def guess_segment_properties
+      Harfbuzz.hb_buffer_guess_segment_properties(@hb_buffer)
+    end
+
+    def normalize_glyphs
+      Harfbuzz.hb_buffer_normalize_glyphs(@hb_buffer)
+    end
+
+    def length
+      Harfbuzz.hb_buffer_get_length(@hb_buffer)
+    end
+
+    def get_glyph_infos
+      length_ptr = FFI::MemoryPointer.new(:uint, 1)
+      info_ptr = Harfbuzz.hb_buffer_get_glyph_infos(@hb_buffer, length_ptr)
+      length = length_ptr.read_uint
+      length.times.map do |i|
+        GlyphInfo.new(info_ptr + (i * GlyphInfo.size))
+      end
+    end
+
+    def get_glyph_positions
+      length_ptr = FFI::MemoryPointer.new(:uint, 1)
+      positions_ptr = Harfbuzz.hb_buffer_get_glyph_positions(@hb_buffer, length_ptr)
+      length = length_ptr.read_uint
+      length.times.map do |i|
+        GlyphPosition.new(positions_ptr + (i * GlyphPosition.size))
+      end
+    end
+
+  end
+end

data/lib/harfbuzz/face.rb

@@ -0,0 +1,46 @@
+module Harfbuzz
+
+  typedef :pointer, :hb_face_t
+
+  attach_function :hb_face_create, [
+    :hb_blob_t,         # blob
+    :uint,              # index
+  ], :hb_face_t
+  attach_function :hb_face_get_index, [:hb_face_t], :uint
+  attach_function :hb_face_get_upem, [:hb_face_t], :uint
+  attach_function :hb_face_get_glyph_count, [:hb_face_t], :uint
+
+  class Face < Base
+
+    attr_reader :hb_face
+
+    def initialize(input, face_index=0)
+      blob = case input
+      when IO
+        Harfbuzz::Blob.new(input.read, :HB_MEMORY_MODE_READONLY)
+      when Blob
+        # use as-is
+      when String
+        Harfbuzz::Blob.new(input, :HB_MEMORY_MODE_READONLY)
+      else
+        raise "Unknown input type: #{input.class}"
+      end
+      @hb_face = Harfbuzz.hb_face_create(blob.hb_blob, face_index)
+      define_finalizer(:hb_buffer_destroy, @hb_face)
+    end
+
+    def index
+      Harfbuzz.hb_face_get_index(@hb_face)
+    end
+
+    def upem
+      Harfbuzz.hb_face_get_upem(@hb_face)
+    end
+
+    def glyph_count
+      Harfbuzz.hb_face_get_glyph_count(@hb_face)
+    end
+
+  end
+
+end

data/lib/harfbuzz/ffi_additions.rb

@@ -0,0 +1,30 @@
+class FFI::Pointer
+
+  # after https://dzone.com/articles/getting-array-strings-char-ffi
+
+  def read_array_of_strings
+    elements = []
+    loc = self
+    until (element = loc.read_pointer).null?
+     elements << element.read_string
+     loc += FFI::Type::POINTER.size
+    end
+    elements
+  end
+
+end
+
+class FFI::MemoryPointer
+
+  # after http://zegoggl.es/2009/05/ruby-ffi-recipes.html
+
+  def self.from_array_of_strings(strings)
+    string_ptrs = strings.map { |s| FFI::MemoryPointer.from_string(s) } + [nil]
+    strings_ptr = new(:pointer, string_ptrs.length)
+    string_ptrs.each_with_index do |ptr, i|
+      strings_ptr[i].put_pointer(0, ptr)
+    end
+    strings_ptr
+  end
+
+end

data/lib/harfbuzz/font.rb

@@ -0,0 +1,68 @@
+module Harfbuzz
+
+  typedef :pointer, :hb_font_t
+
+  attach_function :hb_font_create, [:hb_face_t], :hb_font_t
+  attach_function :hb_font_set_scale, [
+    :hb_font_t,     # font
+    :int,           # x_scale
+    :int,           # y_scale
+  ], :void
+  attach_function :hb_ft_font_set_funcs, [:hb_font_t], :void
+  attach_function :hb_font_get_scale, [
+    :hb_font_t,     # font
+    :pointer,       # int *x_scale
+    :pointer,       # int *y_scale
+  ], :void
+  attach_function :hb_font_get_ppem, [
+    :hb_font_t,     # font
+    :pointer,       # unsigned int *x_ppem
+    :pointer,       # unsigned int *y_ppem
+  ], :void
+  attach_function :hb_font_glyph_to_string, [
+    :hb_font_t,     # font
+    :hb_codepoint_t, # glyph
+    :pointer,       # s
+    :uint,          # size
+  ], :void
+
+  class Font < Base
+
+    attr_reader :hb_font
+
+    def initialize(face)
+      @hb_font = Harfbuzz.hb_font_create(face.hb_face)
+      Harfbuzz.hb_font_set_scale(@hb_font, face.upem, face.upem)
+      Harfbuzz.hb_ft_font_set_funcs(@hb_font)
+      define_finalizer(:hb_font_destroy, @hb_font)
+    end
+
+    def scale
+      x_scale_ptr = FFI::MemoryPointer.new(:int, 1)
+      y_scale_ptr = FFI::MemoryPointer.new(:int, 1)
+      Harfbuzz.hb_font_get_scale(@hb_font, x_scale_ptr, y_scale_ptr)
+      [
+        x_scale_ptr.read_int,
+        y_scale_ptr.read_int,
+      ]
+    end
+
+    def ppem
+      ppem_x_ptr = FFI::MemoryPointer.new(:uint, 1)
+      ppem_y_ptr = FFI::MemoryPointer.new(:uint, 1)
+      Harfbuzz.hb_font_get_ppem(@hb_font, ppem_x_ptr, ppem_y_ptr)
+      [
+        ppem_x_ptr.read_uint,
+        ppem_y_ptr.read_uint,
+      ]
+    end
+
+    def glyph_to_string(glyph)
+      string_ptr = FFI::MemoryPointer.new(:char, 20)
+      Harfbuzz.hb_font_glyph_to_string(@hb_font, glyph, string_ptr, 20)
+      string_ptr.get_string(0, 20)
+    end
+
+  end
+
+end

data/lib/harfbuzz/shaping.rb

@@ -0,0 +1,75 @@
+module Harfbuzz
+
+  typedef :uint32, :hb_tag_t
+
+  class Feature < FFI::Struct
+
+    layout \
+      :tag,   :hb_tag_t,
+      :value, :uint32,
+      :start, :uint,
+      :end,   :uint
+
+  end
+
+  # typedef Feature, :hb_feature_t
+
+  attach_function :hb_shape_list_shapers, [], :pointer
+  attach_function :hb_shape, [
+    :hb_font_t,     # font
+    :hb_buffer_t,   # buffer
+    :pointer,       # features
+    :uint,          # num_features
+  ], :void
+  attach_function :hb_shape_full, [
+    :hb_font_t,     # font
+    :hb_buffer_t,   # buffer
+    :pointer,       # features
+    :uint,          # num_features
+    :pointer,       # shaper_list
+  ], :bool
+  attach_function :hb_feature_from_string, [
+    :pointer,       # str
+    :int,           # len
+    Feature.by_ref, # feature
+  ], :bool
+  attach_function :hb_feature_to_string, [
+    Feature.by_ref, # feature
+    :pointer,       # buf
+    :uint,          # size,
+  ], :void
+
+  def self.shapers
+    Harfbuzz.hb_shape_list_shapers.read_array_of_strings
+  end
+
+  def self.shape(font, buffer, features=nil, shapers=nil)
+    features_ptr, features_len = features_from_strings(features)
+    shapers_ptr = shapers ? FFI::MemoryPointer.from_array_of_strings(shapers) : nil
+    Harfbuzz.hb_shape_full(
+      font.hb_font,
+      buffer.hb_buffer,
+      features_ptr,
+      features_len,
+      shapers_ptr,
+    )
+  end
+
+  def self.features_from_strings(feature_strings)
+    features_len = feature_strings ? feature_strings.length : 0
+    if features_len > 0
+      features_ptr = FFI::MemoryPointer.new(Feature, features_len)
+      feature_strings.each_with_index do |feature_string, i|
+        feature_string_ptr = FFI::MemoryPointer.new(:char, feature_string.bytesize)
+        feature_string_ptr.put_bytes(0, feature_string)
+        feature_ptr = Feature.new(features_ptr + (i * Feature.size))
+        hb_feature_from_string(feature_string_ptr, feature_string.bytesize, feature_ptr) \
+          or raise "Can't get feature from string: #{feature_string.inspect}"
+      end
+    else
+      features_ptr = nil
+    end
+    [features_ptr, features_len]
+  end
+
+end

data/lib/harfbuzz/version.rb

@@ -0,0 +1,5 @@
+module Harfbuzz
+
+  VERSION = '0.1'
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: harfbuzz
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- John Labovitz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\n    Harfbuzz is a Ruby interface to the Harfbuzz text shaping engine.\n
+  \ "
+email: johnl@johnlabovitz.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/example.rb
+- harfbuzz.gemspec
+- lib/harfbuzz.rb
+- lib/harfbuzz/base.rb
+- lib/harfbuzz/blob.rb
+- lib/harfbuzz/buffer.rb
+- lib/harfbuzz/face.rb
+- lib/harfbuzz/ffi_additions.rb
+- lib/harfbuzz/font.rb
+- lib/harfbuzz/shaping.rb
+- lib/harfbuzz/version.rb
+homepage: http://github.com/jslabovitz/harfbuzz-gem
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Ruby interface to the Harfbuzz text shaping engine
+test_files: []