build-tool 0.0.1

data/lib/kde-build/build_system.rb

@@ -0,0 +1,26 @@
+require 'kde-build/build_system/cmake'
+require 'kde-build/build_system/qtcopy'
+require 'kde-build/build_system/autoconf'
+
+module BuildTool; module BuildSystem
+
+@mapping = {
+    'cmake'   => CMake,
+    'qtcopy'   => QtCopy,
+    'autoconf' => AutoConf
+}
+
+module_function
+
+def available
+    @mapping.keys
+end
+
+def get( name )
+    if !available.include? name
+        throw :todo
+    end
+    @mapping[name]
+end
+
+end; end

data/lib/kde-build/build_system/autoconf.rb

@@ -0,0 +1,109 @@
+require 'kde-build/build_system/base'
+
+require 'kde-build/tools/make'
+
+module BuildTool
+
+    module BuildSystem
+
+        class AutoConfError < Exception
+        end
+
+        class AutoConfConfiguration < BaseConfiguration
+
+            option( 'options', "Command line options for autoconf" )
+            option( 'autogen-options', "Command line options for autogen.sh." ).required
+
+            def initialize
+                super
+                self.name = "autoconf"
+            end
+
+        end
+
+        class AutoConf < Base
+
+            def initialize( mod )
+                super
+            end
+
+            def self.config
+                AutoConfConfiguration
+            end
+
+            def self.guess( path )
+                return File.exist? "#{path}/configure.in"
+            end
+
+
+            def bootstrap_with_autogen
+                # First check if autogen contains a configure call
+                puts configuration.class
+                puts configuration.methods(false).inspect
+                rc = self.class.execute( "#{source_directory}/autogen.sh #{configuration.autogen_options}", env )
+            end
+
+            def bootstrap_with_bootstrap
+                raise NotImplementedError, "#{self.class}.bootstrap_with_bootstrap"
+            end
+
+            def bootstrap_with_makefile
+                raise NotImplementedError, "#{self.class}.bootstrap_with_Makefile"
+            end
+
+            def bootstrap( force = false )
+                # Check if we need to bootstrap
+                if !force and File.exist? "#{source_directory}/configure"
+                    return
+                end
+                if File.exist? "#{source_directory}/bootstrap"
+                    return bootstrap_with_bootstrap
+                elsif File.exist? "#{source_directory}/autogen.sh"
+                    return bootstrap_with_autogen
+                elsif File.exist? "#{source_directory}/Makefile.cvs"
+                    return bootstrap_with_makefile
+                end
+
+                throw :AUTOCONF_FAILED_TO_BOOTSTRAP
+            end
+
+            def reconfigure
+                make "clean"
+                bootstrap true
+                configure
+            end
+
+            def configure
+                bootstrap
+                check_build_directory( true )
+                opt = options || ""
+                opt += " --prefix=#{prefix}" if prefix
+                rc = self.class.execute( "#{source_directory}/configure #{opt}", build_directory, env )
+                rc
+            end
+
+            def configured?
+                File.exist? "#{build_directory}/config.cache"
+            end
+
+            def make( command, wd = build_directory )
+                BuildTool::Make.new.make "#{command}", wd
+            end
+
+            def name
+                "AutoConf"
+            end
+
+            def options
+                configuration.options
+            end
+
+            Registry.register( 'AutoConf', AutoConf )
+
+        end
+
+    end
+
+end
+
+

data/lib/kde-build/build_system/base.rb

@@ -0,0 +1,132 @@
+require 'kde-build/subprocess'
+require 'kde-build/configuration'
+
+require 'singleton'
+require 'pathname'
+
+module BuildTool
+
+    module BuildSystem
+
+        class Registry
+
+            include Singleton
+
+            @@tools = Hash.new
+
+            def self.register( name, klass )
+                @@tools[name] = klass
+            end
+
+
+            def self.guess( source_directory )
+                @@tools.each do |name, bt|
+                    return bt if bt.guess( source_directory )
+                end
+                return nil
+            end
+
+        end
+
+        class BaseConfiguration
+
+            include MJ::Configuration::Configurable
+
+            option( 'name', "Name" )
+            option( 'inplace', 'Do not use out of source build' )
+
+        end
+
+
+        class Base
+
+            include MJ::Tools::SubProcess
+
+            attr_accessor :configuration
+
+            def initialize( mod )
+                @module = mod
+            end
+
+            def source_directory
+                @module.source_directory
+            end
+
+            def build_directory
+                if configuration.inplace
+                    @module.source_directory
+                else
+                    @module.build_directory
+                end
+            end
+
+            def inplace
+                configuration.inplace
+            end
+
+            def prefix
+                @module.prefix
+            end
+
+            def env
+                @module.env
+            end
+
+            def build
+                raise NotImplementedError, "#{self.class}::build in #{self.class}"
+            end
+
+            def self.config
+                raise NotImplementedError, "#{self.class}::name in #{self}"
+            end
+
+            def configure
+                raise NotImplementedError, "#{self.class}::configure in #{self.class}"
+            end
+
+            def configured?
+                raise NotImplementedError, "#{self.class}::configured? in #{self.class}"
+            end
+
+            def name
+                raise NotImplementedError, "#{self.class}::name in #{self.class}"
+            end
+
+            def remove_build_directory
+                self.class.execute "rm -rf #{build_directory}"
+            end
+
+        #########
+        protected
+        #########
+
+            def check_build_directory( create = false )
+                if inplace
+                    if File.exist? @module.build_directory
+                        if !File.symlink?( @module.build_directory )
+                           $log.warn( "Could not link build directory to source directory for inplace build of #{@module.name}." )
+                        end
+                    else
+                        FileUtils.mkdir_p( Pathname.new( @module.build_directory ).parent )
+                        File.symlink( @module.source_directory, @module.build_directory )
+                    end
+                else
+                    if File.exist? build_directory
+                        if File.directory? build_directory
+                            return true
+                        else
+                            raise BuildError, "Build directory #{build_directory} exists and is no directory!"
+                        end
+                    elsif create
+                        FileUtils.mkdir_p( build_directory )
+                        return true
+                    else
+                        return false
+                    end
+                end
+            end
+
+        end
+
+end; end
+

