rbplusplus 0.9.1 → 1.0

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/rdoctask'
 require 'rake/contrib/sshpublisher'
 
 PROJECT_NAME = "rb++"
-RBPLUSPLUS_VERSION = "0.9.1"
+RBPLUSPLUS_VERSION = "1.0"
 
 task :default => :test
 
@@ -70,14 +70,11 @@ spec = Gem::Specification.new do |s|
 
   s.description = <<-END
 Rb++ combines the powerful query interface of rbgccxml and the Rice library to 
-make Ruby wrapping extensions easier to write than ever.
+make Ruby wrapping extensions of C++ libraries easier to write than ever.
   END
 
-  s.add_dependency "rbgccxml", "~> 0.9"
-  s.add_dependency "rice", "~> 1.3.0"
-
-  s.add_development_dependency "test-unit", "1.2.3"
-  s.add_development_dependency "mocha", "~> 0.9"
+  s.add_dependency "rbgccxml", "~> 1.0"
+  s.add_dependency "rice", "~> 1.4.0"
 
   patterns = [
     'TODO',
@@ -93,6 +90,4 @@ make Ruby wrapping extensions easier to write than ever.
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_zip = true
-  pkg.need_tar = true
 end

data/lib/rbplusplus/builders/allocation_strategy.rb

@@ -27,7 +27,6 @@ module RbPlusPlus
 namespace Rice {
   template<>
   struct Default_Allocation_Strategy< #{node_name} > {
-    static #{node_name} * allocate();
     static void free(#{node_name} * obj);
   };
 }
@@ -37,12 +36,6 @@ namespace Rice {
 
         pre = "Rice::Default_Allocation_Strategy< #{node_name} >::"
 
-        tmp = "#{node_name} * #{pre}allocate() { return "
-        tmp += @public_constructor ? "new #{node_name};" : "NULL;"
-        tmp += " }"
-
-        registrations << tmp
-
         tmp = "void #{pre}free(#{node_name} * obj) { "
         tmp += @public_destructor ? "delete obj;" : ""
         tmp += " }"

data/lib/rbplusplus/builders/base.rb

@@ -64,8 +64,7 @@ module RbPlusPlus
         raise "Nodes must implement #build"
       end
 
-      # After #build has run, this then triggers the actual generation of the C++
-      # code and returns the final string.
+      # After #build has run, this then triggers the actual generation of the C++ code
       # All nodes must implement this.
       def write
         raise "Nodes must implement #write"
@@ -84,7 +83,13 @@ module RbPlusPlus
         # up sorted farther down the list
         @nodes =
           @nodes.sort_by do |a|
-            a.is_a?(ClassNode) ? superclass_count(a.code) : 0
+            if a.is_a?(ClassNode)
+              superclass_count(a.code)
+            elsif a.is_a?(ImplicitCasterNode) # Hmm, hack
+              1_000_000
+            else
+              0
+            end
           end
       end
 
@@ -111,7 +116,8 @@ module RbPlusPlus
         node.ignored? ||
           (node.moved_to && node.moved_to != self.code) ||
           !node.public? ||
-          (node.is_a?(RbGCCXML::Struct) && node.incomplete?)
+          (node.is_a?(RbGCCXML::Struct) && node.incomplete?) ||
+          node.is_a?(RbGCCXML::FundamentalType)
       end
 
       # Given a new node, build it and add it to our nodes list
@@ -142,7 +148,7 @@ module RbPlusPlus
         if !node._disable_typedef_lookup?
           while found
             last_found = found
-            typedef = RbGCCXML::XMLParsing.find(:node_type => "Typedef", :type => found.attributes["id"])
+            typedef = RbGCCXML::NodeCache.all("Typedef").select {|t| t.attributes["type"] == found.attributes["id"]}.first
 
             # Some typedefs have the access attribute, some don't. We want those without the attribute
             # and those with the access="public". For this reason, we can't put :access => "public" in the

data/lib/rbplusplus/builders/class.rb

@@ -54,10 +54,6 @@ module RbPlusPlus
         unless @director
           check_allocation_strategies
         end
-
-        # For now, build a const& type converter for all class types until Rice has
-        # better management of to_ruby of class types, if it ever happens
-        add_global_child ConstConverterNode.new(self.code, self)
       end
 
       def write
@@ -70,10 +66,10 @@ module RbPlusPlus
         class_names = class_names.join(",")
 
         if parent.rice_variable
-          registrations << "#{prefix} Rice::define_class_under< #{class_names} >" +
+          registrations << "\t#{prefix} Rice::define_class_under< #{class_names} >" +
                              "(#{parent.rice_variable}, \"#{ruby_name}\");"
         else
-          registrations << "#{prefix} Rice::define_class< #{class_names} >(\"#{ruby_name}\");"
+          registrations << "\t#{prefix} Rice::define_class< #{class_names} >(\"#{ruby_name}\");"
         end
 
         handle_custom_code
@@ -83,7 +79,6 @@ module RbPlusPlus
 
       # Here we take the code manually added to the extension via #add_custom_code
       def handle_custom_code
-
         # Any declaration code, usually wrapper function definitions
         self.code._get_custom_declarations.flatten.each do |decl|
           declarations << decl
@@ -91,7 +86,7 @@ module RbPlusPlus
 
         # And the registration code to hook into Rice
         self.code._get_custom_wrappings.flatten.each do |wrap|
-          registrations << "#{wrap.gsub(/<class>/, self.rice_variable)}"
+          registrations << "\t#{wrap.gsub(/<class>/, self.rice_variable)}"
         end
       end
 
@@ -105,16 +100,12 @@ module RbPlusPlus
         # We check here if we're one of those classes and completely skip this step
         return if [self.code.constructors].flatten.empty?
 
-        # Find a public default constructor
-        found = [self.code.constructors.find(:arguments => [], :access => "public")].flatten
-        has_public_constructor = !found.empty?
-
         # See if the destructor is public
         has_public_destructor = self.code.destructor && self.code.destructor.public?
 
-        if !has_public_constructor || !has_public_destructor
+        if !has_public_destructor
           add_global_child AllocationStrategyNode.new(self,
-                            self.code, has_public_constructor, has_public_destructor)
+                            self.code, true, has_public_destructor)
         end
       end
 

data/lib/rbplusplus/builders/const.rb

@@ -20,7 +20,7 @@ module RbPlusPlus
           end
 
         prefix = parent.rice_variable ? "#{parent.rice_variable}." : "Rice::Module(rb_mKernel)."
-        registrations << "#{prefix}const_set(\"#{code.name}\", to_ruby(#{set_to}));"
+        registrations << "\t#{prefix}const_set(\"#{code.name}\", to_ruby(#{set_to}));"
       end
 
     end

data/lib/rbplusplus/builders/constructor.rb

@@ -10,7 +10,7 @@ module RbPlusPlus
 
       def write
         args = [code.parent.qualified_name, code.arguments.map {|a| a.cpp_type.to_cpp }].flatten.compact
-        registrations << "#{parent.rice_variable}.define_constructor(Rice::Constructor< #{args.join(",")} >());"
+        registrations << "\t#{parent.rice_variable}.define_constructor(Rice::Constructor< #{args.join(",")} >());"
       end
 
     end

data/lib/rbplusplus/builders/director.rb

@@ -27,7 +27,7 @@ module RbPlusPlus
       def build
         add_child IncludeNode.new(self, "rice/Director.hpp", :global)
         add_child IncludeNode.new(self, "rice/Constructor.hpp", :global)
-        
+
         # To ensure proper compilation, this director class needs
         # to implement all pure virtual methods found up the
         # inheritance heirarchy of this class. So here, we traverse
@@ -68,15 +68,15 @@ module RbPlusPlus
           end
         end
 
-        declarations << "#{@name}(#{args.join(", ")}) : #{@class_qualified_name}(#{supercall_args.join(", ")}), Rice::Director(self) { }"
+        declarations << "\t\t#{@name}(#{args.join(", ")}) : #{@class_qualified_name}(#{supercall_args.join(", ")}), Rice::Director(self) { }"
 
-        registrations << "#{self.parent.rice_variable}.define_director< #{@name} >();"
-        registrations << "#{self.parent.rice_variable}.define_constructor(Rice::Constructor< #{types.join(", ")} >());"
+        registrations << "\t#{self.parent.rice_variable}.define_director< #{@name} >();"
+        registrations << "\t#{self.parent.rice_variable}.define_constructor(Rice::Constructor< #{types.join(", ")} >());"
       end
 
       def write
         declarations << "class #{@name} : public #{@class_qualified_name}, public Rice::Director  {"
-        declarations << "public:"
+        declarations << "\tpublic:"
 
         # Handle constructors
         if @constructors.empty?
@@ -104,7 +104,7 @@ module RbPlusPlus
           def_arguments = def_arguments.length == 0 ? "" : def_arguments.join(", ")
 
           reverse = ""
-          up_or_raise = 
+          up_or_raise =
             if method.default_return_value
               reverse = "!"
               "return #{method.default_return_value}"
@@ -123,17 +123,17 @@ module RbPlusPlus
 
           # Write out the virtual method that forwards calls into Ruby
           declarations << ""
-          declarations << "virtual #{return_type} #{cpp_name}(#{def_arguments}) #{const} {"
-          declarations << "#{call_down};"
-          declarations << "}"
+          declarations << "\t\tvirtual #{return_type} #{cpp_name}(#{def_arguments}) #{const} {"
+          declarations << "\t\t\t#{call_down};"
+          declarations << "\t\t}"
 
           # Write out the wrapper method that gets exposed to Ruby that handles
           # going up the inheritance chain
           declarations << ""
-          declarations << "#{return_type} default_#{cpp_name}(#{def_arguments}) #{const} {"
-          declarations << "#{up_or_raise};"
-          declarations << "}"
-          
+          declarations << "\t\t#{return_type} default_#{cpp_name}(#{def_arguments}) #{const} {"
+          declarations << "\t\t\t#{up_or_raise};"
+          declarations << "\t\t}"
+
         end
 
         declarations << "};"

data/lib/rbplusplus/builders/enumeration.rb

@@ -20,11 +20,11 @@ module RbPlusPlus
       def write
         second = parent.rice_variable ? ", #{parent.rice_variable}" : ""
 
-        registrations << "#{rice_variable_type} #{rice_variable} = " \
+        registrations << "\t#{rice_variable_type} #{rice_variable} = " \
           "Rice::define_enum<#{code.qualified_name}>(\"#{code.name}\"#{second});"
 
         code.values.each do |v|
-          registrations << "#{rice_variable}.define_value(\"#{v.name}\", #{v.qualified_name});"
+          registrations << "\t#{rice_variable}.define_value(\"#{v.name}\", #{v.qualified_name});"
         end
       end
 

data/lib/rbplusplus/builders/helpers/class.rb

@@ -35,8 +35,6 @@ module RbPlusPlus
             "please use #use_contructor to select which one to use."
         end
 
-        # First, lets see if we have any non-generated constructors
-
         [to_use || real_constructors].flatten.each do |constructor|
           next if do_not_wrap?(constructor)
 
@@ -44,6 +42,15 @@ module RbPlusPlus
             next if ignore_artificial || constructor.arguments.length == 1
           end
 
+          if implicit_converter?(constructor)
+            if constructor.implicit_casting?
+              parent.add_child ImplicitCasterNode.new(constructor, self)
+            end
+
+            # We don't want to expose these constructors to Rice
+            next
+          end
+
           if @director
             @director.wrap_constructor constructor
           else
@@ -52,6 +59,14 @@ module RbPlusPlus
         end
       end
 
+      # Is this constructor a converter constructor?
+      def implicit_converter?(constructor)
+        # Single argument
+        constructor.arguments.length == 1 &&
+          # We are wrapping the type converting from
+          !do_not_wrap?(constructor.arguments[0].cpp_type.base_type)
+      end
+
       # Wrap up any class constants
       def with_constants
         [self.code.constants].flatten.each do |const|

data/lib/rbplusplus/builders/implicit_caster.rb

@@ -0,0 +1,24 @@
+module RbPlusPlus
+  module Builders
+
+    class ImplicitCasterNode < Base
+
+      def initialize(constructor, parent)
+        super(constructor, parent)
+
+        @to = parent.code.qualified_name
+        @from = constructor.arguments[0].cpp_type.base_type.qualified_name
+      end
+
+      def build
+      end
+
+      def write
+        if @from != @to
+          registrations << "\tRice::define_implicit_cast< #{@from}, #{@to} >();"
+        end
+      end
+    end
+
+  end
+end

data/lib/rbplusplus/builders/instance_variable.rb

@@ -15,19 +15,19 @@ module RbPlusPlus
         if !code.cpp_type.const?
           method_name = "wrap_#{parent_name}_#{code.name}_set"
           declarations << "void #{method_name}(#{parent.code.qualified_name}* self, #{code.cpp_type.to_cpp} val) {"
-          declarations << "self->#{code.name} = val;"
+          declarations << "\tself->#{code.name} = val;"
           declarations << "}"
 
-          registrations << "#{parent.rice_variable}.define_method(\"#{ruby_name}=\", &#{method_name});"
+          registrations << "\t#{parent.rice_variable}.define_method(\"#{ruby_name}=\", &#{method_name});"
         end
 
         # Getter
         method_name = "wrap_#{parent_name}_#{code.name}_get"
         declarations << "#{code.cpp_type.to_cpp} #{method_name}(#{parent.code.qualified_name}* self) {"
-        declarations << "return self->#{code.name};"
+        declarations << "\treturn self->#{code.name};"
         declarations << "}"
 
-        registrations << "#{parent.rice_variable}.define_method(\"#{ruby_name}\", &#{method_name});"
+        registrations << "\t#{parent.rice_variable}.define_method(\"#{ruby_name}\", &#{method_name});"
       end
 
     end

data/lib/rbplusplus/builders/method_base.rb

@@ -72,9 +72,9 @@ module RbPlusPlus
 
         funcall = "rb_funcall(#{block_var_name}, rb_intern(\"call\"), #{callback_values.join(", ")})"
         if return_type == "void"
-          declarations << "#{funcall};"
+          declarations << "\t#{funcall};"
         else
-          declarations << "return from_ruby<#{return_type} >(#{funcall});"
+          declarations << "\treturn from_ruby<#{return_type} >(#{funcall});"
         end
 
         declarations << "}"
@@ -96,7 +96,7 @@ module RbPlusPlus
         declarations << "\treturn Qnil;"
         declarations << "}"
 
-        registrations << "#{self.prefix}#{self.rice_method}(\"#{@ruby_name + self.suffix}\", &#{wrapper_func});"
+        registrations << "\t#{self.prefix}#{self.rice_method}(\"#{@ruby_name + self.suffix}\", &#{wrapper_func});"
       end
 
       def wrap_normal_method
@@ -137,13 +137,14 @@ module RbPlusPlus
 
         const = self.code.const? ? " const" : ""
 
-        registrations << "{"
+        registrations << ""
+        registrations << "\t{"
 
-        registrations << "typedef #{return_type} ( #{method_ref} )( #{arguments.join(", ")} )#{const};"
-        registrations << "#{self.prefix}#{self.rice_method}(\"#{@ruby_name + self.suffix}\", " +
+        registrations << "\t\ttypedef #{return_type} ( #{method_ref} )( #{arguments.join(", ")} )#{const};"
+        registrations << "\t\t#{self.prefix}#{self.rice_method}(\"#{@ruby_name + self.suffix}\", " +
                           "#{usage_ref}( &#{code_path} )#{def_args});"
 
-        registrations << "}"
+        registrations << "\t}"
       end
 
       # See http://www.gccxml.org/Bug/view.php?id=9234

data/lib/rbplusplus/builders/module.rb

@@ -45,7 +45,7 @@ module RbPlusPlus
       end
 
       def write
-        prefix = "#{rice_variable_type} #{rice_variable} = "
+        prefix = "\t#{rice_variable_type} #{rice_variable} = "
 
         if parent.rice_variable
           registrations << "#{prefix} Rice::define_module_under(#{parent.rice_variable}, \"#{@name}\");"

data/lib/rbplusplus/logger.rb

@@ -15,6 +15,10 @@ module RbPlusPlus
         @@quiet = val
       end
 
+      def silent!
+        @@silent = true
+      end
+
       def verbose?
         @@verbose = false unless defined?(@@verbose)
         @@verbose
@@ -25,20 +29,25 @@ module RbPlusPlus
         @@quiet
       end
 
+      def silent?
+        @@silent = false unless defined?(@@silent)
+        @@silent
+      end
+
       def info(msg)
-        $stdout.puts "(INFO) #{msg}" unless quiet?
+        $stdout.puts "(INFO) #{msg}" if !quiet? && !silent?
       end
 
       def warn(type, msg)
-        $stdout.puts "(WARNING) #{msg}"
+        $stdout.puts "(WARNING) #{msg}" if !silent?
       end
 
       def debug(msg)
-        $stdout.puts "(DEBUG) #{msg}" if verbose?
+        $stdout.puts "(DEBUG) #{msg}" if verbose? && !silent?
       end
 
       def error(msg)
-        $stderr.puts "(ERROR) #{msg}"
+        $stderr.puts "(ERROR) #{msg}" if !silent?
       end
     end
   end

data/lib/rbplusplus/transformers/class.rb

@@ -1,11 +1,22 @@
 module RbGCCXML
   class Class < Node
+
+    def initialize(*args)
+      super
+
+      @included_classes = []
+      @included_methods = []
+
+      @declarations = []
+      @wrappings = []
+    end
+
     # Class can include nested classes and nested structs.
     #
     # Class can also include external methods/functions as class level methods
     # also supports instance level methods
     #
-    # ex. 
+    # ex.
     #
     #   math_class.includes node.namespaces("Math").functions("mod")
     #
@@ -19,23 +30,21 @@ module RbGCCXML
     #
     def includes(val)
       if (val.is_a?(RbGCCXML::Struct) || val.is_a?(RbGCCXML::Class))
-        cache[:classes] ||= []
-        cache[:classes] << val
+        @included_classes << val
       else
-        cache[:methods] ||= []
-        cache[:methods] << val
+        @included_methods << val
       end
       val.moved_to = self
     end
-    
+
     alias_method :node_classes, :classes
     def classes(*args) #:nodoc:
-      find_with_cache(:classes, node_classes(*args))
+      find_with(node_classes(*args), @included_classes)
     end
 
     alias_method :node_methods, :methods
     def methods(*args) #:nodoc:
-      find_with_cache(:methods, node_methods(*args))
+      find_with(node_methods(*args), @included_methods)
     end
 
     # Specify which superclass to use.
@@ -45,42 +54,42 @@ module RbGCCXML
     # where this method hasn't been used yet.
     #
     # klass should be the node for the class you want to wrap
-    def use_superclass(node)
-      cache[:use_superclass] = node
+    def use_superclass(klass)
+      @use_superclass = klass
     end
 
     def _get_superclass #:nodoc:
-      cache[:use_superclass]
+      @use_superclass
     end
 
-    # Like #use_superclass, this method allows the user to specify 
-    # which constructor Rice should expose to Ruby. 
-    # Rice currently, because of the lack of method overloading, 
+    # Like #use_superclass, this method allows the user to specify
+    # which constructor Rice should expose to Ruby.
+    # Rice currently, because of the lack of method overloading,
     # only supports one constructor definition. Having multiple
     # in the code will work, but only the last defined will actually
-    # work. 
+    # work.
     def use_constructor(node)
-      cache[:use_constructor] = node
+      @use_constructor = node
     end
 
     def _get_constructor #:nodoc:
-      cache[:use_constructor]
+      @use_constructor
     end
 
     # Sometimes, type manipulation, moving nodes around, or flat
     # ignoring nodes just doesn't do the trick and you need to write
     # your own custom wrapper code. This method is for that. There are
-    # two parts to custom code: the declaration and the wrapping. 
+    # two parts to custom code: the declaration and the wrapping.
     #
     # The Declaration:
     #   This is the actual custom code you write. It may need to take
     #   a pointer to the class type as the first parameter
-    #   and follow with that any parameters you want. 
+    #   and follow with that any parameters you want.
     #
     # The Wrapping
     #   The wrapping is the custom (usually one-line) bit of Rice code that
     #   hooks up your declaration with the class in question. To ensure that
-    #   you doesn't need to know the variable of the ruby class object, 
+    #   you doesn't need to know the variable of the ruby class object,
     #   use <class> and rb++ will replace it as needed.
     #
     # Example (taken from Ogre.rb's wrapping of Ogre)
@@ -100,45 +109,45 @@ module RbGCCXML
     # of times for a class, it won't clobber any previous uses.
     #
     def add_custom_code(declaration, wrapping)
-      cache[:declarations] ||= []
-      cache[:declarations] << declaration
-
-      cache[:wrappings] ||= []
-      cache[:wrappings] << wrapping
+      @declarations << declaration
+      @wrappings << wrapping
     end
 
     def _get_custom_declarations #:nodoc:
-      cache[:declarations] || []
+      @declarations
     end
 
     def _get_custom_wrappings #:nodoc:
-      cache[:wrappings] || []
+      @wrappings
     end
 
     # Does this class have virtual methods (especially pure virtual?)
-    # If so, then rb++ will generate a proxy class to handle 
+    # If so, then rb++ will generate a proxy class to handle
     # the message routing as needed.
     def needs_director? #:nodoc:
-      !!cache[:build_director] #[methods].flatten.select {|m| m.virtual? }.length > 0
+      !!@build_director
     end
 
     # Until all the kinks of the director code generation can be
     # worked out, rb++ must be told which classes to build
     # directors for. Simply call this method on the class to do so
     def director
-      cache[:build_director] = true
+      @build_director = true
+    end
+
+    # See RbGCCXML::Constructor::implicit_casting
+    def implicit_casting(state)
+      self.constructors.each {|c| c.implicit_casting(state) }
     end
 
     private
 
     # Take the cache key, and the normal results, adds to the results
     # those that are in the cache and returns them properly.
-    def find_with_cache(type, results)
-      in_cache = cache[type]
-
+    def find_with(results, with = nil)
       ret = QueryResult.new
       ret << results if results
-      ret << in_cache if in_cache
+      ret << with if with
       ret.flatten!
 
       ret.size == 1 ? ret[0] : ret

data/lib/rbplusplus/transformers/constructor.rb

@@ -0,0 +1,30 @@
+module RbGCCXML
+  class Constructor < Function
+
+    # See:
+    #   http://msdn.microsoft.com/en-us/library/h1y7x448.aspx
+    #   http://msdn.microsoft.com/en-us/library/s2ff0fz8(VS.100).aspx
+    #
+    # Single argument constructors of a class are called Conversion constructors.
+    # They manage the conversion of one type to another. Rice handles this functionality
+    # through a special method, define_implicit_cast<From, To>(). 
+    #
+    # Rb++ attempts to find all classes and constructors that fit this pattern
+    # and write out the casting declarations as needed. In the cases where this is
+    # functionality not wanted, use this method to turn off this casting check.
+    #
+    # This method can be called per Constructor or per Class.
+    def implicit_casting(state)
+      @implicit_casting = state
+    end
+
+    def implicit_casting? #:nodoc:
+      if @implicit_casting.nil?
+        @implicit_casting = true
+      end
+
+      @implicit_casting
+    end
+
+  end
+end

data/lib/rbplusplus/transformers/function.rb

@@ -2,19 +2,19 @@ module RbGCCXML
   class Function < Node
     # Always true for functions, false for methods
     def static?
-      !cache[:as_method]
+      !@as_method
     end
 
     # Sets this function to be an instance method.
     # Useful for custom function declaration.
     def as_instance_method
-      cache[:as_method] = true
+      @as_method = true
       self
     end
 
     # Are we wrapping this function as an instance method?
     def as_instance_method?
-      !!cache[:as_method]
+      !!@as_method
     end
 
     # For Class#needs_director?