bee 0.10.2 → 0.11.0

data/lib/bee_console_formatter.rb

@@ -0,0 +1,314 @@
+# 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.
+# 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.
+
+require 'rubygems'
+require 'bee_console_style'
+
+module Bee
+
+  module Console
+
+    # Class to format build output on console.
+    class Formatter
+
+      include Bee::Util::BuildErrorMixin
+
+      # Minimum duration to print on console even if not verbose (in seconds)
+      AUTO_DURATION = 60
+
+      # Construct formatting order
+      CONSTRUCT_FORMATS = {
+        'if' =>    ['if', 'then', 'else'],
+        'while' => ['while', 'do'],
+        'for' =>   ['for', 'in', 'do'],
+        'try' =>   ['try', 'catch'],
+      }
+
+      # Verbosity indicator
+      attr_reader :verbose
+
+      # Constructor.
+      # - style: style as a Hash or a String.
+      # - color: tells if we use default color scheme. Defaults to false.
+      # - verbose: tells if build is verbose. Defaults to false.
+      # - outputer: object on which we call print and puts for outputs.
+      #   Defaults to Kernel.
+      def initialize(style, color=false, verbose=false, outputer=Kernel)
+        @style = Bee::Console::Style.new(style, color)
+        @verbose = verbose
+        @outputer = outputer
+      end
+
+      ##########################################################################
+      #                       LOW LEVEL OUTPUT METHODS                         #
+      ##########################################################################
+
+      # Print a given message on console:
+      # - message: the message to print.
+      def print(message)
+        @outputer.print(message)
+      end
+
+      # Puts a given message on console:
+      # - message: the message to put.
+      def puts(message)
+        @outputer.puts(message)
+      end
+
+      ##########################################################################
+      #                     METHODS CALLED BY LISTENER                         #
+      ##########################################################################
+
+      # Print build start message:
+      # - build: the started build.
+      # - dry_run: tells if we are running in dry mode.
+      def print_build_started(build, dry_run)
+        if @verbose
+          build_type = dry_run ? "dry run of" : "build"
+          puts "Starting #{build_type} '#{build.file}'..."
+        end
+      end
+
+      # Print message when build finished:
+      # - duration: the build duration in seconds.
+      # - success: tells if build was a success.
+      # - exception : exception raised, if any.
+      # - last_target: last met target, if any.
+      # - last_task: last met task, if any.
+      def print_build_finished(duration)
+        puts "Built in #{duration} s" if @verbose or duration >= AUTO_DURATION
+      end
+
+      # Print target:
+      # - target: the target we are running.
+      def print_target(target)
+        puts format_target(target)
+      end
+
+      # Print task:
+      # - task: the task we are running.
+      def print_task(task)
+        puts format_task(task) if @verbose
+      end
+
+      ##########################################################################
+      #                          FORMATTING METHODS                            #
+      ##########################################################################
+
+      # 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
+            if task.keys.length == 1
+              source = format_entry(task)
+            else
+              source = format_construct(task)
+            end
+          end
+        end
+        formatted = '- ' + source.strip.gsub(/\n/, "\n. ")
+        styled = @style.style(formatted, :task)
+        return styled
+      end
+
+      # Format a success string.
+      # - string: string to format.
+      def format_success(string)
+        string = @style.style(string, :success)
+        return string
+      end
+
+      # Format an error string.
+      # - string: string to format.
+      def format_error(string)
+        string = @style.style(string, :error)
+        return string
+      end
+
+      # Format error message:
+      # - exception: raised exception.
+      def format_error_message(exception)
+        message = format_error('ERROR')
+        message << ": "
+        message << exception.to_s
+        if exception.kind_of?(Bee::Util::BuildError)
+          message << "\nIn target '#{exception.target.name}'" if exception.target
+          message << ", in task:\n#{format_task(exception.task)}" if exception.task
+        end
+        return message
+      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.style(line, :target)
+        return formatted
+      end
+
+      ##########################################################################
+      #                       HELP FORMATTING METHODS                          #
+      ##########################################################################
+
+      # Return help about build.
+      # - build: running build.
+      def help_build(build)
+        build.context.evaluate
+        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).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.targets.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
+
+      def format_entry(entry)
+        return YAML::dump(entry).sub(/---/, '').strip
+      end
+
+      def format_construct(construct)
+        for key in CONSTRUCT_FORMATS.keys
+          if construct.has_key?(key)
+            lines = []
+            for entry in CONSTRUCT_FORMATS[key]
+              lines << format_entry({entry => construct[entry]})
+            end
+            return lines.join("\n")
+          end
+        end
+        return "UNKNOWN CONSTRUCT"
+      end
+
+    end
+
+  end
+
+end

