rust_require 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 965d9bac57b7c7c943ecbd174a1e608f9d00ce22
+  data.tar.gz: 1bc2d94473b2ebde3854f693fdaebe5adf3c9ede
+SHA512:
+  metadata.gz: 613dbd5fed2cd485bb3f3cbeb64e27ab4f2a17c222a719d53b2d80322f3918909a3acaee7183af509e670ee1682a60a81c5e97c9f4ca1ac9af1f3de2eedc3614
+  data.tar.gz: c20418ae1136f036af523885bcb88405f0496445335d2381ff4ef614378f8ebb3f30ba9a7f3604ff2b97d2906f1a89ec69fdcaa122c754448f18cf87c481b1ac

data/ext/source_analyzer/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+
+# Stops the installation process if one of these commands is not found in
+# $PATH.
+find_executable('rustc')
+find_executable('rake')
+
+puts `rustc #{File.dirname(__FILE__)}/lib/source_analyzer.rs -o #{File.dirname(__FILE__)}/lib/libsource_analyzer.so`
+
+$makefile_created = true

data/lib/rust_require/c_wrapper_generator.rb

@@ -0,0 +1,75 @@
+require 'json'
+
+module Rust
+  # A Generator for Rust-to-C-wrappers
+  # Is initialized with a Json file containing
+  # relevant info about the rust file
+  class CWrapperGenerator
+    # info file, already parsed with json
+    def initialize(json)
+      @json = json
+    end
+
+    # Generates a Rust-to-C code wrapper as rust code (String)
+    def generate_wrapper
+      generate_mod_wrapper(@json, '')
+    end
+
+    private
+
+    # Generates wrapper fns for fn_headers and submodules in mod (String)
+    # submod_string is mods path eg. "mod::submod::"
+    def generate_mod_wrapper(mod,submod_string)
+      w = mod['submodules'].map do |x|
+        generate_mod_wrapper(x,submod_string+x['name']+'::')
+      end.join("\n")
+
+      w << generate_fns(mod['fn_headers'], submod_string)
+    end
+
+      # Generates wrapper fns for fn_headers (String)
+    def generate_fns(fn_headers, submod_string)
+      fn_headers.map do |fn|
+        WrapperFn.new(submod_string + fn['name'], fn['inputs'], fn['output']).to_s
+      end.join("\n")
+    end
+  end
+end
+
+module Rust
+  class CWrapperGenerator
+    # Rust code of a wrapper function
+    class WrapperFn
+      # original_name: name of the fn to be wrapped (String)
+      # inputs:        input types in order         (Array[String])
+      # output:        output type                  (String || nil)
+      def initialize(original_name, inputs, output)
+        @original_name = original_name
+        @inputs = inputs
+        @output = output
+      end
+
+      # returns string of rust code
+      def to_s
+        # convert inputs
+        input_types = @inputs.map  { |t| Rust::Types.find_type(t) }
+        c_inputs = input_types.map { |t| t.c_input_type } #C input types ([String])
+        input_str = c_inputs.map.with_index { |t,i| "c#{i}: #{t}" }.join(',') #fn foo_wrapper(input_str) ...
+        input_conversions = input_types.map.with_index { |t,i| t.c_input_conversion("c#{i}") }.join(",") #code used to convert input types to c types
+
+        # convert output
+        output_type = Rust::Types.find_type(@output)
+        c_output = output_type.c_output_type
+        output_conversion = output_type.c_output_conversion('output')
+
+        <<-END
+          #[no_mangle]
+          pub extern "C" fn _#{@original_name.gsub('::','_')}_wrapper(#{input_str}) -> #{c_output} {
+            let output = #{@original_name}(#{input_conversions});
+            #{output_conversion}
+          }
+        END
+      end
+    end
+  end
+end

data/lib/rust_require/ruby_wrapper_generator.rb

