RubyInline 3.1.0 → 3.2.0

data/History.txt

@@ -1,7 +1,23 @@
+*** 3.2.0 / 2004-11-27
+
++ 8 minor enhancements
+	+ Gemified
+	+ Added #line preprocessor directives to make debugging inside your ruby file practical.
+	+ Added uninstall rule to Makefile
+	+ Inline::C now generates classes directly instead of included modules.
+	+ Better execeptions are thrown on error.
+	+ Incorporated a bunch of changes from Jonathan Paisley:
+		+ Generation of inline'd class methods. (c_singleton and c_raw_singleton)
+		+ Fixed problems with nested module/classes.
+		+ Inline can now extend the same class multiple times.
++ 2 bug fixes
+	+ Smarter require/instantiation to accomodate other languages better.
+	+ Fixed a logic error where running good code, then bad, then bad again ran the original good code.
+
 *** 3.1.0 / 2004-09-24
 
 + 2 minor enhancement
-	Extended API of Inline::C with prefix(code).
+	+ Extended API of Inline::C with prefix(code).
 	+ Documented all public API.
 + 2 bug fixes
 	+ Cleaned a lot of code and tests.

data/Makefile

@@ -1,5 +1,6 @@
 RUBY?=/usr/local/bin/ruby
 RDOC?=rdoc18
+RUBYLIB=$(shell $(RUBY) -rrbconfig -e 'include Config; print CONFIG["sitelibdir"]')
 
 test:
 	$(RUBY) -I. -w ./test_inline.rb
@@ -28,10 +29,14 @@ bench:
 	@$(RUBY) -I. ./example.rb 2 2> /dev/null
 
 install:
-	@where=`$(RUBY) -rrbconfig -e 'include Config; print CONFIG["sitelibdir"]'`; \
-	echo "installing inline.rb in $$where"; \
-	cp -f inline.rb $$where; \
+	echo "installing inline.rb in $(RUBYLIB)"; \
+	cp -f inline.rb $(RUBYLIB);
 	echo Installed
 
+uninstall:
+	echo "Removing inline.rb from $(RUBYLIB)"; \
+	rm $(RUBYLIB)/inline.rb;
+	echo Removed
+
 clean:
 	rm -rf *~ doc ~/.ruby_inline

data/README.txt

@@ -5,22 +5,22 @@
 
 ** DESCRIPTION:
 
-Ruby Inline is my quick attempt to create an analog to Perl's
-Inline::C. It allows you to embed C or C++ external module code in
-your ruby script directly. The code is compiled and run on the fly
-when needed. The ruby version isn't near as feature-full as the perl
-version, but it is neat!
+Ruby Inline is an analog to Perl's Inline::C. Out of the box, it
+allows you to embed C/++ external module code in your ruby script
+directly. By writing simple builder classes, you can teach how to cope
+with new languages (fortran, perl, whatever). The code is compiled and
+run on the fly when needed.
 
 ** FEATURES/PROBLEMS:
 
 + Quick and easy inlining of your C or C++ code embedded in your ruby script.
-+ Rudimentary automatic conversion between ruby and C basic types
-  (char, unsigned, unsigned int, char *, int, long, unsigned long).
++ Extendable to work with other languages.
++ Automatic conversion between ruby and C basic types
+	+ char, unsigned, unsigned int, char *, int, long, unsigned long
 + inline_c_raw exists for when the automatic conversion isn't sufficient.
 + Only recompiles if the inlined code has changed.
 + Pretends to be secure.
 + Only uses standard ruby libraries, nothing extra to download.
-+ Simple as it can be. Less than 230 lines long... um... sorta simple.
 
 ** SYNOPSYS:
 
@@ -82,10 +82,11 @@ version, but it is neat!
 
 ** REQUIREMENTS:
 
