rbplusplus 0.8 → 0.9

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/rdoctask'
 require 'rake/contrib/sshpublisher'
 
 PROJECT_NAME = "rb++"
-RBPLUSPLUS_VERSION = "0.8"
+RBPLUSPLUS_VERSION = "0.9"
 
 task :default => :test
 
@@ -16,10 +16,13 @@ task :default => :test
 # tests individually
 desc "Run the tests"
 task :test do
-  files = FileList["test/*_test.rb"]
-  puts files.inspect
-  files.each do |file|
-    sh "ruby #{file}"
+  require 'rbconfig'
+  FileList["test/*_test.rb"].each do |file|
+    # To allow multiple ruby installs (like a multiruby test suite), I need to get
+    # the exact ruby binary that's linked to the ruby running the Rakefile. Just saying
+    # "ruby" will find the system's installed ruby and be worthless
+    ruby = File.join(Config::CONFIG["bindir"], Config::CONFIG["RUBY_INSTALL_NAME"])
+    sh "#{ruby} #{file}"
   end
 end
 
@@ -37,14 +40,11 @@ PROJECT_WEB_PATH = "/var/www/gforge-projects/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 "jekyll --pygment website publish/"
     sh "cp -r html/* publish/rbplusplus/"
   end
 
@@ -63,7 +63,7 @@ spec = Gem::Specification.new do |s|
   s.name = "rbplusplus"
   s.version = RBPLUSPLUS_VERSION
   s.summary = 'Ruby library to generate Rice wrapper code'
-  s.homepage = 'http://rbplusplus.rubyforge.org/rbplusplus'
+  s.homepage = 'http://rbplusplus.rubyforge.org'
   s.rubyforge_project = "rbplusplus"
   s.author = 'Jason Roelofs'
   s.email = 'jameskilton@gmail.com'
@@ -73,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.8"
-  s.add_dependency "rice", ">= 1.0.2"
+  s.add_dependency "rbgccxml", "~> 0.9"
+  s.add_dependency "rice", "~> 1.2.0"
 
   patterns = [
     'TODO',

data/TODO

@@ -1,45 +1,13 @@
-TODO
-* Figure out how to fix the error when running rake test
-* Allowing use of "have_library"
-* Other mkmf functions?
+Parts to move into rbgccxml:
 
-* rbgccxml: Continue working with QueryResult#find, making it as powerful
-and robust as possible.
+- Class purely_virtual? (check the abstract attribute)
+- Namespace#methods ?
 
-* Rest of the GCCXML types (as needed):
-  - ArrayType
-  - Converter
-  - Destructor
-  - Field
-  - FunctionType
-  - OperatorFunction
-  - OperatorMethod
-  - OffsetType
-  - Union
-  - Variable
+Move documentation to YARD?
 
-STARTED
-* Adding constructor
-  - Test constructor arguments
-
-DONE
-* Adding -I entries
-* Adding -L and -l entries 
-* Adding classes to global (define_class)
-* Adding modules
-* Adding methods to modules (define_module_function)
-* Adding classes to modules / other classes (define_class_under)
-* Adding methods to classes (.define_method)
-* 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)
-* Adding class-level methods (define_singleton_method)
+Use sdoc?
 
+Logging:
+ - Method overloads, wrap what a method is getting named as
+ - More detail into the writing, multiple and single file writers
+ - More debug messages in the building process

data/lib/rbplusplus/builders/allocation_strategy.rb