@@ -0,0 +1,72 @@
+module Rust
+  # This class generates Ruby wrappers for a dylib
+  # with information from an info.json file and
+  # a ruby Module (or Class) Object
+  class RubyWrapperGenerator
+    # @info_file: info.json file, parsed with JSON
+    def info_file=(info_file)
+      @info_file = info_file
+    end
+
+    # @rust_lib: path to the rust lib to be included (String)
+    attr_writer :rust_lib
+
+    # makes items from lib available in mod
+    # mod: Module/Class into which the wrappers should get included (Module || Class)
+    def include_lib(mod)
+      # attach items according to @info_file
+      attach_items(@info_file, mod, '')
+    end
+
+    # attaches items to mod,
+    # mod_string is the mod's prefix eg 'mod_submod_'
+    def attach_items(rust_module, mod, mod_string)
+      rust_module['submodules'].each do |x|
+        rust_mod = Module.new
+        attach_items(x, rust_mod, mod_string+x['name']+'_')
+        mod.const_set(x['name'].camelize, rust_mod)
+      end
+
+      attach_fns(rust_module['fn_headers'], mod, mod_string)
+    end
+
+    # attaches items via FFI to mod
+    def attach_fns(fn_headers, mod, mod_string)
+      # add ffi and the rust lib to mod
+      mod.extend FFI::Library
+      mod.ffi_lib @rust_lib
+
+      fn_headers.each do |fn|
+        rust_fn_name = fn['name']
+
+        # fn mod::fn() => fn _mod_fn_wrapper
+        wrapper_name = "_#{mod_string+fn['name']}_wrapper".to_sym
+
+        input_types = fn['inputs'].map { |t| Rust::Types.find_type(t) }
+        ffi_input_types = input_types.map { |t| t.ffi_input_type }
+
+
+        output_type = Rust::Types.find_type(fn['output'])
+        ffi_output_type = output_type.ffi_output_type
+
+        # attach fn and define ruby wrapper
+        mod.attach_function wrapper_name, ffi_input_types, ffi_output_type
+        mod.instance_eval do
+          define_method(rust_fn_name) do |*args|
+            # check input parameter count
+            raise ArgumentError, "wrong number of arguments (#{args.count} for #{input_types.count})" unless args.count == input_types.count
+
+            # check & convert ruby objects before handling them to FFI
+            args.map!.with_index do |arg,i|
+              input_types[i].ruby_input_conversion(arg)
+            end
+
+            # call FFI function and convert output
+            raw_output = send wrapper_name, *args
+            output_type.ruby_output_conversion raw_output
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rust_require/rust_require.rb

@@ -0,0 +1,100 @@
+module Rust
+  # Hash to keep record of already required files
+  ALREADY_REQUIRED = Hash.new(false)
+
+  # This should compile 'file_name' with rustc,
+  # generate rust-to-c wrappers and finally
+  # make as much as possible available
+  # in Module 'mod' as ruby objects/methods.
+
+  # file_path: String (path to .rs file)
+  # mod: Module/Class (Module which requires the .rs file)
+  def self.require_rust_file(file_path, mod)
+    # type check haha
+    check_file file_path
+
+    # make the path absolute
+    file_path = File.absolute_path file_path
+
+    # check if the file was already required by mod
+    return if already_required? [file_path,mod]
+
+    register_file [file_path,mod]
+
+    # compute rust crate name 
+    # file name without .rs extension
+    crate_name = File.basename(file_path, '.rs')
+
+    # path of dir containing file_name
+    dir_name = File.dirname(file_path)
+
+    # in case of ../blabla/mod.rs
+    if crate_name == 'mod'
+      crate_name = dir_name.split("/").last
+    end
+
+    # create .rust_require/#{file_name} subfolder
+    subdir = create_subfolder(crate_name, dir_name)
+
+    # TODO: insert check for unmodified input here
+
+    # location of info.json
+    info_file_path = "#{subdir}/info.json"
+
+    # Use Rustc to create wrappers and compile the file + wrappers
+    rustc = Rustc.new(file_path)
+    rustc.subdir         = subdir
+    rustc.info_file_path = info_file_path
+    rustc.output_path    = "#{subdir}/lib#{File.basename(file_path, '.rs')}.so"
+
+    info_file = rustc.create_wrapper
+    rustc.compile
+
+    # Use RubyWrapperGenerator to make items from the compiled
+    # lib available in mod
+    gen = RubyWrapperGenerator.new
+    gen.info_file = info_file
+    gen.rust_lib  = rustc.output_path
+    gen.include_lib(mod)
+
+    true #explicit return value
+  end
+
+  private
+
+  # This checks if file_name is a valid .rs file
+  def self.check_file(file_path)
+    raise ArgumentError, 'input must be a String object' unless file_path.is_a? String
+    raise LoadError, "file #{file_path} not found"       unless File.exists? file_path
+    raise NameError, 'input file must be a .rs file'     unless file_path.end_with? '.rs'
+  end
+
+  # checks if the file/mod combination has already been required
+  def self.already_required?(comb)
+    ALREADY_REQUIRED[comb]
+  end
+
+  # registers a file/mod combination as 'already_required'
+  def self.register_file(comb)
+    ALREADY_REQUIRED[comb] = true
+  end
+
+  # This creates a subfolder '.rust_require/#{crate_name}' in dir_name
+  # to store intermediate files to cache compilation results
+  def self.create_subfolder(crate_name, dir_name)
+    # path of the dirs to be created
+    new_dir_paths = []
+    new_dir_paths << "#{dir_name}/.rust_require"
+    new_dir_paths << "#{dir_name}/.rust_require/#{crate_name}"
+
+    new_dir_paths.each do |path|
+      unless Dir.exists? path
+        # mkdir with permissions: rwx-rx-r
+        Dir.mkdir path, 0754
+      end
+    end
+
+    # return the newly created dir path
+    new_dir_paths[1]
+  end
+end

