ffi-inline 0.0.1

data/Rakefile

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'rake'
+
+task :default => :test
+
+task :test do
+	Dir.chdir 'spec'
+
+	sh 'rspec inliner_spec.rb --color --format doc'
+end

data/examples/ex_1.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../lib')))
+require 'ffi/inliner'
+
+class Foo
+  extend FFI::Inliner
+
+  inline 'void say_hello (char* name) { printf("Hello, %s\n", name); }'
+end
+
+Foo.new.say_hello('foos')

data/ffi-inline.gemspec

@@ -0,0 +1,21 @@
+Kernel.load 'lib/ffi/inliner/version.rb'
+
+Gem::Specification.new {|s|
+  s.name         = 'ffi-inline'
+  s.version      = FFI::Inliner::Version
+  s.authors      = 'meh.'
+  s.email        = 'meh@paranoici.org'
+  s.homepage     = 'http://github.com/meh/ruby-ffi-inline'
+  s.platform     = Gem::Platform::RUBY
+  s.summary      = 'Inline C/C++ in Ruby easily and cleanly.'
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_dependency 'ffi', '>=0.4.0'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+}

data/lib/ffi/inliner/builders/c.rb

@@ -0,0 +1,146 @@
+require 'ffi/inliner/compilers/tcc'
+require 'ffi/inliner/compilers/gcc'
+
+module FFI; module Inliner
+
+Builder.define :c do
+  ToFFI = {
+    'void'          => :void,
+    'char'          => :char,
+    'unsigned char' => :uchar,
+    'int'           => :int,
+    'unsigned int'  => :uint,
+    'long'          => :long,
+    'unsigned long' => :ulong,
+    'float'         => :float,
+    'double'        => :double,
+  }
+
+  attr_reader :code, :compiler, :libraries
+
+  def initialize(code = nil, options = {})
+    super(code)
+
+    @types     = ToFFI.dup
+    @libraries = options[:libraries] || []
+
+    @signatures = []
+
+    use_compiler options[:use_compiler] || options[:compiler] || :gcc
+
+    @signatures << parse_signature(code) if code && !code.empty?
+  end
+
+  def libraries(*libraries)
+    @libraries.concat(libraries)
+  end
+
+  def types(map = nil)
+    map ? @types.merge!(map) : @types
+  end; alias map types
+
+  def raw(code, no_line = false)
+    return super(code) if no_line
+
+    whole, path, line = caller.find { |line| line !~ /ffi-inliner/ }.match(/^(.*?):(\d+):in/).to_a
+
+    super "\n#line #{line.to_i} #{path.inspect}\n" << code
+  end; alias c_raw raw
+
+  def include(path, options = {})
+    delimiter = (options[:quoted] || options[:local]) ? ['"', '"'] : ['<', '>']
+
+    raw "#include #{delimiter.first}#{path}#{delimiter.last}\n", true
+  end
+
+  def typedef (from, to)
+    raw "typedef #{from} #{to};"
+  end
+
+  def function(code, signature = nil)
+    parsed = parse_signature(code)
+
+    if signature
+      parsed[:arguments] = signature[:arguments] if signature[:arguments]
+      parsed[:return]    = signature[:return]    if signature[:return]
+    end
+
+    @signatures << parsed
+
+    raw code
+  end; alias c function
+
+  def struct(ffi_struct)
+    raw %{
+      typedef struct {#{
+        ffi_struct.layout.fields.map {|field|
+          "#{field} #{field.name};"
+        }.join("\n")
+      }} #{ffi_struct.class.name}
+    }, true
+  end
+
+  def to_ffi_type(type, mod = nil)
+    raise ArgumentError, 'type is nil' if type.nil?
+
+    if type.is_a?(Symbol) || type.is_a?(FFI::Type) || (type.is_a?(Class) && type.ancestors.include?(FFI::Struct))
+      type
+    elsif @types[type]
+      @types[type]
+    elsif type.to_s.include? ?*
+      :pointer
+    elsif ((mod || FFI).find_type(type.to_sym) rescue false)
+      type.to_sym
+    else
+      raise "type #{type} not supported"
+    end
+  end
+
+  def shared_object
+    @compiler.compile(@code, @libraries)
+  end
+
+  def signatures
+    @signatures
+  end
+
+private
+
+  # Based on RubyInline code by Ryan Davis
+  # Copyright (c) 2001-2007 Ryan Davis, Zen Spider Software
+  def strip_comments(code)
+    code.gsub(%r(\s*/\*.*?\*/)m, '').
+         gsub(%r(^\s*//.*?\n), '').
+         gsub(%r([ \t]*//[^\n]*), '')
+  end
+
+  # Based on RubyInline code by Ryan Davis
+  # Copyright (c) 2001-2007 Ryan Davis, Zen Spider Software
+  def parse_signature(code)
+    sig = strip_comments(code)
+
+    sig.gsub!(/^\s*\#.*(\\\n.*)*/, '') # strip preprocessor directives
+    sig.gsub!(/\s*\{.*/m, '')          # strip function body
+    sig.gsub!(/\s+/, ' ')              # clean and collapse whitespace
+    sig.gsub!(/\s*\*\s*/, ' * ')       # clean pointers
+    sig.gsub!(/\s*const\s*/, '')       # remove const
+    sig.strip!
+
+    whole, return_type, function_name, arg_string = sig.match(/(.*?(?:\ \*)?)\s*(\w+)\s*\(([^)]*)\)/).to_a
+
+    raise SyntaxError, "cannot parse signature: #{sig}" unless whole
+
+    args = arg_string.split(',').map {|arg|
+      # helps normalize into 'char * varname' form
+      arg = arg.gsub(/\s*\*\s*/, ' * ').strip
+
+      whole, type = arg.gsub(/\s*\*\s*/, ' * ').strip.match(/(((.*?(?:\ \*)?)\s*\*?)+)\s+(\w+)\s*$/).to_a
+
+      type
+    }
+
+    Signature.new(return_type, function_name, args, args.empty? ? -1 : args.length)
+  end
+end
+
+end; end

data/lib/ffi/inliner/builders/cpp.rb

@@ -0,0 +1,27 @@
+require 'ffi/inliner/builders/c'
+require 'ffi/inliner/compilers/gxx'
+
+module FFI; module Inliner
+
+Builder.define Builder[:c], :cplusplus, :cxx, :cpp, 'c++' do
+  def initialize(code = "", options = {})
+    super(code, options) rescue nil
+
+    use_compiler options[:use_compiler] || options[:compiler] || :gxx
+  end
+
+  def function(code, signature = nil)
+    parsed = parse_signature(code)
+
+    if signature
+      parsed[:arguments] = signature[:arguments] if signature[:arguments]
+      parsed[:return]    = signature[:return]    if signature[:return]
+    end
+
+    @signatures << parsed
+
+    raw 'extern "C" {' << code << '}' << "\n"
+  end
+end
+
+end; end

data/lib/ffi/inliner/builders.rb

@@ -0,0 +1,98 @@
+module FFI; module Inliner
+
+Signature = ::Struct.new(:return, :name, :arguments, :arity)
+
+class Builder
+  @builders = []
+
+  def self.[](name)
+    return name if name.is_a?(Builder)
+
+    @builders.find {|builder|
+      builder.name.downcase == name.downcase ||
+      builder.aliases.any? { |ali| ali.downcase == name.downcase }
+    }
+  end
+
+  def self.define (name, *aliases, &block)
+    inherit_from = self
+
+    if name.is_a?(Builder)
+      name = name.class
+    end
+
+    if name.is_a?(Class)
+      inherit_from = name
+      name         = aliases.shift
+    end
+
+    @builders << Class.new(inherit_from, &block).tap {|k|
+      k.instance_eval {
+        define_singleton_method :name do name end
+        define_singleton_method :aliases do aliases end
+      }
+    }
+  end
+
+  attr_reader :code, :compiler
+
+  def initialize(code = "")
+    @code  = code
+    @evals = []
+  end
+
+  def use_compiler(compiler)
+    @compiler = Compiler[compiler]
+  end
+
+  def raw(code)
+    @code << code
+  end
+
+  def eval(&block)
+    @evals << block
+  end
+
+  def to_ffi_type(type)
+    raise 'the Builder has not been specialized'
+  end
+
+  def shared_object
+    raise 'the Builder has not been specialized'
+  end
+
+  def signatures
+    raise 'the Builder has not been specialized'
+  end
+
+  def symbols
+    signatures.map { |s| s.name.to_sym }
+  end
+
+  def build
+    builder = self
+    blocks  = @evals
+
+    mod = Module.new
+    mod.instance_eval {
+      extend FFI::Library
+
+      ffi_lib builder.shared_object
+
+      blocks.each { |block| instance_eval &block }
+
+      builder.signatures.each {|s|
+        attach_function s.name, s.arguments.compact.map {|a|
+          builder.to_ffi_type(a, self)
+        }, builder.to_ffi_type(s.return, self)
+      }
+    }
+
+    mod
+  end
+end
+
+end; end
+
+require 'ffi/inliner/builders/c'
+require 'ffi/inliner/builders/cpp'

data/lib/ffi/inliner/compilers/gcc.rb

@@ -0,0 +1,57 @@
+module FFI; module Inliner
+
+Compiler.define :gcc do
+  def exists?
+    `gcc -v 2>&1'`; $?.success?
+  end
+
+  def compile (code, libraries = [])
+    @code      = code
+    @libraries = libraries
+
+    return output if File.exists?(output)
+
+    unless system(if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+      "sh -c '#{ldshared} -o #{output.shellescape} #{input.shellescape} #{libs}' 2>#{log.shellescape}"
+    else
+      "#{ldshared} -o #{output.shellescape} #{input.shellescape} #{libs} 2>#{log.shellescape}"
+    end)
+      raise CompilationError.new(log)
+    end
+
+    output
+  end
+
+  private
+  def digest
+    Digest::SHA1.hexdigest(@code + @libraries.to_s + @options.to_s)
+  end
+
+  def input
+    File.join(Inliner.directory, "#{digest}.c").tap {|path|
+      File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
+    }
+  end
+
+  def output
+    File.join(Inliner.directory, "#{digest}.#{Compiler::Extension}")
+  end
+
+  def log
+    File.join(Inliner.directory, "#{digest}.log")
+  end
+
+  def ldshared
+    if RbConfig::CONFIG['target_os'] =~ /darwin/
+      "gcc -dynamic -bundle -fPIC #{options}"
+    else
+      "gcc -shared -fPIC #{options}"
+    end
+  end
+
+  def libs
+    @libraries.map { |lib| "-l#{lib}".shellescape }.join(' ')
+  end
+end
+
+end; end

data/lib/ffi/inliner/compilers/gxx.rb

@@ -0,0 +1,23 @@
+module FFI; module Inliner
+
+Compiler.define Compiler[:gcc], :gxx, 'g++' do
+  def exists?
+    `g++ -v 2>&1'`; $?.success?
+  end
+
+  def input
+    File.join(Inliner.directory, "#{digest}.cpp").tap {|path|
+      File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
+    }
+  end
+
+  def ldshared
+    if RbConfig::CONFIG['target_os'] =~ /darwin/
+      "g++ -dynamic -bundle -fPIC #{options}"
+    else
+      "g++ -shared -fPIC #{options}"
+    end
+  end
+end
+
+end; end

data/lib/ffi/inliner/compilers/tcc.rb

@@ -0,0 +1,57 @@
+module FFI; module Inliner
+
+Compiler.define :tcc do
+  def exists?
+    `tcc -v 2>&1'`; $?.success?
+  end
+
+  def compile (code, libraries = [])
+    @code      = code
+    @libraries = libraries
+
+    return output if File.exists?(output)
+
+    unless system(if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+      "sh -c '#{ldshared} #{libs} -o #{output.shellescape} #{input.shellescape}' 2>#{log.shellescape}"
+    else
+      "#{ldshared} #{libs} -o #{output.shellescape} #{input.shellescape} 2>#{log.shellescape}"
+    end)
+      raise CompilationError.new(log)
+    end
+
+    output
+  end
+
+  private
+  def digest
+    Digest::SHA1.hexdigest(@code + @libraries.to_s + @options.to_s)
+  end
+
+  def input
+    File.join(Inliner.directory, "#{digest}.c").tap {|path|
+      File.open(path, 'w') { |f| f.write(@code) } unless File.exists?(path)
+    }
+  end
+
+  def output
+    File.join(Inliner.directory, "#{digest}.#{Compiler::Extension}")
+  end
+
+  def log
+    File.join(Inliner.directory, "#{digest}.log")
+  end
+
+  def ldshared
+    if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+      "tcc -rdynamic -shared -fPIC #{options}"
+    else
+      "tcc -shared #{options}"
+    end
+  end
+
+  def libs
+    @libraries.map { |lib| "-l#{lib}".shellescape }.join(' ')
+  end
+end
+
+end; end

data/lib/ffi/inliner/compilers.rb

@@ -0,0 +1,53 @@
+module FFI; module Inliner
+
+class Compiler
+  Extension = case RbConfig::CONFIG['target_os']
+    when /darwin/      then 'dylib'
+    when /mswin|mingw/ then 'dll'
+    else                    'so'
+    end
+
+  @compilers = []
+
+  def self.[] (name)
+    return name if name.is_a?(Compiler)
+
+    @compilers.find {|compiler|
+      compiler.name.downcase == name.downcase ||
+      compiler.aliases.any? { |ali| ali.downcase == name.downcase }
+    }
+  end
+
+  def self.define (name, *aliases, &block)
+    inherit_from = self
+
+    if name.is_a?(Compiler)
+      name = name.class
+    end
+
+    if name.is_a?(Class)
+      inherit_from = name
+      name         = aliases.shift
+    end
+
+    @compilers << Class.new(inherit_from, &block).new(name, *aliases)
+  end
+
+  attr_reader   :name, :aliases
+  attr_accessor :options
+
+  def initialize(name, *aliases)
+    @name    = name
+    @aliases = aliases
+  end
+
+  def exists?
+    raise 'the Compiler has not been specialized'
+  end
+
+  def compile
+    raise 'the Compiler has not been specialized'
+  end
+end
+
+end; end

data/lib/ffi/inliner/error.rb

@@ -0,0 +1,11 @@
+class CompilationError < RuntimeError
+  def initialize (path)
+    @path = path
+
+    super "compile error: see logs at #{@path}"
+  end
+
+  def log
+    File.read(@path)
+  end
+end

data/lib/ffi/inliner/inliner.rb

@@ -0,0 +1,73 @@
+require 'ffi/inliner/error'
+
+module FFI
+
+module Inliner
+  def self.directory
+    if ENV['FFI_INLINER_PATH'] && !ENV['FFI_INLINER_PATH'].empty?
+      @directory = ENV['FFI_INLINER_PATH']
+    else
+      require 'tmpdir'
+      @directory ||= File.expand_path(File.join(Dir.tmpdir, ".ffi-inliner-#{Process.uid}"))
+    end
+
+    if File.exists?(@directory) && !File.directory?(@directory)
+      raise 'the FFI_INLINER_PATH exists and is not a directory'
+    end
+
+    if !File.exists?(@directory)
+      FileUtils.mkdir(@directory)
+    end
+
+    @directory
+  end
+
+  def inline(*args, &block)
+    if self.class == Class
+      instance_inline(*args, &block)
+    else
+      singleton_inline(*args, &block)
+    end
+  end
+
+  def singleton_inline(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+
+    language, code = if args.length == 2
+      args
+    else
+      block_given? ? [args.shift || :c, ''] : [:c, args.shift || '']
+    end
+
+    builder = Builder[language].new(code, options)
+    yield builder if block_given?
+    mod = builder.build
+
+    builder.symbols.each {|sym|
+      define_singleton_method sym, &mod.method(sym)
+    }
+  end
+
+  def instance_inline(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+
+    language, code = if args.length == 2
+      args
+    else
+      block_given? ? [args.shift || :c, ''] : [:c, args.shift || '']
+    end
+
+    builder = Builder[language].new(code, options)
+    yield builder if block_given?
+    mod = builder.build
+
+    builder.symbols.each {|sym|
+      define_method sym, &mod.method(sym)
+    }
+  end
+end
+
+end
+
+require 'ffi/inliner/compilers'
+require 'ffi/inliner/builders'

data/lib/ffi/inliner/version.rb

@@ -0,0 +1,7 @@
+module FFI
+
+module Inliner
+  Version = '0.0.1'
+end
+
+end

data/lib/ffi/inliner.rb

@@ -0,0 +1,8 @@
+require 'digest/sha1'
+require 'fileutils'
+require 'rbconfig'
+require 'shellwords'
+
+require 'rubygems'
+require 'ffi'
+require 'ffi/inliner/inliner'

data/spec/inliner_spec.rb

@@ -0,0 +1,273 @@
+require 'ffi/inliner'
+
+describe FFI::Inliner do
+  before do
+    module Foo
+      extend FFI::Inliner
+    end
+  end
+
+  it 'should extend the module with inline methods' do
+    module Foo
+      inline %{
+        long factorial (int max) {
+            int i = max, result = 1;
+
+            while (i >= 2) {
+              result *= i--;
+            }
+
+            return result;
+        }
+      }
+
+      inline 'int simple_math() { return 1 + 1; }'
+    end
+
+    Foo.factorial(4).should == 24
+    Foo.simple_math.should == 2
+  end
+
+  it 'should correctly parse function signature' do
+    module Foo
+      inline %{
+        void* func_1 (void* ptr, unsigned int i, unsigned long l, char *c) {
+            return ptr;
+        }
+      }
+    end
+
+    ptr = FFI::MemoryPointer.new(:int)
+    Foo.func_1(ptr, 0xff, 0xffff, FFI::MemoryPointer.from_string('c')).should == ptr
+  end
+
+  it 'should load cached libraries' do
+    File.should_receive(:open).once
+
+    module Foo
+      inline "void* cached_func() {}"
+    end
+
+    module Foo
+      inline "void* cached_func() {}"
+    end
+  end
+
+  it 'should recompile if the code is updated' do
+    module Foo
+      inline "int updated_func() { return 1 + 1; }"
+    end
+
+    Foo.updated_func.should == 2
+
+    module Foo
+      inline "int updated_func() { return 2 + 2; }"
+    end
+
+    Foo.updated_func.should == 4
+  end
+
+  it 'should recompile if the code is changed after a failure' do
+    # unfortunately this doesn't check the real functionality, which is that if a dll is deleted, it isn't re-produced
+    begin
+      module Foo
+        inline "int updated_func2() { asdf }"
+      end
+    rescue
+      begin
+        Foo.updated_func2
+        raise 'should have failed'
+      rescue NoMethodError
+      end
+    end
+
+    module Foo
+      inline "int updated_func2() { return 2 + 2; }"
+    end
+
+    Foo.updated_func2.should == 4
+  end
+
+  it 'should be configured using the block form' do
+    module Foo
+      inline do |builder|
+        builder.function %{
+          int func_1 () {
+            return 0;
+          }
+        }
+
+        builder.function %{
+          int func_2 () {
+            return 1;
+          }
+        }
+      end
+    end
+
+    Foo.func_1.should == 0
+    Foo.func_2.should == 1
+  end
+
+  it 'should allow users to add type maps' do
+    class MyStruct < FFI::Struct
+      layout :dummy, :int
+    end
+    module Foo
+      inline do |builder|
+        builder.map 'my_struct_t *' => 'pointer'
+
+        builder.raw %q{
+          typedef struct {
+            int dummy;
+          } my_struct_t;
+        }
+
+        builder.function 'my_struct_t* use_my_struct (my_struct_t* my_struct) { return my_struct; }'
+      end
+    end
+    my_struct = MyStruct.new
+    Foo.use_my_struct(my_struct).should == my_struct.to_ptr
+  end
+
+  it 'should allow users to include header files' do
+    module Foo
+      inline do |builder|
+        builder.include "stdio.h"
+        builder.include "local_header.h", :quoted => true
+        builder.code.should == "#include <stdio.h>\n#include \"local_header.h\"\n"
+        builder.stub!(:build)
+      end
+    end
+  end
+
+  it 'should allow users to add external libraries' do
+    module Foo
+      inline do |builder|
+        builder.libraries 'foolib1', 'foolib2'
+        builder.stub!(:build)
+        builder.stub!(:symbols) { [] }
+        builder.libraries.should == ['foolib1', 'foolib2']
+      end
+
+      inline "int func() { return 0; }", :libraries => ['foolib1', 'foolib2'] do |builder|
+        builder.stub!(:build)
+        builder.stub!(:symbols) { [] }
+        builder.libraries.should == ['foolib1', 'foolib2']
+      end
+    end
+  end
+
+  if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+    it "should put library links at the end in mingw" do
+      module Foo
+
+        code = <<-CODE
+        #include <windows.h>
+            #include <mmsystem.h>
+            int go() {
+              mixerOpen(0, 0,0,0,0);
+              return 3;
+            }
+        CODE
+
+        inline do |builder|
+          builder.library 'Winmm'
+          builder.raw code
+        end
+
+        inline do |builder|
+          builder.use_compiler :gxx
+          builder.library 'Winmm'
+          builder.raw code
+        end
+      end
+    end
+  end
+
+  it 'should generate C struct from FFI::Struct' do
+    pending do
+      class MyStruct < FFI::Struct
+        layout :a, :int, \
+        :b, :char,
+        :c, :pointer
+      end
+      module Foo
+        extend FFI::Inliner
+        inline do |builder|
+          builder.struct MyStruct
+          builder.code.should == <<EOC
+typedef struct
+{
+int a;
+char b;
+void* c;
+} my_struct_t;
+
+EOC
+        end
+      end
+    end
+  end
+
+  it 'should return the current compiler' do
+    module Foo
+      inline do |builder|
+        builder.compiler.should == FFI::Inliner::Compiler[:gcc]
+      end
+    end
+  end
+
+  it 'should raise errors' do
+    proc {
+      module Foo
+        inline "int boom("
+      end
+    }.should raise_error(/cannot parse/)
+
+    proc {
+      module Foo
+        inline 'int boom() { printf "Hello" }'
+      end
+    }.should raise_error(/compile error/)
+  end
+
+  describe 'GXX compiler' do
+    it 'should compile and link a shim C library that encapsulates C++ code' do
+      module Foo
+        inline :cpp do |builder|
+          builder.raw %{
+            #include <iostream>
+            #include <string>
+
+            using namespace std;
+
+            class Greeter
+            {
+              public:
+                Greeter();
+                string say_hello();
+            };
+
+            Greeter::Greeter () { };
+            string Greeter::say_hello ()
+            {
+                return "Hello foos!";
+            };
+          }
+
+          builder.function %{
+            const char* say_hello () {
+              Greeter greeter;
+
+              return greeter.say_hello().c_str();
+            }
+          }, return: :string
+        end
+      end
+
+      Foo.say_hello.should == 'Hello foos!'
+    end
+  end
+end
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: ffi-inline
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- meh.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: &10074040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *10074040
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &10073120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *10073120
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &10072380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *10072380
+description: 
+email: meh@paranoici.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- examples/ex_1.rb
+- ffi-inline.gemspec
+- lib/ffi/inliner.rb
+- lib/ffi/inliner/builders.rb
+- lib/ffi/inliner/builders/c.rb
+- lib/ffi/inliner/builders/cpp.rb
+- lib/ffi/inliner/compilers.rb
+- lib/ffi/inliner/compilers/gcc.rb
+- lib/ffi/inliner/compilers/gxx.rb
+- lib/ffi/inliner/compilers/tcc.rb
+- lib/ffi/inliner/error.rb
+- lib/ffi/inliner/inliner.rb
+- lib/ffi/inliner/version.rb
+- spec/inliner_spec.rb
+homepage: http://github.com/meh/ruby-ffi-inline
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Inline C/C++ in Ruby easily and cleanly.
+test_files:
+- spec/inliner_spec.rb