@@ -0,0 +1,57 @@
+module RbPlusPlus
+  module Builders
+
+    # Handles code generation for telling Rice how to allocate / deallocate
+    # classes. See ClassNode#check_allocation_strategies.
+    class AllocationStrategyNode < Base
+
+      def initialize(parent, code, has_public_constructor, has_public_destructor)
+        super(code, parent)
+        @public_constructor = has_public_constructor
+        @public_destructor = has_public_destructor
+      end
+
+      # Used by MultipleFileWriter to only wrap a given type once.
+      def qualified_name
+        "#{self.code.qualified_name}_AllocStrat"
+      end
+
+      def build
+      end
+
+      def write
+        includes << "#include <rice/Allocation_Strategies.hpp>"
+
+        node_name = self.code.qualified_name
+        code = <<-END
+namespace Rice {
+  template<>
+  struct Default_Allocation_Strategy< #{node_name} > {
+    static #{node_name} * allocate();
+    static void free(#{node_name} * obj);
+  };
+}
+        END
+
+        declarations << code
+
+        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 += " }"
+
+        registrations << tmp
+      end
+
+    end
+
+  end
+end
+

data/lib/rbplusplus/builders/base.rb

@@ -1,256 +1,159 @@
 module RbPlusPlus
   module Builders
 
-    # Top class for all source generation classes. A builder has three seperate
-    # code "parts" to fill up for the source writer:
+    # Base class for all code generation nodes
     #
-    #   includes
-    #   declarations
-    #   body
+    # A Node is simply a handler for one complete statement or block of C++ code.
     #
-    # includes:
-    #   The list of #include's needed for this builder's code to compile
-    #
-    # declarations:
-    #   Any extra required functions or class declarations that will be defined
-    #   outside of the main body of the code
-    #
-    # body:
-    #   The body is the code that will go in the main control function
-    #   of the file. For extensions, it's Init_extension_name() { [body] }.
-    #   For classes it's usually a register_ClassName() { [body] }, and so on.
-    #
-    # All builders can access their parent and add pieces of code to any of these
-    # three parts
+    # The code generation system for Rb++ is a two step process.
+    # We first, starting with an ExtensionNode, build up an internal representation
+    # of the resulting code, setting up all the code nodes required for proper
+    # wrapping of the library.
     #
+    # Once that's in place, then we run through the tree, actually generating
+    # the C++ wrapper code.
     class Base
 
-      attr_reader :name, :node
-      
-      # Any given builder has a list of sub-builders of any type
-      attr_accessor :builders
-
-      # Builders need to constcuct the following code parts
-      #
-      # The list of includes this builder needs
+      # List of includes for this node
       attr_accessor :includes
-      # The list of declarations to add
+
+      # List of declaration nodes for this node
       attr_accessor :declarations
-      # The body code
-      attr_accessor :body
 
-      # Link to the parent builder who created said builder
+      # List of registeration nodes for this node
+      attr_accessor :registrations
+
+      # Link to the parent node of this node
       attr_accessor :parent
 
-      # The name of the C++ variable related to this builder.
+      # Link to the underlying rbgccxml node this node is writing code for
+      attr_accessor :code
+
+      # List of children nodes
+      attr_accessor :nodes
+
+      # List of children nodes that generate code that the entire extension
+      # needs to be able to read. Code that fits here includes any auto-generated
+      # to_/from_ruby and any Allocation Strategies
+      attr_accessor :global_nodes
+
+      # The Rice variable name for this node
       attr_accessor :rice_variable
+
+      # The type of the rice_variable
       attr_accessor :rice_variable_type
 
-      # Create a new builder.
-      def initialize(name, parser)
-        @name = name
-        @node = parser
-        @builders = []
+      def initialize(code, parent = nil)
+        @code = code
+        @parent = parent
         @includes = []
         @declarations = []
-        @body = []
-        @registered_nodes = []
+        @registrations = []
+        @nodes = []
+        @global_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
+
+      # Does this builder node have child nodes?
+      def has_children?
+        @nodes && !@nodes.empty?
       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)
