rbplusplus 0.1.1 → 0.8

data/test/headers/enums.h

@@ -0,0 +1,77 @@
+/**
+ * This header file is for testing wrapping and using enumerations
+ */
+
+#ifndef __ENUMS__H__
+#define __ENUMS__H__
+
+#include <iostream>
+#include <sstream>
+
+namespace enums {
+  enum TestEnum {
+    VALUE1,
+    VALUE2,
+    VALUE3
+  };
+
+  namespace inner {
+    enum InnerEnum {
+      INNER_1,
+      INNER_2
+    };
+  }
+
+  std::string whatTestEnum(TestEnum e) {
+    std::stringstream stream;
+    stream << "We gots enum " << e;
+    return stream.str();
+  }
+
+  class Tester {
+    public:
+      Tester() {}
+
+      enum MyEnum {
+        I_LIKE_MONEY = 3,
+        YOU_LIKE_MONEY_TOO,
+        I_LIKE_YOU = 7
+      };
+
+      std::string getEnumDescription(MyEnum e) {
+        std::string ret;
+        switch(e) {
+          case I_LIKE_MONEY:
+            ret = "I like money";
+            break;
+          case YOU_LIKE_MONEY_TOO:
+            ret = "You like money!";
+            break;
+          case I_LIKE_YOU:
+            ret = "I like you too";
+            break;
+          default:
+            ret = "What you say?";
+            break;
+        }
+
+        return ret;
+      }
+
+      MyEnum getAnEnum(std::string message) const {
+        MyEnum e;
+
+        if (message == "I like money") {
+          e = I_LIKE_MONEY;
+        } else if (message == "You like money") {
+          e = YOU_LIKE_MONEY_TOO;
+        } else if (message == "I like you") {
+          e = I_LIKE_YOU;
+        }
+        
+        return e;
+      }
+  };
+}
+
+#endif

data/test/headers/external_mapping.h

@@ -0,0 +1,16 @@
+#ifndef EXTERNAL_INCLUDE_TEST
+#define EXTERNAL_INCLUDE_TEST
+
+namespace ExternalIncludeTest {
+  class MapsToInt {
+    public:
+      MapsToInt(int x) {value=x;}
+      int value;
+  };
+  inline MapsToInt return100() {
+    return MapsToInt(100);
+  }
+
+}
+
+#endif

data/test/headers/external_mapping_rice.h

@@ -0,0 +1,20 @@
+//#ifndef USES_INLINE_DEPENDENCY
+//#define USES_INLINE_DEPENDENCY
+
+//#include "external_mapping.h"
+
+//#include "rice/Class.hpp"
+//#include "rice/Data_Type.hpp"
+//#include "rice/Constructor.hpp"
+//#include "rice/Enum.hpp"
+//#include "rice/to_from_ruby.hpp"
+//#include "rice/Address_Registration_Guard.hpp"
+
+//#include <ruby.h>
+
+//template<>
+//Rice::Object to_ruby<MapToInto>(MapToInt & x) {
+//	return to_ruby(x.value);
+//}
+
+//#endif

data/test/headers/include/helper.h

@@ -6,3 +6,4 @@ int helper(int a, int b) {
 }
 
 #endif
+

data/test/headers/nested_struct.h

@@ -0,0 +1,20 @@
+#ifndef __NESTED_STRUCT_H
+#define __NESTED_STRUCT_H
+
+namespace nested {
+  class Klass {
+    public:
+      struct NestedStruct {
+        public:
+          NestedStruct() {}
+          inline int one() { return 1; }
+      };
+    private:
+      struct PrivateNestedStruct {
+        public:
+          PrivateNestedStruct() {}
+      };
+  };
+}
+
+#endif

data/test/headers/overload.h

@@ -0,0 +1,28 @@
+#ifndef __METHOD_OVERLOAD_H__
+#define __METHOD_OVERLOAD_H__
+
+namespace overload {
+  class Mathy {
+    public:
+    Mathy() {}
+    Mathy(int x) {}
+    int times() {
+      return 1;
+    }
+    int times(int x) {
+      return x;
+    }
+    int times(int x, int y) {
+      return x*y;
+    }
+    long times(int x, int y, int z) {
+      return x*y*z;
+    }
+    void nothing() {}
+    void nothing(int x) {}
+    
+    const Mathy &self() const { return *this; }
+    Mathy &self() { return *this; }
+  };
+}
+#endif

data/test/headers/subclass.h

@@ -0,0 +1,42 @@
+#ifndef __SUBCLASS_H__
+#define __SUBCLASS_H__
+namespace subclass {
+  class SuperSuper {
+    public:
+    inline int minOne() { return -1; }
+  };
+  class Super : public SuperSuper {
+    public:
+    inline int zero() { return 0; }
+  };
+  class Base : public Super {
+    public:
+    inline int one() { return 1; }
+    Base() {}
+  };
+  class Sub : public Base {
+    public:
+    Sub() {}
+  };
+  
+  template<class T>
+  class TemplateSuper : public Super {
+    T val;
+    public: 
+    TemplateSuper(T val) {
+      this->val = val;
+    }
+    inline T custom() { return this->val; }
+  };
+  
+  class TemplateSub : public TemplateSuper<int> {
+    public:
+    TemplateSub() : TemplateSuper<int>(0) {}
+  };
+  
+  class TemplatePtr : public TemplateSuper<Base*> {
+    public:
+    TemplatePtr() : TemplateSuper<Base*>(new Base()) {}
+  };
+}
+#endif