-+ Ruby - 1.6.7 & 1.7.2 has been used on FreeBSD 4.6 and MacOSX.
++ Ruby - 1.6.7 & 1.8.2 has been used on FreeBSD 4.6+ and MacOSX.
 + POSIX compliant system (ie pretty much any UNIX, or Cygwin on MS platforms).
 + A C/C++ compiler (the same one that compiled your ruby interpreter).
 + test::unit for running tests ( http://testunit.talbott.ws/ ).
++ rubygems if you'd like.
 
 ** INSTALL:
 

data/example.rb

@@ -1,6 +1,11 @@
 #!/usr/local/bin/ruby -w
 
-require "inline"
+begin
+  require 'rubygems'
+  require_gem "RubyInline"
+rescue LoadError
+  require 'inline'
+end
 
 class MyTest
 

data/inline.gemspec

@@ -11,6 +11,7 @@ spec = Gem::Specification.new do |s|
 
   paragraphs = File.read("README.txt").split(/\n\n+/)
   s.description = paragraphs[3]
+  puts s.description
 
   s.requirements << "A POSIX environment and a compiler for your language."
   s.files = IO.readlines("Manifest.txt").map {|f| f.chomp }

data/inline.rb

@@ -32,16 +32,19 @@
 
 require "rbconfig"
 require "ftools"
+require "digest/md5"
 
 $TESTING = false unless defined? $TESTING
 
+class CompilationError < RuntimeError; end
+
 # The Inline module is the top-level module used. It is responsible
 # for instantiating the builder for the right language used,
 # compilation/linking when needed, and loading the inlined code into
 # the current namespace.
 
 module Inline
-  VERSION = '3.1.0'
+  VERSION = '3.2.0'
 
   $stderr.puts "RubyInline v #{VERSION}" if $DEBUG
 
@@ -96,12 +99,12 @@ module Inline
     }
 
     def ruby2c(type)
-      raise "Unknown type #{type}" unless @@type_map.has_key? type
+      raise ArgumentError, "Unknown type #{type}" unless @@type_map.has_key? type
       @@type_map[type].first
     end
 
     def c2ruby(type)
-      raise "Unknown type #{type}" unless @@type_map.has_key? type
+      raise ArgumentError, "Unknown type #{type}" unless @@type_map.has_key? type
       @@type_map[type].last
     end
 
@@ -152,11 +155,17 @@ module Inline
 	}
       end
 
-      raise "Bad parser exception: #{sig}"
+      raise SyntaxError, "Can't parse signature: #{sig}"
     end # def parse_signature
 
-    def generate(src, expand_types=true)
+    def generate(src, options={})
+
+      if not Hash === options then
+        options = {:expand_types=>options}
+      end
 
+      expand_types = options[:expand_types]
+      singleton = options[:singleton]
       result = self.strip_comments(src)
 
       signature = parse_signature(src, !expand_types)
