build-tool 0.0.3 → 0.1.0

data/lib/kde-build/command/module_based.rb

@@ -1,44 +0,0 @@
-require 'kde-build/command'
-
-module BuildTool
-
-    class ModuleBasedCommand < Command
-
-        def execute( args )
-
-            # If no argument is given show the help and quit.
-            if args.length == 0
-                show_help
-                return
-            end
-
-            # Map the command line to real modules
-            real_modules = []
-            ModuleRegistry.get_modules( args ) do |mod|
-                # Check if the module is fit for the command
-                if is_module_ready( mod )
-                    real_modules.push( mod )
-                end
-            end
-
-            # Execute the command for each module
-            real_modules.each do |mod|
-                begin
-
-                    execute_for_module( mod )
-
-                rescue Interrupt => e
-                    $log.info("SIGBREAK recieved.")
-                    return
-
-                rescue Exception => e
-                    $log.info("error: #{e.class}: #{e.message}")
-                    puts e.backtrace if $verbose
-                end
-
-            end
-        end
-
-    end
-
-end

data/lib/kde-build/command/rebase.rb

@@ -1,50 +0,0 @@
-require 'kde-build/command/module_based'
-
-module BuildTool
-
-    class RebaseCommand < ModuleBasedCommand
-
-        def initialize
-            super( 'rebase', false )
-            self.short_desc = "Rebase the local repository."
-            self.description = <<-"EOS"
-Rebases the local repository against the changes made in the remote
-repository. The changes will be first fetched and then the rebase is done. If
-the vcs doesn't support that separation fetch and rebase are done in one step.
-
-If --no-update is present only a rebase is done. Remember that  svn doesn't
-support that separation and will still fetch changes.
-            EOS
-            @update = true
-            self.options = CmdParse::OptionParserWrapper.new do |opt|
-                opt.separator "Options:"
-                opt.on( "--no-update", "Do not update from the repository" ) { |t|
-                    @update = false
-                    }
-            end
-        end
-
-        def is_module_ready( mod )
-            mod.activate_ssh_key
-            true
-        end
-
-        def execute_for_module( mod )
-
-            $log.info( "###############################################################" )
-            $log.info( "### Rebasing module #{mod.name}" )
-            $log.info( "###############################################################" )
-
-            if mod.checkedout?
-                mod.fetch if @update
-                mod.rebase
-            else
-                mod.init
-            end
-        end
-
-    end
-
-
-end
-

data/lib/kde-build/command/version.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-#
-require 'kde-build/command'
-
-module BuildTool
-
-
-  # The default version command. It adds the options "-v" and "--version" to the global options of
-  # the associated +CommandParser+. When specified on the command line, it shows the version of the
-  # program.
-  class VersionCommand < Command
-
-    def initialize
-      super( 'version', false )
-      self.short_desc = "Show the version of the program"
-    end
-
-    def init
-      case commandparser.main_command.options
-      when CmdParse::OptionParserWrapper
-        commandparser.main_command.options.instance do |opt|
-          opt.on_tail( "--version", "-v", "Show the version of the program" ) do
-            execute( [] )
-          end
-        end
-      end
-    end
-
-    def usage
-      "Usage: #{commandparser.program_name} version"
-    end
-
-    def execute( args )
-      version = commandparser.program_version
-      version = version.join( '.' ) if version.instance_of?( Array )
-      puts commandparser.banner + "\n" if commandparser.banner
-      puts version
-    end
-
-  end
-
-
-end

data/lib/kde-build/configuration.rb