data/test/headers/to_from_ruby.h

@@ -0,0 +1,78 @@
+#ifndef __TO_FROM_RUBY_H__
+#define __TO_FROM_RUBY_H__
+
+#include <string>
+
+namespace to_from_ruby {
+  
+  // Const methods that return references need an explicit to_ruby
+  // definition for the given type
+  class MyType {
+    public:
+    int myValue;
+
+    MyType() { myValue = 0; }
+
+    // Exposing attributes not implemented yet
+    int value() { return myValue; }
+  };
+
+  const MyType& needsToRuby(int value);
+
+  // But rb++ should only make one to_ruby definition or the compiler
+  // will poop
+  const MyType& someOtherMethod(int value);
+
+  // Should also work with class methods
+  class WrappedClass {
+    public:
+      WrappedClass() {}
+
+      const MyType& getMyType(int value) {
+        MyType *type = new MyType();
+        type->myValue = value;
+        return *type;
+      }
+      
+      const WrappedClass &overload() {
+        return *this;
+      }
+    
+      const WrappedClass &overload(int arg) {
+        return *this;
+      }
+  };
+
+  /**
+   * Some types, Rice already wraps for us. Make sure this doesn't cause
+   * a compiler error
+   */
+  void usingConstString(const std::string& in);
+  
+  /* template tests */
+  
+  template<class T>
+  class TemplateClass {
+    T val;
+    public:
+      TemplateClass(T val) {
+        this->val = val;
+      }
+      const T &overload() {
+        return this->val;
+      }
+      const T &overload(int arg) {
+        return this->val;
+      }
+  };
+  
+  inline const TemplateClass<int> &getTemplate() {
+    return *(new TemplateClass<int>(1));
+  }
+  
+  inline const TemplateClass<int> &getTemplate(int overload) {
+    return *(new TemplateClass<int>(overload));
+  }
+}
+
+#endif 

data/test/headers/to_from_ruby_source.cpp

@@ -0,0 +1,22 @@
+#include "to_from_ruby.h"
+
+namespace to_from_ruby {
+
+  const MyType& needsToRuby(int value) {
+    MyType *type = new MyType();
+    type->myValue = value;
+    return *type;
+  }
+
+  // But rb++ should only make one to_ruby definition or the compiler
+  // will poop
+  const MyType& someOtherMethod(int value) {
+    MyType *type = new MyType();
+    type->myValue = value;
+    return *type;
+  };
+
+  void usingConstString(const std::string& in) {
+
+  }
+}

data/test/headers/ugly_helper.h

@@ -0,0 +1,18 @@
+#ifndef UGLY_HELPER
+#define UGLY_HELPER
+
+#include "rice/Class.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+#include "rice/Enum.hpp"
+#include "rice/to_from_ruby.hpp"
+#include "rice/Address_Registration_Guard.hpp"
+
+#include <ruby.h>
+#include "ugly_interface_ns.h"
+
+inline UI::C_UIVector *newInstanceButBetter(Rice::Object *self) {
+  return new UI::C_UIVector();
+}
+
+#endif

data/test/headers/ugly_interface.h

@@ -0,0 +1,115 @@
+#ifndef __UGLY_H__
+#define __UGLY_H__
+
+/*
+Mapping should work for:
+ruby:
+F = function
+M = module
+C = class
+
+c++:
+m = namespace
+f = function
+c = class
+
+  m f c
+F    
+M x x x
+C   x 
+
+*/
+
+//should be exported as UI::add
+inline int uiAdd(int a, int b) {
+  return a+b;
+}
+
+
+//should be exported as UI::subtract
+inline int ui_Subtract(int a, int b) {
+  return a-b;
+}
+
+inline void uiIgnore() {}
+
+class C_UIVector {
+  private:
+    int x;
+  public:
+    C_UIVector() {}
+    int x_() {
+      return this->x;
+    }
+    void set_x(int x) {
+      this->x = x;
+    }
+    static int one() {
+      return 1;
+    }
+    int y_() {
+      return 0;
+    }
+};
+
+
+inline C_UIVector *IlikeVectors(int i) {
+  return new C_UIVector();
+}
+
+class NoConstructor {
+  public:
+    NoConstructor() {}
+};
+
+class Inside {
+  public:
+    Inside() {}
+};
+class Outside {
+};
+
+
+namespace __UI {
+  namespace BAD_UI {
+    class Multiplier {
+    public:
+      Multiplier() {}
+      inline int multiply(int a, int b) {
+        return a*b;
+      }
+    };
+    inline int multiply(int a, int b, int c) {
+      return a*b*c;
+    }
+  }
+}
+
+namespace DMath {
+  inline float divide(float a,float b) {
+    return a/b;
+  }
+}
+
+struct C_STRUCT_Quaternion {
+  public:
+    int i() {
+      return -1;
+    }
+};
+
+namespace I_LEARN_C {
+    inline int mod(int a, int b) {
+      return a%b;
+    }
+    inline int mod2(int a, int b) {
+      return a%b;
+    }
+    class Modder {
+    public:
+      Modder() {}
+      
+    };
+} 
+
+#endif

