fiddle 1.0.0.beta2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1c95f026d86d58a824f9925f5a57d8cebbf00e0a
-  data.tar.gz: ec3332b0ef7aadc1e47bf5d563e61232410395f6
+SHA256:
+  metadata.gz: b7e244560b492c43b7458506409f4d624372766d882e306a48a08fc9ad32671b
+  data.tar.gz: 9a166eb1dded473780e8ea89d1240da28ff6be73e72f2026eff14f6e55f060b9
 SHA512:
-  metadata.gz: 7173bf1fa4282f82118ce7dbe0064b170dc0c21ba6d99fbb7e52e356a6ad9710ba2c47e2225e56a2b9052358a8a7763228f302fc3ffbff97555fc2eca9fe6115
-  data.tar.gz: a271e17bc2a5626e05fff933991829d377333325269a3d4daec33fc70bb524d1d2c1ab36bf749b0e27e17aec5949313ec51aab7dc9c16215fed753d988415f58
+  metadata.gz: 7c4509d95af60a2f16047e431580a3e6b1828b0bcf0820302d678c1b2f8e9462df767ce5a6c7e60ef728fa0d7a3afe667cbbe982e161802dafc49ed0a398bf2a
+  data.tar.gz: 00623b0e514fad355b76ec9d59273c15759d5991c2832c6df10c23ad06ef98f628d5d6381cfd75449ee0c2811b3f58d66b55824993c5d3aef1a2d2be1d79a8de

data/README.md

