rbplusplus 0.1.1 → 0.8

data/lib/rbplusplus/writers/extension.rb

@@ -6,38 +6,46 @@ module RbPlusPlus
     # file with the appropriate options.
     class ExtensionWriter < Base
 
-      # List of -I directives
-      attr_accessor :includes
+      # Options given from the extension
+      attr_accessor :options
 
-      # List of -L directives
-      attr_accessor :library_paths
+      def write
+        extconf = File.join(working_dir, "extconf.rb")
 
-      # List of -l directives
-      attr_accessor :libraries
+        inc_str = @options[:include_paths].flatten.uniq.map {|i| "-I#{i}"}.join(" ")
+        inc_str += " " + @options[:cxxflags].flatten.join(" ")
+        lib_path_str = @options[:library_paths].flatten.uniq.map {|i| "-L#{i}"}.join(" ")
+        lib_str = @options[:libraries].flatten.uniq.map {|i| "-l#{i}"}.join(" ")
+        lib_str += " " + @options[:ldflags].flatten.join(" ")
 
-      # Extra CXXFLAGS
-      attr_accessor :cxxflags
+        File.open(extconf, "w+") do |file|
+          file.puts <<-EOF
+require 'rubygems'
+require 'mkmf-rice'
+
+# Add the arguments to the linker flags.
+def append_ld_flags(flags)
+  flags = [flags] unless flags.is_a?(Array)
+  with_ldflags("\#{$LDFLAGS} \#{flags.join(' ')}") { true }
+end
 
-      # Extra LDFLAGS
-      attr_accessor :ldflags
+$CPPFLAGS += \" -I'#{working_dir}' #{inc_str}\"
+$LDFLAGS += \" #{lib_path_str} #{lib_str}\"
 
-      def write
-        extconf = File.join(working_dir, "extconf.rb")
-
-        @includes ||= []
+if RUBY_PLATFORM =~ /darwin/
+  # In order to link the shared library into our bundle with GCC 4.x on OSX, we have to work around a bug:
+  #   GCC redefines symbols - which the -fno-common prohibits.  In order to keep the -fno-common, we
+  #   remove the flat_namespace (we now have two namespaces, which fixes the GCC clash).  Also, we now lookup
+  #   symbols in both the namespaces (dynamic_lookup).
 
-        inc_str = @includes.flatten.uniq.map {|i| "-I#{i}"}.join(" ")
-        inc_str += " " + @cxxflags.flatten.join(" ")
-        lib_path_str = @library_paths.flatten.uniq.map {|i| "-L#{i}"}.join(" ")
-        lib_str = @libraries.flatten.uniq.map {|i| "-l#{i}"}.join(" ")
-        lib_str += " " + @ldflags.flatten.join(" ")
+  $LDSHARED_CXX.gsub!('suppress', 'dynamic_lookup')
+  $LDSHARED_CXX.gsub!('-flat_namespace', '')
+  
+  append_ld_flags '-all_load'
+end
 