data/lib/kde-build/build_system/cmake.rb

@@ -0,0 +1,82 @@
+require 'kde-build/build_system/base'
+
+require 'kde-build/tools/make'
+
+module BuildTool
+
+    module BuildSystem
+
+        class CMakeConfiguration < BaseConfiguration
+
+            option( 'options', "Command line options for cmake" )
+            option( 'cmake-prefix-path', "CMAKE_PREFIX_PATH environment variable" )
+
+            def initialize
+                super
+                self.name = "cmake"
+            end
+
+        end
+
+        class CMake < BuildSystem::Base
+
+            def initialize( mod )
+                super
+            end
+
+            def self.guess( path )
+                return File.exist? "#{path}/CMakeLists.txt"
+            end
+
+            def self.config
+                CMakeConfiguration
+            end
+
+            # Execute a cmake command in the context of the build directory
+            def cmake( command, wd = build_directory )
+                ENV['CMAKE_PREFIX_PATH'] = configuration.cmake_prefix_path
+                self.class.execute "cmake #{command}", wd, env
+            end
+
+            def make( command, wd = build_directory )
+                BuildTool::Make.new.make "#{command}", wd
+            end
+
+            def build( target )
+                check_build_directory( true )
+                make target
+            end
+
+            def reconfigure( clean )
+                make "clean" if clean
+                self.class.execute "rm #{build_directory}/CMakeCache.txt" if clean
+                configure
+            end
+
+            def configure
+                check_build_directory( true )
+                opt = options
+                opt += " -DCMAKE_INSTALL_PREFIX=#{prefix}" if prefix
+                rc = cmake "#{self.source_directory} #{opt}"
+                rc
+            end
+
+            def configured?
+                File.exist? "#{build_directory}/Makefile"
+            end
+
+            def name
+                "CMake"
+            end
+
+            def options
+                @configuration.options
+            end
+
+            Registry.register( 'CMake', CMake )
+
+        end
+
+    end
+
+end

data/lib/kde-build/build_system/qtcopy.rb

@@ -0,0 +1,125 @@
+require 'kde-build/build_system/base'
+
+require 'kde-build/tools/make'
+
+module BuildTool
+
+    module BuildSystem
+
+        class QtCopyConfiguration < BaseConfiguration
+
+            option( 'options', "Command line options for qmake" )
+
+            def initialize
+                super
+                self.name = "qmake"
+            end
+
+        end
+
+        class QtCopyError < Exception
+        end
+
+
+        class QtCopy < BuildSystem::Base
+
+            def initialize( mod )
+                super
+            end
+
+            def self.guess( path )
+                return File.exist? "#{path}/qmake/qmake.pro"
+            end
+
+            def self.config
+                QtCopyConfiguration
+            end
+
+            # Execute a qmake command in the context of the build directory
+            def qmake( command, wd = build_directory )
+                execute "qmake #{command}", wd, env
+            end
+
+            def make( command, wd = build_directory )
+                BuildTool::Make.new.make "#{command}", wd
+            end
+
+            def build( target )
+                check_build_directory( true )
+                make target
+            end
+
+
+            def reconfigure( clean = false )
+                make "confclean" if clean
+                configure
+            end
+
+            def configure
+                check_build_directory( true )
+                create_configure_new_if_necessary
+                opt = options
+                opt += " --prefix=#{prefix}" if prefix
+                rc = self.class.execute( "sh #{self.source_directory}/configure.new #{opt}", wd = build_directory, env )
+                rc
+            end
+
+
+            def configured?
+                return File.exist? "#{build_directory}/bin/qmake"
+            end
+
+            def create_configure_new
+                if $noop
+                    $log.info("Creating configure.new")
+                    return
+                end
+                confnew = File.new( "#{source_directory}/configure.new", "w" )
+                conf    = File.new( "#{source_directory}/configure", "r" )
+                conf.each do |line|
+                    confnew.write(
+                        line.
+                            sub("read acceptance", "acceptance=yes").
+                            sub("read commercial", "commercial=o") )
+                end
+                confnew.chmod( 0744 )
+            ensure
+                conf.close
+                confnew.close
+            end
+
+            def create_configure_new_if_necessary
+                confnew_name =      "#{source_directory}/configure.new"
+
+                if File.exist? confnew_name
+                    begin
+                        confnew = File.new( "#{source_directory}/configure.new", "r" )
+                        conf    = File.new( "#{source_directory}/configure", "r" )
+                        if ( confnew.mtime > conf.mtime )
+                            return
+                        end
+                    ensure
+                        confnew.close
+                        conf.close
+                    end
+                end
+                create_configure_new
+            end
+
+            def name
+                "QtCopy"
+            end
+
+            def options
+                @configuration.options
+            end
+
+            Registry.register( 'QtCopy', QtCopy )
+
+        end
+
+
+    end
+
+end
+