rbplusplus 0.1

data/lib/rbplusplus.rb

@@ -0,0 +1,31 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/rbplusplus")
+
+gem 'rbgccxml'
+require 'rbgccxml'
+
+require 'inflector'
+require 'rbplusplus/rbplusplus'
+
+module RbPlusPlus
+
+  RBPP_COMMENT = "// This file generated by rb++"
+
+  autoload :Extension, "rbplusplus/extension"
+  autoload :RbModule, "rbplusplus/module"
+
+  module Builders
+    autoload :Base, "rbplusplus/builders/base"
+    autoload :ClassBuilder, "rbplusplus/builders/class"
+    autoload :ExtensionBuilder, "rbplusplus/builders/extension"
+    autoload :ModuleBuilder, "rbplusplus/builders/module"
+  end
+
+  module Writers
+    autoload :Base, "rbplusplus/writers/base"
+    autoload :ExtensionWriter, "rbplusplus/writers/extension"
+    autoload :MultipleFilesWriter, "rbplusplus/writers/multiple_files_writer"
+    autoload :SingleFileWriter, "rbplusplus/writers/single_file_writer"
+  end
+end
+

data/lib/rbplusplus/builders/base.rb

@@ -0,0 +1,116 @@
+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:
+    #
+    #   includes
+    #   declarations
+    #   body
+    #
+    # 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
+    #
+    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
+      attr_accessor :includes
+      # The list of declarations to add
+      attr_accessor :declarations
+      # The body code
+      attr_accessor :body
+
+      # Link to the parent builder who created said builder
+      attr_accessor :parent
+
+      # The name of the C++ variable related to this builder.
+      attr_accessor :rice_variable
+      attr_accessor :rice_variable_type
+
+      # Create a new builder.
+      def initialize(name, parser)
+        @name = name
+        @node = parser
+        @builders = []
+        @includes = []
+        @declarations = []
+        @body = []
+      end
+
+      # All builders must implement this method
+      def build
+        raise "Builder needs to implement #build"
+      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
+        [self.includes.flatten.uniq, "", self.declarations, "", self.body].flatten.join("\n")
+      end
+
+      # Get the full qualified name of the related gccxml node
+      def qualified_name
+        @node.qualified_name
+      end
+
+      # Register all classes
+      def build_classes
+        @node.classes.each do |klass|
+          builder = ClassBuilder.new(self, klass)
+          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(/::/, "_")}"
+
+        proto_string = ["Rice::Object self"]
+        call_string = []
+
+        function.arguments.map{|arg| [arg.cpp_type.name, 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 = function.return_type.name
+        returns = "" if return_type == "void"
+        returns ||= "return"
+
+        declarations << "#{return_type} #{wrapper_func}(#{proto_string}) {"
+        declarations << "\t#{returns} #{function.qualified_name}(#{call_string});"
+        declarations << "}"
+
+        wrapper_func
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/builders/class.rb

@@ -0,0 +1,62 @@
+module RbPlusPlus
+  module Builders
+
+    # This class handles generating source for Class nodes
+    class ClassBuilder < Base
+
+      # Different initializer to keep things clean
+      def initialize(parent, node)
+        super(node.name, node)
+        self.parent = parent
+      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}>"
+
+        includes << "#include <rice/Class.hpp>"
+        includes << "#include <rice/Data_Type.hpp>"
+        includes << "#include <rice/Constructor.hpp>"
+        includes << "#include \"#{node.file_name(false)}\""
+
+        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
+
+        body << class_defn
+
+        # 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(",")}>());"
+        end
+
+        # Methods
+        node.methods.each do |method|
+          m = "define_method"
+          name = method.qualified_name
+
+          if method.static?
+            m = "define_singleton_method"
+            name = build_function_wrapper(method)
+          end
+
+          body << "\t#{rice_variable}.#{m}(\"#{Inflector.underscore(method.name)}\", &#{name});"
+        end
+
+        # Nested Classes
+        node.classes.each do |klass|
+          b = ClassBuilder.new(self, klass)
+          b.build
+          builders << b
+        end
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/builders/extension.rb

@@ -0,0 +1,48 @@
+module RbPlusPlus
+  module Builders
+
+    # This class takes in all classes to be wrapped and builds
+    # the top-level extension Init code
+    class ExtensionBuilder < Base
+      
+      # Need to be given the list of modules as they are a special case
+      attr_accessor :modules
+
+      def build
+        includes << "#include <rice/global_function.hpp>"
+
+        body << "extern \"C\""
+        body << "void Init_#{@name}() {"
+
+        # Explicitly ignore anything from the :: namespace
+        if @node.name != "::"
+          @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});"
+          end
+
+          build_classes
+        end
+
+        build_modules
+      end
+
+      def build_modules
+        @modules.each do |mod|
+          builder = ModuleBuilder.new(self, mod)
+          builder.build
+          builders << builder
+        end
+      end
+
+      # Finish up the required code before doing final output
+      def to_s
+        includes << "using namespace Rice;"
+        body << "}"
+
+        super
+      end
+    end
+  end
+end

