build-tool 0.0.1

data/lib/kde-build/command.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+#
+require 'cmdparse'
+
+module BuildTool
+
+
+    class Command < CmdParse::Command
+
+
+        def show_help
+            puts "#{name}: #{short_desc}"
+            puts description if description
+            if has_commands?
+                list_commands
+            end
+        end
+
+        def complete( args )
+            if options.instance
+                puts options.instance.complete( :long, "-v", true )
+                return ["#{name} Yeah"]
+            else
+                return []
+            end
+        end
+
+    end
+
+end

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

@@ -0,0 +1,119 @@
+# encoding: utf-8
+#
+
+require 'kde-build/command'
+require 'kde-build/command/help'
+
+module BuildTool
+
+
+    class BuildCommand < Command
+
+        def initialize
+            super( 'build', false )
+            self.short_desc = "build [options] [:package|module|path/]..."
+            self.description = "fetch, rebase, build and install the specified modules."
+            @update = true
+            @configure = false
+            @reconfigure = false
+            @install = true
+            @from_scratch = false
+            self.options = CmdParse::OptionParserWrapper.new do |opt|
+                opt.separator "Global Options"
+                opt.on( "--no-update", "Do not update from the repository" ) { |t|
+                    @update = false
+                    }
+                opt.on( "--configure", "Run the configuration step again" ) { |t|
+                    @configure = true
+                    }
+                opt.on( "--reconfigure", "Remove old configuration then run configuration again" ) { |t|
+                    @reconfigure = true
+                    }
+                opt.on( "--no-install", "Do not install" ) { |t|
+                    @install = false
+                    }
+                opt.on( "--from-scratch", "Remove build dir" ) { |t|
+                    @from_scratch = true
+                    }
+                opt.on( "--help", "Show this help" ) { |t|
+                    }
+            end
+        end
+
+        def prepare_execution( mod )
+            skip = false
+            if @update
+                mod.activate_ssh_key
+            else
+                if !mod.checkedout?
+                    $log.error("Module #{mod.name} is not checkedout and will be skipped!")
+                    skip = true
+                end
+            end
+            !skip
+        end
+
+        def execute( args )
+            if args.length == 0
+                show_help
+                return
+            end
+
+            real_modules = []
+
+            ModuleRegistry.get_modules( args ) do |mod|
+                if prepare_execution( mod )
+                    real_modules.push( mod )
+                end
+            end
+
+            real_modules.each do |mod|
+                begin
+                    $log.info( "###############################################################" )
+                    $log.info( "### Building module #{mod.name}" )
+                    $log.info( "###############################################################" )
+
+                    if @from_scratch
+                        mod.remove_build_directory
+                    end
+
+                    if @update
+
+                        if mod.checkedout?
+                            mod.fetch
+                            mod.rebase
+                        else
+                            mod.init
+                        end
+
+                    end
+
+                    if @reconfigure
+                        mod.reconfigure( true )
+
+                    elsif @configure
+                        if mod.configured?
+                            mod.reconfigure
+                        else
+                            mod.configure
+                        end
+
+                    elsif !mod.configured?
+                        mod.configure
+                    end
+
+
+                    mod.build( @install )
+
+                rescue Exception => e
+                    $log.info("error: #{e.class}: #{e.message}")
+                    puts e.backtrace if $verbose
+                end
+                $log.info("")
+
+            end
+        end
+
+    end
+
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+require 'kde-build/command'
+
+module BuildTool
+
+    class FetchCommand < Command
+
+        def initialize
+            super( 'fetch', false )
+            self.short_desc = "Fetch"
+            self.description = "Fetch long"
+            self.options = CmdParse::OptionParserWrapper.new do |opt|
+                opt.on( "--verbose", "Verbose output" ) { |t|
+                    $verbose = true
+                    }
+            end
+
+        end
+
+        def execute( args )
+            puts "do: #{args}"
+        end
+
+    end
+
+
+end

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

