bee 0.4.0 → 0.5.0

data/egg/package/readme.erb

@@ -0,0 +1,23 @@
+= <%= name.capitalize %>
+
+<%= summary %>
+
+= Home Page
+
+This software is hosted on RubyForge (thanks to them for their great job!)
+at <%= homepage %>.
+
+= Documentation
+
+For more information about this software, please read the documentation
+in  "<%= name %>" section on Gem server (type "gem_server" and go at URL
+http://localhost:8808) if you installed it using Gem.
+
+= License
+
+bee is Open Source and released under the Apache License (see LICENE file
+or go to URL http://www.apache.org/licenses/LICENSE-2.0).
+
+= Copyright
+
+<%= name.capitalize %> version <%= version %> (C) <%= author %> - <%= years %>

data/egg/package/test.erb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'bee'
+require 'test/unit'
+$:.unshift(File.join(File.expand_path(File.dirname(__FILE__))))
+require 'test_build'
+require 'test_build_listener'
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bee_task_<%= project_short_name %>'
+
+# Test case for bee task.
+class TestBeeTask<%= project_short_name.capitalize %> < Test::Unit::TestCase
+
+  # Create a context object and load tasks in it.
+  def setup
+    super
+    @context = Bee::Context.new
+    @listener = TestBuildListener.new
+    @build = TestBuild.new(@context, @listener)
+    @package = Bee::Task::<%= project_short_name.capitalize %>.new(@build)
+  end
+
+  def test_hello
+    @package.hello('TEST')
+    assert_equal("Hello TEST!\n", @listener.output)
+  end
+
+end

data/egg/package/test_build.erb

@@ -0,0 +1,16 @@
+- build: package_test
+  default: all
+  description: Build file to test generated and installed package
+
+- target: task
+  description: Test task for generated package
+  script:
+  - <%= project_short_name %>.hello: "World"
+
+- target: egg
+  description: Test egg for generated package
+  script:
+  - "bee -t '<%= project_short_name %>.hello'"
+
+- target: all
+  depends: [task, egg]

data/{test → egg/package}/test_build.rb

@@ -1,4 +1,4 @@
-# Copyright 2006-2007 Michel Casabianca <michel.casabianca@gmail.com>
+# Copyright 2006-2008 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.

data/{test → egg/package}/test_build_listener.rb

@@ -1,4 +1,4 @@
-# Copyright 2006-2007 Michel Casabianca <michel.casabianca@gmail.com>
+# Copyright 2006-2008 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.
@@ -22,11 +22,13 @@ class TestBuildListener
   attr_reader :success
   attr_reader :errors
   attr_accessor :output
+  attr_reader :verbose
   
   def initialize
     @targets = []
     @tasks = []
     @output = ''
+    @verbose = false
   end
   
   def build_started(build)

data/{test/ts_bee.rb → egg/package/test_suite.rb}

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-# Copyright 2006-2007 Michel Casabianca <michel.casabianca@gmail.com>
+# Copyright 2006-2008 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.

data/lib/bee.rb

@@ -1,4 +1,4 @@
-# Copyright 2006-2007 Michel Casabianca <michel.casabianca@gmail.com>
+# Copyright 2006-2008 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,44 +13,61 @@
 # limitations under the License.
 
 require 'yaml'
+require 'bee_task'
 require 'bee_util'
 
 # Module for Bee core classes.
 module Bee
-
+  
   # Class for a build. This class is built from an object resulting from YAML
   # build file parsing.
   class Build
-
+    
     include Bee::Util::BuildErrorMixin
     include Bee::Util::HashCheckerMixin
 
+    # Build key.
+    KEY = 'build'
+    # Build entry description.
+    DESCRIPTION = {
+      'build'       => :mandatory, 
+      'default'     => :optional, 
+      'description' => :optional,
+      'context'     => :optional,
+      'extends'     => :optional}
+
     # Build file.
     attr_reader :file
-    # Base directory (directory where lives the build file). All file paths
-    # are relative to this directory.
+    # Base directory, that is directory where lives the build file.
     attr_reader :base
+    # Current directory, where was started the script.
+    attr_reader :here
     # Build name.
     attr_reader :name
-    # Default target (bee runs target passed on the command line, default
-    # target or first one in build file).
-    attr_reader :default
+    # Parent build.
+    attr_reader :extends
+    # Default target, specified with default entry or fist target in build file.
+    attr_accessor :default
     # Build description.
     attr_reader :description
+    # Build properties.
+    attr_reader :properties
     # Hash for targets, indexed by target name.
     attr_reader :targets
     # Context for Ruby scripts and properties.
     attr_reader :context
-    # Package manager (for task invocation).
+    # Package manager, for task invocation.
     attr_reader :package_manager
-    # Build listener (responsible for displaying build status).
+    # Build listener, responsible for displaying build status.
     attr_reader :listener
     
     # Load a build from a YAML build file.
-    # - file: YAML build file.
+    # - file: YAML build file or URL.
     # - recursive: tells if we look for build file recursively (defaults to
     #   nil).
-    def self.load(file, recursive=nil)
+    # - properties: a hash of additional properties passed on command line.
+    def self.load(file, recursive=nil, properties={})
+      raise "Can't use recursive URL" if recursive and Bee::Util::url?(file)
       if recursive
         begin
           file = Bee::Util::find(file)
@@ -59,140 +76,420 @@ module Bee
                                           "not found recursively")
         end
       end
-      raise Bee::Util::BuildError.new("Build file '#{file}' not found") if 
-        not File.exists?(file)
-      raise Bee::Util::BuildError.new("Build file '#{file}' is not a file") if
-        not File.file?(file)
-      raise Bee::Util::BuildError.new("Build file '#{file}' is not readable") if
-        not File.readable?(file)
-      yaml = File.read(file)
+      begin
+        yaml = Bee::Util::get_file(file)
+      rescue
+        raise Bee::Util::BuildError.
+           new("Error loading build file '#{file}': #{$!}")
+      end
       begin
         object = YAML::load(yaml)
       rescue
         raise Bee::Util::BuildError.
-          new("YAML syntax error in build file: #{$!}")
+          new("YAML syntax error in build file '#{file}': #{$!}")
       end
-      return Build.new(object, file)
+      return Build.new(object, file, properties)
     end
-
+    
     # Constructor:
-    # - object: build description as an object (resulting from YAML loading).
+    # - object: object tree resulting from YAML build file parsing.
     # - file: build file (nil if none).
-    def initialize(object, file)
-      require 'bee_task'
+    # - properties: a hash of additional properties passed on command line.
+    # - here: current directory.
+    def initialize(object, file, properties={}, here=Dir.pwd)
       @file = file
-      if file
-        @base = File.expand_path(File.dirname(file))
-      else
-        @base = File.expand_path(Dir.pwd)
-      end
-      error "Build must be a list" unless object.kind_of?(Array)
-      @properties = {}
-      @targets = {}
+      @base = get_base(@file)
+      @here = here
       @context = Context.new
-      @context.set_property(:base, @base)
-      @properties[:base] = @base
+      @properties = Properties.new(self)
+      @properties.evaluate(@context)
+      @targets = Targets.new(self)
+      parse(object)
+      @properties.overwrite(properties)
       @package_manager = Bee::Task::PackageManager.new(self)
-      # parse object entries
-      for entry in object
-        if entry.key?('build')
-          # build info entry
-          begin
-            check_hash(entry,
-              {'build' => :mandatory, 
-                'default' => :optional, 
-                'description' => :optional,
-                'context' => :optional})
-          rescue
-            error "Error parsing build entry: #{$!}"
-          end
-          error "Duplicate build info" if @name
-          @name = entry['build']
-          @default = entry['default']
-          @description = entry['description']
-          # load context files if any
-          if entry['context']
-            for script in entry['context']
-              begin
-                based_script = File.join(@base, script)
-                evaluated_script = @context.evaluate_object(based_script)
-                source = File.read(evaluated_script)
-                @context.evaluate_script(source)
-              rescue Exception
-                error "Error loading context '#{script}': #{$!}"
-              end
-            end
-          end
-        elsif entry.key?('properties')
-          # properties entry
-          for property in entry['properties']
-            name = property.keys[0]
-            value = @context.evaluate_object(property[name])
-            @context.set_property(name, value, false)
-          end
-        elsif entry.key?('target')
-          # target entry
-          begin
-            target = Target.new(entry, self)
-          rescue
-            error "Error parsing target '#{entry['target']}': #{$!}"
-          end
-          @default = target.name if !@default and @targets.keys.empty?
-          error "Duplicate target definition: '#{target.name}'" if
-            @targets[target.name]
-          @targets[target.name] = target
-        else
-          # unknown entry
-          error "Unknown entry:\n#{YAML::dump(entry)}"
-        end
-      end
     end
 
+    # Evaluate properties.
+    def evaluate_properties
+      @properties.evaluate(@context)
+    end
+    
     # Run build:
     # - targets: list of targets to run.
     # - listener: listener for the build.
-    def run(targets, listener=nil)
+    def run(targets, listener=nil, dry=false)
       @listener = listener
       working_directory = Dir.getwd
+      @listener.build_started(self, dry) if @listener
       begin
-        @listener.build_started(self) if @listener
-        Dir.chdir(base)
-        error "No default target given" if (!@default and targets.length == 0)
-        targets = [@default] if targets.length == 0
-        for target in targets
-          run_target(target)
+        evaluate_properties
+        if not Bee::Util::url?(@base)
+          Dir.chdir(@base)
         end
-        @listener.build_finished(self) if @listener
+        @targets.run(targets, dry)
+        @listener.build_finished(self, dry) if @listener
       rescue Bee::Util::BuildError => e
-        if listener
+        if @listener
           @listener.error(e)
         else
           raise e
         end
       ensure
-        @listener = nil
         Dir.chdir(working_directory)
+        remove_instance_variable(:@listener)
+      end
+    end
+    
+    private
+
+    # Parse entries in build object.
+    # - object: object tree resulting from YAML build file parsing.
+    def parse(object)
+      error "Build must be a list" unless object.kind_of?(Array)
+      first = true
+      for entry in object
+        if entry.key?(Build::KEY)
+          parse_build(entry)
+          error "Build info entry must be first one in build file" if
+            not first
+          first = false
+        elsif entry.key?(Properties::KEY)
+          @properties.write(entry)
+          first = false
+        elsif entry.key?(Target::KEY)
+          @targets.add(entry)
+          first = false
+        else
+          error "Unknown entry:\n#{YAML::dump(entry)}"
+        end
+      end
+      # manage parent build
+      if @parent
+        @properties.extend(@parent.properties)
+        @targets.extend(@parent.targets)
+      end
+    end
+    
+    # Parse a build entry.
+    # - entry: the build entry to parse.
+    def parse_build(entry)
+      begin
+        check_hash(entry, Build::DESCRIPTION)
+      rescue
+        error "Error parsing build info entry: #{$!}"
+      end
+      error "Duplicate build info" if @name
+      @name = entry['build']
+      @default = entry['default']
+      @targets.default = @default
+      @description = entry['description']
+      @extends = entry['extends']
+      # load parent build if any
+      if @extends
+        absolute_path = Bee::Util::absolute_path(@extends, @base)
+        begin
+          @parent = Bee::Build::load(absolute_path)
+        rescue Exception
+          error "Error loading parent build file '#{@extends}': #{$!}"
+        end
+        @default = @default || @parent.default
+        @targets.default = @default
+        @description = @description || @parent.description
+      end
+      # load context files if any
+      context = entry['context']
+      if context
+        context = Array(context)
+        for script in context
+          begin
+            evaluated = @context.evaluate_object(script)
+            source = Bee::Util::get_file(evaluated, @base)
+            @context.evaluate_script(source)
+          rescue Exception
+            error "Error loading context '#{script}': #{$!}"
+          end
+        end
+      end
+    end
+    
+    # Get base for a given file.
+    # - file: build file.
+    def get_base(file)
+      if file
+        if Bee::Util::url?(file)
+          return File.dirname(file)
+        else
+          return File.expand_path(File.dirname(Bee::Util::absolute_path(file, Dir.pwd)))
+        end
+      else
+        return File.expand_path(Dir.pwd)
+      end
+    end
+
+  end
+
+  # Class to manage properties.
+  class Properties
+
+    include Bee::Util::BuildErrorMixin
+
+    # Key for properties entry.
+    KEY = 'properties'
+
+    # List of properties in order of evaluation.
+    attr_reader :list
+    # Hash of properties by name.
+    attr_reader :hash
+
+    # Constructor.
+    # - build: build object.
+    def initialize(build)
+      @list = []
+      @hash = {}
+      @build = build
+      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)
+          list = YAML::load(source)
+          set_properties(list, false)
+        rescue Exception
+          error "Error loading properties file '#{properties}': #{$!}"
+        end
+      else
+        set_properties(properties, false)
       end
     end
 
