rbplusplus 0.8 → 0.9

data/test/enumerations_test.rb

@@ -27,6 +27,11 @@ context "Wrapping enumerations" do
     TestEnum::VALUE2.to_i.should == 1
     TestEnum::VALUE3.to_i.should == 2
   end
+  
+  specify "should only wrap public enums" do
+    assert !defined?(Tester::NotWrapped)
+    assert !defined?(Tester::AlsoNotWrapped)
+  end
 
   specify "should wrap up enumerations at proper nesting" do
     assert defined?(Tester::MyEnum)
@@ -60,4 +65,28 @@ context "Wrapping enumerations" do
     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
+
+  specify "anonymous enumerations' values are added as constants to the parent class" do
+    assert defined?(Tester::ANON_ENUM_VAL1)
+    assert defined?(Tester::ANON_ENUM_VAL2)
+    assert defined?(Tester::ANON_ENUM_VAL3)
+    assert defined?(Tester::ANON_ENUM_VAL4)
+
+    Tester::ANON_ENUM_VAL1.should.equal 1
+    Tester::ANON_ENUM_VAL2.should.equal 2
+    Tester::ANON_ENUM_VAL3.should.equal 5
+    Tester::ANON_ENUM_VAL4.should.equal 3
+  end
+
+  specify "top-level anonymous enumerations' values are added to the global scope" do
+    assert defined?(OUTER_ANON_1)
+    assert defined?(OUTER_ANON_2)
+    assert defined?(FOURTY_TWO)
+    assert defined?(SEPERATE_OUTER_VALUE)
+
+    OUTER_ANON_1.should.equal 0
+    OUTER_ANON_2.should.equal 1
+    FOURTY_TWO.should.equal 42
+    SEPERATE_OUTER_VALUE.should.equal 14
+  end
 end

data/test/extension_test.rb

@@ -5,6 +5,7 @@ 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")
+      e.writer_mode :single
     end
 
     should.not.raise LoadError do
@@ -16,6 +17,7 @@ context "Ruby Extension creation" 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.writer_mode :single
     e.build
     e.write
     e.compile
@@ -27,11 +29,14 @@ context "Ruby Extension creation" do
 
   specify "should properly build working dir as deep as needed" do
     should.not.raise Errno::ENOENT do
+      path = File.join(File.expand_path(File.dirname(__FILE__)), "generated", "path1", "path2")
       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")
+        e.working_dir = path
+        e.writer_mode :single
       end
+
+      assert File.exists?(File.join(path, "extconf.rb"))
     end
   end
 end

data/test/file_writers_test.rb

@@ -10,7 +10,8 @@ context "Multiple file writer (default)" do
     e.sources full_dir("headers/Adder.h")
 
     e.module "Mod" do |m|
-      m.namespace "classes"
+      node = m.namespace "classes"
+      node.classes("Adder").disable_typedef_lookup
     end
 
     e.build
@@ -19,7 +20,7 @@ context "Multiple file writer (default)" do
 
   specify "should properly split up code into multiple files" do
     files = Dir["#{@working_dir}/*"]
-    files.size.should == 6
+    files.size.should == 12
 
     %w(
       extconf.rb
@@ -27,6 +28,12 @@ context "Multiple file writer (default)" do
       _Mod.rb.hpp
       _classes_Adder.rb.cpp
       _classes_Adder.rb.hpp
+      _classes_IntAdder.rb.cpp
+      _classes_IntAdder.rb.hpp
+      _classes_ShouldFindMe.rb.hpp
+      _classes_ShouldFindMe.rb.cpp
+      _rbpp_custom.rb.hpp
+      _rbpp_custom.rb.cpp
       adder.rb.cpp
     ).each do |wants|
       assert_not_nil files.find {|got| File.basename(got) == wants }, "Didn't find #{wants}"
@@ -57,8 +64,8 @@ context "Multiple file writer with to_from_ruby" do
 
     %w(
       extconf.rb
-      _to_from_ruby.rb.hpp
-      _to_from_ruby.rb.cpp
+      _rbpp_custom.rb.hpp
+      _rbpp_custom.rb.cpp
     ).each do |wants|
       assert_not_nil files.find {|got| File.basename(got) == wants }, "Didn't find #{wants}"
     end