@@ -1,209 +0,0 @@
-# encoding: utf-8
-#
-
-require 'kde-build/metaaid'
-
-module MJ;
-
-    class ConfigurationError < Exception
-    end
-
-    module Configuration
-
-        class Option
-
-            attr_accessor :name, :attribute, :description, :default
-
-            def initialize( obj, name, description )
-                @name = name
-                @attribute =self.class.sanitize name
-                @description = description
-                @default = nil
-                @one_of = nil
-                @on_read = nil
-                @on_write = nil
-                @required = false
-
-                install obj
-            end
-
-            def default=( value )
-                @default = value
-                self
-            end
-
-            def self.sanitize( name )
-                name.gsub( /[^a-zA-Z_]/, '_' )
-            end
-
-            def install( obj )
-                attribute = @attribute
-
-                obj.class_def( attribute ) do
-                    opt = self.class.__options__[attribute]
-                    value = self.values[attribute]
-                end
-
-                obj.class_def( "#{attribute}=" ) do
-                    |value|
-                    opt = self.class.__options__[attribute]
-
-                    if !opt
-                        puts self
-                        puts self.class.__options__.inspect
-                        raise Exception, "????"
-                    end
-                    # First validate the value
-                    opt.validate(value)
-                    value = opt.write(value)
-
-                    # Then call the custom on_write method
-                    self.values[attribute] = value
-                end
-            end
-
-            def validate( value )
-                if @one_of and !@one_of.include? value
-                    raise ConfigurationError, "Value #{value} is invalid for #{@name}."
-                end
-                if @required and value === nil || value.empty?
-                    raise ConfigurationError, "Required option #{@name} is not set."
-                end
-            end
-
-            def one_of( options )
-                @one_of = options
-                self
-            end
-
-            def on_write( &block )
-                @on_write = block
-            end
-
-            def required
-                @required = true
-                self
-            end
-
-            def write( value )
-                begin
-                    return @on_write.call( value ) if @on_write
-                    value
-                rescue Exception => e
-                    $log.error("Error while setting #{@name} to #{value}")
-                    raise e
-                end
-            end
-
-            def on_read( &block )
-                @on_read = block
-            end
-
-            def read( value )
-                return @on_read.call( value ) if @on_read
-                value
-            end
-
-        end
-
-        def flatten_values( val, &block )
-            if val.instance_of?( Array )
-                val.each do |i|
-                    flatten_values( i, &block )
-                end
-            elsif val.instance_of?( Hash )
-                val.each do |k, v|
-                    yield k, v
-                end
-            else
-                puts o.class
-                puts o.inspect
-                raise Exception, "??????????"
-            end
-        end
-        module_function :flatten_values
-
-
-        module Configurable
-
-            def self.included( klass )
-                klass.extend( ClassMethods )
-                klass.send( :class_variable_set, '@@__options__', Hash.new )
-            end
-
-            module ClassMethods
-
-                def __options__
-                    class_variable_get( '@@__options__' )
-                end
-
-                def option( name, description )
-                    opt = Option.new( self, name, description )
-                    self.__options__[opt.attribute] = opt
-                    opt
-                end
-
-
-            end
-
-
-            def values
-                return @values if @values
-                @values = Hash.new
-                self.class.__options__.each_pair do |name, opt|
-                    @values[name] = opt.default
-                end
-                @values
-            end
-
-            def set( key, val )
-                begin
-                    # puts "Options = #{self.class.options.inspect}"
-                    self.send( "#{Option.sanitize( key )}=", val )
-                rescue BuildTool::VCS::UnknownVcsError => e
-                    $log.warn( "Unknown vcs '#{key}' configured for #{self.name}:#{self.class}" )
-                    raise e
-                rescue NameError => e
-                    $log.warn( "Unknown option #{key} configured for #{self.name}:#{self.class}" )
-                    raise e
-                rescue Exception => e
-                    $log.warn( "Caught exception #{e.message} for #{self.inspect}:#{self.class} while setting #{key} to #{val.inspect}" )
-                    raise e
-                end
-            end
-
-            def validate
-                begin
-                    self.class.__options__.each_pair do |name, opt|
-                        opt.validate( self.values[opt.attribute] )
-                    end
-                rescue ConfigurationError => e
-                    $log.error( "Validation for #{self.class} (#{self.to_s}) failed: #{e}" )
-                    puts e.backtrace if $verbose
-                    raise e
-                end
-            end
-
-            def parse( val )
-                # If it is a array we expect it to only contain hashes
-                if val.instance_of?( Array )
-                    val.each { |i| parse( i ) }
-                elsif val.instance_of?( Hash )
-                    val.each_pair {
-                        |k, v|
-                        begin
-                            # puts "#{self.class}.#{k} = #{v}"
-                            send "#{Option.sanitize k}=", v
-                        rescue NameError => e
-                            $log.warn( "Unknown option '#{k}' for #{self.class} in #{self.name}: #{e}" )
-                        end
-                    }
-                else
-                    raise Exception, "FIXME"
-                end
-                self
-            end
-        end
-    end
-end
-

data/lib/kde-build/exception.rb

@@ -1,6 +0,0 @@
-module BuildTool
-
-    class BuildToolError < Exception
-    end
-
-end

data/lib/kde-build/metaaid.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-class Object
-
-   # The hidden singleton lurks behind everyone
-   def metaclass; class << self; self; end; end
-   def meta_eval &blk; metaclass.instance_eval( &blk ); end
-
-   # Adds methods to a metaclass
-   def meta_def name, &blk
-     meta_eval { define_method name, &blk }
-   end
-
-   # Defines an instance method within a class
-   def class_def name, &blk
-     class_eval { define_method name, &blk }
-   end
-end

data/lib/kde-build/module.rb