+    # Overwrite properties. Will raise an error if properties don't already
+    # exist.
+    # - object: object tree resulting from YAML build file parsing.
+    def overwrite(object)
+      set_properties(object, true)
+    end
+
+    # Extend with properties of parent build.
+    # - properties: properties of parent build.
+    def extend(properties)
+      current_list = @list
+      current_hash = @hash
+      @list = properties.list
+      @hash = properties.hash
+      index = 0
+      0.upto(current_list.length - 1) do |current|
+        name = current_list[current]
+        pos = @list.index(name)
+        if pos
+          sub = current_list[index .. current]
+          @list[pos .. pos] = sub
+          for name in sub
+            @hash[name] = current_hash[name]
+          end
+          index = current + 1
+        end
+      end
+      tail = current_list[index .. current_list.length() - 1]
+      @list += tail
+      for name in tail
+        @hash[name] = current_hash[name]
+      end
+    end
+
+    # Evaluate properties in context.
+    # - context: build context where properties must be evaluated.
+    def evaluate(context)
+      for name in @list
+        begin
+          value = context.evaluate_object(@hash[name])
+        rescue Bee::Util::BuildError
+          error "Error evaluating property '#{name}': #{$!}"
+        end
+        context.set_property(name, value, true)
+      end
+    end
+
+    private
+
+    # Set default properties.
+    def defaults
+      set(:base, @build.base, false)
+      set(:here, @build.here, false)
+    end
+
+    # Set properties.
+    # - properties: properties as a list of hash if overwrite = false
+    #   or a hash if overwrite = true.
+    # - overwrite: tells if we can overwrite existing properties.
+    def set_properties(properties, overwrite)
+      if overwrite
+        raise "Properties must be a hash" if not properties.kind_of?(Hash)
+        for name in properties.keys
+          expression = properties[name]
+          set(name, expression, overwrite)
+        end
+      else
+        raise "Properties must be a list" if not properties.kind_of?(Array)
+        for property in properties
+          name = property.keys[0]
+          expression = property[name]
+          set(name, expression, overwrite)
+        end
+      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)
+      name = name.to_sym
+      error "Duplicate property definition: '#{name}'" if 
+        not overwrite and @hash.has_key?(name)
+      @list << name
+      @hash[name] = expression
+    end
+
+  end
+
+  # Class to manage targets in a build.
+  class Targets
+
+    include Bee::Util::BuildErrorMixin
+
+    # Parent build.
+    attr_reader :build
+    # Targets hash by name.
+    attr_reader :hash
+    # Targets already run.
+    attr_reader :already_run
+    # Default target.
+    attr_accessor :default
+
+    # Constructor.
+    # - build: build object.
+    def initialize(build)
+      @build = build
+      @hash = {}
+      @already_run = []
+    end
+
+    # Add a new target.
+    # - object: object tree resulting from YAML build file parsing.
+    def add(object)
+      begin
+        target = Target.new(object, self)
+      rescue
+        error "Error parsing target '#{object[Target::KEY]}': #{$!}"
+      end
+      error "Duplicate target definition: '#{target.name}'" if
+        @hash.has_key?(target.name)
+      @hash[target.name] = [target]
+      if !@default
+        @default = target.name
+        @build.default = target.name
+      end
+    end
+
+    # Extend parent targets.
+    # - parent: parent targets.
+    def extend(parent)
+      # set appropriate targets
+      for targets in parent.hash.values
+        for target in targets
+          target.targets = self
+        end
+      end
+      # insert parent targets before current ones
+      for name in parent.hash.keys
+        if @hash[name]
+          @hash[name] = parent.hash[name] + @hash[name]
+        else
+          @hash[name] = parent.hash[name]
+        end
+      end
+      # set default default target to parent one if none was set
+      @default = @default || parent.default
+    end
+
+    # Run targets.
+    # - targets: list of target names to run.
+    def run(targets, dry)
+      error "No default target given" if (!@default and targets.length == 0)
+      targets = [@default] if targets.length == 0
+      for target in targets
+        run_target(target, dry)
+        @already_run.clear
+      end
+    end
+ 
+    # Call super target.
+    # - target: target that calls super.
+    def call_super(target, dry=false)
+      index = @hash[target.name].index(target)
+      error "No super target to call for '#{target.name}'" if index == 0
+      index -= 1
+      @hash[target.name][index].run(dry)
+    end
+
+    # Tells if a given target is last in hierarchy.
+    # - target: given target.
+    def is_last(target)
+      index = @hash[target.name].index(target)
+      last = @hash[target.name].size - 1
+      return index == last
+    end
+    
     # Run a given target.
     # - target: the target to run.
