ruby-czmq-ffi 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c69869de8e6a9780530d4dee8db00fc8a704776f
+  data.tar.gz: 57330fa845967aea66a44db4c015cbf17d46af68
+SHA512:
+  metadata.gz: 94aab407c9d6a5bb4501ad8ee1c4624b62adf666afa5d85f4fdd8a8ae88fe6d953093a598bceaca7d0bfa07e9e36f6b44099551619a179f07b3853607272cb93
+  data.tar.gz: b97258a1ebd37c92e3ab24fe2fae0563981a9f52990ab158775d768f120ebfccc76360a315b876c513713619cabef6abfdae57f90e848b6a995b6b48e5ceb274

data/.gitignore

@@ -0,0 +1,22 @@
+*~
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.ruby-gemset
+coverage
+Gemfile.lock
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mauro Tortonesi
+
+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,38 @@
+# ruby-czmq-ffi
+
+ruby-czmq-ffi provides low-level Ruby bindings for the
+[CZMQ](http://czmq.zeromq.org/) library. ruby-czmq-ffi leverages the FFI
+mechanism, and thus should work on all the main Ruby VMs: YARV/MRI, JRuby, and
+Rubinius.
+
+The ruby-czmq-ffi library was not designed to be used directly by applications,
+but instead to provide functions for higher-level gems such as
+[ruby-czmq](https://github.com/mtortonesi/ruby-czmq).
+
+
+## Installation
+
+### Stable version
+
+You can get the stable version of ruby-czmq-ffi by installing the czmq-ffi gem from
+RubyGems:
+
+    gem install czmq-ffi
+
+### Development version
+
+If you want to try the development version of ruby-czmq-ffi, instead, just place
+this line:
+
+```ruby
+gem ruby-czmq-ffi, git: 'https://github.com/mtortonesi/ruby-czmq-ffi.git'
+```
+
+in your Gemfile and run:
+
+    bundle install
+
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = Dir.glob('test/**/*_test.rb').sort
+  t.verbose = true
+end

data/czmq-ffi.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'czmq-ffi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby-czmq-ffi'
+  spec.version       = LibCZMQ::VERSION
+  spec.authors       = ['Mauro Tortonesi']
+  spec.email         = ['mauro.tortonesi@unife.it']
+  spec.description   = %q{FFI-based Ruby bindings for the CZMQ library}
+  spec.summary       = %q{This gem provides low-level bindings for the CZMQ library, using FFI. 
+    It is not meant to be used directly by applications, but instead to provide
+    functions for higher-level gems such as ruby-czmq.}
+  spec.homepage      = 'https://github.com/mtortonesi/ruby-czmq-ffi'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end

data/lib/czmq-ffi.rb

@@ -0,0 +1,6 @@
+require 'ffi'
+
+require 'czmq-ffi/constants'
+require 'czmq-ffi/libczmq'
+require 'czmq-ffi/structures'
+require 'czmq-ffi/version'

data/lib/czmq-ffi/constants.rb

@@ -0,0 +1,40 @@
+module CZMQ
+  #  Socket types
+  PAIR   = 0
+  PUB    = 1
+  SUB    = 2
+  REQ    = 3
+  REP    = 4
+  XREQ   = 5
+  XREP   = 6
+  PULL   = 7
+  PUSH   = 8
+  XPUB   = 9
+  XSUB   = 10
+  DEALER = XREQ
+  ROUTER = XREP
+  STREAM = 11
+
+  SocketTypeToNameMap = {
+    PAIR   => 'PAIR',
+    PUB    => 'PUB',
+    SUB    => 'SUB',
+    REQ    => 'REQ',
+    REP    => 'REP',
+    PULL   => 'PULL',
+    PUSH   => 'PUSH',
+    XREQ   => 'XREQ',
+    XREP   => 'XREP',
+    ROUTER => 'ROUTER',
+    DEALER => 'DEALER',
+    XPUB   => 'XPUB',
+    XSUB   => 'XSUB',
+    STREAM => 'STREAM',
+  }
+
+  # I/O multiplexing
+  POLL    = 1
+  POLLIN  = 1
+  POLLOUT = 2
+  POLLERR = 4
+end

data/lib/czmq-ffi/libc.rb

@@ -0,0 +1,9 @@
+require 'ffi'
+
+module LibC
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  
+  attach_function :malloc, [:size_t], :pointer
+  attach_function :free, [:pointer], :void
+end

data/lib/czmq-ffi/libczmq.rb

@@ -0,0 +1,305 @@
+require 'czmq-ffi/utils'
+
+module LibCZMQ
+  extend FFI::Library
+
+  begin
+    # This looks like a sensible search path
+    LIB_PATH = %w{/usr/lib /usr/lib64 /usr/local/lib /usr/lib32}
+    CZMQ_LIB_PATH = LIB_PATH.map{ |path| "#{path}/libczmq.#{FFI::Platform::LIBSUFFIX}" }
+    ffi_lib(CZMQ_LIB_PATH + %w{libzmq})
+  rescue LoadError
+    warn 'Could not load the CZMQ Library.'
+    raise
+  end
+
+  ##################################################
+  # zctx-related functions
+  ##################################################
+  attach_function :zctx_new, [], :pointer
+  attach_function :__zctx_destroy, :zctx_destroy, [:pointer], :void
+  attach_function :zctx_set_iothreads, [:pointer, :int], :void
+  attach_function :zctx_set_linger, [:pointer, :int], :void
+  attach_function :zctx_set_pipehwm, [:pointer, :int], :void
+  attach_function :zctx_set_sndhwm, [:pointer, :int], :void
+  attach_function :zctx_set_rcvhwm, [:pointer, :int], :void
+  attach_function :zctx_underlying, [:pointer], :pointer
+
+  def self.zctx_destroy(zctx)
+    zctx_ptr = FFI::MemoryPointer.new(:pointer)
+    zctx_ptr.write_pointer(zctx)
+    __zctx_destroy(zctx_ptr)
+  end
+
+
+  ##################################################
+  # zbeacon-related functions
+  ##################################################
+  attach_function :zbeacon_new, [:int], :pointer # zbeacon_new returns NULL in case of failure
+  attach_function :__zbeacon_destroy, :zbeacon_destroy, [:pointer], :void
+  attach_function :zbeacon_hostname, [:pointer], :pointer
+  attach_function :zbeacon_set_interval, [:pointer, :int], :void
+  attach_function :zbeacon_noecho, [:pointer], :void
+  attach_function :__zbeacon_publish, :zbeacon_publish, [:pointer, :pointer, :size_t], :void
+  attach_function :zbeacon_silence, [:pointer], :void
+  attach_function :__zbeacon_subscribe, :zbeacon_subscribe, [:pointer, :pointer, :size_t], :void
+  attach_function :zbeacon_unsubscribe, [:pointer], :void
+  attach_function :zbeacon_socket, [:pointer], :pointer
+
+  def self.zbeacon_destroy(zbeacon)
+    zbeacon_ptr = FFI::MemoryPointer.new(:pointer)
+    zbeacon_ptr.write_pointer(zbeacon)
+    __zbeacon_destroy(zbeacon_ptr)
+  end
+
+  def self.zbeacon_publish(zbeacon, byte_array)
+    FFI::MemoryPointer.new(:uint8, byte_array.size) do |p|
+      p.write_array_of_int8(byte_array)
+      __zbeacon_publish(zbeacon, p, byte_array.size)
+    end
+  end
+
+  def self.zbeacon_subscribe(zbeacon, byte_array=nil)
+    if byte_array.nil?
+      __zbeacon_subscribe(zbeacon, nil, 0)
+    else
+      FFI::MemoryPointer.new(:uint8, byte_array.size) do |p|
+        p.write_array_of_int8(byte_array)
+        __zbeacon_subscribe(zbeacon, p, byte_array.size)
+      end
+    end
+  end
+
+
+
+  ##################################################
+  # zsocket-related functions
+  ##################################################
+  attach_function :zsocket_new, [:pointer, :int], :pointer
+  attach_function :zsocket_destroy, [:pointer, :pointer], :void
+  attach_function :zsocket_bind, [:pointer, :string, :varargs], :int
+  attach_function :zsocket_unbind, [:pointer, :string, :varargs], :void
+  attach_function :zsocket_connect, [:pointer, :string, :varargs], :void
+  attach_function :zsocket_disconnect, [:pointer, :string, :varargs], :void
+  attach_function :zsocket_poll, [:pointer, :int], :bool
+  attach_function :__zsocket_type_str, :zsocket_type_str, [:pointer], :pointer
+  attach_function :zsocket_sendmem, [:pointer, :pointer, :size_t, :int], :int
+
+  # return nil or (a copy of) the zsocket type name
+  def self.zsocket_type_str(zsocket)
+    type_ptr = __zsocket_type_str(zsocket)
+    type_ptr.null? ? nil : type_ptr.read_string
+  end
+
+
+  ##################################################
+  # zstr-related functions
+  ##################################################
+  attach_function :__zstr_recv, :zstr_recv, [:pointer], :pointer
+  attach_function :__zstr_recv_nowait, :zstr_recv_nowait, [:pointer], :pointer
+  attach_function :zstr_send, [:pointer, :string, :varargs], :int
+  attach_function :zstr_sendm, [:pointer, :string, :varargs], :int
+  attach_function :zstr_sendx, [:pointer, :string, :varargs], :int
+  # attach_function :__zstr_recvx, :zstr_recvx, [:pointer, :pointer, :varargs], :int
+
+  def self.zstr_recv(zsocket)
+    Utils.extract_string(__zstr_recv(zsocket))
+  end
+
+  def self.zstr_recv_nowait(zsocket)
+    Utils.extract_string(__zstr_recv_nowait(zsocket))
+  end
+
+
+  ##################################################
+  # zmsg-related functions
+  ##################################################
+  attach_function :zmsg_new, [], :pointer
+  attach_function :__zmsg_destroy, :zmsg_destroy, [:pointer], :void
+  attach_function :zmsg_recv, [:pointer], :pointer
+  attach_function :__zmsg_send, :zmsg_send, [:pointer, :pointer], :int
+  attach_function :zmsg_size, [:pointer], :size_t
+  attach_function :zmsg_content_size, [:pointer], :size_t
+
+  # zframe add / remove
+  # NOTE: zmsg_push will take ownership of zframe and destroy it at the end
+  attach_function :zmsg_push, [:pointer, :pointer], :int
+  attach_function :zmsg_pop, [:pointer], :pointer
+  # NOTE: zmsg_append will take ownership of zframe and destroy it at the end
+  attach_function :__zmsg_append, :zmsg_append, [:pointer, :pointer], :int
+
+  # memory buffer add / remove
+  attach_function :__zmsg_pushmem, :zmsg_pushmem, [:pointer, :buffer_in, :size_t], :int
+  attach_function :__zmsg_addmem, :zmsg_addmem, [:pointer, :buffer_in, :size_t], :int
+
+  # string add / remove
+  attach_function :zmsg_pushstr, [:pointer, :string, :varargs], :int
+  attach_function :zmsg_addstr, [:pointer, :string, :varargs], :int
+  attach_function :__zmsg_popstr, :zmsg_popstr, [:pointer], :pointer
+
+  # NOTE: zmsg_wrap will take ownership of zframe and destroy it at the end
+  attach_function :zmsg_wrap, [:pointer, :pointer], :void
+  attach_function :zmsg_unwrap, [:pointer], :pointer
+  # NOTE: zmsg_remove will simply remove the zframe without destroying it
+  attach_function :zmsg_remove, [:pointer, :pointer], :void
+  attach_function :zmsg_first, [:pointer], :pointer
+  attach_function :zmsg_next, [:pointer], :pointer
+  attach_function :zmsg_last, [:pointer], :pointer
+
+  # TODO: implement zmsg_encode and zmsg_decode?
+
+  attach_function :zmsg_dup, [:pointer], :pointer
+  attach_function :zmsg_dump, [:pointer], :void
+
+  # These are very low-level functions. Still unsure whether czmq-ffi should provide them.
+  # attach_function :zmsg_save, [:pointer, :pointer], :int
+  # attach_function :zmsg_load, [:pointer, :pointer], :pointer
+  # attach_function :zmsg_dump_to_stream, [:pointer, :pointer], :void
+
+  # NOTE: zmsg_add is deprecated. No point in supporting it.
+  # attach_function :zmsg_add, [:pointer, :pointer], :int
+
+  def self.zmsg_destroy(zmsg)
+    zmsg_ptr = FFI::MemoryPointer.new(:pointer)
+    zmsg_ptr.write_pointer(zmsg)
+    __zmsg_destroy(zmsg_ptr)
+  end
+
+  def self.zmsg_send(zmsg, zsocket)
+    zmsg_ptr = FFI::MemoryPointer.new(:pointer)
+    zmsg_ptr.write_pointer(zmsg)
+    __zmsg_send(zmsg_ptr, zsocket)
+  end
+
+  # zmsg will take ownership of zframe and destroy it at the end
+  def self.zmsg_append(zmsg, zframe)
+    zframe_ptr = FFI::MemoryPointer.new(:pointer)
+    zframe_ptr.write_pointer(zframe)
+    __zmsg_append(zmsg, zframe_ptr)
+  end
+
+  def self.zmsg_pushmem(zmsg, byte_array)
+    rc = nil
+    FFI::MemoryPointer.new(:uint8, byte_array.size) do |p|
+      p.write_array_of_int8(byte_array)
+      rc = __zmsg_pushmem(zmsg, p, byte_array.size)
+    end
+    rc
+  end
+
+  def self.zmsg_addmem(zmsg, byte_array)
+    rc = nil
+    FFI::MemoryPointer.new(:uint8, byte_array.size) do |p|
+      p.write_array_of_int8(byte_array)
+      rc = __zmsg_addmem(zmsg, p, byte_array.size)
+    end
+    rc
+  end
+
+  def self.zmsg_popstr(zmsg)
+    Utils.extract_string(__zmsg_popstr(zmsg))
+  end
+
+
+  ##################################################
+  # zframe-related functions
+  ##################################################
+  attach_function :__zframe_new, :zframe_new, [:buffer_in, :size_t], :pointer
+  attach_function :__zframe_new_empty, :zframe_new_empty, [], :pointer
+  attach_function :__zframe_destroy, :zframe_destroy, [:pointer], :void
+  attach_function :zframe_recv, [:pointer], :pointer
+  attach_function :zframe_recv_nowait, [:pointer], :pointer
+  attach_function :__zframe_send, :zframe_send, [:pointer, :pointer, :int], :int
+  attach_function :zframe_size, [:pointer], :size_t
+  attach_function :zframe_dup, [:pointer], :pointer
+  attach_function :__zframe_strhex, :zframe_strhex, [:pointer], :pointer
+  attach_function :__zframe_strdup, :zframe_strdup, [:pointer], :pointer
+  attach_function :zframe_streq, [:pointer, :string], :bool
+  attach_function :zframe_more, [:pointer], :int
+  attach_function :zframe_set_more, [:pointer, :int], :void
+  attach_function :zframe_eq, [:pointer, :pointer], :bool
+  attach_function :zframe_reset, [:pointer, :buffer_in, :size_t], :void
+
+  # These are very low-level functions. Still unsure whether czmq-ffi should provide them.
+  # attach_function :zframe_data, [:pointer], :pointer
+  # attach_function :zframe_fprint, [:pointer, :string, :pointer], :void
+  # attach_function :zframe_print, [:pointer, :string], :void
+
+  def self.zframe_new(byte_array=nil)
+    if byte_array.nil?
+      __zframe_new_empty
+    else
+      zframe = nil
+      FFI::MemoryPointer.new(:uint8, byte_array.size) do |p|
+        p.write_array_of_int8(byte_array)
+        zframe = __zframe_new(p, byte_array.size)
+      end
+      zframe
+    end
+  end
+
+  def self.zframe_destroy(zframe)
+    zframe_ptr = FFI::MemoryPointer.new(:pointer)
+    zframe_ptr.write_pointer(zframe)
+    __zframe_destroy(zframe_ptr)
+  end
+
+  def self.zframe_send(zframe, zsocket, flags)
+    zframe_ptr = FFI::MemoryPointer.new(:pointer)
+    zframe_ptr.write_pointer(zframe)
+    __zframe_send(zframe_ptr, zsocket, flags)
+  end
+
+  def self.zframe_strhex(zframe)
+    Utils.extract_string(__zframe_strhex(zframe))
+  end
+
+  def self.zframe_strdup(zframe)
+    Utils.extract_string(__zframe_strdup(zframe))
+  end
+
+
+  ##################################################
+  # zpoller-related functions
+  ##################################################
+  attach_function :zpoller_new, [:pointer, :varargs], :pointer
+  attach_function :__zpoller_destroy, :zpoller_destroy, [:pointer], :void
+  attach_function :zpoller_wait, [:pointer, :int], :pointer
+  attach_function :zpoller_expired, [:pointer], :bool
+  attach_function :zpoller_terminated, [:pointer], :bool
+
+  def self.zpoller_destroy(zpoller)
+    zpoller_ptr = FFI::MemoryPointer.new(:pointer)
+    zpoller_ptr.write_pointer(zpoller)
+    __zpoller_destroy(zpoller_ptr)
+  end
+
+
+  ##################################################
+  # zloop-related functions
+  ##################################################
+  attach_function :zloop_new, [], :pointer
+  attach_function :__zloop_destroy, :zloop_destroy, [:pointer], :void
+  callback :zloop_callback, [:pointer, :pointer, :pointer], :int
+  attach_function :zloop_poller, [:pointer, :pointer, :zloop_callback, :pointer], :int
+  attach_function :zloop_poller_end, [:pointer, :pointer], :void
+  attach_function :zloop_set_tolerant, [:pointer, :pointer], :void
+  callback :zloop_timer_callback, [:pointer, :int, :pointer], :int
+  attach_function :zloop_timer, [:pointer, :size_t, :size_t, :zloop_timer_callback, :pointer], :int
+  attach_function :zloop_timer_end, [:pointer, :pointer], :int
+  attach_function :zloop_set_verbose, [:pointer, :bool], :void
+  attach_function :zloop_start, [:pointer], :int
+
+  def self.zloop_destroy(zloop)
+    zloop_ptr = FFI::MemoryPointer.new(:pointer)
+    zloop_ptr.write_pointer(zloop)
+    __zloop_destroy(zloop_ptr)
+  end
+
+  def self.create_zloop_callback(func)
+    FFI::Function.new(:int, [:pointer, :pointer, :pointer]) do |zloopbuf, zpollitembuf, arg|
+      func.call(zloopbuf, zpollitembuf, arg)
+    end
+  end
+
+end

data/lib/czmq-ffi/structures.rb

@@ -0,0 +1,41 @@
+require 'ffi'
+require 'czmq-ffi/constants'
+
+module LibCZMQ
+
+  class ZPollItem < FFI::Struct
+    FD_TYPE = if FFI::Platform::IS_WINDOWS && FFI::Platform::ADDRESS_SIZE == 64
+      # On Windows, zmq.h defines fd as a SOCKET, which is 64 bits on x64.
+      :uint64
+    else
+      :int
+    end
+
+    layout  :socket,  :pointer,
+            :fd,      FD_TYPE,
+            :events,  :short,
+            :revents, :short
+
+    def readable?
+      (self[:revents] & CZMQ::POLLIN) > 0
+    end
+
+    def writable?
+      (self[:revents] & CZMQ::POLLOUT) > 0
+    end
+
+    def inspect
+      "socket [#{self[:socket]}], fd [#{self[:fd]}], events [#{self[:events]}], revents [#{self[:revents]}]"
+    end
+  end
+
+  def self.create_pollitem(args={})
+    pi = ZPollItem.new
+    pi[:socket]  = args[:socket]
+    pi[:fd]      = args[:fd] || 0
+    pi[:events]  = args[:events] || 0
+    pi[:revents] = args[:revents] || 0
+    pi
+  end
+
+end

data/lib/czmq-ffi/utils.rb

@@ -0,0 +1,18 @@
+require 'czmq-ffi/libc'
+
+module Utils
+  def self.extract_string(ffi_str_pointer)
+    # Make sure we don't try to extract a string from a NULL pointer.
+    return nil if ffi_str_pointer.null? # || ffi_str_pointer.nil?
+
+    # Read the string pointed by ffi_str_pointer.
+    str = ffi_str_pointer.read_string
+
+    # The read_string method (actually, the str_new C function nested
+    # inside it) makes a deep copy, so we can safely free ffi_str_pointer.
+    LibC.free(ffi_str_pointer)
+
+    # Return the string we extracted from ffi_str_pointer.
+    str
+  end
+end

data/lib/czmq-ffi/version.rb

@@ -0,0 +1,3 @@
+module LibCZMQ
+  VERSION = '0.0.2'
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+
+require 'czmq-ffi'

data/test/zframe_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+describe LibCZMQ do
+
+  describe 'zframe' do
+
+    it 'should be able to create empty zframes' do
+      zframe = LibCZMQ.zframe_new
+      LibCZMQ.zframe_size(zframe).must_equal 0
+    end
+
+    it 'should be able to create zframes from an (int) array' do
+      zframe = LibCZMQ.zframe_new([ 1, 2, 3, 4, 5, 6 ])
+      LibCZMQ.zframe_size(zframe).must_equal 6
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: ruby-czmq-ffi
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Mauro Tortonesi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: FFI-based Ruby bindings for the CZMQ library
+email:
+- mauro.tortonesi@unife.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- czmq-ffi.gemspec
+- lib/czmq-ffi.rb
+- lib/czmq-ffi/constants.rb
+- lib/czmq-ffi/libc.rb
+- lib/czmq-ffi/libczmq.rb
+- lib/czmq-ffi/structures.rb
+- lib/czmq-ffi/utils.rb
+- lib/czmq-ffi/version.rb
+- test/test_helper.rb
+- test/zframe_test.rb
+homepage: https://github.com/mtortonesi/ruby-czmq-ffi
+licenses:
+- MIT
+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.2.1
+signing_key:
+specification_version: 4
+summary: This gem provides low-level bindings for the CZMQ library, using FFI.  It is not meant to be used directly by applications, but instead to provide functions for higher-level gems such as ruby-czmq.
+test_files:
+- test/test_helper.rb
+- test/zframe_test.rb