fiddle 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 538e522b63f6cd2ec6ee72c138757966cc6e0aab44b381bb01bc464a740aa3a7
-  data.tar.gz: 3fc2e992e471105c4cadd9ee58234c047e7f8899d38ef8476b05a1640ef40284
+  metadata.gz: 6273f6abe03da289f77f31e82b7d43fcb99e7144f096319306e91e6d0bc33659
+  data.tar.gz: de279d21f060c1726c701adc9dba5518bb85b179d3ac4dfd716b995948147163
 SHA512:
-  metadata.gz: a1b2011849c78991b1129999a0469318a60414d3bd5db196cc82a21c86443a6f68cdbce1a3baef1043539e8395641c2ceac121fdf3e712bbc51ad9c2d4dcd12b
-  data.tar.gz: 4a8fc35a372b73f62496760f38f6f0291fe6cbd649c634299b289bf006e46ab585024c7721ef02136f9d2ad45aa1136b6072ab6d7adcbd1bb2081d606cc870fb
+  metadata.gz: 7afc807eaa5b363d2687027ec7c4d2fffc7779286359095e96a266feb7cdbb0bf6addd8b58b5cb41cff9f1ef86764381828e172b63017cc7567d237f46c9c502
+  data.tar.gz: 8d4cb60138cabdff92524750189ae8024faef07e16d21b9b2b10b7a7bfc7e04913bd61dd1f8482feacbb50b5b9a6f2a4e0f2515f62a6a9c32e6bb3f9ff631bc6

data/README.md

@@ -28,7 +28,7 @@ Or install it yourself as:
 
  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')
