rbplusplus 0.1

data/lib/rbplusplus/module.rb

@@ -0,0 +1,56 @@
+module RbPlusPlus
+  # Class representation of a ruby Module to be exposed in the extension.
+  # A Module acts much in the same way as Extension in that it can contain
+  # classes, functions, enumerations, etc. 
+  class RbModule
+
+    # Modules can be nested
+    attr_accessor :modules
+
+    # Modules have a name
+    attr_accessor :name
+
+    # Access to the underlying RbGCCXML parser
+    attr_reader :node
+
+    # Registers a new module definition for this extension.
+    # Use Extension#module or RbModule#module instead
+    # of creating an instance of this class directly
+    #
+    # The block parameter is optional, you can also 
+    # grab the reference of the Module and work with
+    # it as you want:
+    #
+    #   module "Name" do |m|
+    #     ...
+    #   end
+    #   
+    # or
+    #
+    #   m = module "Name"
+    #   ...
+    #
+    # Unlike Extension#new, no special processing is done
+    # in the block version, it's just there for convenience.
+    def initialize(name, parser, &block)
+      @name = name
+      @parser = parser
+      @modules = []
+
+      block.call(self) if block
+    end
+
+    # Specify a C++ namespace from which the contained code will
+    # be wrapped and exposed to Ruby under this Module.
+    def namespace(name)
+      @node = @parser.namespaces(name)
+    end
+
+    # Register another module to be defined inside of
+    # this module. Acts the same as Extension#module.
+    def module(name, &block)
+      @modules << RbModule.new(name, @parser, &block)
+    end
+
+  end
+end

data/lib/rbplusplus/rbplusplus.rb

@@ -0,0 +1,3 @@
+module RbPlusPlus
+  class ConfigurationError < RuntimeError; end
+end

data/lib/rbplusplus/writers/base.rb

@@ -0,0 +1,25 @@
+module RbPlusPlus
+  module Writers
+
+    # Base class for all source code writers.
+    class Base
+
+      attr_reader :builder, :working_dir
+
+      # Writers all take a builder from which to write out 
+      # the source code
+      def initialize(builder, working_dir)
+        @builder = builder
+        @working_dir = working_dir
+      end
+
+      # Write out the code. Must be implemented in a
+      # subclass
+      def write
+        raise "Writers must implement #write"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/writers/extension.rb

@@ -0,0 +1,37 @@
+module RbPlusPlus
+  module Writers
+
+    # Writes out the code for building the extension.
+    # This writer takes care of building the extconf.rb
+    # file with the appropriate options.
+    class ExtensionWriter < Base
+
+      # List of -I directives
+      attr_accessor :includes
+
+      # List of -L directives
+      attr_accessor :library_paths
+
+      # List of -l directives
+      attr_accessor :libraries
+
+      def write
+        extconf = File.join(working_dir, "extconf.rb")
+
+        @includes ||= []
+
+        inc_str = @includes.flatten.uniq.map {|i| "-I#{i}"}.join(" ")
+        lib_path_str = @library_paths.flatten.uniq.map {|i| "-L#{i}"}.join(" ")
+        lib_str = @libraries.flatten.uniq.map {|i| "-l#{i}"}.join(" ")
+
+        File.open(extconf, "w+") do |file|
+          file.puts "require \"rubygems\""
+          file.puts "require \"mkmf-rice\""
+          file.puts %Q($CPPFLAGS = $CPPFLAGS + " -I#{working_dir} #{inc_str} #{lib_path_str} #{lib_str}")
+          file.puts "create_makefile(\"#{builder.name}\")"
+        end
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/writers/multiple_files_writer.rb