-        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}")
-          file.puts %Q($LDFLAGS = $LDFLAGS + " #{lib_path_str} #{lib_str}")
-          file.puts "create_makefile(\"#{builder.name}\")"
+create_makefile(\"#{builder.name}\")
+EOF
         end
       end
 

data/lib/rbplusplus/writers/multiple_files_writer.rb

@@ -5,9 +5,41 @@ module RbPlusPlus
     class MultipleFilesWriter < Base
 
       def write
+        @to_from_include = ""
+        write_to_from_ruby
         _write_node(builder)
       end
 
+      # Write out files that include the auto-generated to_/from_ruby constructs.
+      def write_to_from_ruby
+        # Ignore this if there's nothing to write out
+        return if Builders::TypesManager.body.length == 0
+
+        hpp_file = File.join(working_dir, "_to_from_ruby.rb.hpp")
+        cpp_file = File.join(working_dir, "_to_from_ruby.rb.cpp")
+
+        @to_from_include = "#include \"#{hpp_file}\""
+
+        include_guard = "__RICE_GENERATED_TO_FROM_RUBY_HPP__"
+
+        File.open(hpp_file, "w+") do |f|
+          f.puts "#ifndef #{include_guard}" 
+          f.puts "#define #{include_guard}" 
+          f.puts ""
+          f.puts Builders::TypesManager.includes.uniq.join("\n")
+          f.puts ""
+          f.puts Builders::TypesManager.prototypes.join("\n")
+          f.puts ""
+          f.puts "#endif // #{include_guard}" 
+        end
+
+        File.open(cpp_file, "w+") do |f|
+          f.puts @to_from_include
+          f.puts ""
+          f.puts Builders::TypesManager.body.join("\n");
+        end
+      end
+
       # How this works:
       #
       # We'll recurse through the builder heirarchy, starting at the bottom.
@@ -19,10 +51,15 @@ module RbPlusPlus
         end
 
         filename = if node.parent
-                     node.qualified_name.gsub(/::/, "_")
+                     "_"+node.qualified_name.gsub(/::/, "_")
                    else
                      node.name
                    end
+                   
+        #templated classes
+        filename.gsub!(/[ ,<>]/,"_")
+        #templates to pointers
+        filename.gsub!("*","Ptr")
 
         cpp_file = File.join(working_dir, "#{filename}.rb.cpp")
 
@@ -48,7 +85,8 @@ module RbPlusPlus
           # * Add a call to the register method
           node.parent.includes << hpp_include
 
-          node.parent.body << "#{register_func}(#{register_func_arg});"
+          # Register for proper flattening of the inheritance tree
+          node.parent.register_node(node, "#{register_func}(#{register_func_arg});")
 
           # Modifications to this current node's code:
           # 
@@ -60,6 +98,8 @@ module RbPlusPlus
             hpp.puts "#ifndef #{include_guard}"
             hpp.puts "#define #{include_guard}"
             hpp.puts ""
+            hpp.puts @to_from_include
+            hpp.puts ""
             hpp.puts "void #{register_func}(#{register_func_prototype});"
             hpp.puts "#endif"
           end

data/lib/rbplusplus/writers/single_file_writer.rb

@@ -7,6 +7,11 @@ module RbPlusPlus
       def write
         process_code(builder)
 
+        if Builders::TypesManager.body.length > 0
+          # Handle to_from_ruby constructions
+          builder.declarations << Builders::TypesManager.body
+        end
+
         filename = builder.name
         cpp_file = File.join(working_dir, "#{filename}.rb.cpp")
 

data/lib/rbplusplus.rb

@@ -6,8 +6,11 @@ require 'rbgccxml'
 
 require 'inflector'
 require 'fileutils'
+require 'singleton'
 require 'rbplusplus/rbplusplus'
 
+require 'fileutils'
+
 module RbPlusPlus
 
   RBPP_COMMENT = "// This file generated by rb++"
@@ -20,6 +23,8 @@ module RbPlusPlus
     autoload :ClassBuilder, "rbplusplus/builders/class"
     autoload :ExtensionBuilder, "rbplusplus/builders/extension"
     autoload :ModuleBuilder, "rbplusplus/builders/module"
+    autoload :EnumerationBuilder, "rbplusplus/builders/enumeration"
+    autoload :TypesManager, "rbplusplus/builders/types_manager"
   end
 
   module Writers
@@ -30,3 +35,22 @@ module RbPlusPlus
   end
 end
 
+class String #:nodoc:
+  # Functionize attempts to rename a string in a cpp function friendly way.
+  #
+  # vector<float>::x => vector_float__x
+  def functionize
+    gsub("::","_").gsub(/[ ,<>]/, "_").gsub("*", "Ptr")
+  end
+end
+
+require 'rbplusplus/transformers/rbgccxml'
+require 'rbplusplus/transformers/node_cache'
+require 'rbplusplus/transformers/node'
+require 'rbplusplus/transformers/node_reference'
+require 'rbplusplus/transformers/function'
+require 'rbplusplus/transformers/method'
+require 'rbplusplus/transformers/constructor'
+require 'rbplusplus/transformers/class'
+require 'rbplusplus/transformers/module'
+

data/test/class_methods_test.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Correct handling of static methods" do
+  def setup
+    if !defined?(@@complex_static)
+      super
+      @@complex_static = true 
+      Extension.new "complex" do |e|
+        e.sources full_dir("headers/complex_static_methods.h")
+        node = e.namespace "complex"
+      end
+
+      require 'complex'
+    end
+  end
+
+  specify "should handle complex static methods" do
+    Multiply.multiply(SmallInteger.new(2),SmallInteger.new(2)).should == 4
+  end
+  
+end
+
+context "Correct handling of encapsulated methods" do
+  def setup
+    if !defined?(@@encapsulated)
+      super
+      @@encapsulated = true 
+      Extension.new "encapsulation" do |e|
+        e.sources full_dir("headers/class_methods.h")
+        node = e.namespace "encapsulation"
+      end
+
+      require 'encapsulation'
+    end
+  end
+
+  specify "should handle private/protected/public" do
+    ext = Extended.new
+    ext.public_method.should == 1
+    should.raise NoMethodError do
+      ext.private_method
+    end
+    should.raise NoMethodError do
+      ext.protected_method
+    end
+  end
+  
+  specify "should handle virtual methods" do
+    ext_factory = ExtendedFactory.new
+    ext = ext_factory.new_instance
+    ext.fundamental_type_virtual_method.should == 1
+    ext.user_defined_type_virtual_method.class.should == Base
+  end
+end
+

data/test/classes_test.rb

@@ -40,28 +40,3 @@ context "Extension with wrapped classes" do
 
 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

@@ -126,4 +126,34 @@ context "Compiler settings" do
       e.write
     end
   end
+
+  specify "should be able to add additional headers as needed" do
+    should.not.raise do
+      e = Extension.new "external" 
+      e.working_dir = full_dir("generated")
+      e.sources full_dir("headers/external_mapping.h"), 
+        :includes => full_dir("headers/*rice.h")
+      e.build
+      e.write
+
+      file = full_dir("generated/external.rb.cpp")
+      contents = File.read(file)
+      contents.should.match(%r(headers/external_mapping_rice.h))
+    end
+  end
+
+  specify "can specify other source files to be compiled into the extension" do
+    Extension.new "source_files" do |e|
+      e.sources full_dir("headers/to_from_ruby.h"),
+        :include_paths => full_dir("headers"),
+        :include_source_files => full_dir("headers/to_from_ruby_source.cpp")
+      e.namespace "to_from_ruby"
+    end
+
+    require 'source_files'
+
+    # Don't know if there's any way to catch this nicely. A failure here
+    # is a symbol lookup failure and death to the Ruby VM
+    needs_to_ruby(3).value.should == 3
+  end
 end

data/test/constructors_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Extension with constructors out the whazoo" do
+
+  # Test is currently broken due to something Rice is or isn't doing.
+  xspecify "should make constructors available" do
+    Extension.new "constructors" do |e|
+      e.sources full_dir("headers/constructors.h")
+      node = e.namespace "constructors"
+      e.writer_mode :single
+    end
+
+    require 'constructors'
+
+    should.not.raise NameError do
+#   Constructor overloading not yet supported
+#     s = StringHolder.new
+#     s.set_name "two"
+#     s.get_name.should == "two"
+ 
+      s2 = StringHolder.new "one"
+      s2.get_name.should == "one"
+    end
+
+    should.not.raise NameError do
+      # Test complex constructors
+      d = DoubleStringHolder.new(StringHolder.new("one"), StringHolder.new("two"))
+      one = d.get_one
+      puts "Got one #{one.inspect}"
+      puts "Name is #{one.get_name}"
+#      d.get_one.get_name.should == "one"
+#      d.get_two.get_name.should == "two"
+    end
+    
+    should.raise TypeError do
+      PrivateConstructor.new
+    end
+  end
+
+end

data/test/enumerations_test.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Wrapping enumerations" do
+
+  def setup
+    if !defined?(@@enums_built)
+      super
+      @@enums_built = true 
+      Extension.new "enums" do |e|
+        e.sources full_dir("headers/enums.h")
+        e.namespace "enums"
+        e.writer_mode :single
+
+        e.module "Mod" do |m|
+          m.namespace "inner"
+        end
+      end
+
+      require 'enums'
+    end
+  end
+
+  specify "should wrap up enums properly" do
+    assert defined?(TestEnum)
+
+    TestEnum::VALUE1.to_i.should == 0
+    TestEnum::VALUE2.to_i.should == 1
+    TestEnum::VALUE3.to_i.should == 2
+  end
+
+  specify "should wrap up enumerations at proper nesting" do
+    assert defined?(Tester::MyEnum)
+
+    Tester::MyEnum::I_LIKE_MONEY.to_i.should == 3
+    Tester::MyEnum::YOU_LIKE_MONEY_TOO.to_i.should == 4
+    Tester::MyEnum::I_LIKE_YOU.to_i.should == 7
+  end
+
+  specify "should work in user-defined modules" do
+    assert defined?(Mod::InnerEnum)
+
+    Mod::InnerEnum::INNER_1.to_i.should == 0
+    Mod::InnerEnum::INNER_2.to_i.should == 1
+  end
+
+  specify "should allow use of enumerations as types" do
+    what_test_enum(TestEnum::VALUE1).should == "We gots enum 0";
+
+    # Types should be adhered to
+    should.raise RuntimeError do
+      what_test_enum(Mod::InnerEnum::INNER_1)
+    end
+
+    t = Tester.new
+    t.get_enum_description(Tester::MyEnum::YOU_LIKE_MONEY_TOO).should == "You like money!"
+  end
+
+  specify "should properly build to_ruby converters for const enum return types" do
+    t = Tester.new
+    t.get_an_enum("I like money").should == Tester::MyEnum::I_LIKE_MONEY
+    t.get_an_enum("You like money").should == Tester::MyEnum::YOU_LIKE_MONEY_TOO
+  end
+end

data/test/file_writers_test.rb

@@ -23,10 +23,10 @@ context "Multiple file writer (default)" do
 
     %w(
       extconf.rb
-      Mod.rb.cpp
-      Mod.rb.hpp
-      classes_Adder.rb.cpp
-      classes_Adder.rb.hpp
+      _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}"
@@ -35,6 +35,37 @@ context "Multiple file writer (default)" do
 
 end
 
+context "Multiple file writer with to_from_ruby" do
+
+  setup do
+    @working_dir = File.expand_path(File.dirname(__FILE__) + "/generated")
+
+    e = Extension.new "to_from_ruby"
+    e.working_dir = @working_dir
+    e.sources full_dir("headers/to_from_ruby.h"),
+      :include_paths => full_dir("headers"),
+      :include_source_files => full_dir("headers/to_from_ruby_source.cpp")
+
+    e.namespace "to_from_ruby"
+
+    e.build
+    e.write
+  end
+
+  specify "should have proper written out files" do
+    files = Dir["#{@working_dir}/*"]
+
+    %w(
+      extconf.rb
+      _to_from_ruby.rb.hpp
+      _to_from_ruby.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
@@ -66,3 +97,24 @@ context "Single file writer" do
   end
 
 end
+
+context "Single file writer with to_from_ruby" do
+
+  setup do
+    Extension.new "to_from_ruby" do |e|
+      e.sources full_dir("headers/to_from_ruby.h"),
+        :include_paths => full_dir("headers"),
+        :include_source_files => full_dir("headers/to_from_ruby_source.cpp")
+      e.namespace "to_from_ruby"
+
+      e.writer_mode :single
+    end
+
+  end
+
+  specify "should have compiled properly" do
+    should.not.raise LoadError do
+      require 'to_from_ruby'
+    end
+  end
+end

data/test/generated/extconf.rb

@@ -1,5 +1,25 @@
-require "rubygems"
-require "mkmf-rice"
-$CPPFLAGS = $CPPFLAGS + " -I/home/roelofs/projects/rbplusplus/test/generated  "
-$LDFLAGS = $LDFLAGS + "   "
-create_makefile("adder")
+require 'rubygems'
+require 'mkmf-rice'
+
+# Add the arguments to the linker flags.
+def append_ld_flags(flags)
+  flags = [flags] unless flags.is_a?(Array)
+  with_ldflags("#{$LDFLAGS} #{flags.join(' ')}") { true }
+end
+
+$CPPFLAGS += " -I'/home/roelofs/projects/rbplusplus/test/generated' -I/home/roelofs/projects/rbplusplus/test/headers "
+$LDFLAGS += "   "
+
+if RUBY_PLATFORM =~ /darwin/
+  # In order to link the shared library into our bundle with GCC 4.x on OSX, we have to work around a bug:
+  #   GCC redefines symbols - which the -fno-common prohibits.  In order to keep the -fno-common, we
+  #   remove the flat_namespace (we now have two namespaces, which fixes the GCC clash).  Also, we now lookup
+  #   symbols in both the namespaces (dynamic_lookup).
+
+  $LDSHARED_CXX.gsub!('suppress', 'dynamic_lookup')
+  $LDSHARED_CXX.gsub!('-flat_namespace', '')
+  
+  append_ld_flags '-all_load'
+end
+
+create_makefile("to_from_ruby")

data/test/headers/class_methods.h

@@ -0,0 +1,41 @@
+namespace encapsulation {
+  class Base {
+    protected:
+      virtual int protectedMethod() {
+        return -1;
+      }
+    public:
+      virtual int fundamentalTypeVirtualMethod() = 0;
+      virtual ~Base() {}
+      virtual Base *userDefinedTypeVirtualMethod() = 0;
+  };
+  
+  class Extended : public Base {
+    private:
+      void privateMethod() {
+      }
+    protected:
+      int protectedMethod() {
+        return 1;
+      }
+    public:
+      Extended() {}
+      int publicMethod() {
+        return this->protectedMethod();
+      }
+      int fundamentalTypeVirtualMethod() {
+        return 1;
+      }
+      Base *userDefinedTypeVirtualMethod() {
+        return new Extended();
+      }
+  };
+  
+  class ExtendedFactory {
+  public:
+    ExtendedFactory() {}
+    Base *newInstance() {
+      return new Extended();
+    }
+  };
+}

data/test/headers/complex_static_methods.h

@@ -0,0 +1,25 @@
+#ifndef __COMPLEX_H__
+#define __COMPLEX_H__
+
+namespace complex {
+  class SmallInteger {
+  private:
+    int i;
+  public:
+    SmallInteger(int i) {
+      this->i = i;
+    }
+    int getI() {
+      return this->i;
+    }
+  };
+  
+  class Multiply {
+    public:
+    static int multiply(SmallInteger *i, SmallInteger *i2) {
+      return i->getI() * i2->getI();
+    }
+  };
+}
+
+#endif

data/test/headers/constructors.h

@@ -0,0 +1,47 @@
+#ifndef __CONSTRUCTORS_H__
+#define __CONSTRUCTORS_H__
+
+#include <string>
+
+using namespace std;
+
+namespace constructors {
+  class StringHolder {
+    private:
+      std::string name;
+    public:
+      StringHolder() { }
+      StringHolder(std::string name) {
+        setName(name);
+      }
+      inline std::string getName() {
+        return name;
+      }
+      inline void setName(std::string name) {
+        this->name = name;
+      }
+  };
+  
+  class DoubleStringHolder {
+    private:
+      StringHolder *one, *two;
+    public:
+      DoubleStringHolder(StringHolder *one, StringHolder *two) {
+        this->one = one;
+        this->two = two;
+      }
+      inline StringHolder *getOne() {
+        return this->one;
+      }
+      inline StringHolder *getTwo() {
+        return this->two;
+      }
+  };
+  
+  class PrivateConstructor {
+    private:
+      PrivateConstructor() {}
+  };
+}
+
+#endif