+
+      # Trigger the construction of the internal representation of a given node.
+      # All nodes must implement this.
+      def build
+        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.
+      # All nodes must implement this.
+      def write
+        raise "Nodes must implement #write"
+      end
+
+      # Once building is done, the resulting node tree needs to be sorted according
+      # to subclass / superclass definitions. Like anything with C++, Rice needs to
+      # know about base classes before it can build sub classes. We go through
+      # each node's children, sorting them according to this.
+      def sort
+        @nodes.each { |n| n.sort }
+
+        # sort_by lets us build an array of numbers that Ruby then uses
+        # to sort the list. Our method here is to simply specify the
+        # depth a given class is in a heirarchy, as bigger numbers end
+        # up sorted farther down the list
+        @nodes =
+          @nodes.sort_by do |a|
+            a.is_a?(ClassNode) ? superclass_count(a.code) : 0
           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
-      def build
-        raise "Builder needs to implement #build"
+      # Proxy method for writers
+      def qualified_name
+        self.code.qualified_name
       end
 
-      # Builders should use to_s to make finishing touches on the generated
-      # code before it gets written out to a file.
-      def to_s
-        extras = []
-        #Weird trailing } needs to be destroyed!!!
-        if self.body.flatten[-1].strip == "}"
-          extras << self.body.delete_at(-1)
+      protected
+
+      # Count the heirarchy depth of a given class node
+      def superclass_count(node)
+        count = 0
+        n = node
+        while n = n.superclass
+          count += 1
         end
-    
-        return [
-          self.includes.flatten.uniq, 
-          "", 
-          self.declarations, 
-          "", 
-          self.body,
-          "", 
-          self.registered_nodes, 
-          extras
-        ].flatten.join("\n")
+        count
       end
 
-      # Get the full qualified name of the related gccxml node
-      def qualified_name
-        @node.qualified_name
+      # Should this node be wrapped as it is or has the user
+      # specified something else for this node?
+      def do_not_wrap?(node)
+        node.ignored? || (node.moved_to && node.moved_to != self.code) || !node.public?
       end
 
-      # Register all classes
-      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
+      # Given a new node, build it and add it to our nodes list
+      def add_child(node)
+        node.build
+        nodes << node
       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
+      # Add a node to the "globals" list. See the declaration of global_nodes
+      def add_global_child(node)
+        node.build
+        global_nodes << node
       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.
+      # Any node can also have a typedef. There are cases where it's
+      # much better to use a typedef instead of the original fully qualified
+      # name, for example deep template definitions (say, any STL structures).
+      # This method will look for the best Typedef to use for this node.
+      # This lookup can be disabled on a per-node basis by calling node.disable_typedef_lookup,
+      # as there are cases where the typedef search works against the parsed code.
       #
-      # Returns: the name of the wrapper function
-      def build_function_wrapper(function, append="")
-        return if function.ignored? || function.moved?
-        wrapper_func = "wrap_#{function.qualified_name.gsub(/::/, "_")}#{append}"
+      # @returns the typedef node found or the node passed in (self.code by default)
+      def find_typedef(node = self.code)
+        return node if node.is_a?(RbGCCXML::FundamentalType)
 
-        proto_string = ["Rice::Object self"]
-        call_string = []
-        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}"
-          call_string << "#{name}"
-        end
+        found = last_found = node
 
-        proto_string = proto_string.join(",")
-        call_string = call_string.join(",")
-        return_type = function.return_type.to_s(true)
-        returns = "" if return_type == "void"
-        returns ||= "return"
+        if !node._disable_typedef_lookup?
+          while found
+            last_found = found
+            typedef = RbGCCXML::XMLParsing.find(:node_type => "Typedef", :type => found.attributes["id"])
 
-        declarations << "#{return_type} #{wrapper_func}(#{proto_string}) {"
-        declarations << "\t#{returns} #{function.qualified_name}(#{call_string});"
-        declarations << "}"
+            # 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
+            # query above.
+            found = (typedef && typedef.public?) ? typedef : nil
+          end
+        end
 
-        wrapper_func
+        last_found
       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
+      alias find_typedef_for find_typedef
+
     end
+
   end
 end