data/lib/rust_require/rustc.rb

@@ -0,0 +1,86 @@
+module Rust
+  # A Wrapper to use rustc
+  class Rustc
+    # Path of rustc lint plugin to gather information about .rs files
+    SOURCE_ANALYZER = Gem::Specification.find_by_name('rust_require').full_gem_path + '/ext/source_analyzer/lib/libsource_analyzer.so'
+
+    # default rustc command
+    RUSTC_CMD = 'rustc --crate-type dylib -A dead_code'
+
+    # @output_path: output path for library generated by Rustc
+    attr_accessor :output_path
+
+    # @info_file_path is the info.json file containing infos about the rust lib
+    attr_accessor :info_file_path
+
+    # @subdir is a tempdir
+    attr_writer :subdir
+
+    # input is a String object containing the absolute path to an input file
+    def initialize(input)
+      @input_path = input
+    end
+
+    # creates a c-wrapper for file at @input_path
+    # returns info.json, parsed with JSON
+    def create_wrapper
+      # @input_path with wrappers added
+      @tempfile = "#{File.dirname(@input_path)}/#{File.basename(@input_path, ".*")}_wrapper.rs"
+
+      analyze_tempfile
+
+      # parse info.json
+      info_file = JSON.parse File.open(@info_file_path, 'r').read
+
+      gen = CWrapperGenerator.new(info_file)
+
+      File.open(@tempfile, "w+") do |f|
+        # add necessary extern crate definitions
+        f << <<-SRC
+            #![allow(unused_features)]
+            #![feature(libc,cstr_to_str)]
+            extern crate libc;
+        SRC
+
+        # add the actual file content
+        File.open(@input_path, "r") { |input| f << input.read }
+
+        # add wrappers
+        f << gen.generate_wrapper
+      end
+
+      # return info_file for further use
+      info_file
+    end
+
+    # Compiles file @input_path with rustc
+    def compile
+      print `#{RUSTC_CMD} -L #{File.dirname(@input_path)} #{@tempfile} -o #{@output_path}`
+      raise "rust compiler error" if $? != 0
+      `rm #{@tempfile}`
+    end
+
+    private
+    # Analyze @tempfile with the lint
+    # create an info.json file in @subdir
+    def analyze_tempfile
+      File.open(@tempfile, 'w+') do |f|
+        # injection of the librust_grep_lints plugin
+        f << "#![feature(plugin)]\n#![plugin(source_analyzer)]\n"
+
+        # add the actual file content
+        File.open(@input_path, "r") { |input| f << input.read }
+      end
+
+      # use the lint to just parse the file (no output)
+      print `RUST_REQUIRE_FILE=#{@info_file_path} #{RUSTC_CMD} -Z no-trans -L #{File.dirname(@input_path)} -L #{File.dirname(SOURCE_ANALYZER)} #{@tempfile}`
+      raise "rust compiler error" if $? != 0
+
+      # remove the injected lint plugin again
+      File.open(@tempfile, 'w+') do |f|
+        # add just the actual file content
+        File.open(@input_path, "r") { |input| f << input.read }
+      end
+    end
+  end
+end

