crequire 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in crequire.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Evan Tatarka
+
+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,169 @@
+# crequire
+
+A simply way to require c code in ruby using SWIG.
+
+## Dependencies
+
+* ruby 1.9
+* make
+* SWIG
+
+## A simple example
+
+If you have a header file then the functions are detected automatically. You
+can either define the functions in the header file or define a header and
+implementation file separately.
+
+### example1.h
+
+```c
+int fact(int n) {
+  if (n <= 1) return 1;
+  else return n * fact(n-1);
+}
+
+void swap(int *a, int *b) {
+  int tmp;
+  tmp = *b;
+  *b = *a;
+  *a = tmp;
+}
+```
+
+### test_example1.rb
+
+```ruby
+require "crequire"
+crequire "example1"
+include Example1
+
+fact(4) => 24
+
+a = Intp.new
+a.assign 1
+b = Intp.new
+b.assign 2
+
+swap(a, b)
+
+a.value => 2
+b.value => 1
+```
+
+## A complex example
+
+If you don't define a header file, you must pass in a block to define the
+method signatures.
+
+### example2.c
+
+```c
+int sum(int a, int b) {
+  return a + b;
+}
+
+void add(int *x, int *y, int *r) {
+  *r = *x + *y;
+}
+
+char* echo(char* word) {
+  return word;
+}
+```
+
+### test_example2.rb
+
+```ruby
+require "crequire"
+
+# :force => true forces a compile on every run. Alternatively, you can delete
+# the 'example2.o' file for a recompile.
+
+crequire "example2", :force => true do
+  # To define a function signature, declare the type followed by the function
+  # name, passing in the types as symbols or strings.
+
+  int sum(:int, :int)
+
+  # To make working with pointers easer, you can define them as *INPUT or
+  # *OUTPUT.
+
+  void add("int *INPUT", "int *INPUT", "int *OUTPUT")
+
+  # char* is automatically converted to and from string
+  char* echo("char*")
+end
+
+include Example2
+
+sum(1, 2) => 3
+add(3, 4) => 7
+echo("hi") => "hi"
+```
+
+## Advanced Options
+
+You can use ```:src => string``` to pass in the contents of the interface file
+directly.
+
+### example2.c
+
+```c
+int sum(int a, int b, int times) {
+  int result = a;
+  for (int i = 0; i < times; i++) {
+    result += b;
+  }
+  return result;
+}
+```
+
+### test_example3.rb
+
+```ruby
+require 'crequire'
+
+# ```:interface => directory``` outputs the generated interface file to the given
+# directory. If you want to dump all generated files, you can use
+# ```:dump => directory```.
+
+
+interface = "%module example3 
+%{ 
+extern int sum(int a, int b, int times);
+%}
+extern int sum(int a, int b, int times);" 
+
+# You can use ```:cflags => flags``` to set c compiler options.
+crequire "example3", :force => true, :cflags => "-std=c99", :interface => "example3", :src => interface
+
+include Example3
+
+sum(1, 2, 2) => 5
+```
+
+### example3/example3.i
+
+```c
+%module example3
+%{
+extern int sum(int a, int b);
+%}
+extern int sum(int a, int b);
+```
+
+## Contributing to crequire
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Evan Tatarka. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [:spec]

data/crequire.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/crequire/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Evan Tatarka"]
+  gem.email         = ["evantatarka@gmail.com"]
+  gem.description   = %q{A simple way to require c files using swig.}
+  gem.summary       = %q{A simple way to require c files using swig.}
+  gem.homepage      = "http://github.com/evant/crequire"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "crequire"
+  gem.require_paths = ["lib"]
+  gem.version       = Crequire::VERSION
+
+  gem.add_development_dependency "rspec", "~> 2.7"
+end

data/lib/crequire.rb

@@ -0,0 +1,6 @@
+module Crequire
+  require "crequire/version"
+  require "crequire/swig"
+end
+
+require "crequire/crequire"