-    def run_target(target)
-      error "Target '#{target}' not found" if not @targets[target]
-      @targets[target].run      
+    def run_target(target, dry=false)
+      error "Target '#{target}' not found" if not @hash[target]
+      if not @already_run.include?(target)
+        @already_run << target
+        @hash[target].last.run(dry)
+      end
     end
 
+    # Return targets description as a hash of descriptions indexed by
+    # target name. Dependencies are added after target description.
+    def description
+      description = {}
+      for name in @hash.keys
+        text = @hash[name].last.description
+        depends = ' [' + @hash[name].last.depends.join(', ') + ']' if
+          @hash[name].last.depends and @hash[name].last.depends.length > 0
+        description[name] = (text ? text : '') + (depends ? depends : '')
+      end
+      return description
+    end
+    
   end
-
+  
   # 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
 
-    # Build that encapsulates target.
-    attr_reader :build
+    # 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.
@@ -201,116 +498,118 @@ module Bee
     attr_reader :description
     # Script that run in the target.
     attr_reader :script
-
+    
     # Constructor.
     # - object: object for target, resulting from YAML parsing.
-    # - build: build that encapsulate this target.
-    def initialize(object, build)
-      check_hash(object,
-        {'target' => :mandatory,
-          'depends' => :optional,
-          'description' => :optional,
-          'script' => :optional})
-      @build = build
-      @name = object['target']
+    # - 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.
-    def run
+    # - dry: tells if we run in dry mode. Defaults to false.
+    def run(dry=false)
+      current_dir = Dir.pwd
       begin