data/test/headers/ugly_interface_ns.h

@@ -0,0 +1,8 @@
+#ifndef __UI_NS_H__
+#define __UI_NS_H__
+
+namespace UI {
+  #include "ugly_interface.h"
+}
+
+#endif

data/test/nested_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+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")
+        node = 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/object_persistence_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Object Persistence" do
+  
+  def validate(node)
+    namespaces = node.namespaces
+    
+    node.namespaces.each_with_index do |n, i|
+    
+      #puts "#{node.name}::#{n.name}"
+      namespaces[i].object_id.should == n.object_id
+      
+      classes = n.classes
+      classes.each_with_index do |cls, j|
+        namespaces[i].classes[j].object_id.should == cls.object_id
+      
+        methods = cls.methods
+        methods.each_with_index do |m, k|
+          #puts "#{n.name}::#{cls.name}::#{m.name}"
+          namespaces[i].classes[j].methods[k].object_id.should == m.object_id
+        end 
+      end
+
+      functions = n.functions  
+      functions.each_with_index do |funct, j|
+     #   puts "#{n.name}::#{funct.name}"
+        namespaces[i].functions[j].object_id.should == funct.object_id
+      end
+      
+      validate n
+    end
+
+  end
+
+  specify "seperate query should lazy initialize objects" do
+    Extension.new "ui" do |e|
+      e.sources full_dir("headers/ugly_interface_ns.h")
+      node = e.namespace("UI")
+      validate(node)
+    end
+  end 
+end
+    
+

data/test/overloading_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Extension with overloaded methods" do
+
+  specify "should have all functions available" do
+    Extension.new "overload" do |e|
+      e.sources full_dir("headers/overload.h")
+      node = e.namespace "overload"
+      node.classes("Mathy").methods("times")[0].wrap_as("times")
+    end
+
+    require 'overload'
+
+    math = nil
+    should.not.raise NameError do
+      #Constructor overloading is broken in rice
+      #math = Mathy.new 
+      math = Mathy.new(1)
+    end
+    
+    should.not.raise NameError do
+      math.times.should == 1
+      math.times_1(3).should == 3
+      math.times_2(3,2).should == 6
+      math.times_3(3,2,3).should == 18
+    end
+    
+    should.not.raise NameError do
+      math.nothing_0
+      math.nothing_1(1)
+      math.self_0.class.should == math.self_1.class
+    end
+
+  end
+
+end

data/test/struct_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Nested Struct" do
+
+  specify "should be accessible" do
+    Extension.new "nested" do |e|
+      e.sources full_dir("headers/nested_struct.h")
+      e.namespace "nested"
+    end
+
+    require 'nested'
+
+    should.not.raise NameError do
+      Klass::NestedStruct.new.one.should == 1
+    end
+
+    should.raise NameError do
+      Klass::PrivateNestedStruct.new
+    end
+  end
+  
+end

data/test/subclass_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Extension with class hierachies" do
+
+  specify "should make super classes methods available" do
+    Extension.new "subclass" do |e|
+      e.sources full_dir("headers/subclass.h")
+      node = e.namespace "subclass"
+      
+      node.classes("SuperSuper").ignore
+      e.module("Sub") do |m|
+        node.classes.each do |c|
+          m.includes c
+        end
+      end
+    end
+
+    require 'subclass'
+    should.not.raise NameError do
+      Sub::Base.new.one.should == Sub::Sub.new.one
+      Sub::Base.new.zero.should == Sub::Sub.new.zero
+    end
+    should.not.raise NameError do
+      Sub::TemplateSub.new.zero.should == Sub::TemplateSub.new.custom
+    end
+    should.not.raise NameError do
+      Sub::TemplatePtr.new.custom
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -16,4 +16,9 @@ class Test::Unit::TestCase
   def setup
     `rm -rf #{full_dir('generated')}/*`
   end
+
+  def teardown
+    RbGCCXML::XMLParsing.clear_cache
+    NodeCache.instance.clear
+  end
 end

data/test/to_from_ruby_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Properly build known required to_ruby and from_ruby methods" do
+
+  specify "should build for const & types as needed" 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"
+    end
+
+    require 'to_from_ruby'
+
+    needs_to_ruby(4).value.should == 4
+    some_other_method(7).value.should == 7
+
+    c = WrappedClass.new
+    c.get_my_type(17).value.should == 17
+    c.overload_0.class.should == c.overload_1(0).class
+    
+    get_template_0(1).overload_0.should == get_template_1.overload_1(1)
+  end
+end