build-tool 0.0.3 → 0.1.0

data/lib/build-tool/commands.rb

@@ -0,0 +1,639 @@
+require "build-tool/singleton"
+require 'build-tool/errors'
+require 'shellwords'
+require 'optparse'
+require 'delegate'
+
+
+module BuildTool; module Commands;
+
+    #
+    # Mixin which allows defining attribute easily
+    #
+    module ClassAttribute
+
+        def def_attribute( *names )
+            class_eval do
+                names.each do |name|
+                    define_method( name ) do |*args|
+                        case args.size
+                        when 0 then instance_variable_get( "@#{name}" )
+                        else    instance_variable_set( "@#{name}", *args )
+                        end
+                    end
+                end
+            end
+        end
+
+    end
+
+
+    #
+    # Module that provides some standard helptext functionality
+    #
+    module HelpText
+
+        module ClassMethods
+
+            extend ClassAttribute
+
+            def_attribute :name
+            def_attribute :description
+            def_attribute :cmdalias
+
+        end
+
+        def name
+            self.class.name
+        end
+
+        def cmdalias
+            self.class.cmdalias
+        end
+
+        def description
+            self.class.description
+        end
+
+        def self.included( klass )
+            klass.extend( ClassMethods )
+        end
+
+    end # module HelpText
+
+    #
+    # Base class for all commands
+    #
+    class Base
+
+        class UsageError < BuildTool::Error; end
+
+        include HelpText
+
+        attr_reader :options
+        attr_reader :parent
+
+        def initialize(parent = nil)
+            @options = OptionParser.new
+            @options.set_program_name( name )
+            initialize_options
+            @skip_command = false
+            @parent = parent
+        end
+
+        def applicable?
+            true
+        end
+
+        def configuration
+            Application::instance.configuration
+        end
+
+        def initialize_options
+        end
+
+        def complete_readline_1_8( string )
+            # Readline in 1.8 does not provide all needed information. We have to hand made
+            # it ourselves. We get the complete commandline here.
+
+            # We want the complete commandline in line_buffer
+            line_buffer = string
+            # An array of completed arguments/options in args
+            args = Shellwords.shellwords( line_buffer )
+
+            # And the string to complete in string. If the last character is a space we
+            # complete from that. if not we take the last arg
+            if line_buffer.empty? or line_buffer[-1] == 32
+                args << ""
+            end
+
+            do_complete_1_8( args )
+        end
+
+        def do_complete_1_8( args )
+            # puts "do_complete_1_8( #{args.inspect} )"
+            compl = complete_arguments( args )
+            if compl.length >= 1
+                return compl.collect do |res|
+                    args.dup[0..-2].push(res).join(" ")
+                end
+            else
+                return []
+            end
+        end
+
+        def complete_readline_1_9( string )
+            # We have three sources of information (ruby 1.9 only)
+            # argument:
+            #   See Readline::completer_word_break_characters . The part
+            #   of the command line to complete
+            # Readline::line_buffer
+            #   The complete command line
+            # Readline::point
+            #   The position of the cursor in commandline
+            # Ruby 1.9 <start>
+            # First check if we have to complete the first shellword (command)
+            args = Shellwords.shellwords( string )
+
+            # And the string to complete in string. If the last character is a space we
+            # complete from that. if not we take the last arg
+            if string.empty? or string[-1] == 32
+                args << ""
+            end
+
+            do_complete_1_9( args )
+        end
+
+        def do_complete_1_9( args )
+            return complete_arguments( args )
+        end
+
+        def complete( string )
+            if Readline.respond_to? "line_buffer"
+                complete_readline_1_9( string )
+            else
+                complete_readline_1_8( string )
+            end
+        end
+
+        def complete_arguments( args )
+            res = each_option.collect { |sw|
+                sw.long.collect { |long|
+                    res = []
+                    long = long.clone
+                    if long.sub!( '[no-]', 'no-' )
+                        res << long if long.start_with? args[-1]
+                        long = long.sub( 'no-', '' )
+                    end
+                    res << long if long.start_with? args[-1]
+                    res
+                }
+            }
+            res.flatten.compact.sort
+        end
+
+        def each_option
+            list = options.instance_variable_get( "@stack" )
+            if block_given?
+                list.each do |l|
+                    l.list.each do |sw|
+                        next if sw.is_a? String
+                        yield sw
+                    end
+                end
+            else
+                list.collect { |l| l.list.collect { |sw| sw unless sw.is_a? String } }.flatten.compact
+            end
+        end
+
+        def do_execute
+            raise NotImplementedError, "#{self.class}.do_execute() not implemented"
+        end
+
+        def execute( args )
+            @options = OptionParser.new
+            @options.set_program_name( name )
+
+            @parsing = true
+            initialize_options
+            begin
+                realargs =  @options.parse( args )
+            rescue OptionParser::ParseError => e
+                logger.error( "#{e}" )
+                @skip_command = true
+            end
+            @parsing = false
+
+            if !@skip_command
+                begin
+                    return do_execute( realargs )
+                rescue BuildTool::Error => e
+                    logger.error   e.message
+                    logger.verbose e.backtrace.join("\n")
+                end
+            end
+
+            # Either we skipped the command or we catched an exception
+            return -1;
+        end
+
+        def show_help( args = [] )
+            # Just ignore potential arguments
+            say @options.help
+            skip_command
+            return 0
+        end
+
+        # During option parsing use this method to tell the class to not
+        # execute the command
+        def skip_command
+            @skip_command = true
+        end
+
+        def say( *args )
+            logger.info( *args )
+        end
+
+        def usage( error )
+            logger.error error
+            show_help
+            return -2
+        end
+
+    end # class Base
+
+
+    class Alias < SimpleDelegator
+
+        attr_reader :name
+        def initialize( alternate, cmd )
+            super( cmd )
+            @name = alternate
+            @cmd = cmd
+        end
+
+    end
+
+
+    class Standard < Base
+
+        def initialize_options
+            options.separator "Common options"
+
+            options.on( "-v", "--verbose", "Enable verbose output" ) do
+                Logging.appenders['stdout'].level = [ Logging.appenders['stdout'].level-1, 0 ].max
+            end
+
+            options.on( nil, "--dry-run", "Enable dry run." ) do
+                $noop = true
+            end
+
+            options.on( "-h", "--help", "Show this help text" ) do
+                show_help
+            end
+        end
+
+        def complete_modules( name, all = false )
+            res = []
+            found = false
+            configuration.modules.each do |mod|
+                next if ( !all and mod.is_template? )
+                # We match on the following conditions:
+                #   1. name  = mod.name
+                #   2. name/ matches beginning of mod.name
+                #   3. name starts with ":". Look for package instead of
+                #   module
+                if name.end_with?('/') and mod.name.start_with? name
+                    res << mod
+                    found = true
+                elsif mod.name == name
+                    res << mod
+                    found = true
+                end
+            end
+            raise UsageError, "Unknown module/package #{name}" if !found
+            return res
+        end
+
+        def while_logging_to( dir, fname, level, &block )
+            got_exception = false
+            dirname = @log_directory
+            dirname = "#{@log_directory}/#{dir}" if dir
+            FileUtils.mkdir_p( dirname )
+            Logging.logger['root'].add_appenders(
+                Logging.appenders.file(
+                    fname,
+                    :filename => dirname + '/' + fname,
+                    :layout => Logging::Layouts::Pattern.new( :pattern => '%m\n' ),
+                    :level => level ))
+
+            begin
+                yield
+            rescue Interrupt => e
+                logger.error "User Interrupt!"
+            rescue Exception => e
+                logger.error   "#{e.class}:#{e.message}"
+                got_exception = true
+                raise e
+            ensure
+                Logging.logger['root'].remove_appenders( fname )
+                logger.info("More information in #{dirname}/#{fname}") if got_exception
+            end
+        end
+
+        def initialize_log_directory
+            logdir = configuration.log_directory
+
+            # Ensure the base log directory exists
+            if !File.exist? "#{logdir}"
+                FileUtils.mkdir_p "#{logdir}"
+            end
+
+            i = -1
+
+            begin
+                @log_directory = "#{logdir}/#{Date.today.to_s}-%02d" % i+=1
+            end until !File.exist?( @log_directory )
+
+            FileUtils.mkdir_p( @log_directory )
+            FileUtils.rm_f( "#{logdir}/latest" )
+            FileUtils.ln_sf( @log_directory, "#{logdir}/latest" )
+        end
+
+    end # class Standard
+
+    class ModuleBasedCommand < Standard
+
+        def is_module_ready?( mod )
+            true
+        end
+
+        def do_execute( args )
+
+            if args.length == 0
+                # *TODO* print better message
+                return usage( "Not enough arguments." )
+            end
+
+            # 1. Resolve the modules
+            modules = []
+            args.each do |arg|
+                complete_modules( arg ).each do |mod|
+                    modules << mod
+                end
+            end
+
+            # 2. Check prerequisites
+            isready = true
+            modules.each do |mod|
+                isready &= is_module_ready?( mod )
+            end
+
+            if !isready
+                logger.error "Found problems. Exiting"
+                return -1
+            end
+
+            # 3. Let's go
+            initialize_log_directory
+
+            rc = 0      # Our return code.
+
+            while_logging_to nil, 'build-status', :info do
+
+                modules.each do |mod|
+
+                    begin
+                        logger.info ""
+                        logger.info "#### Module #{mod.name}"
+                        do_execute_module( mod )
+                    rescue Interrupt => e
+                        raise e
+                    rescue BuildTool::Error => e
+                        logger.error   e.message
+                        logger.verbose e.backtrace.join("\n")
+                        rc = -1
+                    rescue Exception => e
+                        logger.error   "#{e.class}:#{e.message}"
+                        logger.verbose e.backtrace.join("\n")
+                        rc = -1
+                    ensure
+                        logger.info "#### Module #{mod.name} finished"
+                    end
+                end
+
+            end
+
+            return rc;
+        end
+
+    end
+
+
+    #
+    # Commands that has subcommands
+    #
+    class SubCommands < Base
+
+        def initialize( *args )
+            super( *args )
+            @commands = []
+        end
+
+        def add_command( cmd )
+            logger.trace "#{name}: Adding command #{cmd.name}"
+            @commands << cmd
+        end
+
+        def get_command( name )
+            partial = Array.new
+            @commands.each do |cmd|
+                return cmd if cmd.name == name
+                partial << cmd if cmd.name.start_with? name
+            end
+            if partial.length == 1
+                return partial[0]
+            end
+            nil
+        end
+
+        def execute( args )
+            # There has to be a subcommand
+            if args.length == 0
+                return show_help
+            end
+
+            cmd = get_command( args[0] )
+            if cmd.nil?
+                if self.name
+                    raise UsageError, "Unknown command #{args[0]} for #{self.name}"
+                else
+                    raise UsageError, "Unknown command #{args[0]}"
+                end
+            end
+            cmd.execute( args[1..-1] )
+        end
+
+        def do_complete_1_8( args )
+            # puts "#{self.name}.do_complete_1_8( #{args.inspect}"
+            if args.length <= 1
+                # There is only one or no argument. We try to complete to a
+                # command.
+                if subcmd = get_command( args[0] )
+                    # We have a exact match. If we had to complete to get to
+                    # the commands return here. If not forward to the command
+                    if args[0] != subcmd.name
+                        return [ subcmd.name ]
+                    else
+                        return subcmd.do_complete_1_8( [""] ).collect do |res|
+                            [ subcmd.name ].push(res).join(" ")
+                        end
+                    end
+                else
+                    # We have a no exact match. Complete the available
+                    # commands
+                    return complete_command( args[0] )
+                end
+            else
+                # At least two arguments are present
+                if subcmd = get_command( args[0] )
+                    # We have a exact match. Forward to that command.
+                    return subcmd.do_complete_1_8( args[1..-1] ).collect do |res|
+                        [ subcmd.name ].push(res).join(" ")
+                    end
+                else
+                    # No exact match. Since there is at least on argument
+                    # behind the current position just keep the user input
+                    # intact.
+                    return []
+                end
+            end
+        end
+
+        def do_complete_1_9( args )
+            # puts "#{self.name}.do_complete_1_9( #{args.inspect} )"
+            if args.length <= 1
+                if subcmd = get_command( args[0] )
+                    return subcmd.do_complete_1_9( [""] )
+                else
+                    return complete_command( args[0] )
+                end
+            else
+                if subcmd = get_command( args[0] )
+                    return subcmd.do_complete_1_9( args[1..-1] )
+                else
+                    return args
+                end
+            end
+        end
+
+        def complete_command( cmdname )
+            # puts "#{self.name}.complete_command( #{cmdname.inspect} )"
+            cmds = @commands.collect { |com|
+                com.name if com.name.start_with? cmdname
+            }.compact
+        end
+
+        def complete_arguments( args, string )
+            # args[0] is supposed to contain the command name
+            if cmd = get_command( args[0] )
+                return cmd.complete_arguments( args, string )
+            else
+                return []
+            end
+        end
+
+        def show_help( args = [] )
+            if args.length == 0
+                @commands.each do |cmd|
+                    say "%-20s: %s" % [ cmd.name, cmd.description ]
+                end
+            else
+                if cmd = get_command( args[0] )
+                    cmd.show_help( args[1..-1] )
+                else
+                    if self.name
+                        raise UsageError, "Unknown command #{args[0]} for #{self.name}"
+                    else
+                        raise UsageError, "Unknown command #{args[0]}"
+                    end
+                end
+            end
+            return 0
+        end
+
+        def load_commands( path, parentmod )
+            # puts "load_commands( #{path}, #{parentmod} )"
+            # Load the commands
+            Dir[  "#{path}/*.rb" ].each do |mod|
+                cmdname = Pathname.new( mod ).basename( '.rb' ).to_s
+                load_command( path, parentmod, cmdname )
+            end
+        end
+
+        def load_command( path, parentmod, mod )
+            # puts "load_command( #{path}, #{parentmod}, #{mod} )"
+            load "#{path}/#{mod}.rb"
+            self.instance_eval %{
+                if #{parentmod}::#{mod.capitalize}.instance_of? ::Module
+                    cmd = #{parentmod}::#{mod.capitalize}.create( self )
+                else
+                    cmd = #{parentmod}::#{mod.capitalize}.new( self )
+                end
+                return if !cmd.applicable?
+
+                if cmd.cmdalias
+                    parent.add_command( Alias.new( cmd.cmdalias, cmd ) )
+                end
+                if cmd.is_a?( SubCommands )
+                    cmd.load_commands( "#{path}/#{mod}", "#{parentmod}::#{mod.capitalize}" )
+                end
+                add_command( cmd )
+            }
+        end
+
+    end # class SubCommands
+
+
+    #
+    # 
+    #
+    class Shell < SubCommands
+
+        name   "shell"
+
+        def execute( args )
+            if args.length == 0
+                return cli
+            end
+            super
+        end
+
+        def cli
+            require 'readline'
+
+            Readline.completion_proc = method(:complete)
+            if !Readline.respond_to? "line_buffer"
+                # 1.8 :(
+                Readline.completer_word_break_characters = "\x00"
+            end
+
+            while true
+
+                begin
+
+                    line = Readline.readline('> ', true)
+
+                    return 0 if line.nil?
+
+                    # Ignore whitespace lines
+                    next if Shellwords.shellwords( line ).length == 0
+
+                    # Remove duplicate or empty lines from history
+                    if line =~ /^\s*$/ or Readline::HISTORY.to_a[-2] == line
+                        Readline::HISTORY.pop
+                    end
+
+                    # Split the line like bash would do it
+                    execute Shellwords.shellwords( line )
+
+                rescue BuildTool::Error => e
+                    logger.error e.message
+                    logger.verbose e.backtrace.join("\n")
+                rescue StandardError => e
+                    logger.error e.message
+                    logger.error e.backtrace.join("\n")
+                rescue Interrupt => e
+                    say "Use CTRL-D for exit!"
+                end
+
+            end
+
+            return 0
+        end
+
+    end # class Shell
+
+
+end; end;
+