-        if not @evaluated
-          @evaluated = true
-          for depend in @depends
-            @build.run_target(depend)
-          end
-          @build.listener.target(self) if @build.listener
-          if @script
-            case @script
-            when String
-              run_task(@script)
-            when Array
-              for task in @script
-                run_task(task)
-              end
-            end
-          end
+        for depend in @depends
+          @targets.run_target(depend, dry)
+        end
+        @targets.build.listener.target(self) if 
+          @targets.build.listener and @targets.is_last(self)
+        for task in @script
+          run_task(task, dry)
         end
       ensure
-        Dir.chdir(@build.base)
+        Dir.chdir(current_dir)
       end
     end
-
+    
     private
-
+    
     # Run a task.
     # - task: the task to run.
-    def run_task(task)
-      @build.listener.task(task) if @build.listener
+    # - 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)
+        run_shell(task, dry)
       when Hash
         error "A task entry must be a Hash with a single key" if
           task.keys.length != 1
         if task.key?('rb')
           # ruby script
           script = task['rb']
-          run_ruby(script)
+          run_ruby(script, dry)
+        elsif task.key?('super')
+          # call super target
+          targets.call_super(self, dry)
         else
           # must be a task
-          run_bee_task(task)
+          run_bee_task(task, dry)
         end
       end
     end
