fontconfig 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fontconfig.gemspec
+gemspec
+
+gem 'minitest', '<5'
+gem 'minitest-reporters', git:'https://github.com/axskern/minitest-reporters.git'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Vasily Fedoseyev
+
+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,29 @@
+# Fontconfig
+
+Ruby bindings for fontconfig (http://fontconfig.org)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fontconfig'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fontconfig
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('fontconfig')
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.libs.push 'spec'
+end
+
+
+task :bundler do
+  require 'bundler/setup'
+end
+
+task :test => [:compile, :bundler]
+
+task :default => :test

data/ext/fontconfig/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+require 'pkg-config'
+
+PKGConfig.have_package('fontconfig')
+
+create_makefile('fontconfig')

data/ext/fontconfig/fc_config.c

@@ -0,0 +1,357 @@
+#include "rb_fontconfig.h"
+
+VALUE rb_cFcConfig;
+
+static size_t fc_config_memsize(const void *p) { return 0; }
+static void fc_config_free(void* p){
+  if(p){
+// FcConfigDestroy -- Destroy a configuration
+    FcConfigDestroy((FcConfig*)p);
+  }
+}
+
+static const rb_data_type_t Fc_Config_data_type = {
+    "FcConfig", 0, fc_config_free, fc_config_memsize,
+};
+
+static VALUE config_wrap(FcConfig* p){
+  return TypedData_Wrap_Struct(rb_cFcConfig, &Fc_Config_data_type, p);
+}
+
+int is_fc_config(VALUE val){
+  return rb_typeddata_is_kind_of(val, &Fc_Config_data_type);
+}
+
+#define CONFIG_UNWRAP(c) ((FcConfig*)RTYPEDDATA_DATA(c))
+
+// FcConfigParseAndLoad -- load a configuration file
+static VALUE rb_config_parse_and_load(int argc, VALUE *argv, VALUE self){
+  VALUE path, complain = Qnil;
+  rb_scan_args(argc, argv, "11", &path, &complain);
+  if(TYPE(path)!=T_STRING)
+    path = rb_any_to_s(path);
+
+  int res = FcConfigParseAndLoad(CONFIG_UNWRAP(self), RSTRING_PTR(path), RTEST(complain));
+  return BOOL2VAL(res);
+}
+
+// FcConfigCreate -- Create a configuration
+static VALUE rb_config_new(int argc, VALUE *argv, VALUE klass){
+  FcConfig * conf = FcConfigCreate();
+  VALUE file;
+  rb_scan_args(argc, argv, "01", &file);
+
+  if(!conf){
+    rb_raise(rb_eRuntimeError, "Cannot create FcConfig");
+  }
+  VALUE self = config_wrap(conf);
+  if(RTEST(file)){
+    if(!rb_config_parse_and_load(1, &file, self) == Qfalse){
+      FcConfigDestroy(conf);
+      RTYPEDDATA_DATA(self) = 0;
+      rb_raise(rb_eRuntimeError, "Cannot load FcConfig");
+    }
+  }
+  return self;
+}
+
+// FcConfigFilename -- Find a config file
+static VALUE rb_config_filename(VALUE klass, VALUE filename){
+  // in FONTCONFIG_PATH
+  char* fname = 0;
+  if(RTEST(filename)){
+    if(TYPE(filename) != T_STRING)
+      filename = rb_any_to_s(filename);
+    fname = RSTRING_PTR(filename);
+  }
+  char* res = FcConfigFilename(fname);
+  if(!res){
+    rb_raise(rb_eRuntimeError, "cannot get config filename");
+  }
+  VALUE rb_res = rb_str_new2(res);
+  FcStrFree(res); //?
+  return rb_res;
+}
+
+// FcConfigGetCurrent -- Return current configuration
+//// FcConfigReference -- Increment config reference count
+static VALUE rb_config_get_current(VALUE klass){
+  FcConfig* conf = FcConfigGetCurrent();
+  if(!conf)
+    rb_raise(rb_eRuntimeError, "no current in FcConfigGetCurrent");
+  FcConfigReference(conf);
+  return config_wrap(conf);
+}
+
+// FcConfigSetCurrent -- Set configuration as default
+static VALUE rb_config_set_current(VALUE self){
+  return BOOL2VAL(FcConfigSetCurrent(CONFIG_UNWRAP(self)));
+}
+
+// FcConfigUptoDate -- Check timestamps on config files
+static VALUE rb_config_up_to_date_p(VALUE self){
+  return BOOL2VAL(FcConfigUptoDate(CONFIG_UNWRAP(self)));
+}
+
+// FcConfigHome -- return the current home directory.
+static VALUE rb_config_home(VALUE klass){
+  char* home = FcConfigHome();
+  if(!home)
+    return Qnil;
+  return rb_str_new2(home);
+}
+
+// FcConfigEnableHome -- controls use of the home directory.
+static VALUE rb_config_enable_home(int argc, VALUE *argv, VALUE klass){
+  VALUE enable;
+  if(rb_scan_args(argc, argv, "01", &enable) == 0){
+    enable = Qtrue;
+  }
+  return BOOL2VAL(FcConfigEnableHome(RTEST(enable)));
+}
+
+// FcConfigBuildFonts -- Build font database
+static VALUE rb_config_build_fonts(VALUE self){
+  //TODO: set some flag?
+  //changes after this have undetermined effects
+  return BOOL2VAL(FcConfigBuildFonts(CONFIG_UNWRAP(self)));
+}
+
+VALUE FcStrList2Array(FcStrList* list){
+  VALUE res = rb_ary_new();
+  char* str;
+  while(str = FcStrListNext(list)){
+    rb_ary_push(res, rb_str_new2(str));
+  }
+  FcStrListDone(list);
+  return res;
+}
+
+// FcConfigGetConfigDirs -- Get config directories
+static VALUE rb_config_get_config_dirs(VALUE self){
+  FcStrList * list = FcConfigGetConfigDirs(CONFIG_UNWRAP(self));
+  return FcStrList2Array(list);
+}
+
+// FcConfigGetFontDirs -- Get font directories
+static VALUE rb_config_get_font_dirs(VALUE self){
+  FcStrList * list = FcConfigGetFontDirs(CONFIG_UNWRAP(self));
+  return FcStrList2Array(list);
+}
+
+// FcConfigGetConfigFiles -- Get config files
+static VALUE rb_config_get_config_files(VALUE self){
+  FcStrList * list = FcConfigGetConfigFiles(CONFIG_UNWRAP(self));
+  return FcStrList2Array(list);
+}
+
+// FcConfigGetCacheDirs -- return the list of directories searched for cache files
+static VALUE rb_config_get_cache_dirs(VALUE self){
+  FcStrList * list = FcConfigGetCacheDirs(CONFIG_UNWRAP(self));
+  return FcStrList2Array(list);
+}
+
+// FcConfigGetRescanInterval -- Get config rescan interval
+static VALUE rb_config_get_rescan_interval(VALUE self){
+  return INT2FIX(FcConfigGetRescanInterval(CONFIG_UNWRAP(self)));
+}
+
+// FcConfigSetRescanInterval -- Set config rescan interval
+static VALUE rb_config_set_rescan_interval(VALUE self, VALUE interval){
+  interval = rb_to_int(interval);
+  return INT2FIX(FcConfigSetRescanInterval(CONFIG_UNWRAP(self), NUM2INT(interval)));
+}
+
+// FcConfigGetSysRoot -- Obtain the system root directory
+static VALUE rb_config_get_sys_root(VALUE self){
+  const char* res = FcConfigGetSysRoot(CONFIG_UNWRAP(self));
+  if(!res)
+    return Qnil;
+  return rb_str_new2(res);
+}
+
+// FcConfigSetSysRoot -- Set the system root directory
+static VALUE rb_config_set_sys_root(VALUE self, VALUE root){
+  FcConfigSetSysRoot(CONFIG_UNWRAP(self), StringValuePtr(root));
+  return self;
+}
+
+// FcFontRenderPrepare -- Prepare pattern for loading font file
+static VALUE rb_config_font_render_prepare(VALUE self, VALUE pat, VALUE font){
+  if(!is_fc_pattern(pat) || !is_fc_pattern(font)){
+    rb_raise(rb_eArgError, "arguments must be Fontconfig::Pattern");
+  }
+  FcPattern * res = FcFontRenderPrepare(CONFIG_UNWRAP(self), (FcPattern*)RTYPEDDATA_DATA(pat), (FcPattern*)RTYPEDDATA_DATA(font));
+  if(!res){
+    rb_raise(rb_eRuntimeError, "FcFontRenderPrepare returned NULL");
+  }
+  return pattern_wrap(res);
+}
+
+// FcConfigAppFontClear -- Remove all app fonts from font database
+static VALUE rb_config_app_font_clear(VALUE self){
+  FcConfigAppFontClear(CONFIG_UNWRAP(self));
+  return self;
+}
+
+// FcConfigAppFontAddFile -- Add font file to font database
+static VALUE rb_config_app_font_add_file(VALUE self, VALUE path){
+  return BOOL2VAL(FcConfigAppFontAddFile(CONFIG_UNWRAP(self), StringValuePtr(path)));
+}
+
+// FcConfigAppFontAddDir -- Add fonts from directory to font database
+static VALUE rb_config_app_font_add_dir(VALUE self, VALUE path){
+  return BOOL2VAL(FcConfigAppFontAddDir(CONFIG_UNWRAP(self), StringValuePtr(path)));
+}
+
+
+// FcFontMatch -- Return best font
+// This function should be called only after FcConfigSubstitute and FcDefaultSubstitute called on pattern
+// TODO: check for this?
+static VALUE rb_config_font_match(VALUE self, VALUE pattern){
+  if(!is_fc_pattern(pattern)){
+    rb_raise(rb_eArgError, "argument must be Fontconfig::Pattern");
+  }
+  FcResult res; // result of FcFontRenderPrepare for font and the provided pattern //???
+  FcPattern* match = FcFontMatch(CONFIG_UNWRAP(self), RTYPEDDATA_DATA(pattern), &res);
+  if(match){
+    return pattern_wrap(match);
+  }
+  return Qnil;
+}
+
+VALUE symPattern, symFont, symScan;
+
+FcMatchKind sym2match_kind(VALUE match_kind){
+  if(match_kind == symPattern)
+    return FcMatchPattern;
+  else if(match_kind == symFont)
+    return FcMatchFont;
+  else if(match_kind == symScan)
+    return FcMatchScan;
+  else
+    rb_raise(rb_eArgError, "match_kind argument must be one of [:pattern, :font, :scan]");
+  return FcMatchPattern;
+}
+
+// FcConfigSubstitute -- Execute substitutions
+static VALUE rb_config_substitute(int argc, VALUE *argv, VALUE self){
+  VALUE pattern, match_kind;
+  rb_scan_args(argc, argv, "11", &pattern, &match_kind);
+
+  if(!is_fc_pattern(pattern)){
+    rb_raise(rb_eArgError, "argument must be Fontconfig::Pattern");
+  }
+  FcMatchKind kind = FcMatchPattern; //TODO: default?
+  if(RTEST(match_kind))
+    kind = sym2match_kind(match_kind);
+
+  return BOOL2VAL(FcConfigSubstitute(CONFIG_UNWRAP(self), RTYPEDDATA_DATA(pattern), kind));
+}
+
+// FcConfigSubstituteWithPat -- Execute substitutions
+static VALUE rb_config_substitute_with_pat(int argc, VALUE *argv, VALUE self){
+  VALUE pattern, pat, match_kind;
+  int n = rb_scan_args(argc, argv, "12", &pattern, &pat, &match_kind);
+
+  if(n == 2){
+    match_kind = pat;
+    pat = Qnil;
+  }
+
+  if(!is_fc_pattern(pattern)){
+    rb_raise(rb_eArgError, "argument must be Fontconfig::Pattern");
+  }
+  FcPattern* pat_pat = 0;
+  if(RTEST(pat)){
+    if(!is_fc_pattern(pat)){
+      rb_raise(rb_eArgError, "argument must be Fontconfig::Pattern");
+    }
+    pat_pat = RTYPEDDATA_DATA(pat);
+  }
+  FcMatchKind kind = FcMatchPattern; //TODO: default?
+  if(RTEST(match_kind))
+    kind = sym2match_kind(match_kind);
+
+  return BOOL2VAL(FcConfigSubstituteWithPat(CONFIG_UNWRAP(self), RTYPEDDATA_DATA(pattern), pat_pat, kind));
+}
+
+// FcFontList -- List fonts
+static VALUE rb_config_font_list(int argc, VALUE *argv, VALUE self){
+  // FcPattern *p, FcObjectSet *os(optional)
+  VALUE pattern, object_set;
+  FcObjectSet* os = 0;
+  rb_scan_args(argc, argv, "11", &pattern, &object_set);
+  if(!is_fc_pattern(pattern)){
+    rb_raise(rb_eArgError, "argument must be Fontconfig::Pattern");
+  }
+  if(object_set){
+    if(is_FcObjectSet(object_set)){
+      os = RTYPEDDATA_DATA(object_set);
+    } else {
+      //TODO: convert array to os?
+      rb_raise(rb_eArgError, "os must be Fontconfig::ObjectSet");
+    }
+  }
+  FcFontSet* set = FcFontList(CONFIG_UNWRAP(self), RTYPEDDATA_DATA(pattern), os);
+
+  return self;
+}
+
+// FcConfigGetFonts -- Get config font set
+static VALUE config_get_fonts(VALUE self, FcSetName set_name){
+  FcFontSet* set = FcConfigGetFonts(CONFIG_UNWRAP(self), set_name);
+
+}
+
+static VALUE rb_config_get_system_fonts(VALUE self){
+  return config_get_fonts(self, FcSetSystem);
+}
+
+static VALUE rb_config_get_application_fonts(VALUE self){
+  return config_get_fonts(self, FcSetApplication);
+}
+
+
+void Init_fontconfig_config(){
+  rb_cFcConfig = rb_define_class_under(rb_cFontconfig, "Config", rb_cObject);
+  rb_define_singleton_method(rb_cFcConfig, "new", rb_config_new, -1);
+  rb_define_method(rb_cFcConfig, "parse_and_load", rb_config_parse_and_load, -1);
+  rb_define_singleton_method(rb_cFcConfig, "filename", rb_config_filename, 1);
+  rb_define_singleton_method(rb_cFcConfig, "get_current", rb_config_get_current, 0);
+  rb_define_method(rb_cFcConfig, "set_current!", rb_config_set_current, 0);
+  rb_define_method(rb_cFcConfig, "up_to_date?", rb_config_up_to_date_p, 0);
+  rb_define_singleton_method(rb_cFcConfig, "home", rb_config_home, 0);
+  rb_define_singleton_method(rb_cFcConfig, "enable_home!", rb_config_enable_home, -1);
+  rb_define_method(rb_cFcConfig, "build_fonts!", rb_config_build_fonts, 0);
+
+  rb_define_method(rb_cFcConfig, "config_dirs", rb_config_get_config_dirs, 0);
+  rb_define_method(rb_cFcConfig, "font_dirs", rb_config_get_font_dirs, 0);
+  rb_define_method(rb_cFcConfig, "config_files", rb_config_get_config_files, 0);
+  rb_define_method(rb_cFcConfig, "cache_dirs", rb_config_get_cache_dirs, 0);
+
+  rb_define_method(rb_cFcConfig, "rescan_interval",  rb_config_get_rescan_interval, 0);
+  rb_define_method(rb_cFcConfig, "rescan_interval=", rb_config_set_rescan_interval, 1);
+  rb_define_method(rb_cFcConfig, "sys_root", rb_config_get_sys_root, 0);
+  rb_define_method(rb_cFcConfig, "set_sys_root!", rb_config_set_sys_root, 1);
+
+  rb_define_method(rb_cFcConfig, "font_render_prepare", rb_config_font_render_prepare, 2);
+
+  rb_define_method(rb_cFcConfig, "app_font_clear!", rb_config_app_font_clear, 0);
+  rb_define_method(rb_cFcConfig, "app_font_add_file", rb_config_app_font_add_file, 1);
+  rb_define_method(rb_cFcConfig, "app_font_add_dir", rb_config_app_font_add_dir, 1);
+
+  rb_define_method(rb_cFcConfig, "font_match", rb_config_font_match, 1);
+
+  symPattern = ID2SYM(rb_intern("pattern"));
+  symFont = ID2SYM(rb_intern("font"));
+  symScan = ID2SYM(rb_intern("scan"));
+  rb_define_method(rb_cFcConfig, "substitute", rb_config_substitute, -1);
+  rb_define_method(rb_cFcConfig, "substitute_with_pat", rb_config_substitute_with_pat, -1);
+
+
+// FcConfigGetBlanks -- Get config blanks
+// FcFontSort -- Return list of matching fonts
+
+// FcConfigGetCache -- DEPRECATED used to return per-user cache filename
+}

data/ext/fontconfig/fc_fontset.c

@@ -0,0 +1,111 @@
+#include "rb_fontconfig.h"
+
+VALUE rb_cFcFontSet;
+
+static size_t fc_object_set_memsize(const void *p) { return 0; }
+static void fc_object_set_free(void* p){
+  if(p){
+    FcFontSetDestroy((FcFontSet*)p);
+  }
+}
+
+static const rb_data_type_t FcFontSet_data_type = {
+    "FcFontSet", 0, fc_object_set_free, fc_object_set_memsize,
+};
+
+VALUE font_set_wrap(FcFontSet* p){
+  return TypedData_Wrap_Struct(rb_cFcFontSet, &FcFontSet_data_type, p);
+}
+
+int is_FcFontSet(VALUE val){
+  return rb_typeddata_is_kind_of(val, &FcFontSet_data_type);
+}
+
+#define OSET_UNWRAP(c) ((FcFontSet*)RTYPEDDATA_DATA(c))
+
+static VALUE rb_oset_add(VALUE self, VALUE val){
+  if(!is_fc_pattern(val)){
+    rb_raise(rb_eArgError, "argument must be a FcPattern");
+  }
+  if(!FcFontSetAdd(OSET_UNWRAP(self), pattern_unwrap(val))){
+    rb_raise(rb_eRuntimeError, "cannot insert into FcFontSet");
+  }
+  return val;
+}
+
+static VALUE oset_add_i(VALUE str, VALUE self, int argc, VALUE *argv){
+  return rb_oset_add(self, str);
+}
+
+static VALUE rb_oset_new(int argc, VALUE *argv, VALUE klass){
+  VALUE optional = Qnil;
+  rb_scan_args(argc, argv, "01", &optional);
+  FcFontSet* set = FcFontSetCreate();
+  if(!set)
+    rb_raise(rb_eRuntimeError, "cannot create FcFontSet");
+
+  VALUE self = object_set_wrap(set);
+  if(optional != Qnil){
+    ID each = rb_intern("each");
+    if(!rb_respond_to(optional, each))
+      rb_raise(rb_eArgError, "parameter must be enumerable");
+    rb_block_call(optional, each, 0, 0, oset_add_i, self);
+  }
+  return self;
+}
+
+
+static VALUE rb_oset_each(VALUE self){
+  int i;
+  FcFontSet* os = OSET_UNWRAP(self);
+  for (i = 0; i < os->nfont; i++){
+    rb_yield(pattern_wrap(os->fonts[i]));
+  }
+  return self;
+}
+
+static VALUE rb_oset_size(VALUE self){
+  return INT2NUM(OSET_UNWRAP(self)->nfont);
+}
+
+static VALUE rb_oset_at(VALUE self, VALUE index){
+
+  int i = NUM2INT(index);
+  FcFontSet* os = OSET_UNWRAP(self);
+
+  if(i < 0 || i >= os->nfont)
+    return Qnil;
+  return pattern_wrap(os->fonts[i]);
+}
+
+static VALUE rb_oset_print(VALUE self){
+  FcFontSetPrint(OSET_UNWRAP(self));
+  return self;
+}
+
+static VALUE rb_oset_match(VALUE self, VALUE config, VALUE pattern){
+  FcFontSet* set = OSET_UNWRAP(self);
+  FcConfig* conf = 0;
+  if(RTEST(config) && is_fc_config(config))
+    conf = CONFIG_UNWRAP(config);
+  if(!RTEST(pattern) || !is_fc_pattern(pattern))
+    rb_raise(rb_eArgError, "pattern must be Fontconfig::Pattern");
+  FcResult res;
+  FcPattern* result = FcFontSetMatch(conf, &set, 1, pattern_unwrap(pattern), &res);
+  if(!result)
+    return Qnil;
+  return pattern_wrap(result);
+}
+
+void Init_fontconfig_fontset(){
+  rb_cFcFontSet = rb_define_class_under(rb_cFontconfig, "FontSet", rb_cObject);
+  rb_define_singleton_method(rb_cFcFontSet, "new", rb_oset_new, -1);
+  rb_define_method(rb_cFcFontSet, "add", rb_oset_add, 1);
+  rb_define_method(rb_cFcFontSet, "<<",  rb_oset_add, 1);
+  rb_define_method(rb_cFcFontSet, "each", rb_oset_each, 0);
+  rb_define_method(rb_cFcFontSet, "size", rb_oset_size, 0);
+  rb_define_method(rb_cFcFontSet, "[]", rb_oset_at, 1);
+  rb_define_method(rb_cFcFontSet, "debug_print", rb_oset_print, 0);
+  rb_define_method(rb_cFcFontSet, "match_pattern", rb_oset_match, 1);
+  rb_include_module(rb_cFcFontSet, rb_mEnumerable);
+}

data/ext/fontconfig/fc_objectset.c

@@ -0,0 +1,87 @@
+#include "rb_fontconfig.h"
+
+VALUE rb_cFcObjectSet;
+
+static size_t fc_object_set_memsize(const void *p) { return 0; }
+static void fc_object_set_free(void* p){
+  if(p){
+    FcObjectSetDestroy((FcObjectSet*)p);
+  }
+}
+
+static const rb_data_type_t FcObjectSet_data_type = {
+    "FcObjectSet", 0, fc_object_set_free, fc_object_set_memsize,
+};
+
+static VALUE object_set_wrap(FcObjectSet* p){
+  return TypedData_Wrap_Struct(rb_cFcObjectSet, &FcObjectSet_data_type, p);
+}
+
+int is_FcObjectSet(VALUE val){
+  return rb_typeddata_is_kind_of(val, &FcObjectSet_data_type);
+}
+
+#define OSET_UNWRAP(c) ((FcObjectSet*)RTYPEDDATA_DATA(c))
+
+static VALUE rb_oset_add(VALUE self, VALUE str){
+  if(!FcObjectSetAdd(OSET_UNWRAP(self), StringValuePtr(str))){
+    rb_raise(rb_eRuntimeError, "cannot insert into FcObjectSet");
+  }
+  return str;
+}
+
+static VALUE oset_add_i(VALUE str, VALUE self, int argc, VALUE *argv){
+  return rb_oset_add(self, str);
+}
+
+static VALUE rb_oset_new(int argc, VALUE *argv, VALUE klass){
+  VALUE optional = Qnil;
+  rb_scan_args(argc, argv, "01", &optional);
+  FcObjectSet* set = FcObjectSetCreate();
+  if(!set)
+    rb_raise(rb_eRuntimeError, "cannot create FcObjectSet");
+
+  VALUE self = object_set_wrap(set);
+  if(optional != Qnil){
+    ID each = rb_intern("each");
+    if(!rb_respond_to(optional, each))
+      rb_raise(rb_eArgError, "parameter must be enumerable");
+    rb_block_call(optional, each, 0, 0, oset_add_i, self);
+  }
+  return self;
+}
+
+
+static VALUE rb_oset_each(VALUE self){
+  int i;
+  FcObjectSet* os = OSET_UNWRAP(self);
+  for (i = 0; i < os->nobject; i++){
+    rb_yield(rb_str_new2(os->objects[i]));
+  }
+  return self;
+}
+
+static VALUE rb_oset_size(VALUE self){
+  return INT2NUM(OSET_UNWRAP(self)->nobject);
+}
+
+static VALUE rb_oset_at(VALUE self, VALUE index){
+
+  int i = NUM2INT(index);
+  FcObjectSet* os = OSET_UNWRAP(self);
+
+  if(i < 0 || i >= os->nobject)
+    return Qnil;
+  return rb_str_new2(os->objects[i]);
+}
+
+void Init_fontconfig_objectset(){
+  rb_cFcObjectSet = rb_define_class_under(rb_cFontconfig, "ObjectSet", rb_cObject);
+  rb_define_singleton_method(rb_cFcObjectSet, "new", rb_oset_new, -1);
+  rb_define_method(rb_cFcObjectSet, "add", rb_oset_add, 1);
+  rb_define_method(rb_cFcObjectSet, "<<",  rb_oset_add, 1);
+  rb_define_method(rb_cFcObjectSet, "each", rb_oset_each, 0);
+  rb_define_method(rb_cFcObjectSet, "size", rb_oset_size, 0);
+  rb_define_method(rb_cFcObjectSet, "[]", rb_oset_at, 1);
+  rb_include_module(rb_cFcObjectSet, rb_mEnumerable);
+}

data/ext/fontconfig/fc_pattern.c

@@ -0,0 +1,202 @@
+#include "rb_fontconfig.h"
+#include <fontconfig/fontconfig.h>
+
+VALUE rb_cFcPattern;
+
+static size_t fc_pattern_memsize(const void *p) { return 0; }
+static void fc_pattern_free(void* p){
+  if(p){
+    FcPatternDestroy((FcPattern*)p);
+  }
+}
+
+static const rb_data_type_t Fc_Pattern_data_type = {
+    "FcPattern", 0, fc_pattern_free, fc_pattern_memsize,
+};
+
+VALUE pattern_wrap(FcPattern* p){
+  return TypedData_Wrap_Struct(rb_cFcPattern, &Fc_Pattern_data_type, p);
+}
+
+int is_fc_pattern(VALUE val){
+  return rb_typeddata_is_kind_of(val, &Fc_Pattern_data_type);
+}
+
+#define PATTERN_UNWRAP(c) ((FcPattern*)RTYPEDDATA_DATA(c))
+
+
+static VALUE rb_pattern_parse(VALUE klass, VALUE string){
+  if(TYPE(string) != T_STRING)
+    string = rb_any_to_s(string);
+  FcPattern* p = FcNameParse(RSTRING_PTR(string));
+  return pattern_wrap(p);
+}
+
+static VALUE rb_pattern_new(int argc, VALUE *argv, VALUE klass){
+  VALUE optional = Qnil;
+  rb_scan_args(argc, argv, "01", &optional);
+  if(optional != Qnil){
+    if(TYPE(optional) == T_STRING)
+      return rb_pattern_parse(klass, optional);
+
+    rb_raise(rb_eArgError, "parameter must be a string");
+  } else {
+    return pattern_wrap(FcPatternCreate());
+  }
+}
+
+static VALUE rb_pattern_format(VALUE self, VALUE format){
+  if(TYPE(format) != T_STRING)
+    format = rb_any_to_s(format);
+  char* res = FcPatternFormat(PATTERN_UNWRAP(self), RSTRING_PTR(format));
+  VALUE str = rb_str_new2((char*)res);
+  FcStrFree(res);
+  return str;
+}
+
+static VALUE rb_pattern_to_s(VALUE self){
+  char* res = FcNameUnparse(PATTERN_UNWRAP(self));
+  VALUE str = rb_str_new2((char*)res);
+  FcStrFree(res);
+  return str;
+}
+
+static VALUE rb_pattern_duplicate(VALUE self){
+  FcPattern* p = FcPatternDuplicate(PATTERN_UNWRAP(self));
+  return pattern_wrap(p);
+}
+
+static VALUE rb_pattern_debugprint(VALUE self){
+  FcPatternPrint(PATTERN_UNWRAP(self));
+  return Qnil;
+}
+
+static VALUE rb_pattern_equal(VALUE self, VALUE other){
+  if(!is_fc_pattern(other)){
+    //TODO: cast?
+    return Qfalse;
+  }
+  return FcPatternEqual(PATTERN_UNWRAP(self), PATTERN_UNWRAP(other)) ? Qtrue : Qfalse;
+}
+
+static VALUE rb_pattern_hash(VALUE self){
+  int res = FcPatternHash(PATTERN_UNWRAP(self));
+  return INT2NUM(res);
+}
+
+static VALUE rb_pattern_add(int argc, VALUE *argv, VALUE self){
+  VALUE object, value, append;
+  rb_scan_args(argc, argv, "21", &object, &value, &append);
+  FcValue val;
+  switch(TYPE(value)){
+    case T_NONE: case T_NIL: val.type = FcTypeVoid; break;
+    case T_FIXNUM: val.type = FcTypeInteger; val.u.i = NUM2INT(value); break;
+    case T_FLOAT: val.type = FcTypeDouble; val.u.d = NUM2DBL(value); break;
+    case T_STRING: val.type = FcTypeString; val.u.s = RSTRING_PTR(value); break;
+    case T_TRUE: val.type = FcTypeBool; val.u.b = 1; break;
+    case T_FALSE: val.type = FcTypeBool; val.u.b = 0; break;
+    case T_OBJECT:
+      //TODO: increment object references?
+      // ...
+      //  FcTypeMatrix: //    m               FcMatrix *
+      //  FcTypeCharSet: //   c               FcCharSet *
+      //  FcTypeFTFace: //  f   void * (FT_Face)
+      //  FcTypeLangSet
+    default:
+      rb_raise(rb_eArgError, "unsupported type for value");
+      break;
+  }
+  if(TYPE(object)!=T_STRING)
+    object = rb_any_to_s(object);
+  int res = FcPatternAdd(PATTERN_UNWRAP(self), RSTRING_PTR(object), val, RTEST(append));
+  //TODO: raise on errors?
+  return res? Qtrue : Qfalse;
+}
+
+static VALUE fc_value_to_value(FcValue* val){
+  //FcTypeString, FcTypeMatrix and FcTypeCharSet reference memory, need FcValueDestroy or so
+  switch(val->type){
+    case FcTypeVoid: return Qnil;
+    case FcTypeInteger: return INT2FIX(val->u.i);
+    case FcTypeDouble: return rb_float_new(val->u.d);
+    case FcTypeString: return rb_str_new2(val->u.s);
+    case FcTypeBool: return val->u.b? Qtrue : Qfalse;
+    case FcTypeMatrix: //    m               FcMatrix *
+    case FcTypeCharSet: //   c               FcCharSet *
+    case FcTypeFTFace: //  f   void * (FT_Face)
+    case FcTypeLangSet: // l   FcLangSet * l
+      //TODO
+      // note: data is not copied, we have a pointer to internal structure
+      return Qnil;
+    default:
+      rb_raise(rb_eRuntimeError, "got unknown FcValue type %d", val->type);
+      break;
+  }
+  return Qnil;
+}
+
+static VALUE rb_pattern_get(VALUE self, VALUE object, VALUE id){
+  Check_Type(id, T_FIXNUM);
+  if(TYPE(object)!=T_STRING)
+    object = rb_any_to_s(object);
+  FcValue val;
+  FcResult res = FcPatternGet(PATTERN_UNWRAP(self), RSTRING_PTR(object), FIX2INT(id), &val);
+  if(res == FcResultMatch){
+    VALUE r_res = fc_value_to_value(&val);
+    // FcValueDestroy(val); // gives malloc error
+    return r_res;
+  }
+  if(res == FcResultNoMatch || res == FcResultNoId){
+    //raise?
+    return Qnil;
+  }
+  if(res == FcResultOutOfMemory){
+    rb_raise(rb_eRuntimeError, "FcResultOutOfMemory");
+  }
+  //FcResultTypeMismatch cannot be here
+  return Qnil;
+}
+
+static VALUE rb_pattern_delete(VALUE self, VALUE object){
+  if(TYPE(object)!=T_STRING)
+    object = rb_any_to_s(object);
+  int res = FcPatternDel(PATTERN_UNWRAP(self), RSTRING_PTR(object));
+  return res? Qtrue : Qfalse;
+}
+
+static VALUE rb_pattern_remove(VALUE self, VALUE object, VALUE id){
+  Check_Type(id, T_FIXNUM);
+  if(TYPE(object)!=T_STRING)
+    object = rb_any_to_s(object);
+  int res = FcPatternRemove(PATTERN_UNWRAP(self), RSTRING_PTR(object), FIX2INT(id));
+  return res? Qtrue : Qfalse;
+}
+
+rb_pattern_default_substitute(VALUE self){
+  FcDefaultSubstitute(PATTERN_UNWRAP(self));
+  return self;
+}
+
+
+void Init_fontconfig_pattern(){
+  rb_cFcPattern = rb_define_class_under(rb_cFontconfig, "Pattern", rb_cObject);
+  rb_define_singleton_method(rb_cFcPattern, "new", rb_pattern_new, -1);
+  rb_define_singleton_method(rb_cFcPattern, "parse", rb_pattern_parse, 1);
+  rb_define_method(rb_cFcPattern, "dup", rb_pattern_duplicate, 0);
+
+  rb_define_method(rb_cFcPattern, "==", rb_pattern_equal, 1);
+  // rb_define_method(rb_cFcPattern, "equal_subset", rb_pattern_equal, 1);
+  // filter - need set
+  rb_define_method(rb_cFcPattern, "add", rb_pattern_add, -1);
+  rb_define_method(rb_cFcPattern, "get", rb_pattern_get, 2);
+  rb_define_method(rb_cFcPattern, "delete", rb_pattern_delete, 1);
+  rb_define_method(rb_cFcPattern, "remove", rb_pattern_remove, 2);
+
+  rb_define_method(rb_cFcPattern, "hash", rb_pattern_hash, 0);
+  rb_define_method(rb_cFcPattern, "to_s", rb_pattern_to_s, 0);
+  rb_define_method(rb_cFcPattern, "unparse", rb_pattern_to_s, 0);
+  rb_define_method(rb_cFcPattern, "format", rb_pattern_format, 1);
+  rb_define_method(rb_cFcPattern, "debug_print", rb_pattern_debugprint, 0);
+  rb_define_method(rb_cFcPattern, "default_substitute!", rb_pattern_default_substitute, 0);
+
+}

data/ext/fontconfig/fontconfig.c

@@ -0,0 +1,24 @@
+#include "rb_fontconfig.h"
+#include <fontconfig/fontconfig.h>
+
+VALUE rb_cFontconfig;
+
+static VALUE rb_fc_version(VALUE self){
+  int version = FcGetVersion();
+  return INT2FIX(version);
+}
+
+
+void Init_fontconfig_pattern();
+void Init_fontconfig_objectset();
+void Init_fontconfig_fontset();
+void Init_fontconfig_config();
+
+void Init_fontconfig(){
+  rb_cFontconfig = rb_define_module("Fontconfig");
+  rb_define_singleton_method(rb_cFontconfig, "library_version", rb_fc_version, 0);
+  Init_fontconfig_pattern();
+  Init_fontconfig_objectset();
+  Init_fontconfig_fontset();
+  Init_fontconfig_config();
+}

data/ext/fontconfig/rb_fontconfig.h

@@ -0,0 +1,19 @@
+#include <ruby.h>
+#include <fontconfig/fontconfig.h>
+
+extern VALUE rb_cFontconfig;
+
+
+#define BOOL2VAL(p) ((p) ? Qtrue : Qfalse)
+
+int is_fc_pattern(VALUE val);
+VALUE pattern_wrap(FcPattern* p);
+#define pattern_unwrap(c) ((FcPattern*)RTYPEDDATA_DATA(c))
+
+int is_FcObjectSet(VALUE val);
+
+VALUE font_set_wrap(FcFontSet* p);
+int is_FcFontSet(VALUE val);
+
+int is_fc_config(VALUE val);
+#define CONFIG_UNWRAP(c) ((FcConfig*)RTYPEDDATA_DATA(c))

data/fontconfig.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/fontconfig/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Vasily Fedoseyev"]
+  gem.email         = ["vasilyfedoseyev@gmail.com"]
+  gem.description   = %q{}
+  gem.summary       = %q{Ruby bindings for fontconfig library}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "fontconfig"
+  gem.require_paths = ["lib"]
+  gem.version       = Fontconfig::VERSION
+
+  gem.extensions = "ext/fontconfig/extconf.rb"
+
+  gem.add_dependency "pkg-config"
+  gem.add_development_dependency "rake-compiler"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "minitest-reporters"
+end

data/lib/fontconfig/version.rb

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

data/lib/fontconfig.rb

@@ -0,0 +1,32 @@
+require "fontconfig/version"
+
+require 'rbconfig'
+require "fontconfig.#{RbConfig::CONFIG['DLEXT']}"
+
+module Fontconfig
+  class Pattern
+
+    class Proxy
+      def initialize pattern, key
+        @pattern = pattern
+        @key = key
+      end
+
+      def [](num)
+        @pattern.get(@key, num)
+      end
+
+      def <<(obj)
+        @pattern.add(@key, obj, true)
+      end
+
+      def delete!
+        @pattern.delete(@key)
+      end
+    end
+
+    def [](key)
+      return Proxy.new(self, key)
+    end
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,16 @@
+require 'minitest/autorun'
+require 'test_helper'
+
+describe Fontconfig do
+  subject { Fontconfig }
+
+  it "should be" do
+    subject.wont_be_nil
+  end
+
+  it "version" do
+    # puts "Lib version #{subject.library_version}"
+    subject.library_version.must_be :>, 0
+  end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+require 'test_helper'
+
+describe Fontconfig::Config do
+  describe "class methods" do
+    subject { Fontconfig::Config }
+    describe "new" do
+      it "works" do
+        subject.new.must_be_instance_of subject
+      end
+
+      it "loads config" do
+        skip
+        subject.new "some_config_file"
+      end
+
+      it "raises if cannot load" do
+        assert_raises(RuntimeError){
+          subject.new "some_config_file"
+        }
+      end
+    end
+
+    it "filename" do
+      res = subject.filename('')
+      puts "res is #{res}"
+      res.must_be_instance_of String
+    end
+  end
+
+  subject { Fontconfig::Config.new }
+
+
+  it "config_dirs" do
+    r = subject.config_dirs
+    puts "config_dirs is '#{r}'"
+    r.must_be_instance_of Array
+  end
+end

data/spec/object_set_spec.rb

@@ -0,0 +1,26 @@
+require 'minitest/autorun'
+require 'test_helper'
+
+describe Fontconfig::ObjectSet do
+  describe "class methods" do
+    subject { Fontconfig::ObjectSet }
+    describe "new" do
+      it "works" do
+        subject.new.must_be_instance_of subject
+      end
+
+      it "init by array of strings" do
+        arr = %w{str1 str2 str3}.sort
+        (s = subject.new(arr)).must_be_instance_of subject
+        s.to_a.sort.must_equal arr
+      end
+    end
+  end
+
+  subject { Fontconfig::ObjectSet.new }
+
+  it "add" do
+    subject << "str"
+    subject.to_a.must_equal ["str"]
+  end
+end

data/spec/pattern_spec.rb

@@ -0,0 +1,51 @@
+require 'minitest/autorun'
+require 'test_helper'
+
+describe Fontconfig::Pattern do
+
+  describe "class methods" do
+    subject { Fontconfig::Pattern }
+
+    it "create by parsing" do
+      res = subject.parse("Monospace Bold 12px")
+      res.must_be_instance_of subject
+    end
+
+  end
+
+  describe "instance" do
+    subject { Fontconfig::Pattern.parse("monospace-Bold-Italic 21") }
+
+    it "to_s" do
+      res = subject.to_s
+      res.must_be_kind_of String
+    end
+
+    it "format" do
+      res = subject.format("%{family}")
+      # subject.debug_print
+      # puts "format #{res}"
+      res.must_be_kind_of String
+    end
+
+    it "hash" do
+      subject.hash.must_be_kind_of Fixnum
+    end
+
+    it "set/det/delete" do
+      subject.add("key", "value")
+      subject.add("key", "value2", true)
+      subject.get("key", 0).must_equal "value"
+      subject.get("key", 1).must_equal "value2"
+      subject.delete("key")
+      subject.get("key", 0).must_be_nil
+    end
+
+    it "default_substitute!" do
+      subject.default_substitute!
+      subject["familylang"][0].must_equal "en"
+    end
+
+  end
+
+end

data/spec/test_helper.rb

@@ -0,0 +1,5 @@
+
+require "minitest/reporters"
+MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new
+
+require 'fontconfig'

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: fontconfig
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Vasily Fedoseyev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pkg-config
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- vasilyfedoseyev@gmail.com
+executables: []
+extensions:
+- ext/fontconfig/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ext/fontconfig/extconf.rb
+- ext/fontconfig/fc_config.c
+- ext/fontconfig/fc_fontset.c
+- ext/fontconfig/fc_objectset.c
+- ext/fontconfig/fc_pattern.c
+- ext/fontconfig/fontconfig.c
+- ext/fontconfig/rb_fontconfig.h
+- fontconfig.gemspec
+- lib/fontconfig.rb
+- lib/fontconfig/version.rb
+- spec/base_spec.rb
+- spec/config_spec.rb
+- spec/object_set_spec.rb
+- spec/pattern_spec.rb
+- spec/test_helper.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'
+      segments:
+      - 0
+      hash: -3843724065432744597
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3843724065432744597
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby bindings for fontconfig library
+test_files:
+- spec/base_spec.rb
+- spec/config_spec.rb
+- spec/object_set_spec.rb
+- spec/pattern_spec.rb
+- spec/test_helper.rb