build-tool 0.0.3 → 0.1.0

data/lib/kde-build/build_system.rb

@@ -1,28 +0,0 @@
-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
-
-class UnknownBuildSystemError < Exception; end
-
-def get( name )
-    if !available.include? name
-        raise UnknownBuildSystemError, "Buildsystem '#{name}' is not supported"
-    end
-    @mapping[name]
-end
-
-end; end

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

@@ -1,108 +0,0 @@
-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
-                self.class.execute( "#{source_directory}/autogen.sh #{configuration.autogen_options}", build_directory, 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( clean )
-                if clean
-                    return false if make( "clean" ) != 0
-                    return false if !bootstrap( true ) != 0
-                end
-                configure
-            end
-
-            def configure
-                check_build_directory( true )
-                bootstrap
-                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.status"
-            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

@@ -1,139 +0,0 @@
-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' ).
-                default = false
-
-        end
-
-
-        class Base
-
-            include MJ::Tools::SubProcess
-
-            attr_accessor :configuration
-
-            def initialize( mod )
-                @module = mod
-            end
-
-            def info
-                puts "Build System:      #{name}"
-                puts "  Out Of Source Build: #{!inplace}"
-                puts "  Options:             #{options}"
-            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

@@ -1,94 +0,0 @@
-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 )
-                myenv = env
-                myenv['CMAKE_PREFIX_PATH'] = cmake_prefix_path
-                self.class.execute "cmake #{command}", wd, env
-            end
-
-            def cmake_prefix_path
-                @configuration.cmake_prefix_path
-            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 )
-                if clean
-                    return false if make( "clean" ) != 0
-                end
-                return false if self.class.execute( "rm #{build_directory}/CMakeCache.txt" ) != 0
-                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 info
-                super
-                puts "  CMAKE_PREFIX_PATH:   #{cmake_prefix_path}"
-            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

@@ -1,127 +0,0 @@
-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
-                begin
-                    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
-            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
-