data/lib/crequire/crequire.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+require 'tmpdir'
+
+class Require
+  def initialize(file_path)
+    @full_path = File.expand_path file_path
+    @path = File.dirname @full_path
+    @name = File.basename file_path
+  end
+
+  def require(options = {}, &block)
+    if options[:force] or !File.exists? "#{@full_path}.o"
+
+      @src = options[:src]
+      @cflags = options[:cflags]
+      @dump_interface = options[:interface]
+      if options[:dump]
+        dir = options[:dump]
+        FileUtils.mkpath dir
+        save dir, &block
+        install dir
+      else
+        Dir.mktmpdir do |tmp|
+          save tmp, &block
+          install tmp
+        end
+      end
+    end
+
+    Kernel.require @name
+  end
+
+  def interface(source=nil, &block)
+    if source
+      source
+    else
+      swig = SWIG::Context.new(@name)
+      swig.input &block if block
+      swig.interface
+    end
+  end
+
+  private
+
+  def save(path, &block)
+    save_interface path, &block
+    save_extconf path
+  end
+
+  def save_interface(path, &block)
+    File.open(File.join(path, "#{@name}.i"), 'w') do |file|
+      file << interface(@src, &block)
+    end
+  end
+
+  def save_extconf(path)
+    File.open(File.join(path, "extconf.rb"), 'w') do |file|
+      file << extconf
+    end
+  end
+
+  def extconf
+    output = "require 'mkmf'\n"
+    output << "$CFLAGS << ' #{@cflags}'\n" if @cflags
+    output << "create_makefile('#{@name}')"
+  end
+
+  def install(path)
+    try_copy "#{@name}.c", path
+    try_copy "#{@name}.h", path
+
+    dir = Dir.pwd
+    Dir.chdir path
+    `swig -ruby "#{@name}.i"`
+    exit if $? != 0
+
+    `ruby extconf.rb`
+    `make`
+    `make install`
+    Dir.chdir dir
+
+    output = File.join path, "#{@name}_wrap.o"
+    FileUtils.cp output, "#{@full_path}.o"
+
+    if @dump_interface
+      i = File.join path, "#{@name}.i"
+      dest = File.join @dump_interface, "#{@name}.i"
+      FileUtils.cp i, dest
+    end
+  end
+
+  def try_copy(name, path)
+    from = File.join @path, name
+    to = File.join path, name
+    if File.exists? from
+      FileUtils.cp from, to
+    end
+  end
+end
+
+def crequire(file_path, options = {}, &block)
+  Require.new(file_path).require options, &block
+end

data/lib/crequire/string_helper.rb

@@ -0,0 +1,29 @@
+module StringHelper
+  def charpp(value = nil)
+    if value
+      Charpp.new(self, self.copy_charpp(value))
+    else
+      Charpp.new(self, self.new_charpp)
+    end
+  end
+
+  class Charpp
+    def initialize(type, pointer)
+      @type = type
+      @pointer = pointer
+    end
+
+    def pointer
+      @pointer
+    end
+
+    def value
+      type.charpp_value(@pointer)
+    end
+
+    def delete
+      type.delete_charpp(@pointer)
+      @pointer = nil
+    end
+  end
+end

data/lib/crequire/swig.rb