@@ -0,0 +1,71 @@
+# encoding: utf-8
+#
+require 'kde-build/command'
+
+module BuildTool
+
+
+  # The default help command. It adds the options "-h" and "--help" to the global options of the
+  # associated +CommandParser+. When the command is specified on the command line, it can show the
+  # main help or individual command help.
+  class HelpCommand < Command
+
+    def initialize
+      super( 'help', false )
+      self.short_desc = 'Provide help for individual commands'
+      self.description = 'This command prints the program help if no arguments are given. ' \
+      'If one or more command names are given as arguments, these arguments are interpreted ' \
+      'as a hierachy of commands and the help for the right most command is show.'
+    end
+
+    def init
+      case commandparser.main_command.options
+      when CmdParse::OptionParserWrapper
+        commandparser.main_command.options.instance do |opt|
+          opt.on_tail( "-h", "--help", "Show help" ) do
+            execute( [] )
+          end
+        end
+      end
+    end
+
+    def usage
+      "Usage: #{commandparser.program_name} help [COMMAND SUBCOMMAND ...]"
+    end
+
+    def execute( args )
+      if args.length > 0
+        cmd = commandparser.main_command
+        arg = args.shift
+        while !arg.nil? && cmd.commands[ arg ]
+          cmd = cmd.commands[arg]
+          arg = args.shift
+        end
+        if arg.nil?
+          cmd.show_help
+        else
+          raise InvalidArgumentError, args.unshift( arg ).join(' ')
+        end
+      else
+        show_program_help
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def show_program_help
+      puts commandparser.banner + "\n" if commandparser.banner
+      puts "Usage: #{commandparser.program_name} [options] COMMAND [options] [COMMAND [options] ...] [args]"
+      puts ""
+      list_commands( 1, commandparser.main_command )
+      puts ""
+      puts commandparser.main_command.options.summarize
+      puts
+    end
+
+  end
+
+
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+#
+require 'kde-build/command'
+
+module BuildTool
+
+
+    class InfoCommand < Command
+
+        def initialize
+            super( 'info', false )
+            self.short_desc = "Information about a module"
+            self.description = "Retrieve Information aboud modules"
+        end
+
+        def execute( args )
+            args.each do |modname|
+                mod = ModuleRegistry.get_modules( modname ) do |mod|
+                    if mod == nil
+                        puts "#{modname} is unknown"
+                        return
+                    end
+
+                    puts "Building: #{modname}"
+                    puts "Repository:  #{mod.repository}"
+                    puts "Remote Path: #{mod.remote_path}"
+                    puts "Stage:       #{mod.workdir}"
+                    puts "Build Directory: #{mod.build_directory}"
+                    puts "Source Directory: #{mod.source_directory}"
+
+                    puts "VCS:              #{mod.vcs.name}"
+                    puts "                  #{mod.vcs.configuration.externals}"
+                    puts "  checkedout:     #{mod.vcs.checkedout?}"
+                end
+            end
+        end
+
+    end
+
+
+end
+

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

@@ -0,0 +1,43 @@
+# 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

@@ -0,0 +1,186 @@
+# encoding: utf-8
+#
+
+require 'kde-build/metaaid'
+
+module MJ;
+
+    class ConfigurationError < Exception
+    end
+
+    module Configuration
+
+        class Option
+
+            attr_accessor :name, :attribute, :description
+
+            def initialize( obj, name, description )
+                @name = name
+                @attribute =self.class.sanitize name
+                @description = description
+                @one_of = nil
+                @on_read = nil
+                @on_write = nil
+                @required = false
+                install obj
+            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]
+                    opt.read(value)
+                end
+
+                obj.class_def( "#{attribute}=" ) do
+                    |value|
+                    opt = self.class.__options__[attribute]
+
+                    if !opt
+                        puts self
+                        puts self.class.__options__.inspect
+                    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
+                exit( -1 )
+            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
+                @values ||= Hash.new
+            end
+
+            def set( key, val )
+                # puts "Options = #{self.class.options.inspect}"
+                self.send( "#{Option.sanitize( key )}=", val )
+            end
+
+            def validate
+                begin
+                    self.class.__options__.each_pair do |name, opt|
+                        opt.validate( @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
+                    throw "TODO"
+                end
+                self
+            end
+        end
+    end
+end
+