bee 0.9.0 → 0.10.0

data/lib/bee_console.rb

@@ -62,7 +62,7 @@ targets        Targets to run (default target if omitted).'
        | |__   ___  ___                                                   
  ____  | '_ \ / _ \/ _ \  _____ _____ _____ _____ _____ _____ _____ _____ _____
 |____| | |_) |  __/  __/ |_____|_____|_____|_____|_____|_____|_____|_____|_____|
-       |_.__/ \___|\___|  0.9.0                         http://bee.rubyforge.org
+       |_.__/ \___|\___|  0.10.0                        http://bee.rubyforge.org
 
 EOF
 
@@ -180,7 +180,12 @@ EOF
         puts "ERROR: parsing command line (type 'bee -h' for help)"
         exit(EXIT_PARSING_CMDLINE)
       end
-      formatter = Formatter.new(style, color)
+      begin
+        formatter = Formatter.new(style, color)
+      rescue
+        puts "ERROR: bad format string '#{style}'"
+        exit(EXIT_PARSING_CMDLINE)
+      end
       begin
         if logo
           puts BEE_LOGO
@@ -372,7 +377,7 @@ EOF
           help << "build: #{build.name}\n"
         end
         if build.extends
-          help << "extends: #{build.extends}\n"
+          help << "extends: #{build.extends.map{|b| b.name}.join(', ')}\n"
         end
         if build.description
           help << format_description('description', build.description, 0, false)
@@ -434,10 +439,8 @@ EOF
           end
           description = 'No description found'
           if properties
-            for property in properties
-              if property.keys == ['description']
-                description = property['description']
-              end
+            if properties['description']
+              description = properties['description']
             end
           end
           help << format_title(name)
@@ -475,33 +478,27 @@ EOF
         return colorized
       end
 
-      # Parse style from command line. If error occurs parsing style, return
-      # nil (which means default style).
+      # Parse style from command line.
       # - 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
+        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
-          return style
-        rescue
-          # if parsing fails, return default style (nil)
-          return nil
+          style[key] = value
         end
+        return style
       end
 
       # Format a description.

data/lib/bee_context.rb

