bee 0.1.1 → 0.2.0

data/lib/bee_console.rb

@@ -0,0 +1,539 @@
+# Copyright 2006 Michel Casabianca <casa@sweetohm.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Module for Bee stuff.
+module Bee
+
+  module Console
+
+    require 'bee'
+    require 'getoptlong'
+
+    # Command line help.
+    HELP = 'Usage: bee [options] [targets]
+-h        Print help about usage and exit.
+-b        Print help about build and exit.
+-k [task] Print help about all tasks or given one.
+-t        Write template build file on disk.
+-v        Enable verbose mode.
+-s style  Define style for output (see documentation).
+-f file   Build file to run (defaults to "build.yml").
+targets   Targets to run (default target if omitted).'
+    # Name for default build file.
+    DEFAULT_BUILD_FILE = 'build.yml'
+    # Exit value on error parsing command line
+    EXIT_PARSING_CMDLINE = 1
+    # Exit value on build error
+    EXIT_BUILD_ERROR = 2
+    # Exit value on unknown error
+    EXIT_UNKNOWN_ERROR = 3
+
+    # Parse command line and return parsed arguments.
+    def self.parse_command_line
+      help = false
+      help_build = false
+      help_task = false
+      task = nil
+      template = false
+      verbose = false
+      style = nil
+      file = DEFAULT_BUILD_FILE
+      targets = []
+      # read options in BEEOPT environment variable
+      options = ENV['BEEOPT']
+      options.split(' ').reverse.each { |option| ARGV.unshift(option) } if
+        options
+      # parse command line arguments
+      opts = GetoptLong.new(['--help', '-h', GetoptLong::NO_ARGUMENT],
+                            ['--help-build', '-b', GetoptLong::NO_ARGUMENT],
+                            ['--help-task','-k', GetoptLong::OPTIONAL_ARGUMENT],
+                            ['--template', '-t', GetoptLong::NO_ARGUMENT ],
+                            ['--verbose', '-v', GetoptLong::NO_ARGUMENT],
+                            ['--style', '-s', GetoptLong::REQUIRED_ARGUMENT],
+                            ['--file', '-f', GetoptLong::REQUIRED_ARGUMENT])
+      opts.each do |opt, arg|
+        case opt
+        when '--help'
+          help = true
+        when '--help-build'
+          help_build = true
+        when '--help-task'
+          help_task = true
+          task = arg
+        when '--template'
+          template = true
+        when '--verbose'
+          verbose = true
+        when '--style'
+          style = arg
+        when '--file'
+          file = arg
+        end
+      end
+      targets = ARGV
+      return [help, help_build, help_task, task, template, verbose, style,
+              file, targets]
+    end
+
+    # Start build from command line.
+    def self.start_command_line
+      STDOUT.sync = true
+      begin
+        help, help_build, help_task, task, template, verbose, style, file,
+        targets = parse_command_line
+      rescue
+        puts "ERROR: parsing command line (type 'bee -h' for help)"
+        exit(EXIT_PARSING_CMDLINE)
+      end
+      formatter = Formatter.new(style)
+      begin
+        if help
+          readme = File.join(File.dirname(__FILE__), '..', 'README')
+          if File.exists?(readme)
+            copyright = File.read(readme).strip!.split("\n")[-1]
+            puts copyright
+          end
+          puts HELP
+        elsif help_build
+          build = Build.new(file)
+          puts formatter.help_build(build)
+        elsif help_task
+          build = Build.new(file)
+          puts formatter.help_task(build, task)
+        elsif template
+          puts "Writing build template in file '#{file}'..."
+          raise BuildError.new("Build file '#{file}' already exists") if 
+            File.exists?(file)
+          File.open(file, 'w') { |file| file.write(BUILD_TEMPLATE) }
+          puts formatter.format_success("OK")
+        else
+          listener = ConsoleListener.new(formatter, verbose)
+          build = Build.new(file)
+          build.run(targets, listener)
+        end
+      rescue BuildError
+        puts "#{formatter.format_error('ERROR')}: #{$!}"
+        exit(EXIT_BUILD_ERROR)
+      rescue SystemExit
+        # do nothing, exit in code
+      rescue Exception => e
+        puts "#{formatter.format_error('ERROR')}: #{$!}"
+        puts e.backtrace.join("\n")
+        exit(EXIT_UNKNOWN_ERROR)
+      end
+    end
+
+    #########################################################################
+    #                            FORMATTER CLASS                            #
+    #########################################################################
+
+    # Class to format build output on console.
+    class Formatter
+
+      include BuildErrorMixin
+
+      ###################### ANSI COLORS AND STYLES #########################
+
+      # 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 ############################
+
+      # Default style (supposed to work on any configuration).
+      DEFAULT_STYLE = {
+        :line_character => '-'
+      }
+      # Default line length.
+      DEFAULT_LINE_LENGTH = 80
+      # 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'      
+      }
+
+      ############################## METHODS ################################
+
+      # Constructor.
+      # - style: style as a Hash or a String.
+      def initialize(style)
+        # if style is a String, this is command line argument
+        style = parse_style_from_command_line(style) if style.kind_of?(String)
+        # if style is nil, set default style
+        @style = style || DEFAULT_STYLE
+        # set default values for keys if nil
+        for key in DEFAULT_STYLE.keys
+          @style[key] = @style[key] || DEFAULT_STYLE[key]
+        end
+      end
+
+      # Format a target.
+      # - target: target to format.
+      def format_target(target)
+        name = target.name
+        # generate title line
+        length = @style[:line_length] || line_length || DEFAULT_LINE_LENGTH
+        right = ' ' + @style[:line_character]*2
+        left = @style[:line_character]*(length - (name.length + 4)) + ' '
+        line = left + name + right
+        # apply style
+        formatted = style(line, 
+                          @style[:target_style], 
+                          @style[:target_foreground],
+                          @style[:target_background])
+        return formatted
+      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 = 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 = ''
+        if build.name
+          help << "- Build: #{build.name.inspect}\n"
+        end
+        if build.description
+          help << format_description('Description', build.description, 2, false)
+        end
+        if build.properties.keys.length > 0
+          help << "- Properties:\n"
+          for property in build.properties.keys.sort
+            help << "  - #{property}: #{build.properties[property].inspect}\n"
+          end
+        end
+        if build.targets.length > 0
+          help << "- Targets:\n"
+          for target in build.targets.values.sort { |a, b| a.name <=> b.name }
+            help << format_description(target.name, target.description, 2)
+          end
+        end
+        help << "- Default: #{build.default}"
+        return help.strip
+      end
+
+      # Return help about task(s).
+      # - build: running build.
+      # - task: task to print help about (all tasks if nil).
+      def help_task(build, task)
+        task = nil if task.length == 0
+        help = ''
+        if task
+          error "Task '#{task}' not loaded" if not build.tasks[task]
+          help << build.tasks[task]
+        else
+          for task in build.tasks.keys.sort
+            help << format_description(task, build.tasks[task], 0, true)
+          end
+        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
+
+      # Get line length calling IOCTL. Return nil if call failed.
+      def line_length
+        begin
+          tiocgwinsz = 0x5413
+          string = [0, 0, 0, 0].pack('SSSS')
+          if $stdin.ioctl(tiocgwinsz, string) >= 0 then
+            rows, cols, xpixels, ypixels = string.unpack('SSSS')
+            return cols
+          end
+        rescue
+          return nil
+        end
+      end
+
+      # Parse style from command line. If error occurs parsing style, return
+      # nil (which means default style).
+      # - string: style to parse.
+      def parse_style_from_command_line(string)
+        return if not string
+        style = {}
+        begin
+          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
+        rescue
+          # if parsing fails, return default style (nil)
+          return nil
+        end
+      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
+          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
+        end
+        return string
+      end
+
+    end
+
+    #########################################################################
+    #                           CONSOLE LISTENER                            #
+    #########################################################################
+
+    # Listener when running in a console. Prints messages on the console using
+    # a given formatter.
+    class ConsoleListener
+
+      # 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
+
+      # 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)
+        @start_time = Time.now
+        @end_time = nil
+        @duration = nil
+        @success = nil
+        @last_target = nil
+        @last_task = nil
+        puts "Starting build '#{build.file}'..." if @verbose
+      end
+
+      # Called when build is finished.
+      # - build: the build object.
+      def build_finished(build)
+        @end_time = Time.now
+        @duration = @end_time - @start_time
+        @success = true
+        puts "Built in #{@duration} s" if @verbose
+        puts @formatter.format_success('OK')
+      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 an error was raised.
+      # - exception: raised exception.
+      def error(exception)
+        @end_time = Time.now
+        @duration = @end_time - @start_time
+        @success = false
+        puts "Built in #{@duration} s" if @verbose
+        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
+        puts "#{@formatter.format_error('ERROR')}: #{message}"
+      end
+
+    end
+
+    #########################################################################
+    #                            BUILD TEMPLATE                             #
+    #########################################################################
+
+    BUILD_TEMPLATE = 
+      '# Template build file
+- build: template
+  description: Template build file.
+  default: hello
+
+# Build properties
+- properties:
+  - user: "#{ENV[\'USER\']}"
+
+# Build targets
+- target: capitalize
+  description: Capitalize user name
+  script:
+  - rb: "who = user.capitalize"
+
+- target: hello
+  depends: capitalize
+  description: Print greatings.
+  script:
+  - "echo \"Hello #{who}!\""
+'
+
+  end
+
+end