@@ -0,0 +1,130 @@
+module SWIG
+  class Context
+    def initialize(name)
+      @name = name
+      @functions = []
+      @pointers = []
+    end
+
+    def input(&block)
+      instance_eval &block
+      self
+    end
+
+    def method_missing(m, *args)
+      if args.size == 1 and args[0].class <= Function
+        func = args[0]
+        func.return = m
+        @functions << func
+      elsif args.size == 0
+        Unknown.new(m.to_s, self)
+      else
+        Function.new(m.to_s, args.map {|arg| arg.to_s})
+      end
+    end
+
+    def <<(input)
+      @pointers << input if input.is_a? Pointer
+      @functions << input if input.is_a? Function
+    end
+
+    def pointer(p, name = nil)
+      @pointers << Pointer.new(p, name)    
+    end
+
+    def interface
+      output = "%module #{@name}\n"
+      if @pointers.size > 0
+        output << "%include \"cpointer.i\"\n" +
+          @pointers.map {|p| p.to_s}.join("\n")
+      end
+      output << "%{\n"
+      output << if @functions.size > 0
+                  @functions.map {|f| f.to_s}.join("\n")
+                else
+                  "#include \"#{@name}.h\""
+                end
+      output << "\n%}\n"
+      output << if @functions.size > 0
+                  @functions.map {|f| f.to_swig_s}.join("\n")
+                else
+                  "%include \"#{@name}.h\""    
+                end
+    end
+  end
+
+  class Unknown
+    attr_accessor :name, :args
+
+    def initialize(name, context)
+      @context = context
+      @name = name
+      @args = []
+    end
+
+    def *(other)
+      @context << Function.new(other.name, other.args, @name + "*")
+    end
+
+    def to_s
+      @context << Function.new(@name).to_sig
+    end
+
+    def to_swig_s
+      @context << Function.new(@name).to_swig
+    end
+  end
+
+  class Function
+    attr_accessor :name, :args, :return
+
+    def initialize(name, args = [], ret = :void)
+      @name = name
+      @args = args
+      @return = ret
+    end
+
+    def to_s
+      res = "extern #{@return} #{@name}("
+      res << @args.each_with_index.map do |arg,i|
+        if arg =~ /(INPUT)|(OUTPUT)/
+          arg.to_s.gsub(/(INPUT)|(OUTPUT)/, "arg#{i}")
+        else
+          arg.to_s + " arg#{i}"
+        end
+      end.join(", ")
+      res << ");"
+    end
+
+    def to_swig_s
+      res = "extern #{@return} #{@name}("
+      res << @args.each_with_index.map do |arg,i|
+        if arg =~ /(INPUT)|(OUTPUT)/
+          arg.to_s
+        else
+          arg.to_s + " arg#{i}"
+        end
+      end.join(", ")
+      res << ");"
+    end
+  end
+
+  class Pointer
+    attr_accessor :name, :class_name
+
+    def initialize(name, class_name)
+      @name = name.to_s
+      @class_name = class_name ? class_name.to_s : name.to_s + 'p'
+    end
+
+    def to_s
+      "%pointer_class(#{@name}, #{camelize(@class_name)});"
+    end
+
+    private
+
+    def camelize(word)
+        word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+  end
+end

data/lib/crequire/version.rb

@@ -0,0 +1,3 @@
+module Crequire
+  VERSION = "0.0.1"
+end

data/spec/add.c

@@ -0,0 +1,3 @@
+void add(int *x, int *y, int *r) {
+    *r = *x + *y;
+}

data/spec/crequire_spec.rb

