fiddle 1.0.0.beta1 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2fe43921484c5d31435a574dfefe01f997a7d32d
-  data.tar.gz: e03146994af328004ad234e857040db4820f3734
+SHA256:
+  metadata.gz: bb11df53ed0c5fb29347565ba3c56fb21ec02fe764db7f63184c1ebe5dd9ea76
+  data.tar.gz: 3f1571515de5917bfb3215fa45382ca59808ca94d5a0c4c966c1e924f6ed9f30
 SHA512:
-  metadata.gz: a5ba7ff66c1000fbc80c61294523e9acba69f39bdce1f168dd748821a1fa2213204b69a3174ab74274e1343f936a8fe0a78053d4b43c6736ac7232e38e6a70d8
-  data.tar.gz: b650a3bb827441f5a34e51e66df247c8c707383de10083f717a15500fffa020d1f5704b53558ea1b5338a3481fa968a17f2ddfa63ec51ab5b3b7c1f3fbf5a052
+  metadata.gz: e6f266dc69d93931746b269af9698a582f1ad59430e3a35d25073e5193d12d19a94021aac5acfdee8c8c72cda6359c2a6b528e2df7d8b695c8a23ec827e1a8c4
+  data.tar.gz: 884144e33963f0d549c90dbee74893663512f1e4eb216082cb332bb4fd62303969cbc77a03804b3c7f5f5b8a2916a96dc284c0857174ef88a308461633af5b0a

data/LICENSE.txt

@@ -1,21 +1,22 @@
-The MIT License (MIT)
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
 
-Copyright (c) 2017 SHIBATA Hiroshi
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
 
-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.
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

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
 
@@ -32,10 +101,9 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/hsbt/fiddle.
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/fiddle.
 
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
+The gem is available as open source under the terms of the [BSD-2-Clause](https://opensource.org/licenses/BSD-2-Clause).

data/Rakefile

@@ -1,13 +1,11 @@
 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")
 
-task :default => :test
+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