data/lib/rust_require/types/primitives.rb

@@ -0,0 +1,61 @@
+module Rust
+  # Implement primitive types:
+  module Types
+    # nil
+    class Nil < Type
+      @rust_type = 'nil'
+
+      def c_type; '()'; end
+      def ffi_output_type; :void; end
+      def ffi_input_type
+        raise ArgumentError, "nil as ffi input is not supported by the ffi gem"
+      end
+    end
+
+    class Bool < Type
+        @rust_type = "bool"
+    end
+
+    class Isize < Type
+        @rust_type = "isize"
+        def ffi_type; :int; end
+    end
+
+    class Usize < Type
+        @rust_type = "usize"
+        def ffi_type; :uint; end
+    end
+
+    # more metaprogramming!!
+    %w[8 16 32 64].each do |x|
+      usize = Class.new(Type) do
+        @rust_type = "u#{x}"
+        def ffi_type; rust_type.sub('u', 'uint').to_sym; end
+      end
+
+      isize = Class.new(Type) do
+        @rust_type = "i#{x}"
+        def ffi_type; rust_type.sub('i', 'int').to_sym; end
+      end
+
+      const_set('U'+x, usize)
+      const_set('I'+x, isize)
+    end
+
+    class F32 < Type
+      @rust_type = 'f32'
+
+      # Ruby Floats are always f64
+      def c_type; 'f64'; end
+      def c_input_conversion(name); "#{name} as f32"; end
+      def c_output_conversion(name); "#{name} as f64"; end
+
+      def ffi_type; :double; end
+    end
+
+    class F64 < Type
+      @rust_type = 'f64'
+      def ffi_type; :double; end
+    end
+  end
+end

data/lib/rust_require/types/string.rb