data/test/function_pointer_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "properly handles and wraps function pointer arguments" do
+
+  def setup
+    if !defined?(@@function_pointers)
+      super
+      @@function_pointers = true 
+      Extension.new "function_pointers" do |e|
+        e.sources full_dir("headers/function_pointers.h")
+        node = e.namespace "function_pointers"
+      end
+
+      require 'function_pointers'
+    end
+  end
+
+  specify "no arguments, no return" do
+    proc_called = false
+
+    set_callback do
+      proc_called = true
+    end
+
+    call_callback
+
+    assert proc_called
+  end
+
+  specify "arguments, no return" do
+    proc_arg = nil
+
+    set_callback_with_args do |i|
+      proc_arg = i
+    end
+
+    call_callback_with_args(10)
+
+    proc_arg.should == 10
+  end
+
+  specify "arguments and return" do
+    proc_arg = nil
+    set_callback_returns do |i|
+      proc_arg = i
+      i * 10
+    end
+
+    ret = call_callback_returns(8)
+
+    proc_arg.should == 8
+    ret.should == 80
+  end
+
+end
+

data/test/function_pointers_classes_test.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Function pointers into class methods" do
+
+  def setup
+    if !defined?(@@function_pointers_class)
+      super
+      @@function_pointers_class = true 
+      Extension.new "function_pointers_class" do |e|
+        e.sources full_dir("headers/function_pointers_class.h")
+        node = e.namespace "function_pointers_class"
+      end
+
+      require 'function_pointers_class'
+    end
+  end
+
+
+  specify "works" do
+    t = PointerTest.new
+    t.set_callback do |i|
+      42
+    end
+
+    t.call_callback(12).should == 42
+  end
+end

data/test/generated/extconf.rb

@@ -7,7 +7,7 @@ def append_ld_flags(flags)
   with_ldflags("#{$LDFLAGS} #{flags.join(' ')}") { true }
 end
 
-$CPPFLAGS += " -I'/home/roelofs/projects/rbplusplus/test/generated' -I/home/roelofs/projects/rbplusplus/test/headers "
+$CPPFLAGS += " -I'/home/roelofs/projects/rbplusplus/test/generated'  "
 $LDFLAGS += "   "
 
 if RUBY_PLATFORM =~ /darwin/
@@ -22,4 +22,4 @@ if RUBY_PLATFORM =~ /darwin/
   append_ld_flags '-all_load'
 end
 
-create_makefile("to_from_ruby")
+create_makefile("function_pointers_class")

data/test/headers/Adder.cpp

@@ -0,0 +1,8 @@
+#include "Adder.h"
+
+namespace classes {
+  const int Adder::MY_VALUE = 10;
+  const float Adder::HideMe = 14.35;
+
+  Adder::Adder() : const_var(14) { }
+}

data/test/headers/Adder.h