data/lib/rbplusplus/builders/module.rb

@@ -0,0 +1,67 @@
+module RbPlusPlus
+  module Builders
+
+    # This class handles generating source for a requested Module
+    class ModuleBuilder < Base
+
+      # Initializer takes the parent object and the RbModule construction
+      def initialize(parent, mod)
+        super(mod.name, mod.node)
+        @module = mod
+        self.parent = parent
+      end
+
+      def build
+        # Using qualified name with underscores here to allow for nested modules
+        # of the same name
+        self.rice_variable = "rb_m#{self.qualified_name.gsub(/::/, "_")}"
+        self.rice_variable_type = "Rice::Module"
+
+        includes << "#include <rice/Module.hpp>"
+
+        mod_defn = "\t#{rice_variable_type} #{rice_variable} = "
+        if !parent.is_a?(ExtensionBuilder)
+          mod_defn += "Rice::define_module_under(#{parent.rice_variable}, \"#{name}\");"
+        else
+          mod_defn += "Rice::define_module(\"#{name}\");"
+        end
+
+        body << mod_defn
+
+        # If a namespace has been given to this module, find and wrap the appropriate code
+        if @node
+          build_functions
+          build_classes
+        end
+
+        # Build each inner module
+        @module.modules.each do |mod|
+          builder = ModuleBuilder.new(self, mod)
+          builder.build
+          builders << builder
+        end
+      end
+
+      # Process functions to be added to this module
+      def build_functions
+        @node.functions.each do |func|
+          includes << "#include \"#{func.file_name(false)}\""
+
+          func_name = Inflector.underscore(func.name)
+          wrapped_name = build_function_wrapper(func)
+          body << "\t#{self.rice_variable}.define_module_function(\"#{func_name}\", &#{wrapped_name});"
+        end
+      end
+
+      # Special name handling. Qualified name is simply the name of this module
+      def qualified_name
+        if parent.is_a?(ModuleBuilder)
+          "#{parent.qualified_name}::#{self.name}"
+        else
+          self.name
+        end
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/extension.rb