@@ -0,0 +1,79 @@
+module Rust
+  module Types
+    class String < Type
+      @rust_type = 'String'
+
+      def not_implemented
+        raise NotImplementedError, 'String as rust input type is not supported, use &str instead!'
+      end
+
+      def c_input_type
+        not_implemented
+      end
+
+      def c_output_type; '(*const u8,usize)'; end
+
+      def c_output_conversion(name)
+        <<-CODE
+        {
+            let mut #{name} = #{name};
+            #{name}.shrink_to_fit();
+            let tuple = (#{name}.as_ptr(), #{name}.len());
+            std::mem::forget(#{name});
+            tuple
+        }
+        CODE
+      end
+
+      def c_input_conversion(slice)
+        not_implemented
+      end
+
+      def ffi_type; Rust::Slice.by_value; end
+
+      def ruby_output_conversion(slice)
+        (start,len) = slice.unpack
+        start.read_string(len.to_i).force_encoding("UTF-8")
+      end
+
+      def ruby_input_conversion(str)
+        not_implemented
+      end
+    end
+
+    class StrSlice < Type
+      def rust_type_regex
+        /^&(mut)?( )?str$/
+      end
+
+      def not_implemented
+        raise NotImplementedError, '&str as rust output parameter is not supported, use String instead!'
+      end
+
+      def c_output_type
+        not_implemented
+      end
+
+      def c_output_conversion(name)
+        not_implemented
+      end
+
+      def c_input_conversion(slice)
+        "#{slice}"
+      end
+
+      def ffi_type; Rust::Slice.by_value; end
+
+      def ruby_output_conversion(slice)
+        not_implemented
+      end
+
+      def ruby_input_conversion(str)
+        str.encode!(Encoding::UTF_8)
+        len = str.bytesize
+        start = FFI::MemoryPointer.from_string(str).address
+        Rust::Slice.from(start, len)
+      end
+    end
+  end
+end

data/lib/rust_require/types.rb

@@ -0,0 +1,98 @@
+module Rust
+  # a rust fat pointer
+  class Slice < FFI::Struct
+    layout :ptr, :pointer,
+           :len, :uint
+
+    def self.from(start, len)
+      s = new
+      s[:ptr] = start
+      s[:len] = len
+      s
+    end
+
+    def unpack
+      [self[:ptr], self[:len]]
+    end
+  end
+
+  # Types are used to implement support
+  # for rust types in rust_require
+  module Types
+    # returns type instance for rust_type
+    def self.find_type(rust_type)
+      # find types in module constants
+      type = constants
+       .map     { |c| const_get(c) }
+       .keep_if { |c| c.is_a?(Class) && c.ancestors.include?(Type) && c != Type} #just Type subclass objects, excluding Type itself
+       .map     { |c| c.new } # instances of the Type classes
+       .find    { |c| c.rust_type_regex =~ rust_type }
+
+      if type
+        type.rust_type = rust_type
+        type
+      else
+        raise NotImplementedError, "type #{rust_type} is not implemented!"
+      end
+    end
+
+    # The base class for Types with simple defaults
+    class Type
+      # accessor for @rust_type of Type class
+      def self.rust_type; @rust_type; end
+
+      # set @rust_type from class variable @rust_type
+      def initialize
+        @rust_type = self.class.rust_type
+      end
+
+      # name of the rust type (String)
+      # raises error when @rust_type is nil
+      def rust_type
+        raise NotImplementedError, "This is a bug." if @rust_type.nil?
+        @rust_type
+      end
+
+      attr_writer :rust_type
+
+      def rust_type_regex
+        Regexp.new @rust_type
+      end
+
+      def c_type; rust_type; end
+
+      # name of the type passed in from ruby (String)
+      def c_input_type; c_type; end
+
+      # name of the type returned by the wrapper fn to ruby
+      def c_output_type; c_type; end
+
+      # rust code performing necessary conversions on input from ruby
+      # with name before passing it to original rust fn (String)
+      def c_input_conversion(name); name; end
+
+      # rust code performing necessary conversions on output with name
+      # from rust fn before returning it to ruby (String)
+      def c_output_conversion(name); name; end
+
+      # Border between Rust and Ruby
+      ########################################
+
+      # shortcut for ffi type (input and output)
+      def ffi_type; rust_type.to_sym; end
+
+      # returns symbol understood by ruby ffi gem corresponding to @rust_type as input
+      def ffi_input_type; ffi_type; end
+
+      # returns symbol understood by ruby ffi gem corresponding to @rust_type as output
+      def ffi_output_type; ffi_type; end
+
+      # return value will directly be passed into the ffi fn
+      def ruby_input_conversion(obj); obj; end
+
+      # obj is return value of ffi fn
+      # return value will be the final result of ffi call
+      def ruby_output_conversion(obj); obj; end
+    end
+  end
+end

data/lib/rust_require/version.rb

@@ -0,0 +1,3 @@
+module Rust
+  VERSION = "0.2.0"
+end

data/lib/rust_require.rb

@@ -0,0 +1,21 @@
+# Extern libs
+require 'ffi'
+require 'active_support/core_ext/string/inflections'
+
+# Libs
+require_relative 'rust_require/version.rb'
+require_relative 'rust_require/rust_require.rb'
+require_relative 'rust_require/rustc.rb'
+require_relative 'rust_require/types.rb'
+require_relative 'rust_require/c_wrapper_generator.rb'
+require_relative 'rust_require/ruby_wrapper_generator.rb'
+
+# Types
+require_relative 'rust_require/types/primitives.rb'
+require_relative 'rust_require/types/string.rb'
+
+class Module
+  def rust_require(file)
+    Rust.require_rust_file(file, self)
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: rust_require
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Florian Lackner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.99'
+description: |2
+          A ruby gem that generates bindings to rust files automatically.
+email: lacknerflo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/source_analyzer/extconf.rb
+- ext/source_analyzer/lib/libsource_analyzer.so
+- lib/rust_require.rb
+- lib/rust_require/c_wrapper_generator.rb
+- lib/rust_require/ruby_wrapper_generator.rb
+- lib/rust_require/rust_require.rb
+- lib/rust_require/rustc.rb
+- lib/rust_require/types.rb
+- lib/rust_require/types/primitives.rb
+- lib/rust_require/types/string.rb
+- lib/rust_require/version.rb
+homepage: https://github.com/flo-l/rust_require
+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.4.6
+signing_key: 
+specification_version: 4
+summary: An automatic rust binding generator
+test_files: []