@@ -1,8 +1,12 @@
 # Fiddle
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/fiddle`. To experiment with that code, run `bin/console` for an interactive prompt.
+[![Build Status](https://travis-ci.org/ruby/fiddle.svg?branch=master)](https://travis-ci.org/ruby/fiddle)
 
-TODO: Delete this and the text above, and describe your gem
+A libffi wrapper for Ruby.
+
+Fiddle is an extension to translate a foreign function interface (FFI) with ruby.
+
+It wraps [libffi](http://sourceware.org/libffi/), a popular C library which provides a portable interface that allows code written in one language to call code written in another language.
 
 ## Installation
 
@@ -22,7 +26,72 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+ Here we will use Fiddle::Function to wrap [floor(3) from libm](http://linux.die.net/man/3/floor)
+
+```ruby
+require 'fiddle'
+
+libm = Fiddle.dlopen('/lib/libm.so.6')
+
+floor = Fiddle::Function.new(
+          libm['floor'],
+          [Fiddle::TYPE_DOUBLE],
+          Fiddle::TYPE_DOUBLE
+        )
+
+puts floor.call(3.14159) #=> 3.0
+```
+
+### Nested Structs
+
+You can use hashes to create nested structs, where the hash keys are member names and the values are the nested structs:
+
+```ruby
+StudentCollegeDetail = struct [
+  'int college_id',
+  'char college_name[50]'
+]
+
+StudentDetail = struct [
+  'int id',
+  'char name[20]',
+  { clg_data: StudentCollegeDetail }
+]
+```
+
+You can also specify an anonymous nested struct, like so:
+
+```ruby
+StudentDetail = struct [
+  'int id',
+  'char name[20]',
+  {
+    clg_data: struct([
+                      'int college_id',
+                      'char college_name[50]'
+                    ])
+  }
+]
+```
+
+The position of a hash (and the order of the keys in the hash, in the case of a hash with multiple entries), dictate the offsets of the nested struct in memory. The following examples are both syntactically valid but will lay out the structs differently in memory:
+
+```ruby
+# order of members in memory: position, id, dimensions
+Rect = struct [ { position: struct(['float x', 'float y']) },
+                'int id',
+                { dimensions: struct(['float w', 'float h']) }
+              ]
+
+# order of members in memory: id, position, dimensions
+Rect = struct [ 'int id',
+                {
+                  position: struct(['float x', 'float y']),
+                  dimensions: struct(['float w', 'float h'])
+                }
+              ]
+```
+
 
 ## Development
 

data/Rakefile

@@ -1,13 +1,12 @@
 require "bundler/gem_tasks"
-require "rake/testtask"
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test" << "test/lib"
-  t.libs << "lib"
-  t.test_files = FileList['test/**/test_*.rb']
+desc "Run test"
+task :test do
+  ruby("test/run.rb")
 end
 
 require 'rake/extensiontask'
 Rake::ExtensionTask.new("fiddle")
+Rake::ExtensionTask.new("-test-/memory_view")
 
 task :default => [:compile, :test]

data/bin/downloader.rb

@@ -0,0 +1,331 @@
+# Used by configure and make to download or update mirrored Ruby and GCC
+# files. This will use HTTPS if possible, falling back to HTTP.
+
+require 'fileutils'
+require 'open-uri'
+require 'pathname'
+begin
+  require 'net/https'
+rescue LoadError
+  https = 'http'
+else
+  https = 'https'
+
+  # open-uri of ruby 2.2.0 accept an array of PEMs as ssl_ca_cert, but old
+  # versions are not.  so, patching OpenSSL::X509::Store#add_file instead.
+  class OpenSSL::X509::Store
+    alias orig_add_file add_file
+    def add_file(pems)
+      Array(pems).each do |pem|
+        if File.directory?(pem)
+          add_path pem
+        else
+          orig_add_file pem
+        end
+      end
+    end
+  end
+  # since open-uri internally checks ssl_ca_cert using File.directory?,
+  # allow to accept an array.
+  class <<File
+    alias orig_directory? directory?
+    def File.directory? files
+      files.is_a?(Array) ? false : orig_directory?(files)
+    end
+  end
+end
+
+class Downloader
+  def self.https=(https)
+    @@https = https
+  end
+
+  def self.https?
+    @@https == 'https'
+  end
+
+  def self.https
+    @@https
+  end
+
+  class GNU < self
+    def self.download(name, *rest)
+      if https?
+        super("https://raw.githubusercontent.com/gcc-mirror/gcc/master/#{name}", name, *rest)
+      else
+        super("https://repo.or.cz/official-gcc.git/blob_plain/HEAD:/#{name}", name, *rest)
+      end
+    end
+  end
+
+  class RubyGems < self
+    def self.download(name, dir = nil, since = true, options = {})
+      require 'rubygems'
+      options = options.dup
+      options[:ssl_ca_cert] = Dir.glob(File.expand_path("../lib/rubygems/ssl_certs/**/*.pem", File.dirname(__FILE__)))
+      super("https://rubygems.org/downloads/#{name}", name, dir, since, options)
+    end
+  end
+
+  Gems = RubyGems
+
+  class Unicode < self
+    def self.download(name, *rest)
+      super("http://www.unicode.org/Public/#{name}", name, *rest)
+    end
+  end
+
+  def self.mode_for(data)
+    /\A#!/ =~ data ? 0755 : 0644
+  end
+
+  def self.http_options(file, since)
+    options = {}
+    if since
+      case since
+      when true
+        since = (File.mtime(file).httpdate rescue nil)
+      when Time
+        since = since.httpdate
+      end
+      if since
+        options['If-Modified-Since'] = since
+      end
+    end
+    options['Accept-Encoding'] = '*' # to disable Net::HTTP::GenericRequest#decode_content
+    options
+  end
+
+  # Downloader.download(url, name, [dir, [since]])
+  #
+  # Update a file from url if newer version is available.
+  # Creates the file if the file doesn't yet exist; however, the
+  # directory where the file is being created has to exist already.
+  # The +since+ parameter can take the following values, with associated meanings:
+  #  true ::
+  #    Take the last-modified time of the current file on disk, and only download
+  #    if the server has a file that was modified later. Download unconditionally
+  #    if we don't have the file yet. Default.
+  #  +some time value+ ::
+  #    Use this time value instead of the time of modification of the file on disk.
+  #  nil ::
+  #    Only download the file if it doesn't exist yet.
+  #  false ::
+  #    always download url regardless of whether we already have a file,
+  #    and regardless of modification times. (This is essentially just a waste of
+  #    network resources, except in the case that the file we have is somehow damaged.
+  #    Please note that using this recurringly might create or be seen as a
+  #    denial of service attack.)
+  #
+  # Example usage:
+  #   download 'http://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt',
+  #            'UnicodeData.txt', 'enc/unicode/data'
+  def self.download(url, name, dir = nil, since = true, options = {})
+    options = options.dup
+    url = URI(url)
+    dryrun = options.delete(:dryrun)
+    if name
+      file = Pathname.new(under(dir, name))
+    else
+      name = File.basename(url.path)
+    end
+    cache_save = options.delete(:cache_save) {
+      ENV["CACHE_SAVE"] != "no"
+    }
+    cache = cache_file(url, name, options.delete(:cache_dir))
+    file ||= cache
+    if since.nil? and file.exist?
+      if $VERBOSE
+        $stdout.puts "#{file} already exists"
+        $stdout.flush
+      end
+      if cache_save
+        save_cache(cache, file, name)
+      end
+      return file.to_path
+    end
+    if dryrun
+      puts "Download #{url} into #{file}"
+      return
+    end
+    if link_cache(cache, file, name, $VERBOSE)
+      return file.to_path
+    end
+    if !https? and URI::HTTPS === url
+      warn "*** using http instead of https ***"
+      url.scheme = 'http'
+      url = URI(url.to_s)
+    end
+    if $VERBOSE
+      $stdout.print "downloading #{name} ... "
+      $stdout.flush
+    end
+    begin
+      data = url.read(options.merge(http_options(file, since.nil? ? true : since)))
+    rescue OpenURI::HTTPError => http_error
+      if http_error.message =~ /^304 / # 304 Not Modified
+        if $VERBOSE
+          $stdout.puts "#{name} not modified"
+          $stdout.flush
+        end
+        return file.to_path
+      end
+      raise
+    rescue Timeout::Error
+      if since.nil? and file.exist?
+        puts "Request for #{url} timed out, using old version."
+        return file.to_path
+      end
+      raise
+    rescue SocketError
+      if since.nil? and file.exist?
+        puts "No network connection, unable to download #{url}, using old version."
+        return file.to_path
+      end
+      raise
+    end
+    mtime = nil
+    dest = (cache_save && cache && !cache.exist? ? cache : file)
+    dest.parent.mkpath
+    dest.open("wb", 0600) do |f|
+      f.write(data)
+      f.chmod(mode_for(data))
+      mtime = data.meta["last-modified"]
+    end
+    if mtime
+      mtime = Time.httpdate(mtime)
+      dest.utime(mtime, mtime)
+    end
+    if $VERBOSE
+      $stdout.puts "done"
+      $stdout.flush
+    end
+    if dest.eql?(cache)
+      link_cache(cache, file, name)
+    elsif cache_save
+      save_cache(cache, file, name)
+    end
+    return file.to_path
+  rescue => e
+    raise "failed to download #{name}\n#{e.message}: #{url}"
+  end
+
+  def self.under(dir, name)
+    dir ? File.join(dir, File.basename(name)) : name
+  end
+
+  def self.cache_file(url, name, cache_dir = nil)
+    case cache_dir
+    when false
+      return nil
+    when nil
+      cache_dir = ENV['CACHE_DIR']
+      if !cache_dir or cache_dir.empty?
+        cache_dir = ".downloaded-cache"
+      end
+    end
+    Pathname.new(cache_dir) + (name || File.basename(URI(url).path))
+  end
+
+  def self.link_cache(cache, file, name, verbose = false)
+    return false unless cache and cache.exist?
+    return true if cache.eql?(file)
+    if /cygwin/ !~ RUBY_PLATFORM or /winsymlink:nativestrict/ =~ ENV['CYGWIN']
+      begin
+        file.make_symlink(cache.relative_path_from(file.parent))
+      rescue SystemCallError
+      else
+        if verbose
+          $stdout.puts "made symlink #{name} to #{cache}"
+          $stdout.flush
+        end
+        return true
+      end
+    end
+    begin
+      file.make_link(cache)
+    rescue SystemCallError
+    else
+      if verbose
+        $stdout.puts "made link #{name} to #{cache}"
+        $stdout.flush
+      end
+      return true
+    end
+  end
+
+  def self.save_cache(cache, file, name)
+    if cache and !cache.eql?(file) and !cache.exist?
+      begin
+        file.rename(cache)
+      rescue
+      else
+        link_cache(cache, file, name)
+      end
+    end
+  end
+end
+
+Downloader.https = https.freeze
+
+if $0 == __FILE__
+  since = true
+  options = {}
+  until ARGV.empty?
+    case ARGV[0]
+    when '-d'
+      destdir = ARGV[1]
+      ARGV.shift
+    when '-p'
+      # strip directory names from the name to download, and add the
+      # prefix instead.
+      prefix = ARGV[1]
+      ARGV.shift
+    when '-e'
+      since = nil
+    when '-a'
+      since = false
+    when '-n', '--dryrun'
+      options[:dryrun] = true
+    when '--cache-dir'
+      options[:cache_dir] = ARGV[1]
+      ARGV.shift
+    when /\A--cache-dir=(.*)/m
+      options[:cache_dir] = $1
+    when /\A-/
+      abort "#{$0}: unknown option #{ARGV[0]}"
+    else
+      break
+    end
+    ARGV.shift
+  end
+  dl = Downloader.constants.find do |name|
+    ARGV[0].casecmp(name.to_s) == 0
+  end unless ARGV.empty?
+  $VERBOSE = true
+  if dl
+    dl = Downloader.const_get(dl)
+    ARGV.shift
+    ARGV.each do |name|
+      dir = destdir
+      if prefix
+        name = name.sub(/\A\.\//, '')
+        if name.start_with?(destdir+"/")
+          name = name[(destdir.size+1)..-1]
+          if (dir = File.dirname(name)) == '.'
+            dir = destdir
+          else
+            dir = File.join(destdir, dir)
+          end
+        else
+          name = File.basename(name)
+        end
+        name = "#{prefix}/#{name}"
+      end
+      dl.download(name, dir, since, options)
+    end
+  else
+    abort "usage: #{$0} url name" unless ARGV.size == 2
+    Downloader.download(ARGV[0], ARGV[1], destdir, since, options)
+  end
+end