@@ -42,6 +42,57 @@ floor = Fiddle::Function.new(
 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
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -1,10 +1,8 @@
 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'

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

data/bin/extlibs.rb

@@ -0,0 +1,262 @@
+#!/usr/bin/ruby
+
+# Used to download, extract and patch extension libraries (extlibs)
+# for Ruby. See common.mk for Ruby's usage.
+
+require 'digest'
+require_relative 'downloader'
+
+class Vars < Hash
+  def pattern
+    /\$\((#{Regexp.union(keys)})\)/
+  end
+
+  def expand(str)
+    if empty?
+      str
+    else
+      str.gsub(pattern) {self[$1]}
+    end
+  end
+end
+
+class ExtLibs
+  def cache_file(url, cache_dir)
+    Downloader.cache_file(url, nil, :cache_dir => cache_dir)
+  end
+
+  def do_download(url, cache_dir)
+    Downloader.download(url, nil, nil, nil, :cache_dir => cache_dir)
+  end
+
+  def do_checksum(cache, chksums)
+    chksums.each do |sum|
+      name, sum = sum.split(/:/)
+      if $VERBOSE
+        $stdout.print "checking #{name} of #{cache} ..."
+        $stdout.flush
+      end
+      hd = Digest(name.upcase).file(cache).hexdigest
+      if hd == sum
+        if $VERBOSE
+          $stdout.puts " OK"
+          $stdout.flush
+        end
+      else
+        if $VERBOSE
+          $stdout.puts " NG"
+          $stdout.flush
+        end
+        raise "checksum mismatch: #{cache}, #{name}:#{hd}, expected #{sum}"
+      end
+    end
+  end
+
+  def do_extract(cache, dir)
+    if $VERBOSE
+      $stdout.puts "extracting #{cache} into #{dir}"
+      $stdout.flush
+    end
+    ext = File.extname(cache)
+    case ext
+    when '.gz', '.tgz'
+      f = IO.popen(["gzip", "-dc", cache])
+      cache = cache.chomp('.gz')
+    when '.bz2', '.tbz'
+      f = IO.popen(["bzip2", "-dc", cache])
+      cache = cache.chomp('.bz2')
+    when '.xz', '.txz'
+      f = IO.popen(["xz", "-dc", cache])
+      cache = cache.chomp('.xz')
+    else
+      inp = cache
+    end
+    inp ||= f.binmode
+    ext = File.extname(cache)
+    case ext
+    when '.tar', /\A\.t[gbx]z\z/
+      pid = Process.spawn("tar", "xpf", "-", in: inp, chdir: dir)
+    when '.zip'
+      pid = Process.spawn("unzip", inp, "-d", dir)
+    end
+    f.close if f
+    Process.wait(pid)
+    $?.success? or raise "failed to extract #{cache}"
+  end
+
+  def do_patch(dest, patch, args)
+    if $VERBOSE
+      $stdout.puts "applying #{patch} under #{dest}"
+      $stdout.flush
+    end
+    Process.wait(Process.spawn("patch", "-d", dest, "-i", patch, *args))
+    $?.success? or raise "failed to patch #{patch}"
+  end
+
+  def do_link(file, src, dest)
+    file = File.join(dest, file)
+    if (target = src).start_with?("/")
+      target = File.join([".."] * file.count("/"), src)
+    end
+    return unless File.exist?(File.expand_path(target, File.dirname(file)))
+    File.unlink(file) rescue nil
+    begin
+      File.symlink(target, file)
+    rescue
+    else
+      if $VERBOSE
+        $stdout.puts "linked #{target} to #{file}"
+        $stdout.flush
+      end
+      return
+    end
+    begin
+      src = src.sub(/\A\//, '')
+      File.copy_stream(src, file)
+    rescue
+      if $VERBOSE
+        $stdout.puts "failed to link #{src} to #{file}: #{$!.message}"
+      end
+    else
+      if $VERBOSE
+        $stdout.puts "copied #{src} to #{file}"
+      end
+    end
+  end
+
+  def do_exec(command, dir, dest)
+    dir = dir ? File.join(dest, dir) : dest
+    if $VERBOSE
+      $stdout.puts "running #{command.dump} under #{dir}"
+      $stdout.flush
+    end
+    system(command, chdir: dir) or raise "failed #{command.dump}"
+  end
+
+  def do_command(mode, dest, url, cache_dir, chksums)
+    extracted = false
+    base = /.*(?=\.tar(?:\.\w+)?\z)/
+
+    case mode
+    when :download
+      cache = do_download(url, cache_dir)
+      do_checksum(cache, chksums)
+    when :extract
+      cache = cache_file(url, cache_dir)
+      target = File.join(dest, File.basename(cache)[base])
+      unless File.directory?(target)
+        do_checksum(cache, chksums)
+        extracted = do_extract(cache, dest)
+      end
+    when :all
+      cache = do_download(url, cache_dir)
+      target = File.join(dest, File.basename(cache)[base])
+      unless File.directory?(target)
+        do_checksum(cache, chksums)
+        extracted = do_extract(cache, dest)
+      end
+    end
+    extracted
+  end
+
+  def run(argv)
+    cache_dir = nil
+    mode = :all
+    until argv.empty?
+      case argv[0]
+      when '--download'
+        mode = :download
+      when '--extract'
+        mode = :extract
+      when '--patch'
+        mode = :patch
+      when '--all'
+        mode = :all
+      when '--cache'
+        argv.shift
+        cache_dir = argv[0]
+      when /\A--cache=/
+        cache_dir = $'
+      when '--'
+        argv.shift
+        break
+      when /\A-/
+        warn "unknown option: #{argv[0]}"
+        return false
+      else
+        break
+      end
+      argv.shift
+    end
+
+    success = true
+    argv.each do |dir|
+      Dir.glob("#{dir}/**/extlibs") do |list|
+        if $VERBOSE
+          $stdout.puts "downloading for #{list}"
+          $stdout.flush
+        end
+        vars = Vars.new
+        extracted = false
+        dest = File.dirname(list)
+        url = chksums = nil
+        IO.foreach(list) do |line|
+          line.sub!(/\s*#.*/, '')
+          if /^(\w+)\s*=\s*(.*)/ =~ line
+            vars[$1] = vars.expand($2)
+            next
+          end
+          if chksums
+            chksums.concat(line.split)
+          elsif /^\t/ =~ line
+            if extracted and (mode == :all or mode == :patch)
+              patch, *args = line.split.map {|s| vars.expand(s)}
+              do_patch(dest, patch, args)
+            end
+            next
+          elsif /^!\s*(?:chdir:\s*([^|\s]+)\|\s*)?(.*)/ =~ line
+            if extracted and (mode == :all or mode == :patch)
+              command = vars.expand($2.strip)
+              chdir = $1 and chdir = vars.expand(chdir)
+              do_exec(command, chdir, dest)
+            end
+            next
+          elsif /->/ =~ line
+            if extracted and (mode == :all or mode == :patch)
+              link, file = $`.strip, $'.strip
+              do_link(vars.expand(link), vars.expand(file), dest)
+            end
+            next
+          else
+            url, *chksums = line.split(' ')
+          end
+          if chksums.last == '\\'
+            chksums.pop
+            next
+          end
+          unless url
+            chksums = nil
+            next
+          end
+          url = vars.expand(url)
+          begin
+            extracted = do_command(mode, dest, url, cache_dir, chksums)
+          rescue => e
+            warn e.inspect
+            success = false
+          end
+          url = chksums = nil
+        end
+      end
+    end
+    success
+  end
+
+  def self.run(argv)
+    self.new.run(argv)
+  end
+end
+
+if $0 == __FILE__
+  exit ExtLibs.run(ARGV)
+end