bee 0.10.2 → 0.11.0

data/lib/bee_console.rb

@@ -1,4 +1,4 @@
-# Copyright 2006-2010 Michel Casabianca <michel.casabianca@gmail.com>
+# Copyright 2006-2011 Michel Casabianca <michel.casabianca@gmail.com>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,23 +13,24 @@
 # limitations under the License.
 
 require 'rubygems'
-require 'bee'
-require 'bee_task'
+require 'bee_build'
 require 'bee_util'
+require 'bee_listener'
+require 'bee_console_formatter'
 require 'getoptlong'
 require 'yaml'
 
-# Module for Bee stuff.
 module Bee
 
   module Console
 
     # Command line help.
-    HELP = 'Usage: bee [options] [targets]
+    HELP = <<'EOF'
+Usage: bee [options] [targets]
 -V             Print version and exit.
 -h             Print help about usage and exit.
 -b             Print help about build and exit.
--n             Don\'t actually run any commands; just print them.
+-n             Don't actually run any commands; just print them.
 -k task        Print help about tasks in a package (writing "foo.?") or a 
                given one (writing "foo.bar") and exit.
 -e egg         Print help about templates in a given package (writing 
@@ -45,7 +46,10 @@ module Bee
 -l             Print bee logo on console.
 -a             Print list of available targets.
 -o             Print list of available options.
-targets        Targets to run (default target if omitted).'
+-f             Print list of available tasks.
+-g             Print list of available templates.
+targets        Targets to run (default target if omitted).
+EOF
     # Options descriptions.
     OPTIONS = [
         ['--version', '-V', GetoptLong::NO_ARGUMENT],
@@ -65,6 +69,8 @@ targets        Targets to run (default target if omitted).'
         ['--logo', '-l', GetoptLong::NO_ARGUMENT],
         ['--targets', '-a', GetoptLong::NO_ARGUMENT],
         ['--options', '-o', GetoptLong::NO_ARGUMENT],
+        ['--tasks', '-x', GetoptLong::NO_ARGUMENT],
+        ['--templates', '-y', GetoptLong::NO_ARGUMENT],
     ]
     # Name for default build file.
     DEFAULT_BUILD_FILE = 'build.yml'
@@ -109,6 +115,8 @@ EOF
       logo = false
       print_targets = false
       print_options = false
+      print_tasks = false
+      print_templates = false
       targets = []
       # read options in BEEOPT environment variable
       options = ENV[BEE_OPT_ENV]
@@ -158,13 +166,18 @@ EOF
           print_targets = true
         when '--options'
           print_options = true
+        when '--tasks'
+          print_tasks = true
+        when '--templates'
+          print_templates = true
         end
       end
       targets = Array.new(ARGV)
       ARGV.replace(old_argv)
-      return [version, help, help_build, help_task, help_template, task,
-              properties, dry_run, template, verbose, style, color, file,
-              recursive, logo, print_targets, print_options, targets]
+      return version, help, help_build, help_task, task, help_template,
+             template, properties, dry_run, verbose, style, color, file,
+             recursive, logo, print_targets, print_options, print_tasks,
+             print_templates, targets
     end
 
     # Parse a command line property.
@@ -173,7 +186,7 @@ EOF
     def self.parse_property(property)
       begin
         index = property.index('=')
-        raise "No = sign" if not index
+        raise "No = sign (should be 'name=value')" if not index
         name = property[0..index-1]
         value = YAML::load(property[index+1..-1])
         return name, value
@@ -187,33 +200,28 @@ EOF
     def self.start_command_line(arguments)
       STDOUT.sync = true
       begin
-        version, help, help_build, help_task, help_template, task,
-          properties, dry_run, template, verbose, style, color, file,
-          recursive, logo, print_targets, print_options,
-          targets = parse_command_line(arguments)
+        version, help, help_build, help_task, task, help_template,
+          template, properties, dry_run, verbose, style, color, file,
+          recursive, logo, print_targets, print_options, print_tasks,
+          print_templates, targets = parse_command_line(arguments)
       rescue
-        # DEBUG
-        puts $!.backtrace
-        puts "ERROR: parsing command line (type 'bee -h' for help)"
+        puts "ERROR: parsing command line: #{$!}"
         exit(EXIT_PARSING_CMDLINE)
       end
       begin
-        formatter = Formatter.new(style, color)
+        formatter = Formatter.new(style, color, verbose)
       rescue
         puts "ERROR: bad format string '#{style}'"
         exit(EXIT_PARSING_CMDLINE)
       end
       begin
-        if logo
-          puts BEE_LOGO
-        end
+        puts BEE_LOGO if logo
         if version
           puts Bee.version
         elsif help
           puts HELP
         elsif help_build
           build = Build.load(file, recursive, properties)
-          build.evaluate_properties
           puts formatter.help_build(build)
         elsif help_task
           puts formatter.help_task(task)
@@ -221,7 +229,7 @@ EOF
           puts formatter.help_template(template)
         elsif template
           file = Bee::Util::find_template(template)
-          listener = Listener.new(formatter, verbose)
+          listener = Listener.new(formatter)
           build = Build.load(file, false, properties)
           build.run(targets, listener, dry_run)
         elsif print_targets
@@ -234,459 +242,30 @@ EOF
           print targets.join(' ')
         elsif print_options
           print OPTIONS.map {|o| o[0]}.join(' ')
+        elsif print_tasks
+          print Bee::Task::PackageManager.list_tasks.join(' ')
+        elsif print_templates
+          print Bee::Task::PackageManager.list_templates.join(' ')
         else
-          listener = Listener.new(formatter, verbose)
+          listener = Listener.new(formatter)
           build = Build.load(file, recursive, properties)
           build.run(targets, listener, dry_run)
+          puts formatter.format_success('OK')
         end
-      rescue Bee::Util::BuildError => e
-        puts "#{formatter.format_error('ERROR')}: #{$!}"
-        puts e.backtrace.join("\n") if verbose
+      rescue Bee::Util::BuildError
+        puts formatter.format_error_message($!)
         exit(EXIT_BUILD_ERROR)
-      rescue Interrupt => e
-        puts "#{formatter.format_error('ERROR')}: Build was interrupted!"
-        puts e.backtrace.join("\n") if verbose
+      rescue Interrupt
+        puts "\n#{formatter.format_error('ERROR')}: Build was interrupted!"
+        puts $!.backtrace.join("\n") if verbose
         exit(EXIT_INTERRUPT_ERROR)
-      rescue Exception => e
+      rescue Exception
         puts "#{formatter.format_error('ERROR')}: #{$!}"
-        puts e.backtrace.join("\n")
+        puts $!.backtrace.join("\n")
         exit(EXIT_UNKNOWN_ERROR)
       end
     end
 
-    # Class to format build output on console.
-    class Formatter
-
-      include Bee::Util::BuildErrorMixin
-
-      # List of colors.
-      COLORS = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
-      # Foreground color codes.
-      FOREGROUND_COLOR_CODES = {
-        :black   => 30,
-        :red     => 31,
-        :green   => 32,
-        :yellow  => 33,
-        :blue    => 34,
-        :magenta => 35,
-        :cyan    => 36,
-        :white   => 37
-      }
-      # Background color codes.
-      BACKGROUND_COLOR_CODES = {
-        :black   => 40,
-        :red     => 41,
-        :green   => 42,
-        :yellow  => 43,
-        :blue    => 44,
-        :magenta => 45,
-        :cyan    => 46,
-        :white   => 47
-      }
-      # List of styles.
-      STYLES = [:reset, :bright, :dim, :underscore, :blink, :reverse, :hidden]
-      # Style codes.
-      STYLE_CODES = {
-        :reset      => 0,
-        :bright     => 1,
-        :dim        => 2,
-        :underscore => 4,
-        :blink      => 5,
-        :reverse    => 7,
-        :hidden     => 8
-      }
-
-      # Default style (supposed to work on any configuration).
-      DEFAULT_STYLE = {
-        :line_character => '-'
-      }
-      # Color style (supposed to work on color terminals).
-      COLOR_STYLE = {
-        :line_character     => '-',
-        :target_foreground  => :yellow,
-        :task_foreground    => :blue,
-        :success_style      => :bright,
-        :success_foreground => :green,
-        :error_style        => :bright,
-        :error_foreground   => :red
-      }
-      # Short style keys for command line
-      SHORT_STYLE_KEYS = {
-        'lc' => 'line_character',
-        'll' => 'line_length',
-        'ts' => 'target_style',
-        'tf' => 'target_foreground',
-        'tb' => 'target_background',
-        'ks' => 'task_style',
-        'kf' => 'task_foreground',
-        'kb' => 'task_background',
-        'ss' => 'success_style',
-        'sf' => 'success_foreground',
-        'sb' => 'success_background',
-        'es' => 'error_style',
-        'ef' => 'error_foreground',
-        'eb' => 'error_background'
-      }
-
-      # Constructor.
-      # - style: style as a Hash or a String.
-      # - color: a boolean telling if we use default color scheme.
-      def initialize(style, color=false)
-        # set default or color style
-        if color
-          @style = COLOR_STYLE.clone
-        else
-          @style = DEFAULT_STYLE.clone
-        end
-        # if style is a String, this is command line argument
-        if style.kind_of?(String)
-          @style.merge!(parse_style_from_command_line(style))
-        elsif style.kind_of?(Hash)
-          @style.merge!(style)
-        end
-      end
-
-      # Format a target.
-      # - target: target to format.
-      def format_target(target)
-        name = target.name
-        return format_title(name)
-      end
-
-      # Format a task.
-      # - task: task to format.
-      def format_task(task)
-        if task.kind_of?(String)
-          source = task
-        elsif task.kind_of?(Hash)
-          if task.key?('rb')
-            source = "rb: #{task['rb']}"
-          else
-            source = YAML::dump(task)
-            source = source.sub(/---/, '')
-          end
-        end
-        formatted = '- ' + source.strip.gsub(/\n/, "\n. ")
-        styled = style(formatted,
-                       @style[:task_style], 
-                       @style[:task_foreground],
-                       @style[:task_background])
-        return styled
-      end
-
-      # Format a success string.
-      # - string: string to format.
-      def format_success(string)
-        string = style(string,
-                       @style[:success_style], 
-                       @style[:success_foreground],
-                       @style[:success_background])
-        return string
-      end
-
-      # Format an error string.
-      # - string: string to format.
-      def format_error(string)
-        string = style(string,
-                       @style[:error_style], 
-                       @style[:error_foreground],
-                       @style[:error_background])
-        return string
-      end
-
-      # Return help about build.
-      # - build: running build.
-      def help_build(build)
-        help = ''
-        # print build name and description
-        if build.name
-          help << "build: #{build.name}\n"
-        end
-        if build.extends
-          help << "extends: #{build.extends.map{|b| b.name}.join(', ')}\n"
-        end
-        if build.description
-          help << format_description('description', build.description, 0, false)
-        end
-        # print build properties
-        if build.context.properties.length > 0
-          help << "properties:\n"
-          for property in build.context.properties.sort
-            help << "- #{property}: " +
-              "#{build.context.get_property(property, true).inspect}\n"
-          end
-        end
-        # print build targets
-        description = build.targets.description
-        if description.length > 0
-          help << "targets:\n"
-          for name in description.keys.sort
-            help << format_description(name, description[name], 0)
-          end
-        end
-        # print default target
-        help << "default: #{build.default}\n"
-        return help.strip
-      end
-
-      # Return help about task(s).
-      # - task: task to print help about (all tasks if nil).
-      def help_task(task)
-        task = '?' if task == nil or task.length == 0
-        package_manager = Bee::Task::PackageManager.new(nil)
-        methods = package_manager.help_task(task)
-        help = ''
-        for method in methods.keys.sort
-          text = methods[method].strip
-          help << format_title(method)
-          help << "\n"
-          help << text
-          help << "\n"
-          if text =~ /Alias for \w+/
-            alias_method = text.scan(/Alias for (\w+)/).flatten[0]
-            help << "\n"
-            help << package_manager.help_task(alias_method)[alias_method].strip
-            help << "\n"
-          end
-        end
-        return help
-      end
-
-      # Return help about template(s).
-      # - template: template to print help about (all templates if nil).
-      def help_template(template)
-        templates = Bee::Util::search_templates(template)
-        help = ''
-        for name in templates.keys
-          build = YAML::load(File.read(templates[name]))
-          properties = nil
-          for entry in build
-            properties = entry['properties'] if entry['properties']
-          end
-          description = 'No description found'
-          if properties
-            if properties['description']
-              description = properties['description']
-            end
-          end
-          help << format_title(name)
-          help << "\n"
-          help << description
-          help << "\n"
-        end
-        return help
-      end
-
-      private
-
-      # Apply style to a string:
-      # - string: the string to apply style to.
-      # - style: style to apply on string.
-      # - foreground: foreground color for string.
-      # - background: background color for string.
-      def style(string, style, foreground, background)
-        # check style, foreground and background colors
-        error "Unknown style '#{style}'" unless 
-          STYLES.member?(style) or not style
-        error "Unknown color '#{foreground}'" unless
-          COLORS.member?(foreground) or not foreground
-        error "Unknown color '#{background}'" unless
-          COLORS.member?(background) or not background
-        # if no style nor colors, return raw string
-        return string if not foreground and not background and not style
-        # insert style and colors in string
-        colorized = "\e["
-        colorized << "#{STYLE_CODES[style]};" if style
-        colorized << "#{FOREGROUND_COLOR_CODES[foreground]};" if foreground
-        colorized << "#{BACKGROUND_COLOR_CODES[background]};" if background
-        colorized = colorized[0..-2]
-        colorized << "m#{string}\e[#{STYLE_CODES[:reset]}m"
-        return colorized
-      end
-
-      # Parse style from command line.
-      # - string: style to parse.
-      def parse_style_from_command_line(string)
-        return if not string
-        style = {}
-        for pair in string.split(',')
-          key, value = pair.split(':')
-          key = SHORT_STYLE_KEYS[key] || key
-          key = key.to_sym
-          if key == :line_length
-            value = value.to_i
-          elsif key == :line_character
-            value = ' ' if not value or value.length == 0
-          else
-            value = value.to_sym
-            error "Unkown color or style '#{value}'" if 
-              not COLORS.member?(value) and not STYLES.member?(value)
-          end
-          style[key] = value
-        end
-        return style
-      end
-
-      # Format a description.
-      # - title: description title (project, property or target name).
-      # - text: description text.
-      # - indent: indentation width.
-      # - bullet: tells if we must put a bullet.
-      def format_description(title, text=nil, indent=0, bullet=true)
-        string = ' '*indent
-        string << '- ' if bullet
-        string << title
-        if text and !text.empty?
-          string << ": "
-          if text.split("\n").length > 1
-            string << "\n"
-            text.split("\n").each do |line|
-              string << ' '*(indent+2) + line.strip + "\n"
-            end
-          else
-            string << text.strip + "\n"
-          end
-        else
-          string << "\n"
-        end
-        return string
-      end
-
-      # Format a title.
-      # - title: title to format.
-      def format_title(title)
-        length = @style[:line_length] || Bee::Util::term_width
-        right = ' ' + @style[:line_character]*2
-        size = length - (title.length + 4)
-        size = 2 if size <= 0
-        left = @style[:line_character]*size + ' '
-        line = left + title + right
-        # apply style
-        formatted = style(line, 
-                          @style[:target_style], 
-                          @style[:target_foreground],
-                          @style[:target_background])
-        return formatted
-      end
-
-    end
-
-    # Listener when running in a console. Prints messages on the console using
-    # a given formatter.
-    class Listener
-
-      # Formatter used by listener.
-      attr_reader :formatter
-      # Verbosity flag.
-      attr_reader :verbose
-      # Build start time.
-      attr_reader :start_time
-      # Build end time.
-      attr_reader :end_time
-      # Build duration.
-      attr_reader :duration
-      # Build success.
-      attr_reader :success
-      # Last target met.
-      attr_reader :last_target
-      # Last task met.
-      attr_reader :last_task
-      # Minimum duration to print on console even if not verbose (in seconds)
-      AUTO_DURATION = 60
-
-      # Constructor.
-      # - formatter: the formatter to use to output on console.
-      # - verbose: tells if we run in verbose mode.
-      def initialize(formatter, verbose)
-        @formatter = formatter
-        @verbose = verbose
-      end
-
-      # Called when build is started.
-      # - build: the build object.
-      def build_started(build, dry_run)
-        @start_time = Time.now
-        @end_time = nil
-        @duration = nil
-        @success = nil
-        @last_target = nil
-        @last_task = nil
-        build_type = dry_run ? "dry run of" : "build"
-        puts "Starting #{build_type} '#{build.file}'..." if @verbose
-      end
-
-      # Called when a target is met.
-      # - target: the target object.
-      def target(target)
-        @last_target = target
-        @last_task = nil
-        puts @formatter.format_target(target)
-      end
-
-      # Called when a task is met.
-      # - task: task source (shell, Ruby or task).
-      def task(task)
-        @last_task = task
-        puts @formatter.format_task(task) if @verbose
-      end
-
-      # Called when build is finished.
-      # - build: the build object.
-      def build_finished(build, dry_run)
-        duration unless dry_run
-        @success = true
-        puts @formatter.format_success('OK')
-      end
-
-      # Called when an error was raised.
-      # - exception: raised exception.
-      def error(exception)
-        duration
-        @success = false
-        message = ''
-        message << "In target '#{@last_target.name}'" if @last_target
-        message << ", in task:\n#{@formatter.format_task(@last_task)}\n" if
-          @last_task
-        message << ': ' if @last_target and not @last_task
-        message << exception.to_s
-        raise Bee::Util::BuildError.new(message)
-      end
-
-      # Recover from a previous error (catching it for instance).
-      def recover
-        @success = true
-      end
-
-      # Print text on the console.
-      # - text: text to print.
-      def print(text)
-        Kernel.print(text)
-      end
-      
-      # Puts text on the console.
-      # - text: text to puts.
-      def puts(text)
-        Kernel.puts(text)
-      end
-
-      # Get input string.
-      # Return string entered by the user.
-      def gets
-        return STDIN.gets
-      end
-
-      private
-
-      # Compute build duration and print it if verbose.
-      def duration
-        @end_time = Time.now
-        @duration = @end_time - @start_time
-        @duration = (@duration * 1000).round / 1000
-        puts "Built in #{@duration} s" if @verbose or @duration >= AUTO_DURATION
-      end
-      
-    end
-
   end
 
 end