rbplusplus 0.8 → 0.9

data/lib/rbplusplus.rb

@@ -1,7 +1,7 @@
 $:.unshift File.expand_path(File.dirname(__FILE__))
 $:.unshift File.expand_path(File.dirname(__FILE__) + "/rbplusplus")
 
-gem 'rbgccxml'
+require 'rubygems'
 require 'rbgccxml'
 
 require 'inflector'
@@ -15,23 +15,50 @@ module RbPlusPlus
 
   RBPP_COMMENT = "// This file generated by rb++"
 
-  autoload :Extension, "rbplusplus/extension"
-  autoload :RbModule, "rbplusplus/module"
+  autoload :Extension,                "rbplusplus/extension"
+  autoload :RbModule,                 "rbplusplus/module"
+  autoload :Logger,                   "rbplusplus/logger"
 
   module Builders
-    autoload :Base, "rbplusplus/builders/base"
-    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"
+
+    autoload :Base,                   "rbplusplus/builders/base"
+    autoload :ExtensionNode,          "rbplusplus/builders/extension"
+
+    autoload :ConstNode,              "rbplusplus/builders/const"
+    autoload :ModuleNode,             "rbplusplus/builders/module"
+    autoload :IncludeNode,            "rbplusplus/builders/include"
+    autoload :EnumerationNode,        "rbplusplus/builders/enumeration"
+
+    # Class related nodes
+    autoload :ClassNode,              "rbplusplus/builders/class"
+    autoload :DirectorNode,           "rbplusplus/builders/director"
+    autoload :ConstructorNode,        "rbplusplus/builders/constructor"
+    autoload :InstanceVariableNode,   "rbplusplus/builders/instance_variable"
+
+    # Rice type-management nodes
+    autoload :ConstConverterNode,     "rbplusplus/builders/const_converter"
+    autoload :AllocationStrategyNode, "rbplusplus/builders/allocation_strategy"
+
+    # Method Nodes
+    autoload :MethodBase,             "rbplusplus/builders/method_base"
+    autoload :MethodNode,             "rbplusplus/builders/method"
+    autoload :StaticMethodNode,       "rbplusplus/builders/static_method"
+    autoload :DirectorMethodNode,     "rbplusplus/builders/director_method"
+    autoload :ModuleFunctionNode,     "rbplusplus/builders/module_function"
+    autoload :GlobalFunctionNode,     "rbplusplus/builders/global_function"
+
+    # Helpers
+    autoload :ClassHelpers,           "rbplusplus/builders/helpers/class"
+    autoload :EnumerationHelpers,     "rbplusplus/builders/helpers/enumeration"
+    autoload :ModuleHelpers,          "rbplusplus/builders/helpers/module"
+
   end
 
   module Writers
-    autoload :Base, "rbplusplus/writers/base"
-    autoload :ExtensionWriter, "rbplusplus/writers/extension"
-    autoload :MultipleFilesWriter, "rbplusplus/writers/multiple_files_writer"
-    autoload :SingleFileWriter, "rbplusplus/writers/single_file_writer"
+    autoload :Base,                   "rbplusplus/writers/base"
+    autoload :ExtensionWriter,        "rbplusplus/writers/extension"
+    autoload :MultipleFilesWriter,    "rbplusplus/writers/multiple_files_writer"
+    autoload :SingleFileWriter,       "rbplusplus/writers/single_file_writer"
   end
 end
 
@@ -39,18 +66,17 @@ class String #:nodoc:
   # Functionize attempts to rename a string in a cpp function friendly way.
   #
   # vector<float>::x => vector_float__x
-  def functionize
+  def as_variable
     gsub("::","_").gsub(/[ ,<>]/, "_").gsub("*", "Ptr")
   end
 end
 
+# Transformer classes that reopen RbGCCXML classes to add functionality
 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'
+require 'rbplusplus/transformers/method'
+require 'rbplusplus/transformers/namespace'
 

data/test/allocation_strategies_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Allocation Strategies" do
+
+  def setup
+    if !defined?(@@alloc_strat_built)
+      super
+      @@alloc_strat_built = true 
+      Extension.new "alloc_strats" do |e|
+        e.sources full_dir("headers/alloc_strats.h")
+        node = e.namespace "alloc_strats"
+      end
+    end
+  end
+
+  # The test here is simple because if the allocation
+  # strategies aren't properly defined, the extension
+  # won't even compile. GCC will complain about trying to
+  # instantiate an object with a non-public constructor
+  # and it all dies.
+  specify "properly figures out what allocation to do" do
+    assert_nothing_raised LoadError  do
+      require 'alloc_strats'
+    end 
+
+    # Private constructor, public destructor
+    assert defined?(NoConstructor)
+
+    # Private constructor and destructor
+    assert defined?(Neither)
+  end
+
+end