@@ -0,0 +1,183 @@
+module RbPlusPlus
+
+  # This is the starting class for Rb++ wrapping. All Rb++ projects start with this
+  # class:
+  #   
+  #   Extension.new "extension_name" do |e|
+  #     ...
+  #   end
+  #
+  # "extension_name" is what the resulting Ruby library will be named, aka in your code
+  # you will have
+  #
+  #   require "extension_name"
+  #
+  # It is recommended that you use the block format of this class's initializer.
+  # If you want more fine-grained control of the whole process, don't use
+  # the block format. Instead you should do the following:
+  #
+  #   e = Extension.new "extension_name"
+  #   ...
+  #
+  # The following calls are required in both formats:
+  #
+  #   #sources - The directory / array / name of C++ header files to parse. 
+  #   
+  # In the non-block format, the following calls are required:
+  #
+  #   #working_dir - Specify the directory where the code will be generated. This needs
+  #   to be a full path.
+  #
+  # In the non-block format, you need to manually fire the different steps of the
+  # code generation process, and in this order:
+  #
+  #   #build - Fires the code generation process
+  #
+  #   #write - Writes out the generated code into files
+  #
+  #   #compile - Compiles the generated code into a Ruby extension. 
+  #   
+  class Extension
+
+    # Where will the generated code be put
+    attr_accessor :working_dir
+
+    # The list of modules to create
+    attr_accessor :modules
+
+    # List of extra include directives
+    attr_accessor :includes
+
+    # List of directories for library searching
+    attr_accessor :lib_paths
+
+    # List of libraries to link
+    attr_accessor :libraries
+
+    # Create a new Ruby extension with a given name. This name will be
+    # the module built into the extension. 
+    # This constructor can be standalone or take a block. 
+    def initialize(name, &block)
+      @name = name
+      @modules = []
+      @writer_mode = :multiple
+      @includes = []
+      @lib_paths = []
+      @libraries = []
+
+      if block
+        build_working_dir(&block)
+        block.call(self)
+        build
+        write
+        compile
+      end
+    end
+
+    # Define where we can find the header files to parse
+    # Can give an array of directories, a glob, or just a string.
+    # All file names should be full paths, not partial.
+    #
+    # Options can be the following:
+    #
+    # * <tt>:include_paths</tt> - An array or string of full paths to be added as -I flags
+    # * <tt>:library_paths</tt> - An array or string of full paths to be added as -L flags
+    # * <tt>:libraries</tt> - An array or string of full paths to be added as -l flags
+    def sources(dirs, options = {})
+      parser_options = {}
+
+      if (paths = options.delete(:include_paths))
+        @includes << paths
+        parser_options[:includes] = @includes
+      end
+
+      if (lib_paths = options.delete(:library_paths))
+        @lib_paths << lib_paths 
+      end
+
+      if (libs = options.delete(:libraries))
+        @libraries << libs
+      end
+
+      @parser = RbGCCXML.parse(dirs, parser_options)
+    end
+
+    # Set a namespace to be the main namespace used for this extension.
+    # Specifing a namespace on the Extension itself will mark functions,
+    # class, enums, etc to be globally available to Ruby (aka not in it's own
+    # module)
+    def namespace(name)
+      @node = @parser.namespaces(name)
+    end
+
+    # Mark that this extension needs to create a Ruby module of
+    # a give name. Like Extension, this can be used with or without
+    # a block.
+    def module(name, &block)
+      m = RbModule.new(name, @parser, &block)
+      @modules << m
+      m
+    end
+
+    # How should we write out the source code? This can be one of two modes:
+    # * <tt>:multiple</tt> (default) - Each class and module gets it's own set of hpp/cpp files
+    # * <tt>:single</tt> - Everything gets written to a single file
+    def writer_mode(mode)
+      raise "Unknown writer mode #{mode}" unless [:multiple, :single].include?(mode)
+      @writer_mode = mode
+    end
+
+    # Start the code generation process. 
+    def build
+      raise ConfigurationError.new("Must specify working directory") unless @working_dir
+      raise ConfigurationError.new("Must specify which sources to wrap") unless @parser
+
+      @builder = Builders::ExtensionBuilder.new(@name, @node || @parser)
+      @builder.modules = @modules
+      @builder.build
+    end
+
+    # Write out the generated code into files.
+    # #build must be called before this step or nothing will be written out
+    def write
+      prepare_working_dir
+      
+      # Create the code
+      writer_class = @writer_mode == :multiple ? Writers::MultipleFilesWriter : Writers::SingleFileWriter
+      writer_class.new(@builder, @working_dir).write
+
+      # Create the extconf.rb
+      extconf = Writers::ExtensionWriter.new(@builder, @working_dir)
+      extconf.includes = @includes
+      extconf.library_paths = @lib_paths
+      extconf.libraries = @libraries
+      extconf.write
+    end
+
+    # Compile the extension.
+    # This will create an rbpp_compile.log file in @working_dir. View this
+    # file to see the full compilation process including any compiler
+    # errors / warnings.
+    def compile
+      FileUtils.cd @working_dir do
+        system("ruby extconf.rb > rbpp_compile.log 2>&1")
+        system("make >> rbpp_compile.log 2>&1")
+      end
+    end
+
+    protected
+
+    # If the working dir doesn't exist, make it
+    # and if it does exist, clean it out
+    def prepare_working_dir
+      FileUtils.mkdir_p @working_dir unless File.directory?(@working_dir)
+      FileUtils.rm_rf "#{@working_dir}/*"
+    end
+
+    # Cool little eval / binding hack, from need.rb
+    def build_working_dir(&block)
+      @working_dir = File.expand_path(
+        File.join(File.dirname(eval("__FILE__", block.binding)), "generated"))
+    end
+  end
+end