rbplusplus 0.1.1 → 0.8

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/rdoctask'
 require 'rake/contrib/sshpublisher'
 
 PROJECT_NAME = "rb++"
-RBPLUSPLUS_VERSION = "0.1.1"
+RBPLUSPLUS_VERSION = "0.8"
 
 task :default => :test
 
@@ -11,12 +11,15 @@ task :default => :test
 # The tests wrap and load C++ wrapper code constantly.
 # When running all the tests at once, we very quickly run 
 # into problems where Rice crashes because 
-# a given C++ class is already wrapped. So we need to run the
+# a given C++ class is already wrapped, or glibc doesn't like our 
+# unorthodox handling of it's pieces. So we need to run the
 # tests individually
 desc "Run the tests"
 task :test do
-  FileList["test/*_test.rb"].each do |file|
-    ruby file
+  files = FileList["test/*_test.rb"]
+  puts files.inspect
+  files.each do |file|
+    sh "ruby #{file}"
   end
 end
 
@@ -31,16 +34,29 @@ end
 RUBYFORGE_USERNAME = "jameskilton"
 PROJECT_WEB_PATH = "/var/www/gforge-projects/rbplusplus"
 
-desc "Update the website" 
-task :upload_web => :rdoc  do |t|
-  unless File.directory?("publish")
-    mkdir "publish"
-    mkdir "publish/rbplusplus"
+namespace :web do
+  desc "Build website"
+  task :build => :rdoc do |t|
+    cd "website" do
+      sh "webgen"
+    end
+
+    unless File.directory?("publish")
+      mkdir "publish"
+    end
+    sh "cp -r website/output/* publish/"
+    sh "cp -r html/* publish/rbplusplus/"
+  end
+
+  desc "Update the website" 
+  task :upload => "web:build"  do |t|
+    Rake::SshDirPublisher.new("#{RUBYFORGE_USERNAME}@rubyforge.org", PROJECT_WEB_PATH, "publish").upload
+  end
+
+  desc "Clean up generated website files" 
+  task :clean do
+    rm_rf "publish"
   end
-  sh "cp -r website publish/"
-  sh "cp -r html/* publish/rbplusplus/"
-	Rake::SshDirPublisher.new("#{RUBYFORGE_USERNAME}@rubyforge.org", PROJECT_WEB_PATH, "publish").upload
-  rm_rf "publish"
 end
 
 spec = Gem::Specification.new do |s|
@@ -57,8 +73,8 @@ Rb++ combines the powerful query interface of rbgccxml and the Rice library to
 make Ruby wrapping extensions easier to write than ever.
   END
 