-
+    
     # Run a given shell script.
     # - script: the scrip to run.
-    def run_shell(script)
+    def run_shell(script, dry=false)
       @listener.task(script) if @listener
-      evaluated_script = @build.context.evaluate_object(script)
-      system(evaluated_script)
-      error "Script exited with value #{$?}" if $? != 0
+      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.
-    def run_ruby(script)
+    # - dry: tells if we run in dry mode.
+    def run_ruby(script, dry=false)
       @listener.task(script) if @listener
+      return if dry
       begin
-        @build.context.evaluate_script(script)
+        @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)
-      require 'bee_task'
+    def run_bee_task(task, dry=false)
       @listener.task(task) if @listener
-      @build.package_manager.run_task(task)
+      return if dry
+      @targets.build.package_manager.run_task(task)
     end
-    
-  end
 
+  end
+  
   # 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
       @context_binding = get_binding
     end
-
+    
     # Set a given property in context.
     # - name: the property name.
     # - value: the property value.
@@ -324,7 +623,7 @@ module Bee
         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.
@@ -333,6 +632,8 @@ module Bee
         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
@@ -342,13 +643,13 @@ module Bee
     def properties
       return eval('local_variables', @context_binding)
     end
-
+    
     # Evaluate a script in context.
-    # - script: script to evaluate.
+    # - 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}'
@@ -387,14 +688,14 @@ module Bee
         return object
       end
     end
-
+    
     private
-
+    
     # Get a binding as script context.
     def get_binding
       return binding
     end
-
+    
   end
-
+  
 end