data/test/class_methods_encapsulate_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+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
+
+  specify "don't wrap methods that use non-public types in their arguments" do
+    arg = ArgumentAccess.new
+
+    # Single argument methods
+    should.raise NoMethodError do
+      arg.wrap_me_private
+    end
+    should.raise NoMethodError do
+      arg.wrap_me_protected
+    end
+
+    should.not.raise NoMethodError do
+      arg.wrap_me_public ArgumentAccess::PublicStruct.new
+    end
+    
+    # Multiple argument methods
+    should.raise NoMethodError do
+      arg.wrap_me_many_no
+    end
+    should.not.raise NoMethodError do
+      arg.wrap_me_many_yes(1, 2.0, ArgumentAccess::PublicStruct.new)
+    end
+  end
+end
+

data/test/class_methods_test.rb

@@ -5,12 +5,12 @@ context "Correct handling of static methods" do
     if !defined?(@@complex_static)
       super
       @@complex_static = true 
-      Extension.new "complex" do |e|
+      Extension.new "complex_test" do |e|
         e.sources full_dir("headers/complex_static_methods.h")
         node = e.namespace "complex"
       end
 
-      require 'complex'
+      require 'complex_test'
     end
   end
 
@@ -20,36 +20,3 @@ context "Correct handling of static methods" do
   
 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

@@ -7,8 +7,19 @@ context "Extension with wrapped classes" do
       super
       @@adder_built = true 
       Extension.new "adder" do |e|
-        e.sources full_dir("headers/Adder.h")
-        e.namespace "classes"
+        e.sources full_dir("headers/Adder.h"),
+          :include_source_files => [
+            full_dir("headers/Adder.h"),
+            full_dir("headers/Adder.cpp")
+          ]
+        node = e.namespace "classes"
+        adder = node.classes("Adder")
+        adder.use_constructor(
+          adder.constructors.find(:arguments => [])
+        )
+
+        adder.constants("HideMe").ignore
+        adder.disable_typedef_lookup
       end
 
       require 'adder'
@@ -38,5 +49,64 @@ context "Extension with wrapped classes" do
     Adder.do_adding(1, 2, 3, 4, 5).should == 15
   end
 
+  specify "should use typedefs when findable" do
+    assert defined?(IntAdder), "Did not use the typedef for TemplateAdder"
+  end
+
+  specify "finds and uses multi-nested typedefs" do
+    assert defined?(ShouldFindMe), "Didn't find top level typedef for NestedTemplate"
+  end
+
+  specify "can turn off typedef lookup for certain classes" do
+    assert !defined?(DontFindMeBro), "Found a typedef we shouldn't have"
+  end
+
+  specify "makes class constants available" do
+    Adder::MY_VALUE.should == 10
+  end
+
+  specify "can ignore constants" do
+    assert !defined?(Adder::HideMe), "Found HideMe when I shouldn't have"
+  end
+
+  specify "makes public instance variables accessible" do
+    a = Adder.new
+    a.value1 = 10
+    a.value2 = 15.5
+    a.value3 = "This is a value!"
+    a.should_be_transformed = "TRANSFORM"
+
+    a.value1.should.equal 10
+    a.value2.should.be.close 15.5, 0.01
+    a.value3.should.equal "This is a value!"
+
+    a.should_be_transformed.should.equal "TRANSFORM"
+  end
+
+  specify "const variables are exported as read-only" do
+    a = Adder.new
+
+    should.raise NoMethodError do
+      a.const_var = "This is a value!"
+    end
+
+    a.const_var.should.equal 14
+  end
+
+  specify "can subclass a wrapped class and go from there" do
+    class MyAdder < Adder
+      def add_integers(a, b)
+        a * b
+      end
+
+      def add_strings(a, b)
+        super(a, b) + "woot"
+      end
+    end
+
+    a = MyAdder.new
+    a.add_integers(3, 7).should.equal 21
+    a.add_strings("piz", "owned").should.equal "pizownedwoot"
+  end
 end
 