@@ -7,7 +7,11 @@ using namespace std;
 namespace classes {
   class Adder {
     public:
-      Adder() { }
+      Adder();
+
+      static const int MY_VALUE;
+
+      static const float HideMe;
 
       static int doAdding(int a, int b, int c, int d, int e) {
         return a + b + c + d + e;
@@ -20,7 +24,33 @@ namespace classes {
       string addStrings(string a, string b) { return a + b; }
 
       string getClassName() { return "Adder"; }
+
+      int value1;
+      float value2;
+      string value3;
+
+      string shouldBeTransformed;
+
+      const int const_var;
+  };
+
+  template<typename T>
+  class TemplateAdder {
+
   };
+
+  typedef TemplateAdder<int> IntAdder;
+
+  template<typename T>
+  class NestedTemplate {
+
+  };
+
+  typedef NestedTemplate<int> SuperTemplate;
+  typedef SuperTemplate MiddleTypedef;
+  typedef MiddleTypedef ShouldFindMe;
+
+  typedef Adder DontFindMeBro;
 }
 
 #endif 

data/test/headers/alloc_strats.h

@@ -0,0 +1,26 @@
+#ifndef __ALLOC_STRATS_H__
+#define __ALLOC_STRATS_H__
+
+namespace alloc_strats {
+
+  class NoConstructor {
+    public:
+      ~NoConstructor() { }
+
+    private:
+      NoConstructor() { }
+  };
+
+  class Neither {
+    private:
+      Neither() {}
+      ~Neither() {}
+    public:
+      NoConstructor* getConstructor() { return 0; }
+
+      Neither* getInstance() { return 0; }
+  };
+}
+
+
+#endif

data/test/headers/class_methods.h

@@ -1,3 +1,6 @@
+#ifndef __ENCAPSULATE_H__
+#define __ENCAPSULATE_H__
+
 namespace encapsulation {
   class Base {
     protected:
@@ -38,4 +41,31 @@ namespace encapsulation {
       return new Extended();
     }
   };
+
+  class ArgumentAccess {
+    struct PrivateStruct { }; 
+
+  protected:
+    struct ProtStruct { };
+
+  public:
+    struct PublicStruct { 
+      PublicStruct() {}
+    };
+
+    ArgumentAccess() {}
+    ~ArgumentAccess() {}
+
+    // Only wrap methods that use public structs
+    void wrapMePrivate(PrivateStruct st) { }
+    void wrapMeProtected(ProtStruct st) { }
+    void wrapMePublic(PublicStruct st) { }
+
+    // And make sure it works with multiple arguments
+    void wrapMeManyNo(int a, float b, PublicStruct st1, ProtStruct st2) { }
+    void wrapMeManyYes(int a, float b, PublicStruct st1) { }
+
+  };
 }
+
+#endif

data/test/headers/code/custom_to_from_ruby.cpp

@@ -0,0 +1,11 @@
+#include "custom_to_from_ruby.hpp"
+
+template<>
+Rice::Object to_ruby<short int>(short int const & a) {
+  return INT2NUM(a);
+}
+
+template<>
+short int from_ruby<short int>(Rice::Object x) {
+  return FIX2INT(x.value());
+}

data/test/headers/code/custom_to_from_ruby.hpp

@@ -0,0 +1,13 @@
+#ifndef __CUSTOM_TO_RUBY_H__
+#define __CUSTOM_TO_RUBY_H__
+
+#include <rice/Object.hpp>
+#include <rice/to_from_ruby.hpp>
+
+template<>
+Rice::Object to_ruby<short int>(short int const & a);
+
+template<>
+short int from_ruby<short int>(Rice::Object x);
+
+#endif

data/test/headers/constructors.h

@@ -6,34 +6,22 @@
 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;
+      std::string one, two;
     public:
-      DoubleStringHolder(StringHolder *one, StringHolder *two) {
+
+      DoubleStringHolder(std::string one, std::string two) {
         this->one = one;
         this->two = two;
       }
-      inline StringHolder *getOne() {
+
+      DoubleStringHolder() { }
+
+      inline std::string getOne() {
         return this->one;
       }
-      inline StringHolder *getTwo() {
+      inline std::string getTwo() {
         return this->two;
       }
   };

data/test/headers/default_arguments.h

@@ -0,0 +1,49 @@
+#ifndef __DEFAULT_ARGS_H__
+#define __DEFAULT_ARGS_H__
+
+#include <string>
+#include <iostream>
+using namespace std;
+
+namespace default_args {
+
+  // Global functions
+  int global_do(int x, int y = 3, int z = 10) {
+    return x * y * z;
+  }
+
+  // Module functions
+  int module_do(int x, int y = 3, int z = 10) {
+    return x + y + z;
+  }
+
+  class Tester {
+    public:
+      Tester() { }
+
+      // Class methods 
+      std::string concat(std::string value1, std::string value2, const char* with = "-") {
+        return value1 + std::string(with) + value2;
+      }
+
+      // Class static methods
+      static std::string build(std::string base, int times = 3) {
+        std::string out = "";
+        for(int i = 0; i < times; i++) {
+          out += base;
+        }
+        return out;
+      }
+  };
+
+  class Directed {
+    public:
+      // Director methods
+      virtual int virtualDo(int x, int y = 10) {
+        return x * y;
+      }
+  };
+  
+}
+
+#endif // __DEFAULT_ARGS_H__

data/test/headers/director.h

@@ -0,0 +1,148 @@
+#ifndef __DIRECTOR__H__
+#define __DIRECTOR__H__
+
+#include <vector>
+#include <string>
+
+namespace director {
+
+  /**
+   * Abstract base class
+   */
+  class Worker {
+    public:
+      virtual ~Worker() {  }
+
+      enum ZeeEnum {
+        VALUE = 4
+      };
+
+      int getNumber() { return 12; }
+
+      virtual int doSomething(int num) { return num * 4; }
+      
+      virtual int process(int num) = 0;
+
+      virtual int doProcess(int num) { return doProcessImpl(num); }
+      virtual int doProcessImpl(int num) const = 0;
+  };
+
+  /**
+   * Subclass that implements pure virtual
+   */
+  class MultiplyWorker : public Worker {
+    public:
+      virtual ~MultiplyWorker() { }
+
+      virtual int process(int num) { return num * 2; }
+  };
+
+  /**
+   * Class to handle workers
+   */
+  class Handler {
+    std::vector<Worker*> mWorkers;
+
+    public:
+
+      void addWorker(Worker* worker) { mWorkers.push_back(worker); }
+
+      int processWorkers(int start) {
+        std::vector<Worker*>::iterator i = mWorkers.begin();
+        int results = start;
+
+        for(; i != mWorkers.end(); i++) {
+          results = (*i)->process(results);
+        }
+
+        return results;
+      }
+
+      int addWorkerNumbers() {
+        std::vector<Worker*>::iterator i = mWorkers.begin();
+        int results = 0;
+
+        for(; i != mWorkers.end(); i++) {
+          results += (*i)->getNumber();
+        }
+
+        return results;
+      }
+  };
+
+
+  /**
+   * Testing renaming works w/ directors
+   */
+  class BadNameClass {
+    public:
+      BadNameClass() { }
+
+      virtual bool _is_x_ok_to_run() { return false; }
+
+      virtual int __do_someProcessing() { return 14; }
+  };
+
+  /**
+   * Testing constructor args
+   */
+  class VirtualWithArgs {
+    int a_;
+    bool b_;
+    public:
+      VirtualWithArgs(int a, bool b) {
+        a_ = a;
+        b_ = b;
+      }
+
+      virtual int processA(std::string in) {
+        return in.length() + a_;
+      }
+
+      virtual bool processB() {
+        return b_;
+      }
+  };
+
+  /**
+   * Testing non-public constructors
+   */
+  class NoConstructor {
+    protected:
+      NoConstructor() { }
+      NoConstructor(const NoConstructor&) { }
+
+    public:
+      virtual int doSomething() { return 4; }
+  };
+
+  /**
+   * Test inheritance heirarchy with virtual methods
+   * throughout the tree
+   */
+  class VBase {
+    public:
+      VBase() { }
+      virtual ~VBase() { }
+
+      virtual std::string methodOne() = 0;
+      virtual std::string methodTwo() = 0;
+      virtual std::string methodThree() = 0;
+  };
+
+  class VOne : public VBase { 
+    public:
+      virtual std::string methodOne() {
+        return "methodOne";
+      }
+  };
+
+  class VTwo : public VOne {
+    public:
+      virtual std::string methodTwo() {
+        return "methodTwo";
+      }
+  };
+}
+
+#endif

data/test/headers/enums.h

@@ -15,6 +15,16 @@ namespace enums {
     VALUE3
   };
 
+  enum {
+    OUTER_ANON_1,
+    OUTER_ANON_2,
+    FOURTY_TWO = 42
+  };
+
+  enum {
+    SEPERATE_OUTER_VALUE = 14
+  };
+
   namespace inner {
     enum InnerEnum {
       INNER_1,
@@ -29,6 +39,16 @@ namespace enums {
   }
 
   class Tester {
+      enum NotWrapped {
+        I_IS_PRIVATE
+      };
+
+    protected:
+
+      enum AlsoNotWrapped {
+        CAUSE_I_IS_PROT
+      };
+
     public:
       Tester() {}
 
@@ -38,6 +58,19 @@ namespace enums {
         I_LIKE_YOU = 7
       };
 
+      /*
+       * Anonymous Enums
+       */
+      enum {
+        ANON_ENUM_VAL1 = 1
+      };
+
+      enum {
+        ANON_ENUM_VAL2 = 2,
+        ANON_ENUM_VAL3 = 5,
+        ANON_ENUM_VAL4 = 3
+      };
+
       std::string getEnumDescription(MyEnum e) {
         std::string ret;
         switch(e) {

data/test/headers/function_pointers.h

@@ -0,0 +1,32 @@
+/**
+ * Code to wrap and handle function callbacks by exposing them
+ * into Ruby as block arguments
+ */
+#ifndef __FUNCTION_POINTERS_H__
+#define __FUNCTION_POINTERS_H__
+
+namespace function_pointers {
+
+  // One that takes no argument, no return
+  typedef void(*Callback) (void);
+  Callback emptyCallback;
+
+  void setCallback(Callback cb) { emptyCallback = cb; }
+  void callCallback() { emptyCallback(); }
+
+  // With an argument, no return
+  typedef void(*ArgCallback) (int num);
+  ArgCallback argumentCallback;
+
+  void setCallbackWithArgs(ArgCallback cb) { argumentCallback = cb; }
+  void callCallbackWithArgs(int in) { argumentCallback(in); }
+
+  // With argument and returns a value
+  typedef int(*ReturnCallback) (int num);
+  ReturnCallback returnCallback;
+
+  void setCallbackReturns(ReturnCallback cb) { returnCallback = cb; }
+  int callCallbackReturns(int in) { return returnCallback(in); }
+}
+
+#endif