data/lib/bee_console_style.rb

@@ -0,0 +1,222 @@
+# 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.
+# 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.
+
+require 'rubygems'
+require 'bee_util'
+
+module Bee
+
+  module Console
+
+    # Class to manage a style for console output.
+    class Style
+
+      include Bee::Util::BuildErrorMixin
+
+      # style attributes
+      attr_reader :line_character
+      attr_reader :line_length
+      attr_reader :target_style
+      attr_reader :target_foreground
+      attr_reader :target_background
+      attr_reader :task_style
+      attr_reader :task_foreground
+      attr_reader :task_background
+      attr_reader :success_style
+      attr_reader :success_foreground
+      attr_reader :success_background
+      attr_reader :error_style
+      attr_reader :error_foreground
+      attr_reader :error_background
+
+      # List of style types
+      TYPES = [:target, :task, :success, :error]
+
+      # 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'
+      }
+
+      # Build the style from command line arguments:
+      # - style: the style as a hash or a string (as passed on command line).
+      #   Defaults to nil.
+      # - color: tells if we use color style. Defaults to nil.
+      def initialize(style=nil, color=nil)
+        @line_character = nil
+        @line_length = nil
+        @target_style = nil
+        @target_foreground = nil
+        @target_background = nil
+        @task_style = nil
+        @task_foreground = nil
+        @task_background = nil
+        @success_style = nil
+        @success_foreground = nil
+        @success_background = nil
+        @error_style = nil
+        @error_foreground = nil
+        @error_background = nil
+        apply(color ? COLOR_STYLE : DEFAULT_STYLE)
+        apply(style)
+      end
+
+      # Apply style to a string:
+      # - string: the string to apply style to.
+      # - type: the type of style to apply (one of :target, :task, :success or
+      #   :error).
+      def style(string, type)
+        raise "Type '#{type}' unknown: must be one of " + TYPES.map{|e| ":#{e}"}.join(', ') if
+          not TYPES.include?(type)
+        style = eval("@#{type}_style")
+        foreground = eval("@#{type}_foreground")
+        background = eval("@#{type}_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
+
+      private
+
+      # Apply a given style:
+      # - style: the style as a hash or a string.
+      def apply(style)
+        if style.kind_of?(Hash)
+          for key, value in style
+            check_attribute_value(key, value)
+            eval("@#{key} = #{value.inspect}")
+          end
+        elsif style.kind_of?(String)
+          for pair in style.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 if value
+            end
+            check_attribute_value(key, value)
+            eval("@#{key} = #{value.inspect}")
+          end
+        else
+          raise "Style must ne a Hash or a String" if style
+        end
+      end
+
+      def check_attribute_value(attribute, value)
+        raise "Attribute '#{attribute}' must be a symbol" unless
+          attribute.kind_of?(Symbol)
+        raise "Unknown attribute '#{attribute}'" unless
+          instance_variable_defined?("@#{attribute}".to_sym)
+        if attribute == :line_length
+          raise "'line_length' attribute must be an integer" unless
+            value.kind_of?(Integer)
+        elsif attribute == :line_character
+          raise "'line_character' must be a single character" unless
+            value.kind_of?(String) and value.length == 1
+        else
+          raise "Value '#{value}' should be a symbol" unless
+            value.kind_of?(Symbol)
+          if attribute.to_s[-6..-1] == '_style'
+            raise "Unkown style '#{value}'" if not STYLES.member?(value)
+          else
+            raise "Unkown color '#{value}'" if not COLORS.member?(value)
+          end
+        end
+      end
+
+    end
+
+  end
+
+end