-  s.add_dependency "rbgccxml", "0.1.1"
-  s.add_dependency "rice", "1.0.1"
+  s.add_dependency "rbgccxml", "0.8"
+  s.add_dependency "rice", ">= 1.0.2"
 
   patterns = [
     'TODO',

data/TODO

@@ -3,6 +3,21 @@ TODO
 * Allowing use of "have_library"
 * Other mkmf functions?
 
+* rbgccxml: Continue working with QueryResult#find, making it as powerful
+and robust as possible.
+
+* Rest of the GCCXML types (as needed):
+  - ArrayType
+  - Converter
+  - Destructor
+  - Field
+  - FunctionType
+  - OperatorFunction
+  - OperatorMethod
+  - OffsetType
+  - Union
+  - Variable
+
 STARTED
 * Adding constructor
   - Test constructor arguments
@@ -18,6 +33,11 @@ DONE
 * Adding classes to classes (ad infinitum)
 * Look into file naming when dealing with Modules
 * Nested Modules
+* Recognizing and building to_ruby / from_ruby methods for const type references
+* Moving the to_ruby / from_ruby definitions to a place that all will know about them
+* Enumerations
+* Proper TypesManager dealings with single_file writer mode
+* Working with the defined C++ heirarchy chain
 
 No longer waiting on rice - just building a wrapper myself now. 
 * Adding global methods (Kernel-level methods)

data/lib/rbplusplus/builders/base.rb

@@ -54,6 +54,91 @@ module RbPlusPlus
         @includes = []
         @declarations = []
         @body = []
+        @registered_nodes = []
+      end
+      
+      # adds a register function to the Init or register of this node
+      def register_node(node, register_func)
+        @registered_nodes << [node, register_func]
+      end
+      
+    private
+      
+      def nested_level(node, level=0)
+        return level if node.is_a?(RbGCCXML::Namespace) || node.is_a?(RbGCCXML::Enumeration)
+        return level if node.super_classes.length == 0
+        node.super_classes.each do |sup|
+          level = nested_level(sup, level+1)
+        end
+        return level
+      end
+      
+    public
+      
+      # Sorts the registered nodes by hierachy, registering the base classes
+      # first.
+      #
+      # this is necessary for Rice to know about inheritance
+      def registered_nodes
+        #sort by hierachy
+        nodes = @registered_nodes.sort_by do |build, func|
+          if build.node.nil?
+            0
+          else  
+            nested_level(build.node)
+          end
+        end
+        
+        #collect the sorted members
+        nodes.collect do |node, func|
+          func
+        end
+      end
+      
+      # The name of the header file to include
+      # This is the file default, so long as it matches one of the export files
+      # If not this returns all exported files.
+      #
+      # This was added to workaround badly declared namespaces
+      def header_files(node)
+        file = node.file_name(false)
+        return [file] if self.class.sources.include?(file)
+        self.class.sources
+      end
+      
+      # Adds the necessary includes in order to compile the specified node
+      def add_includes_for(node)
+        header_files(node).each do |header|
+          includes << "#include \"#{header}\""
+        end
+      end
+      
+      # Include any user specified include files
+      def add_additional_includes
+        self.class.additional_includes.each do |inc|
+          includes << "#include \"#{inc}\""
+        end
+      end
+      
+      # Set a list of user specified include files
+      def self.additional_includes=(addl)
+        @@additional_includes = addl
+      end
+      
+      # Get an array of user specified include files
+      def self.additional_includes
+        @@additional_includes || []
+      end
+      
+      # A list of all the source files.  This is used in order to prevent files 
+      # that are not in the list from being included and mucking things up
+      def self.sources=(sources)
+        @@sources = sources
+      end
+      
+      # Retrieves a list of user specified source files
+      def self.sources
+        @@sources || []
       end
 
       # All builders must implement this method
@@ -64,7 +149,22 @@ module RbPlusPlus
       # Builders should use to_s to make finishing touches on the generated
       # code before it gets written out to a file.
       def to_s
-        [self.includes.flatten.uniq, "", self.declarations, "", self.body].flatten.join("\n")
+        extras = []
+        #Weird trailing } needs to be destroyed!!!
+        if self.body.flatten[-1].strip == "}"
+          extras << self.body.delete_at(-1)
+        end
+    
+        return [
+          self.includes.flatten.uniq, 
+          "", 
+          self.declarations, 
+          "", 
+          self.body,
+          "", 
+          self.registered_nodes, 
+          extras
+        ].flatten.join("\n")
       end
 
       # Get the full qualified name of the related gccxml node
@@ -73,25 +173,37 @@ module RbPlusPlus
       end
 
       # Register all classes
-      def build_classes
-        @node.classes.each do |klass|
+      def build_classes(classes = nil)
+        classes ||= [@node.classes, @node.structs].flatten
+        classes.each do |klass|
+          next if klass.ignored? || klass.moved?
+          next unless klass.public?
           builder = ClassBuilder.new(self, klass)
           builder.build
           builders << builder
         end
       end
 
+      # Find and wrap up all enumerations
+      def build_enumerations
+        @node.enumerations.each do |enum|
+          builder = EnumerationBuilder.new(self, enum)
+          builder.build
+          builders << builder
+        end
+      end
+
       # Compatibility with Rice 1.0.1's explicit self requirement, build a quick
       # wrapper that includes a self and discards it, forwarding the call as needed.
       #
       # Returns: the name of the wrapper function
-      def build_function_wrapper(function)
-        wrapper_func = "wrap_#{function.qualified_name.gsub(/::/, "_")}"
+      def build_function_wrapper(function, append="")
+        return if function.ignored? || function.moved?
+        wrapper_func = "wrap_#{function.qualified_name.gsub(/::/, "_")}#{append}"
 
         proto_string = ["Rice::Object self"]
         call_string = []
-
-        function.arguments.map{|arg| [arg.cpp_type.name, arg.name]}.each do |parts|
+        function.arguments.map{|arg| [arg.cpp_type.to_s(true), arg.name]}.each do |parts|
           type = parts[0]
           name = parts[1]
           proto_string << "#{type} #{name}"
@@ -100,7 +212,7 @@ module RbPlusPlus
 
         proto_string = proto_string.join(",")
         call_string = call_string.join(",")
-        return_type = function.return_type.name
+        return_type = function.return_type.to_s(true)
         returns = "" if return_type == "void"
         returns ||= "return"
 
@@ -111,6 +223,34 @@ module RbPlusPlus
         wrapper_func
       end
 
+      # Compatibility with Rice 1.0.1's method overloading issues. Build a quick
+      # wrapper that includes a self, forwarding the call as needed.
+      #
+      # Returns: the name of the wrapper function
+      def build_method_wrapper(cls, method, i)
+        return if method.ignored? || method.moved?
+        wrapper_func = "wrap_#{method.qualified_name.functionize}_#{i}"
+        proto_string = ["#{cls.qualified_name} *self"]
+        call_string = []
+        method.arguments.map{|arg| [arg.cpp_type.to_s(true), arg.name]}.each do |parts|
+          type = parts[0]
+          name = parts[1]
+          proto_string << "#{type} #{name}"
+          call_string << "#{name}"
+        end
+        
+        proto_string = proto_string.join(",")
+        call_string = call_string.join(",")
+        return_type = method.return_type.to_s(true)
+        returns = "" if return_type == "void"
+        returns ||= "return"
+        
+        declarations << "#{return_type} #{wrapper_func}(#{proto_string}) {"
+        declarations << "\t#{returns} self->#{method.qualified_name}(#{call_string});"
+        declarations << "}"
+        
+        wrapper_func
+      end
     end
   end
 end

data/lib/rbplusplus/builders/class.rb

@@ -11,52 +11,127 @@ module RbPlusPlus
       end
 
       def build
-        class_name = node.name
-        full_name = node.qualified_name
-        self.rice_variable = "rb_c#{class_name}"
-        self.rice_variable_type = "Rice::Data_Type<#{full_name}>"
+
+        #Handles templated super classes
+        @typedef_name = node.qualified_name.functionize
+        
+        #Handles templated super classes passing in complex members
+        var_name = node.name
+        var_name.gsub!("::","_")
+        var_name.gsub!(/[ ,<>]/, "_")
+        var_name.gsub!("*", "Ptr")
+        
+        self.rice_variable = "rb_c#{var_name}"
+        self.rice_variable_type = "Rice::Data_Type<#{self.qualified_name} >"
 
         includes << "#include <rice/Class.hpp>"
         includes << "#include <rice/Data_Type.hpp>"
-        includes << "#include <rice/Constructor.hpp>"
-        includes << "#include \"#{node.file_name(false)}\""
+        includes << "#include <rice/Constructor.hpp>"  
+        
+        add_additional_includes
+        add_includes_for node
+        
+        self.declarations.insert(0,"typedef #{node.qualified_name} #{@typedef_name};")
+        
+        @body << class_definition
+        
+        @body += constructors
+        
+        @body += methods
 
-        class_defn = "\t#{rice_variable_type} #{rice_variable} = "
-        if !parent.is_a?(ExtensionBuilder)
-          class_defn += "Rice::define_class_under<#{full_name}>(#{parent.rice_variable}, \"#{class_name}\");"
-        else
-          class_defn += "Rice::define_class<#{full_name}>(\"#{class_name}\");"
-        end
+        # Nested Classes
+        build_classes
 
-        body << class_defn
+        # Enumerations
+        build_enumerations
+      end
 
+      # Build the constructors, and return an array of rice code
+      def constructors
+        result = []
+        # There are no constructors on purely virtual classes.
+        node.methods.each do |method|
+          next unless method.is_a? RbGCCXML::Method
+          return [] if method.purely_virtual?
+        end
         # Constructors
         node.constructors.each do |init|
-          args = [full_name, init.arguments.map {|a| a.cpp_type }].flatten
-          body << "\t#{rice_variable}.define_constructor(Rice::Constructor<#{args.join(",")}>());"
+          next if init.ignored?
+          next unless init.public?
+          args = [@typedef_name, init.arguments.map {|a| a.cpp_type.to_s(true) }].flatten
+          result << "\t#{rice_variable}.define_constructor(Rice::Constructor<#{args.join(",")}>());"
         end
-
-        # Methods
+        result
+      end
+      
+      # Build the methods, and return an array of rice code
+      def methods
+        result = []
+        # Methods are thrown into a hash table so that we can 
+        # determine overloaded methods
+        methods_hash = {}
         node.methods.each do |method|
-          m = "define_method"
-          name = method.qualified_name
-
-          if method.static?
-            m = "define_singleton_method"
-            name = build_function_wrapper(method)
+          next unless method.public?
+  
+          methods_hash[method.qualified_name] ||= []
+          methods_hash[method.qualified_name] << method
+        end
+        
+        methods_hash.each do |key, methods|
+          #Add any method with a const return type to the typemanager
+          methods.each do |method|
+            next if method.ignored? || method.moved?
+            if method.return_type.const? || method.const?
+              TypesManager.build_const_converter(method.return_type)
+            end
           end
+          #No overloaded methods
+          if methods.length == 1
+            method = methods[0]
+            next if method.ignored? || method.moved?
+            m = "define_method"
+            name = method.qualified_name
 
-          body << "\t#{rice_variable}.#{m}(\"#{Inflector.underscore(method.name)}\", &#{name});"
-        end
+            if method.static?
+              m = "define_singleton_method"
+              name = build_function_wrapper(method)
+            end
 
-        # Nested Classes
-        node.classes.each do |klass|
-          b = ClassBuilder.new(self, klass)
-          b.build
-          builders << b
+            result << "\t#{rice_variable}.#{m}(\"#{Inflector.underscore(method.name)}\", &#{name});"  
+          else
+            #Handle overloaded methods
+            #currently we just append an index to them if they have not been renamed
+            #for example getOrigin() and getOrigin(x,y) become
+            #get_origin_0 and get_origin_1
+            methods.each_with_index do |method, i|
+              next if method.ignored? || method.moved?
+              name = build_method_wrapper(node, method, i)
+              m = "define_method"
+              method_name = "#{Inflector.underscore(method.name)}"
+              method_name += "_#{i}" unless method.renamed?
+              result << "\t#{rice_variable}.#{m}(\"#{method_name}\", &#{name});"  
+            end
+          end
         end
+        result
+      end
+      
+      # Return a rice string representing Rice's class definition.
+      def class_definition        
+        class_defn = "\t#{rice_variable_type} #{rice_variable} = "
+        
+        class_name = node.name
+        supers = node.super_classes.collect { |s| s.qualified_name }
+        class_names = [@typedef_name, supers].flatten.join(",")
+        
+        if !parent.is_a?(ExtensionBuilder)
+          class_defn += "Rice::define_class_under<#{class_names} >(#{parent.rice_variable}, \"#{class_name}\");"
+        else
+          class_defn += "Rice::define_class<#{class_names} >(\"#{class_name}\");"
+        end
+        class_defn
       end
-
     end
+    
   end
 end

data/lib/rbplusplus/builders/enumeration.rb

@@ -0,0 +1,40 @@
+module RbPlusPlus
+  module Builders
+
+    # This class handles generating source for a requested Module
+    class EnumerationBuilder < Base
+      
+      # Different initializer to keep things clean
+      def initialize(parent, node)
+        super(node.name, node)
+        self.parent = parent
+      end
+
+      def build
+        includes << "#include <rice/Enum.hpp>"
+        enum_name = node.name
+        full_name = node.qualified_name
+        self.rice_variable = "rb_e#{enum_name}"
+        self.rice_variable_type = "Rice::Enum<#{full_name}>"
+        
+        add_additional_includes
+        
+        defn = "\t#{rice_variable_type} #{rice_variable} = "
+        
+        second_arg = ""
+        if !parent.is_a?(ExtensionBuilder)
+          second_arg = ", #{parent.rice_variable}"
+        end
+
+        defn += "Rice::define_enum<#{full_name}>(\"#{enum_name}\" #{second_arg});"
+
+        body << defn
+
+        node.values.each do |v|
+          body << "\t#{rice_variable}.define_value(\"#{v.name}\", #{v.to_s(true)});"
+        end
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/builders/extension.rb

@@ -11,17 +11,43 @@ module RbPlusPlus
       def build
         includes << "#include <rice/global_function.hpp>"
 
+        add_additional_includes
+
         body << "extern \"C\""
         body << "void Init_#{@name}() {"
 
         # Explicitly ignore anything from the :: namespace
         if @node.name != "::"
+        
+          #Build a hash table to handle overloaded functions
+          func_hash = {}
           @node.functions.each do |func|
-            includes << "#include \"#{func.file_name(false)}\""
-            wrapper_name = build_function_wrapper(func)
-            body << "\tdefine_global_function(\"#{Inflector.underscore(func.name)}\", &#{wrapper_name});"
+            next if func.ignored? || func.moved?
+            
+            func_hash[func.name] ||= []
+            func_hash[func.name] << func
           end
+          #Iterate through the hash table to handle overloaded functions
+          func_hash.each do |key, funcs|
+            funcs.each_with_index do |func, i|
+              add_includes_for func
+              
+              #append _#{i} to overloaded methods
+              #this needs to be done in both the wrapper function and the ruby function
+              func_append = ""
+              func_append = "_#{i}" if funcs.size > 1
+              wrapper_name = func.special_qualified_name || build_function_wrapper(func, func_append)
+
+              if func.return_type.const? || func.const?
+                TypesManager.build_const_converter(func.return_type)
+              end
 
+              ruby_name = "#{Inflector.underscore(func.name)}#{func_append}"
+              body << "\tdefine_global_function(\"#{ruby_name}\", &#{wrapper_name});"
+            end
+          end
+          
+          build_enumerations
           build_classes
         end
 
@@ -39,9 +65,8 @@ module RbPlusPlus
       # Finish up the required code before doing final output
       def to_s
         includes << "using namespace Rice;"
-        body << "}"
-
-        super
+        
+        super + "\n}"
       end
     end
   end

data/lib/rbplusplus/builders/module.rb

@@ -18,6 +18,8 @@ module RbPlusPlus
         self.rice_variable_type = "Rice::Module"
 
         includes << "#include <rice/Module.hpp>"
+        
+        add_additional_includes
 
         mod_defn = "\t#{rice_variable_type} #{rice_variable} = "
         if !parent.is_a?(ExtensionBuilder)
@@ -29,11 +31,14 @@ module RbPlusPlus
         body << mod_defn
 
         # If a namespace has been given to this module, find and wrap the appropriate code
-        if @node
-          build_functions
-          build_classes
+        if self.node
+          build_enumerations 
         end
 
+        build_functions unless @module.functions.empty?
+        build_classes(@module.classes) unless @module.classes.empty?
+   
+
         # Build each inner module
         @module.modules.each do |mod|
           builder = ModuleBuilder.new(self, mod)
@@ -44,11 +49,12 @@ module RbPlusPlus
 
       # Process functions to be added to this module
       def build_functions
-        @node.functions.each do |func|
-          includes << "#include \"#{func.file_name(false)}\""
+        @module.functions.each do |func|
+          next if func.ignored? || func.moved? # fine grained function filtering
+          add_includes_for func
 
           func_name = Inflector.underscore(func.name)
-          wrapped_name = build_function_wrapper(func)
+          wrapped_name = func.special_qualified_name || build_function_wrapper(func)
           body << "\t#{self.rice_variable}.define_module_function(\"#{func_name}\", &#{wrapped_name});"
         end
       end