@@ -0,0 +1,138 @@
+# Copyright 2006-2010 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.
+
+# Module for Bee core classes.
+module Bee
+  
+  # Class for Ruby scripts context. All embedded Ruby scripts run in this
+  # context where build properties are defined as Ruby variables.
+  class Context
+
+    include Bee::Util::BuildErrorMixin
+    
+    # The binding of this context.
+    attr_reader :context_binding
+    
+    # Constructor.
+    def initialize(properties)
+      @properties = properties
+      @context_binding = get_binding
+    end
+    
+    # Set a given property in context.
+    # - name: the property name.
+    # - value: the property value.
+    # - override: tells if we can overwrite an existing value.
+    def set_property(name, value, overwrite=true)
+      error "Property '#{name}' was already defined" if 
+        !overwrite and properties.include?(name.to_s)
+      begin
+        eval("#{name} = #{value.inspect}", @context_binding)
+      rescue Exception
+        error "Error setting property '#{name} = #{value.inspect}': #{$!}"
+      end
+    end
+    
+    # Get a given property in context.
+    # - name: the property name.
+    # - strict: raise an error if given property was not set.
+    def get_property(name, strict=false)
+      error "Property '#{name}' was not set" if 
+        strict and !properties.include?(name.to_s)
+      begin
+        eval("#{name}", @context_binding)
+      rescue NameError
+        error "Property '#{name}' was not set"
+      rescue Exception
+        error "Error getting property '#{name}': #{$!}"
+      end
+    end
+    
+    # Return list of properties (as local variables of binding).
+    def properties
+      return eval('local_variables', @context_binding).map{ |var| var.to_s }
+    end
+    
+    # Evaluate a script in context.
+    # - script: source of the script to evaluate.
+    def evaluate_script(script)
+      eval(script, @context_binding)
+    end
+    
+    # Process a given object, replacing properties references with their
+    # string value, symbol with their raw value. Property references have
+    # same form than variable references in ruby strings: '#{variable}'
+    # will be replaced with variable string value.
+    # - object: object to process.
+    def evaluate_object(object)
+      case object
+      when NilClass
+        # nil: return nil
+        return nil
+      when String
+        # string: replace embedded Ruby expressions
+        object = object.gsub(/#\{.+?\}/) do |match|
+          expression = match[2..-2]
+          begin
+            value = evaluate_script(expression)
+          rescue
+            error "Error evaluating expression '#{expression}': #{$!}"
+          end
+          value
+        end
+        return object 
+      when Symbol
+        # symbol: return property object
+        property = object.to_s
+        begin
+          value = eval("#{property}", @context_binding)
+        rescue
+          error "Property '#{property}' was not set"
+        end
+        return evaluate_object(value)
+      when Array
+        # array: evaluate each element
+        return object.collect { |element| evaluate_object(element) }
+      when Hash
+        # hash: evaluate all keys and values
+        evaluated = {}
+        object.each_pair do |key, value| 
+          evaluated[evaluate_object(key)] = evaluate_object(value)
+        end
+        return evaluated
+      else
+        return object
+      end
+    end
+    
+    private
+    
+    # Get a binding as script context.
+    def get_binding
+      return binding
+    end
+
+    # Catch missing properties
+    def method_missing(name, *args, &block)
+      stack = Thread.current[:stack]
+      if stack
+        @properties.evaluate_property(name, self)
+      else
+        raise NoMethodError.new("undefined method `#{name}'", name, args)
+      end
+    end 
+    
+  end
+
+end

data/lib/bee_properties.rb

@@ -0,0 +1,145 @@
+# Copyright 2006-2010 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 'bee_context'
+
+# Module for Bee core classes.
+module Bee
+  
+  # Class to manage properties.
+  class Properties
+
+    include Bee::Util::BuildErrorMixin
+
+    # Key for properties entry.
+    KEY = 'properties'
+
+    # List of system properties
+    SYSTEM_PROPERTIES = [:base, :here]
+
+    # Properties expressions as a hash.
+    attr_reader :expressions
+    # Properties values as a hash
+    attr_reader :values
+
+    # Constructor.
+    # - build: build object.
+    def initialize(build)
+      @build = build
+      @expressions = {}
+      @values = {}
+      defaults
+    end
+
+    # Write properties. Will raise an error on duplicate definitions.
+    # - object: object tree resulting from YAML build file parsing or string
+    #   for a properties file to load.
+    def write(object)
+      properties = object[Properties::KEY]
+      if properties.kind_of?(String)
+        begin
+          source = Bee::Util::get_file(properties, @build.base)
+          hash = YAML::load(source)
+          set_properties(hash, false)
+        rescue Exception
+          error "Error loading properties file '#{properties}': #{$!}"
+        end
+      else
+        set_properties(properties, false)
+      end
+    end
+
+    # Overwrite properties with those passed.
+    # - properties: properties as a hash.
+    def overwrite(properties)
+      set_properties(properties, true)
+    end
+
+    # Extend with properties of parent build.
+    # - properties: properties of parent build.
+    def extend(properties)
+      for name in properties.expressions.keys
+        @expressions[name] = properties.expressions[name] if 
+          !@expressions.include?(name)
+      end
+    end
+
+    # Evaluate properties in context.
+    # - context: build context where properties must be evaluated.
+    def evaluate(context)
+      for name in @expressions.keys
+        Thread.current[:stack] = []
+        evaluate_property(name, context) if !@values[name]
+      end
+      Thread.current[:stack] = nil
+    end
+
+    # Evaluate a given property.
+    # - name: the name of the property to evaluate.
+    # - context: the context in which the property must be evaluated.
+    # - stack: the stack of evaluated objects.
+    def evaluate_property(name, context)
+      stack = Thread.current[:stack]
+      error "Unknown property '#{name}'" if !@expressions.keys.include?(name)
+      error "Circular properties: #{stack.join(', ')}" if stack.include?(name)
+      begin
+        stack.push(name)
+        value = context.evaluate_object(@expressions[name])
+        stack.pop
+        @values[name] = value
+        context.set_property(name, value, true)
+      rescue
+        error "Error evaluating property '#{name}': #{$!}"
+      end
+      value
+    end
+
+    private
+
+    # Set default properties.
+    def defaults
+      set(:base, @build.base, false)
+      set(:here, @build.here, false)
+    end
+
+    # Set properties.
+    # - properties: properties as a hash.
+    # - overwrite: tells if we can overwrite existing properties.
+    def set_properties(properties, overwrite)
+      error "Properties must be a hash" if not properties.kind_of?(Hash)
+      for name in properties.keys
+        expression = properties[name]
+        set(name, expression, overwrite)
+      end
+    end
+
+    # Set a property.
+    # - name: property name (as a string or symbol).
+    # - expression: property expression (as a string) to be evaluated in
+    #   context to get value.
+    # - overwrite: tells if we can overwrite existing properties.
+    def set(name, expression, overwrite)
+      error "Property '#{name}' collides with a function of the context" if
+        Bee::Context.method_defined?(name) or 
+        Bee::Context.private_method_defined?(name)
+      return if expression == nil
+      name = name.to_sym
+      error "Duplicate property definition: '#{name}'" if 
+        not overwrite and @expressions.has_key?(name)
+      @expressions[name] = expression
+    end
+
+  end
+
+end

data/lib/bee_target.rb

@@ -0,0 +1,287 @@
+# Copyright 2006-2010 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.
+
+# Module for Bee core classes.
+module Bee
+  
+  # Class for a target. It is built from the YAML build file and manages a
+  # target, in particular, tasks execution.
+  class Target
+    
+    include Bee::Util::BuildErrorMixin
+    include Bee::Util::HashCheckerMixin
+
+    # Target key.
+    KEY = 'target'
+    # Target entry description.
+    DESCRIPTION = {
+      'target'      => :mandatory,
+      'depends'     => :optional,
+      'description' => :optional,
+      'script'      => :optional}
+
+    # Targets for build.
+    attr_accessor :targets
+    # Name of the target.
+    attr_reader :name
+    # Target dependencies.
+    attr_accessor :depends
+    # Target description.
+    attr_accessor :description
+    # Script that run in the target.
+    attr_reader :script
+    
+    # Constructor.
+    # - object: object for target, resulting from YAML parsing.
+    # - targets: build targets.
+    def initialize(object, targets)
+      check_hash(object, Target::DESCRIPTION)
+      @targets = targets
+      @name = object[Target::KEY]
+      error "Target name cannot be 'null'" if @name == nil
+      @depends = object['depends']||[]
+      @depends = Array(@depends)
+      @description = object['description']
+      @script = object['script']
+      @script = [@script] if @script.kind_of?(String)
+      @script = [] if not @script
+    end
+    
+    # Run target.
+    # - dry: tells if we run in dry mode. Defaults to false.
+    def run(dry=false)
+      current_dir = Dir.pwd
+      begin
+        for depend in @depends
+          @targets.run_target(depend, dry)
+        end
+        @targets.build.listener.target(self) if 
+          @targets.build.listener and @targets.is_last(self)
+        run_block(@script, dry)
+      ensure
+        Dir.chdir(current_dir)
+      end
+    end
+    
+    private
+    
+    # Run a task.
+    # - task: the task to run.
+    # - dry: whether to just print.
+    def run_task(task, dry=false)
+      @targets.build.listener.task(task) if @targets.build.listener
+      case task
+      when String
+        # shell script
+        run_shell(task, dry)
+      when Hash
+        if task.keys.length > 1
+          # construct
+          run_construct(task, dry)
+        else
+          if task.key?('rb')
+            # ruby script
+            script = task['rb']
+            run_ruby(script, dry)
+          elsif task.key?('sh')
+            # shell script
+            script = task['sh']
+            run_shell(script, dry)
+          elsif task.key?('super')
+            # call super target
+            targets.call_super(self, dry)
+          else
+            # must be a task
+            run_bee_task(task, dry)
+          end
+        end
+      end
+    end
+    
+    # Run a given shell script.
+    # - script: the scrip to run.
+    def run_shell(script, dry=false)
+      @listener.task(script) if @listener
+      return if dry
+      evaluated_script = @targets.build.context.evaluate_object(script)
+      if evaluated_script != ''
+        system(evaluated_script)
+        error "Script exited with value #{$?}" if $? != 0
+      end
+    end
+    
+    # Run a given shell script.
+    # - script: the scrip to run.
+    # - dry: tells if we run in dry mode.
+    def run_ruby(script, dry=false)
+      @listener.task(script) if @listener
+      return if dry
+      begin
+        @targets.build.context.evaluate_script(script)
+      rescue Exception
+        error "Error running Ruby script: #{$!}"
+      end
+    end
+    
+    # Run a given bee task.
+    # - task: task to run as a Hash.
+    def run_bee_task(task, dry=false)
+      @listener.task(task) if @listener
+      return if dry
+      @targets.build.package_manager.run_task(task)
+    end
+
+    # Run a given construct.
+    # - construct: construct to run as a Hash.
+    def run_construct(construct, dry=false)
+      @listener.task(construct) if @listener
+      return if dry
+      # if construct
+      if construct.keys.include?('if')
+        construct_if(construct, dry)
+      # while construct
+      elsif construct.keys.include?('while')
+        construct_while(construct, dry)
+      # for construct
+      elsif construct.keys.include?('for')
+        construct_for(construct, dry)
+      # try construct
+      elsif construct.keys.include?('try')
+        construct_try(construct, dry)
+      else
+        error "Unknown construct '#{construct.keys.join('-')}'"
+      end
+    end
+
+    # Run if construct.
+    # - task: the construct as a hash.
+    # - dry: tells if we run in dry mode.
+    def construct_if(task, dry)
+      # test entries
+      error "If-then-else construct must include 'then' entry" if
+        not task.keys.include?('then')
+      unknown_keys = task.keys - ['if', 'then', 'else']
+      error "If-then-else construct may only include 'if', 'then' and 'else' entries" if
+        unknown_keys.length > 0
+      error "If entry in if-then-else construct must be a string" if
+        not task['if'].kind_of?(String)
+      error "Then entry in if-then-else construct must be a list" if
+        not task['then'].kind_of?(Array)
+      error "Else entry in if-then-else construct must be a list" if
+        task['else'] and not task['else'].kind_of?(Array)
+      # evaluate condition in the build context
+      if evaluate(task['if'])
+        run_block(task['then'], dry)
+      else
+        run_block(task['else'], dry) if task['else']
+      end
+    end
+
+    # Run while construct.
+    # - task: the construct as a hash.
+    # - dry: tells if we run in dry mode.
+    def construct_while(task, dry)
+      # test entries
+      error "While-do construct must include 'do' entry" if
+        not task.keys.include?('do')
+      unknown_keys = task.keys - ['while', 'do']
+      error "While-do construct may only include 'while' and 'do' entries" if
+        unknown_keys.length > 0
+      error "While entry in while-do construct must be a string" if
+        not task['while'].kind_of?(String)
+      error "Do entry in while-do construct must be a list" if
+        not task['do'].kind_of?(Array)
+      # evaluate condition in the build context
+      while evaluate(task['while'])
+        run_block(task['do'], dry)
+      end
+    end
+
+    # Run for construct.
+    # - task: the construct as a hash.
+    # - dry: tells if we run in dry mode.
+    def construct_for(task, dry)
+      # test entries
+      error "For-in-do construct must include 'in' and 'do' entries" if
+        not task.keys.include?('in') or not task.keys.include?('do')
+      unknown_keys = task.keys - ['for', 'in', 'do']
+      error "For-in-do construct may only include 'for', 'in' and 'do' entries" if
+        unknown_keys.length > 0
+      error "For entry in for-in-do construct must be a string" if
+        not task['for'].kind_of?(String)
+      error "In entry in for-in-do construct must be a list or a string" if
+        not task['in'].kind_of?(Enumerable) and not task['in'].kind_of?(String)
+      error "Do entry in for-in-do construct must be a list" if
+        not task['do'].kind_of?(Array)
+      # iterate over list
+      if task['in'].kind_of?(String)
+        enumerable = evaluate(@targets.build.context.
+                              evaluate_object(task['in']))
+      else
+        enumerable = task['in']
+      end
+      for element in enumerable
+        begin
+          @targets.build.context.set_property(task['for'], element)
+        rescue
+          error "Error setting property '#{task['for']}'"
+        end
+        run_block(task['do'], dry)
+      end
+    end
+
+    # Run try-catch construct.
+    # - task: the construct as a hash.
+    # - dry: tells if we run in dry mode.
+    def construct_try(task, dry)
+      # test entries
+      error "Try-catch construct must include 'catch' entry" if
+        not task.keys.include?('catch')
+      unknown_keys = task.keys - ['try', 'catch']
+      error "Try-catch construct may only include 'try' and 'catch' entries" if
+        unknown_keys.length > 0
+      error "Try entry in try-catch construct must be a list" if
+        not task['try'].kind_of?(Array)
+      error "Catch entry in try-catch construct must be a list" if
+        not task['catch'].kind_of?(Array)
+      # try and catch errors
+      begin
+        run_block(task['try'], dry)
+      rescue
+        @targets.build.listener.recover if @targets.build.listener
+        run_block(task['catch'], dry)
+      end
+    end
+
+    # Run a block, that is a list of tasks.
+    # - block: the block to run as a list of tasks.
+    # - dry: tells if we run in dry mode.
+    def run_block(block, dry)
+      for task in block
+        run_task(task, dry)
+      end   
+    end
+
+    # Evaluate a given expression and raise a BuildError if an error happens.
+    def evaluate(expression)
+      begin
+        return @targets.build.context.evaluate_script(expression)
+      rescue
+        error "Error evaluating expression: #{$!}"
+      end
+    end
+
+  end
+
+end