@@ -1,227 +0,0 @@
-# encoding: utf-8
-#
-require 'kde-build/tools/ssh.rb'
-require 'kde-build/tools/logging.rb'
-
-module BuildTool
-
-    class ConfigureError < Exception
-    end
-
-    class BuildError < Exception
-    end
-
-    class Module
-
-        def initialize(config)
-            @config = config
-            @build_system = nil
-            @vcs = nil
-        end
-
-        def activate_ssh_key
-            # No key, no cookies
-            return if !@config.ssh_key
-
-            ssh = MJ::Tools::SSH.new
-            if !ssh.has_key? ssh_key
-                ssh.add_key(ssh_file)
-            end
-        end
-
-        def name
-            @config.name
-        end
-
-        # The build directory
-        def build_directory
-            "#{workdir}/bld/#{local_path}"
-        end
-
-        def local_path
-            @local_path = @config.local_path || @config.remote_path
-        end
-
-        def build( install, clean = false )
-            $log.info("Compiling")
-            rc = nil
-            if clean
-                while_logging_to( name, "50_build" ) do
-                    if build_system.make( "clean" ) != 0
-                        raise BuildError, "make returned error code #{rc}"
-                    end
-                    $log.info( "make clean was successful" )
-                end
-            end
-
-            while_logging_to( name, "50_build" ) do
-                rc =
-                    if install
-                        build_system.make( "install"  )
-                    else
-                        build_system.make
-                    end
-
-                if rc != 0
-                    raise BuildError, "make returned error code #{rc}"
-                end
-                $log.info( "build was  successful" )
-            end
-        end
-
-        # The build system
-        def build_system
-            if not @build_system
-                if not @config.build_system
-                    klass = BuildTool::BuildSystem::Registry.guess( source_directory )
-                    if !klass
-                        raise ModuleError, "Failed to guess the build system for #{name}"
-                    end
-                else
-                    klass = BuildTool::BuildSystem::get(@config.build_system.name)
-                end
-                @build_system = klass.new( self )
-                @build_system.configuration = @config.build_system
-            end
-            @build_system
-        end
-
-
-        def remove_build_directory
-            $log.info("removing #{build_directory}")
-            build_system.remove_build_directory
-        end
-
-
-        # Configure the module
-        def reconfigure( clean = false )
-            $log.info("Reconfiguring")
-            while_logging_to( name, "30_configure" ) do
-                if !$noop and !vcs.checkedout?
-                    raise ConfigureError, "Module is not checked out."
-                end
-                rc = build_system.reconfigure( clean )
-                if rc != 0
-                    raise ConfigureError, "configure returned error code #{rc}"
-                end
-            end
-        end
-
-        # Configure the module
-        def configure
-            $log.info("configuring")
-            while_logging_to( name, "30_configure" ) do
-                if !$noop and !vcs.checkedout?
-                    raise ConfigureError, "Module is not checked out."
-                end
-                rc = build_system.configure
-                if rc != 0
-                    raise ConfigureError, "configure returned error code #{rc}"
-                end
-            end
-        end
-
-        # Is the module already configured?
-        def configured?
-            if !vcs.checkedout?
-                return false
-            end
-            build_system.configured?
-        end
-
-        def checkedout?
-            vcs.checkedout?
-        end
-
-        def env
-            @config.env
-        end
-
-        def fetch
-            $log.info("Fetching from #{remote_path}")
-            while_logging_to( name, "20_fetch" ) do
-                vcs.fetch
-            end
-        end
-
-        def init
-            $log.info("Initializing #{local_path} from #{remote_path}")
-            while_logging_to( name, "10_initialize" ) do
-                vcs.init
-            end
-        end
-
-        def info
-            puts "############### Module #{name}"
-            puts "Repository:        #{remote_path}"
-            puts "SSH Key:           #{ssh_file}" if ssh_file
-            puts "Local Checkout:    #{workdir}/#{local_path} #{configured? ? '(EXISTS)' : '' }"
-            puts "Build Directory:   #{build_directory} #{checkedout? ? '(EXISTS)' : '' }"
-            puts "Prefix:            #{prefix}"
-            puts "Environment:"
-            env.each do |var, val|
-                puts "  %-20s %s" % [ var + ":", val ]
-            end if env
-            vcs.info
-            build_system.info
-        end
-
-        def ssh_key
-            return @config.ssh_key
-        end
-
-        def ssh_file
-            return @config.ssh_file
-        end
-
-        # The root directory for the +/bld+, +/src+ and +/log+ directories
-        def workdir
-            Application::instance.workdir
-        end
-
-        def rebase
-            $log.info("rebasing")
-            while_logging_to( name, "40_rebase" ) do
-                vcs.rebase
-            end
-        end
-
-        # The absolute remote path
-        def remote_path
-            "#{repository}/#{@config.remote_path}"
-        end
-
-        # The repository url
-        def repository
-            @config.repository
-        end
-
-        def prefix
-            @config.prefix
-        end
-
-        # The absolute source directory.
-        def source_directory
-            "#{workdir}/src/#{local_path}"
-        end
-
-        # reimplement
-        def to_yaml_type
-            "!michael-jansen.biz,2009-01-01/Module"
-        end
-
-        # #########
-        # protected
-        # #########
-
-        def vcs
-            if ! @vcs
-                @vcs = VCS::get(@config.vcs.name).new( remote_path, source_directory )
-                @vcs.configuration = @config.vcs
-            end
-            @vcs
-        end
-
-    end
-
-end