@@ -0,0 +1,98 @@
+require 'tmpdir'
+require 'fileutils'
+require 'crequire'
+
+describe "interface" do
+  before :each do
+    @crequire = Require.new 'test'
+  end
+
+  it "should use the interface source if given" do
+    @crequire.interface("test").should == "test"
+  end
+
+  it "should include the module name" do
+    @crequire.interface.should include("%module test")  
+  end
+
+  it "should default to including headers" do
+    @crequire.interface.should include('#include "test.h"')
+    @crequire.interface.should include('%include "test.h"')
+  end
+
+  it "should generate a custom interface correctly" do
+    @crequire.interface { int sum(:int, :int) }.should
+    include("extern int sum(int arg0, int arg1);")
+  end
+
+  context "with pointers" do
+    it "should include cpointer.i" do
+      @crequire.interface { pointer :int }.should
+      include('%include "cpointer.i"')
+    end
+
+    it "should include a pointer with the given name and class name" do
+      @crequire.interface { pointer :int, :int_pointer }.should
+      include('%pointer_class(int, IntPointer);')
+    end
+
+    it "should include a pointer with a default class name" do
+      @crequire.interface { pointer :int }.should
+      include('%pointer_class(int, Intp);')
+    end
+  end
+end
+
+describe "crequire" do
+  context "with a simple function" do
+    before :all do
+      crequire 'spec/fact', :force => true
+    end
+
+    it "should correctly call the function" do
+      Fact.fact(4).should == 24
+    end
+  end
+
+  context "with a function with INPUT and OUTPUT pointers" do
+    before :all do
+      crequire 'spec/add', :force => true do
+        void add("int *INPUT", "int *INPUT", "int *OUTPUT")
+      end
+
+      it "should correctly call the function" do
+        Add.add(1, 2).should == 3
+      end
+    end
+  end
+
+  context "with a function with char*" do
+    before :all do
+      crequire 'spec/echo', :force => true do
+        char* echo("char*")
+      end
+    end
+
+    it "should correctly call the function" do
+      Echo.echo("test").should == "test"
+    end
+  end
+
+  context "with custom interface input" do
+    before :all do
+      interface = <<-TEXT
+        %module sum
+        %{
+        extern int sum(int arg0, int arg1);
+        %}
+        extern int sum(int arg0, int arg1);
+      TEXT
+
+      crequire 'spec/sum', :force => true, :src => interface
+    end
+
+    it "should correctly call the function" do
+      Sum.sum(1, 2).should == 3
+    end
+  end
+end

data/spec/echo.c

@@ -0,0 +1,3 @@
+char* echo(char* text) {
+    return text;
+}

data/spec/fact.h

@@ -0,0 +1,4 @@
+int fact(int a) {
+  if (a <= 0) return 1;
+  else return a * fact(a - 1);
+}

data/spec/sum.c

@@ -0,0 +1,3 @@
+int sum(int a, int b) {
+    return a + b;
+}

data/spec/swig_spec.rb

@@ -0,0 +1,29 @@
+require 'rspec'
+require 'crequire/swig'
+
+describe SWIG do
+    it "should correctly convert a function to a string" do
+      SWIG::Context.new("test").input { int sum(:int, :int) }.interface.should
+        include("extern int sum(int arg0, int arg1);")
+    end
+
+    it "should correctly convert a function into a swig signature" do
+      SWIG::Context.new("test").input { void add("int *INPUT", "int *INPUT", "int *OUTPUT") }.interface.should
+        include("extern void add(int *INPUT, int *INPUT, int *OUTPUT);")
+    end 
+
+    it "should correctly parse pointer returned pointers" do
+      SWIG::Context.new("test").input { char* echo("char *INPUT") }.to_s.should
+        include("extern char* echo(char *arg0);")
+    end
+
+    it "should have the correct pointer_class with default name" do
+      SWIG::Context.new("test").input { pointer :int }.interface.should
+      include("%pointer_class(int, Intp);")
+    end
+
+    it "should have the correct pointer_class with given name" do
+      SWIG::Context.new("test").input { pointer :double, :double_pointer }.interface.should
+      include("%pointer_class(double, DoublePointer);")
+    end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: crequire
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Evan Tatarka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &17167880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: *17167880
+description: A simple way to require c files using swig.
+email:
+- evantatarka@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- crequire.gemspec
+- lib/crequire.rb
+- lib/crequire/crequire.rb
+- lib/crequire/string_helper.rb
+- lib/crequire/swig.rb
+- lib/crequire/version.rb
+- spec/add.c
+- spec/crequire_spec.rb
+- spec/echo.c
+- spec/echo.o
+- spec/fact.h
+- spec/fact.o
+- spec/sum.c
+- spec/sum.o
+- spec/swig_spec.rb
+homepage: http://github.com/evant/crequire
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A simple way to require c files using swig.
+test_files: []