@@ -190,7 +199,7 @@ module Inline
 	result.sub!(/[^;\/\"\>]+#{function_name}\s*\([^\{]+\{/, "\n" + prefix)
 	result.sub!(/\A\n/, '') # strip off the \n in front in case we added it
 	unless return_type == "void" then
-	  raise "couldn't find return statement for #{function_name}" unless 
+	  raise SyntaxError, "Couldn't find return statement for #{function_name}" unless 
 	    result =~ /return/ 
 	  result.gsub!(/return\s+([^\;\}]+)/) do
 	    "return #{c2ruby(return_type)}(#{$1})"
@@ -204,8 +213,11 @@ module Inline
 	result.sub!(/\A\n/, '') # strip off the \n in front in case we added it
       end
 
+      file, line = caller[1].split(/:/)
+      result = "# line #{line.to_i - 1} \"#{file}\"\n" + result
+
       @src << result
-      @sig[function_name] = arity
+      @sig[function_name] = [arity,singleton]
 
       return result if $TESTING
     end # def generate
@@ -215,14 +227,14 @@ module Inline
     public
 
     def load
-      require "#{@so_name}" or raise "require on #{@so_name} failed"
-      @mod.class_eval "include #{@mod_name}"
+      require "#{@so_name}" or raise LoadError, "require on #{@so_name} failed"
     end
 
     def build
       rb_file = File.expand_path(caller[1].split(/:/).first) # [MS]
+      so_exists = File.file? @so_name
 
-      unless File.file? @so_name and File.mtime(rb_file) < File.mtime(@so_name)
+      unless so_exists and File.mtime(@rb_file) < File.mtime(@so_name)
 	
 	src_name = "#{Inline.directory}/#{@mod_name}.c"
 	old_src_name = "#{src_name}.old"
@@ -233,15 +245,21 @@ module Inline
 	  io.puts @src.join("\n\n")
 	  io.puts
 	  io.puts
-	  io.puts "  VALUE c#{@mod_name};"
 	  io.puts "#ifdef __cplusplus"
 	  io.puts "extern \"C\" {"
 	  io.puts "#endif"
 	  io.puts "  void Init_#{@mod_name}() {"
-	  io.puts "    c#{@mod_name} = rb_define_module(\"#{@mod_name}\");"
+          io.puts "    VALUE c = rb_cObject;"
+          @mod.name.split("::").each do |n|
+            io.puts "    c = rb_const_get_at(c,rb_intern(\"#{n}\"));"
+          end
 	  @sig.keys.sort.each do |name|
-	    arity = @sig[name]
-	    io.print "   rb_define_method(c#{@mod_name}, \"#{name}\", "
+	    arity, singleton = @sig[name]
+            if singleton then
+              io.print "    rb_define_singleton_method(c, \"#{name}\", "
+            else
+	      io.print "    rb_define_method(c, \"#{name}\", "
+            end
 	    io.puts  "(VALUE(*)(ANYARGS))#{name}, #{arity});"
 	  end
 	  io.puts
@@ -254,13 +272,15 @@ module Inline
 
 	# recompile only if the files are different
 	recompile = true
-	if should_compare and File::compare(old_src_name, src_name, $DEBUG) then
+	if so_exists and should_compare and
+            File::compare(old_src_name, src_name, $DEBUG) then
 	  recompile = false
 
 	  # Updates the timestamps on all the generated/compiled files.
 	  # Prevents us from entering this conditional unless the source
 	  # file changes again.
-	  File.utime(Time.now, Time.now, src_name, old_src_name, @so_name)
+          t = Time.now
+	  File.utime(t, t, src_name, old_src_name, @so_name)
 	end
 
 	if recompile then
@@ -287,10 +307,16 @@ module Inline
 	  if /mswin32/ =~ RUBY_PLATFORM then
 	    cmd += " -link /INCREMENTAL:no /EXPORT:Init_#{@mod_name}"
 	  end
+
+          cmd += " 2> /dev/null" if $TESTING
 	  
 	  $stderr.puts "Building #{@so_name} with '#{cmd}'" if $DEBUG
 	  `#{cmd}`
-	  raise "error executing #{cmd}: #{$?}" if $? != 0
+          if $? != 0 then
+            bad_src_name = src_name + ".bad"
+            File.rename src_name, bad_src_name
+            raise CompilationError, "error executing #{cmd}: #{$?}\nRenamed #{src_name} to #{bad_src_name}"
+          end
 	  $stderr.puts "Built successfully" if $DEBUG
 	end
 
@@ -299,10 +325,20 @@ module Inline
       end # unless (file is out of date)
     end # def build
       
+    attr_reader :mod
     def initialize(mod)
       @mod = mod
-      @mod_name = "Mod_#{@mod}"
-      @so_name = "#{Inline.directory}/#{@mod_name}.#{Config::CONFIG["DLEXT"]}"
+      if @mod then
+        # Figure out which script file defined the C code
+        @rb_file = File.expand_path(caller[2].split(/:/).first) # [MS]
+        # Extract the basename of the script and clean it up to be 
+        # a valid C identifier
+        rb_script_name = File.basename(@rb_file).gsub(/[^a-zA-Z0-9_]/,'_')
+        # Hash the full path to the script
+        suffix = Digest::MD5.new(@rb_file).to_s[0,4]
+        @mod_name = "Inline_#{@mod.name.gsub('::','__')}_#{rb_script_name}_#{suffix}"
+        @so_name = "#{Inline.directory}/#{@mod_name}.#{Config::CONFIG["DLEXT"]}"
+      end
       @src = []
       @sig = {}
       @flags = []
@@ -350,7 +386,11 @@ module Inline
     # conversions can be extended by using +add_type_converter+.
     
     def c src
-      self.generate(src)
+      self.generate(src,:expand_types=>true)
+    end
+
+    def c_singleton src
+      self.generate(src,:expand_types=>true,:singleton=>true)
     end
     
     # Adds a raw C function to the source. This version does not
@@ -358,7 +398,11 @@ module Inline
     # coding conventions.
     
     def c_raw src
-      self.generate(src, false)
+      self.generate(src)
+    end
+
+    def c_raw_singleton src
+      self.generate(src, :singleton=>true)
     end
 
   end # class Inline::C
@@ -371,8 +415,15 @@ class Module
   # parameter.
   
   def inline(lang = :C, testing=false)
-    require "inline/#{lang}" unless lang == :C
-    builder = Inline.const_get(lang).new self
+
+    begin
+      builder_class = Inline.const_get(lang)
+    rescue NameError
+      require "inline/#{lang}"
+      builder_class = Inline.const_get(lang)
+    end
+
+    builder = builder_class.new self
 
     yield builder
 
@@ -417,9 +468,9 @@ class Dir
     mode = File.stat(path).mode
     unless ((mode % 01000) & 0022) == 0 then
       if $TESTING then
-	raise 'InsecureDir'
+	raise SecurityError, "Directory #{path} is insecure"
       else
-	$stderr.puts "#{path} is insecure (#{sprintf('%o', mode)}), needs 0700 for perms"
+	$stderr.puts "#{path} is insecure (#{sprintf('%o', mode)}), needs 0700 for perms. Exiting."
 	exit 1
       end
     end

data/test_inline.rb

@@ -1,16 +1,13 @@
-#!/usr/bin/ruby -w 
+#!/usr/local/bin/ruby -w 
 
 $TESTING = true
 
 require 'inline'
+require 'tempfile'
 require 'test/unit'
 
 File.umask(0)
 
-#class TestFile < Test::Unit::TestCase
-# TODO def test_write_with_backup
-#end
-
 class TestDir < Test::Unit::TestCase
 
   def setup
@@ -32,7 +29,7 @@ class TestDir < Test::Unit::TestCase
 	Dir.assert_secure path
       end
     else
-      assert_raises(perms.nil? ? Errno::ENOENT : RuntimeError) do
+      assert_raises(perms.nil? ? Errno::ENOENT : SecurityError) do
 	Dir.assert_secure path
       end
     end
@@ -103,7 +100,7 @@ class TestC < Test::Unit::TestCase
     assert_equal 'NUM2UINT', x.ruby2c("unsigned long")
     assert_equal 'NUM2UINT', x.ruby2c("unsigned")
 
-    assert_raises RuntimeError do
+    assert_raises ArgumentError do
       x.ruby2c('blah')
     end
   end
@@ -118,7 +115,7 @@ class TestC < Test::Unit::TestCase
     assert_equal 'UINT2NUM',    x.c2ruby("unsigned long")
     assert_equal 'UINT2NUM',    x.c2ruby("unsigned")
 
-    assert_raises RuntimeError do
+    assert_raises ArgumentError do
       x.c2ruby('blah')
     end
   end
@@ -216,6 +213,8 @@ class TestC < Test::Unit::TestCase
     inline do |builder|
       result = builder.generate src, expand_types
     end
+    result.gsub!(/\# line \d+/, '# line N')
+    expected = '# line N "./test_inline.rb"' + "\n" + expected
     assert_equal(expected, result)
   end
 
@@ -425,7 +424,9 @@ puts(s); return rb_str_new2(s)}"
       result = builder.c "int add(int a, int b) { return a + b; }"
     end
 
-    expected = "static VALUE add(VALUE self, VALUE _a, VALUE _b) {\n  int a = FIX2INT(_a);\n  int b = FIX2INT(_b);\n return INT2FIX(a + b); }"
+    expected = "# line N \"./test_inline.rb\"\nstatic VALUE add(VALUE self, VALUE _a, VALUE _b) {\n  int a = FIX2INT(_a);\n  int b = FIX2INT(_b);\n return INT2FIX(a + b); }"
+
+    result.gsub!(/\# line \d+/, '# line N')
 
     assert_equal expected, result
     assert_equal [expected], builder.src
@@ -439,19 +440,103 @@ puts(s); return rb_str_new2(s)}"
       result = builder.c_raw src.dup
     end
 
-    expected = src
+    result.gsub!(/\# line \d+/, '# line N')
+    expected = "# line N \"./test_inline.rb\"\n" + src
 
     assert_equal expected, result
     assert_equal [expected], builder.src
   end
 
-  # I have _no_ idea how to test these
-  # TODO def test_build
-  # TODO def test_load
+  def util_simple_code(klassname, c_src)
+    result = "
+      require 'inline'
+
+      class #{klassname}
+        inline do |builder|
+          builder.c <<-EOC
+            #{c_src}
+          EOC
+        end
+      end"
+    result
+  end
+
+  def util_test_build(src)
+    tempfile = Tempfile.new("util_test_build")
+    tempfile.write src
+    tempfile.flush
+    tempfile.rewind
+    rb_file = tempfile.path + ".rb"
+    File.rename tempfile.path, rb_file
+    begin
+      Kernel.module_eval { require rb_file }
+      yield if block_given?
+    rescue Exception => err
+      raise err
+    ensure
+      File.unlink rb_file
+    end
+  end
+
+  def test_build_good
+    code = util_simple_code(:DumbTest1, "long dumbpi() { return 314; }")
+    util_test_build(code) do
+      result = DumbTest1.new.dumbpi
+      assert_equal(314, result)
+    end
+  end
+
+  def test_build_bad
+    code = util_simple_code(:DumbTest2, "void should_puke() { 1+1  2+2 }")
+    assert_raises(CompilationError) do 
+      util_test_build(code) do
+        flunk
+      end
+    end
+  end
+
+  def test_load
+    # totally tested by test_build
+  end
 
 end # class TestC
 end # class TestInline
 
+$test_module_code = <<-EOR
+module Foo
+  class Bar
+    inline do |builder|
+      builder.c <<-EOC
+        static int forty_two_instance() { return 42; }
+      EOC
+      builder.c_singleton <<-EOC
+        static int twenty_four_class() { return 24; }
+      EOC
+    end
+  end
+end
+EOR
+
+$test_module_code2 = <<-EOR
+require 'inline'
+
+# Demonstrates native functions in nested classes and
+# extending a class more than once from different ruby
+# source files
+module Foo
+  class Bar
+    inline do |builder|
+      builder.c <<-EOC
+        int twelve_instance() { return 12; }
+      EOC
+      builder.c_singleton <<-EOC
+        int twelve_class() { return 12; }
+      EOC
+    end
+  end
+end
+EOR
+
 class TestModule < Test::Unit::TestCase
 
   def setup
@@ -463,19 +548,35 @@ class TestModule < Test::Unit::TestCase
     `rm -rf #{@rootdir}` unless $DEBUG
   end
 
+  def test_nested
+    Object.class_eval $test_module_code
+    fb = Foo::Bar.new
+    assert_equal(fb.forty_two_instance, 42)
+    assert_equal(Foo::Bar.twenty_four_class, 24)
+
+    tempfile = Tempfile.new("test_inline_nested")
+    tempfile.write($test_module_code2)
+    tempfile.flush
+    tempfile.rewind
+    `cp #{tempfile.path} #{tempfile.path}.rb`
+    require "#{tempfile.path}.rb"
+    assert_equal(fb.twelve_instance,12)
+    assert_equal(Foo::Bar.twelve_class,12)
+    `rm "#{tempfile.path}.rb"`
+  end
+
   def test_inline
     self.class.inline(:C) do |builder|
       builder.c "int add(int a, int b) { return a + b; }"
     end
     assert(test(?d, Inline.directory),
 	   "inline dir should have been created")
-    assert(test(?f, File.join(Inline.directory, "Mod_TestModule.c")),
-	   "Source should have been created")
-    assert(test(?f, File.join(Inline.directory,
-			      "Mod_TestModule.#{Config::CONFIG["DLEXT"]}")),
+    matches = Dir[File.join(Inline.directory, "Inline_TestModule_test_inline_rb_*.c")]
+    assert_equal(matches.length,1,
 	   "Source should have been created")
+    library_file = matches.first.gsub(/\.c$/) { "." + Config::CONFIG["DLEXT"] }
+    assert(test(?f, library_file),
+	   "Library file should have been created")
   end
 
 end
-
-# Number of errors detected: 4

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: RubyInline
 version: !ruby/object:Gem::Version 
-  version: 3.1.0
-date: 2004-11-19
+  version: 3.2.0
+date: 2004-11-27
 summary: Multi-language extension coding within ruby.
 require_paths: 
   - "."
@@ -12,10 +12,10 @@ author: Ryan Davis
 email: ryand-ruby@zenspider.com
 homepage: http://www.zenspider.com/ZSS/Products/RubyInline/
 rubyforge_project: rubyinline
-description: "Ruby Inline is my quick attempt to create an analog to Perl's Inline::C. It
-  allows you to embed C or C++ external module code in your ruby script directly.
-  The code is compiled and run on the fly when needed. The ruby version isn't near
-  as feature-full as the perl version, but it is neat!"
+description: "Ruby Inline is an analog to Perl's Inline::C. Out of the box, it allows you to
+  embed C/++ external module code in your ruby script directly. By writing simple
+  builder classes, you can teach how to cope with new languages (fortran, perl,
+  whatever). The code is compiled and run on the fly when needed."
 autorequire: inline
 default_executable: 
 bindir: bin