@@ -0,0 +1,84 @@
+module RbPlusPlus
+  module Writers
+    # Writer that takes a builder and writes out the code in
+    # multiple files.
+    class MultipleFilesWriter < Base
+
+      def write
+        _write_node(builder)
+      end
+
+      # How this works:
+      #
+      # We'll recurse through the builder heirarchy, starting at the bottom.
+      # This lets us to properly link up each file so that all classes / modules / 
+      # functions get properly exposed.
+      def _write_node(node)
+        node.builders.each do |b|
+          _write_node(b)
+        end
+
+        filename = if node.parent
+                     node.qualified_name.gsub(/::/, "_")
+                   else
+                     node.name
+                   end
+
+        cpp_file = File.join(working_dir, "#{filename}.rb.cpp")
+
+        if node.parent
+          hpp_file = File.join(working_dir, "#{filename}.rb.hpp")
+          hpp_include = "#include \"#{hpp_file}\""
+          register_func = "register_#{filename}"
+
+          include_guard = "__RICE_GENERATED_#{filename}_HPP__"
+
+          register_func_arg = ""
+          register_func_prototype = ""
+
+          if !node.parent.is_a?(Builders::ExtensionBuilder)
+            register_func_arg = node.parent.rice_variable
+            register_func_prototype = "#{node.parent.rice_variable_type} #{register_func_arg}"
+          end
+
+          # Changes we need to make to the parent for everything to work across multiple 
+          # files
+          #
+          # * Add an include to the hpp file
+          # * Add a call to the register method
+          node.parent.includes << hpp_include
+
+          node.parent.body << "#{register_func}(#{register_func_arg});"
+
+          # Modifications to this current node's code:
+          # 
+          # * Add a register prototype to the header file
+          # * Set include in node to the header file
+          # * Wrap the body in a register method
+
+          File.open(hpp_file, "w+") do |hpp|
+            hpp.puts "#ifndef #{include_guard}"
+            hpp.puts "#define #{include_guard}"
+            hpp.puts ""
+            hpp.puts "void #{register_func}(#{register_func_prototype});"
+            hpp.puts "#endif"
+          end
+
+          node.includes << hpp_include
+
+          node.body = [
+            "void #{register_func}(#{register_func_prototype}) {",
+            node.body,
+            "}"
+          ]
+        end
+
+        File.open(cpp_file, "w+") do |cpp|
+          cpp.puts node.to_s
+        end
+      end
+
+
+    end
+  end
+end

data/lib/rbplusplus/writers/single_file_writer.rb

@@ -0,0 +1,37 @@
+module RbPlusPlus
+  module Writers
+    # Writer that takes a builder and writes out the code in
+    # one single file
+    class SingleFileWriter < Base
+
+      def write
+        process_code(builder)
+
+        filename = builder.name
+        cpp_file = File.join(working_dir, "#{filename}.rb.cpp")
+
+        File.open(cpp_file, "w+") do |cpp|
+          cpp.puts builder.to_s
+        end
+      end
+
+      protected
+
+      # What we do here is to go through the builder heirarchy
+      # and push all the code from children up to the parent, 
+      # ending up with all the code in the top-level builder
+      def process_code(builder)
+        builder.builders.each do |b|
+          process_code(b)
+        end
+
+        return unless builder.parent
+
+        builder.parent.includes << builder.includes
+        builder.parent.body << builder.body
+        builder.parent.declarations << builder.declarations
+      end
+
+    end
+  end
+end

data/test/classes_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Extension with wrapped classes" do
+
+  def setup
+    if !defined?(@@adder_built)
+      super
+      @@adder_built = true 
+      Extension.new "adder" do |e|
+        e.sources full_dir("headers/Adder.h")
+        e.namespace "classes"
+      end
+
+      require 'adder'
+    end
+  end
+
+  specify "should make classes available as Ruby runtime constants" do
+    assert defined?(Adder), "Adder isn't defined"
+  end
+
+  specify "should make wrapped classes constructable" do
+    a = Adder.new
+    a.should.not.be.nil
+  end
+
+  specify "should make functions of the class available" do
+    # Wrapped method names default to underscore'd
+    adder = Adder.new
+    adder.add_integers(1,2).should == 3
+    adder.add_floats(1.0, 2.0).should.be.close(3.0, 0.001)
+    adder.add_strings("Hello", "World").should == "HelloWorld"
+    adder.get_class_name.should == "Adder"
+  end
+
+  # Explicit self
+  specify "should properly wrap static methods as class methods" do
+    Adder.do_adding(1, 2, 3, 4, 5).should == 15
+  end
+
+end
+
+context "Wrapping Classes within classes" do
+
+  def setup
+    if !defined?(@@nested_built)
+      super
+      @@nested_built = true 
+      Extension.new "nested" do |e|
+        e.sources full_dir("headers/nested_classes.h")
+        e.namespace "classes"
+      end
+
+      require 'nested'
+    end
+  end
+
+  specify "should properly make nested classes available" do
+    assert defined?(TestClass) 
+    assert defined?(TestClass::InnerClass) 
+    assert defined?(TestClass::InnerClass::Inner2) 
+
+    TestClass.new.should.not.be.nil
+    TestClass::InnerClass.new.should.not.be.nil
+    TestClass::InnerClass::Inner2.new.should.not.be.nil
+  end
+end