data/test/compiling_test.rb

@@ -156,4 +156,17 @@ context "Compiler settings" do
     # is a symbol lookup failure and death to the Ruby VM
     needs_to_ruby(3).value.should == 3
   end
+
+  specify "can specify a directory containing code to be included into compilation process" do
+    Extension.new "code_dir" do |e|
+      e.sources full_dir("headers/needs_code.h"),
+        :include_source_dir => full_dir("headers/code")
+
+      e.namespace "needs_code"
+    end
+
+    require 'code_dir'
+
+    get_number(2).should == 2
+  end
 end

data/test/constructors_test.rb

@@ -2,34 +2,25 @@ 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
+  specify "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"
+      node.classes("DoubleStringHolder").use_constructor(
+        node.classes("DoubleStringHolder").constructors.find(:arguments => [nil, nil])
+      )
     end
 
+    require 'constructors'
+
     should.not.raise NameError do
       # Test complex constructors
-      d = DoubleStringHolder.new(StringHolder.new("one"), StringHolder.new("two"))
+      d = DoubleStringHolder.new("one", "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"
+      d.get_one.should == "one"
+      d.get_two.should == "two"
     end
     
     should.raise TypeError do

data/test/custom_code_test.rb

@@ -0,0 +1,53 @@
+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"),
+          :include_source_files => [
+            full_dir("headers/Adder.h"),
+            full_dir("headers/Adder.cpp")
+          ]
+        node = e.namespace "classes"
+        adder = node.classes("Adder")
+
+        adder.use_constructor( adder.constructors.find(:arguments => []))
+        adder.disable_typedef_lookup
+
+        decl = <<-END
+int subtractIntegers(classes::Adder* self, int a, int b) {
+  return a - b;
+}
+
+int multiplyIntegers(classes::Adder* self, int a, int b) {
+  return a * b;
+}
+        END
+
+        wrapping = <<-END
+<class>.define_method(\"sub_ints\", &subtractIntegers);
+<class>.define_method(\"mult_ints\", &multiplyIntegers);
+END
+
+        adder.add_custom_code( decl, wrapping )
+      end
+
+      require 'adder'
+    end
+  end
+
+  specify "Adder has new custom methods" do
+    a = Adder.new
+    a.should.respond_to(:sub_ints)
+    a.should.respond_to(:mult_ints)
+
+    a.sub_ints(5, 4).should.equal 1
+    a.mult_ints(5, 4).should.equal 20
+  end
+
+end
+

data/test/default_arguments_test.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Default arguments properly exposed" do
+
+  def setup
+    if !defined?(@@defargs_built)
+      super
+      @@defargs_built = true 
+      Extension.new "defargs" do |e|
+        e.sources full_dir("headers/default_arguments.h")
+        e.writer_mode :single
+        node = e.namespace "default_args"
+
+        e.module "Inner" do |m|
+          m.includes node.functions("module_do")
+        end
+
+        node.classes("Directed").director
+      end
+
+      require 'defargs'
+    end
+  end
+
+  specify "global functions" do
+    global_do(1, 4, 5).should.equal 20
+    global_do(1, 4).should.equal 40
+    global_do(1).should.equal 30
+  end
+
+  specify "module functions" do
+    Inner.module_do(5).should.equal 18
+    Inner.module_do(5, 5).should.equal 20
+    Inner.module_do(5, 5, 5).should.equal 15
+  end
+
+  specify "class instance methods" do
+    tester = Tester.new
+    tester.concat("this", "that").should.equal "this-that"
+    tester.concat("this", "that", ";").should.equal "this;that"
+  end
+
+  specify "class static methods" do
+    Tester.build("base").should.equal "basebasebase"
+    Tester.build("woot", 5).should.equal "wootwootwootwootwoot"
+  end
+
+  specify "director methods" do
+    d = Directed.new
+    d.virtual_do(3).should.equal 30
+    d.virtual_do(3, 9).should.equal 27
+
+    class MyD < Directed
+      def virtual_do(x, y = 10)
+        super(x * 3, y)
+      end
+    end
+
+    myd = MyD.new
+    myd.virtual_do(10).should.equal 300
+  end
+
+  specify "throw argument error on bad types" do
+    should.raise TypeError do
+      global_do(1, "three")
+    end
+  end
+
+end

data/test/director_test.rb

@@ -0,0 +1,173 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Director proxy generation" do
+
+  def setup
+    if !defined?(@@director_built)
+      super
+      @@director_built = true
+      Extension.new "director" do |e|
+        e.sources full_dir("headers/director.h")
+
+        node = e.namespace "director"
+
+        # As director is pretty complicated to get right
+        # automatically for now, we force-specify which
+        # classes to have directors set on.
+        %w(Worker MultiplyWorker BadNameClass VirtualWithArgs NoConstructor VBase VOne VTwo).each do |k|
+          node.classes(k).director
+        end
+
+        node.classes("Worker").methods("doProcessImpl").default_return_value(0)
+
+        klass = node.classes("BadNameClass")
+        klass.wrap_as("BetterNamedClass")
+        klass.methods("_is_x_ok_to_run").wrap_as("x_ok?")
+        klass.methods("__do_someProcessing").wrap_as("do_processing")
+      end
+
+      require 'director'
+    end
+  end
+
+  specify "polymorphic calls extend into Ruby" do
+    class MyWorker < Worker
+      def process(num)
+        num + 10
+      end
+    end
+
+    h = Handler.new
+    h.add_worker(MyWorker.new)
+
+    h.process_workers(5).should.equal 15
+  end
+
+  specify "super calls on pure virtual raise exception" do
+    class SuperBadWorker < Worker
+      def process(num)
+        super + 10
+      end
+    end
+
+    should.raise NotImplementedError do
+      SuperBadWorker.new.process(10)
+    end
+  end
+
+  specify "allows super calls to continue back into C++ classes" do
+    class SuperGoodWorker < Worker
+      def do_something(num)
+        super + 10
+      end
+    end
+
+    should.not.raise NotImplementedError do
+      SuperGoodWorker.new.do_something(10).should.equal 50
+    end
+  end
+
+  specify "can specify a default return value in the wrapper" do
+    class MyAwesomeWorker < Worker
+      def do_process_impl(num)
+        num + 7
+      end
+
+      def process(num)
+        num + 8
+      end
+    end
+
+    w = MyAwesomeWorker.new
+    w.do_process(3).should.equal 10
+
+    h = Handler.new
+    h.add_worker(w)
+
+    h.process_workers(10).should.equal 18
+  end
+
+  specify "properly adds all constructor arguments" do
+    v = VirtualWithArgs.new 14, true
+    v.process_a("hi").should.equal 16
+    v.process_b.should.be true
+  end
+
+  specify "takes into account renamed methods / classes" do
+    c = BetterNamedClass.new
+    assert !c.x_ok?
+
+    c.do_processing.should.equal 14
+  end
+
+  specify "handles no constructors" do
+    class MyThing < NoConstructor
+    end
+
+    n = MyThing.new
+    n.do_something.should.equal 4
+  end
+
+  specify "only builds method wrappers for virtual methods" do
+    class NumberWorker < Worker
+      def get_number
+        super + 15
+      end
+    end
+
+    # Super calls still work
+    w = NumberWorker.new
+    w.get_number.should.equal 27
+
+    # But polymorphism stops in the C++
+    h = Handler.new
+    h.add_worker(w)
+
+    h.add_worker_numbers.should.equal 12
+  end
+
+  specify "Directors implement all pure virtual methods up the inheritance tree" do
+    vbase = VBase.new
+    v1 = VOne.new
+    v2 = VTwo.new
+
+    v1.method_one.should.equal "methodOne"
+
+    should.raise NotImplementedError do
+      v1.method_two
+    end
+    should.raise NotImplementedError do
+      v1.method_three
+    end
+
+    v2.method_one.should.equal "methodOne"
+    v2.method_two.should.equal "methodTwo"
+
+    should.raise NotImplementedError do
+      v2.method_three
+    end
+  end
+
+  specify "handles superclasses of the class with virtual methods" do
+    class QuadWorker < MultiplyWorker
+      def process(num)
+        num * 4
+      end
+    end
+
+    h = Handler.new
+
+    h.add_worker(MultiplyWorker.new)
+    h.process_workers(5).should.equal 10
+
+    h.add_worker(QuadWorker.new)
+    h.process_workers(5).should.equal 40
+  end
+
+  specify "multiple files writer properly handles directors and nested nodes" do
+    assert defined?(Worker::ZeeEnum)
+    assert defined?(Worker::ZeeEnum::VALUE)
+    Worker::ZeeEnum::VALUE.to_i.should.equal 4
+  end
+
+end