data/test/compiling_test.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Compiler settings" do
+
+  specify "should be able to specify include paths" do
+    Extension.new "compiler" do |e|
+      e.sources full_dir("headers/with_includes.h"), 
+        :include_paths => full_dir("headers/include")
+      e.namespace "code"
+    end
+
+    require 'compiler'
+
+    assert defined?(func)
+  end
+
+  specify "should be able to specify library paths" do
+    # Single path
+    e = Extension.new "libs_test" 
+    e.working_dir = full_dir("generated")
+    e.sources full_dir("headers/empty.h"),
+        :library_paths => "/usr/lib/testing/123"
+    e.build
+    e.write
+
+    ext_file = full_dir("generated/extconf.rb")
+
+    contents = File.read(ext_file)
+
+    contents.should.match(%r(-L/usr/lib/testing/123))
+
+    # Clean up
+    `rm -rf #{full_dir('generated')}/*`
+
+    # Array of paths
+    e = Extension.new "libs_test" 
+    e.working_dir = full_dir("generated")
+    e.sources full_dir("headers/empty.h"),
+        :library_paths => ["/usr/lib/testing/456", "/var/lib/stuff"]
+    e.build
+    e.write
+
+    ext_file = full_dir("generated/extconf.rb")
+
+    contents = File.read(ext_file)
+
+    contents.should.match(%r(-L/usr/lib/testing/456))
+    contents.should.match(%r(-L/var/lib/stuff))
+  end
+
+  specify "should be able to link to external libraries" do
+    # Single library
+    e = Extension.new "libs_test" 
+    e.working_dir = full_dir("generated")
+    e.sources full_dir("headers/empty.h"),
+        :libraries => "lib123"
+    e.build
+    e.write
+
+    ext_file = full_dir("generated/extconf.rb")
+
+    contents = File.read(ext_file)
+
+    contents.should.match(%r(-llib123))
+    
+    # Clean up
+    `rm -rf #{full_dir('generated')}/*`
+
+    # Array of libraries
+    e = Extension.new "libs_test" 
+    e.working_dir = full_dir("generated")
+    e.sources full_dir("headers/empty.h"),
+        :libraries => ["ponzor", "wonko", "prankit"]
+    e.build
+    e.write
+
+    ext_file = full_dir("generated/extconf.rb")
+
+    contents = File.read(ext_file)
+
+    contents.should.match(%r(-lponzor))
+    contents.should.match(%r(-lwonko))
+    contents.should.match(%r(-lprankit))
+  end
+end

data/test/extension_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Ruby Extension creation" do
+
+  specify "should create a valid Ruby extension" do
+    Extension.new "ext_test" do |e|
+      e.sources full_dir("headers/empty.h")
+    end
+
+    should.not.raise LoadError do
+      require("ext_test")
+    end
+  end
+
+  specify "should create a valid Ruby extension without a block" do
+    e = Extension.new "extension"
+    e.sources full_dir("headers/empty.h")
+    e.working_dir = File.join(File.expand_path(File.dirname(__FILE__)), "generated")
+    e.build
+    e.write
+    e.compile
+
+    should.not.raise LoadError do
+      require("ext_test")
+    end
+  end
+
+  specify "should properly build working dir as deep as needed" do
+    should.not.raise Errno::ENOENT do
+      Extension.new "extension" do |e|
+        e.sources full_dir("headers/empty.h")
+        e.working_dir = File.join(File.expand_path(File.dirname(__FILE__)), 
+                                  "generated", "path1", "path2")
+      end
+    end
+  end
+end
+

data/test/file_writers_test.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Multiple file writer (default)" do
+
+  setup do
+    @working_dir = File.expand_path(File.dirname(__FILE__) + "/generated")
+
+    e = Extension.new "adder"
+    e.working_dir = @working_dir
+    e.sources full_dir("headers/Adder.h")
+
+    e.module "Mod" do |m|
+      m.namespace "classes"
+    end
+
+    e.build
+    e.write
+  end
+
+  specify "should properly split up code into multiple files" do
+    files = Dir["#{@working_dir}/*"]
+    files.size.should == 6
+
+    %w(
+      extconf.rb
+      Mod.rb.cpp
+      Mod.rb.hpp
+      classes_Adder.rb.cpp
+      classes_Adder.rb.hpp
+      adder.rb.cpp
+    ).each do |wants|
+      assert_not_nil files.find {|got| File.basename(got) == wants }, "Didn't find #{wants}"
+    end
+  end
+
+end
+
+context "Single file writer" do
+
+  setup do
+    @working_dir = File.expand_path(File.dirname(__FILE__) + "/generated")
+
+    e = Extension.new "adder"
+    e.working_dir = @working_dir
+    e.sources full_dir("headers/Adder.h")
+    e.writer_mode :single
+
+    e.module "Mod" do |m|
+      m.namespace "classes"
+    end
+
+    e.build
+    e.write
+  end
+
+  specify "should properly write out all code in a single file" do
+    files = Dir["#{@working_dir}/*"]
+    files.size.should == 2
+
+    %w(
+      extconf.rb
+      adder.rb.cpp
+    ).each do |wants|
+      assert_not_nil files.find {|got| File.basename(got) == wants }, "Didn't find #{wants}"
+    end
+  end
+
+end