rook 0.1.0 → 0.2.0

data/lib/rook/cookbook.rb

@@ -1,6 +1,6 @@
 ##
-## $Rev: 31 $
-## $Release: 0.1.0 $
+## $Rev: 36 $
+## $Release: 0.2.0 $
 ## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 
@@ -15,6 +15,19 @@ module Rook
 
 
 
+  class CookbookError < RookError
+
+
+    def initialize(message, validation_errors)
+      @errors = validation_errors
+    end
+    attr_reader :errors
+
+
+  end
+
+
+
   class CookbookValidator < Kwalify::Validator
 
 
@@ -52,9 +65,9 @@ module Rook
       when 'PROP'
         value.each do |k, v|
           if !k.is_a?(String)
-            errors << error("#{path}/#{k}", "property name is not a string.")
-          elsif k !~ /\A[a-zA-Z_][-\w]*\*?\z/ && k != '.desc'
-            errors << error("#{path}/#{k}", "invlaid property name.")
+            errors << create_error("#{path}/#{k}", "property name is not a string.")
+          elsif k !~ /\A[a-zA-Z_]\w*\*?\z/ && k != '.desc'
+            errors << create_error("#{path}/#{k}", "invlaid property name.")
           elsif k[-1] == ?* && !v.is_a?(String)
             errors << create_error("#{path}/#{k}", "expr is not a string.")
           end
@@ -67,19 +80,6 @@ module Rook
 
 
 
-  class CookbookError < RookError
-
-
-    def initialize(message, validation_errors)
-      @errors = validation_errors
-    end
-    attr_reader :errors
-
-
-  end
-
-
-
   ##
   ## represents cookbook
   ##
@@ -99,20 +99,20 @@ module Rook
 
     ##
     def initialize(bookname=nil, load_yaml=true, expand_tab=true)
-      @precookings = []
+      @preparations = []
       @properties  = []
-      @variables   = []
+      @parameters  = []
       @materials   = []
       @recipes     = []
       @bookname    = bookname
       load_yamlfile(bookname, expand_tab) if bookname && load_yaml
     end
-    attr_reader :properties, :variables, :recipes, :materials, :precookings
+    attr_reader :properties, :parameters, :recipes, :materials, :preparations
     attr_accessor :bookname
 
 
-    def precooking
-      return @precookings.map { |hash| hash['code'] }.join("\n")
+    def preparation
+      return @preparations.map { |hash| hash['code'] }.join("\n")
     end
 
 
@@ -143,91 +143,106 @@ module Rook
 
     def load_ydoc(ydoc, parser=nil)
       ydoc = ydoc.dup
-      #
-      code = ydoc['precooking']
-      ydoc['precookings'] = [ { 'code'=>code } ] if code
-      #
-      [ 'properties', 'variables' ].each do |key|
-        next unless ydoc[key]
-        list = []
-        ydoc[key].each_with_index do |prop, i|
+      # preparation
+      if code = ydoc['preparation*']
+        linenum = parser.path_linenum('/preparation*')
+        @preparations << { 'code'=>code, 'linenum'=>linenum+1 }
+      end
+      # properties, parameters
+      [ 'properties', 'parameters' ].each do |part|
+        next unless ydoc[part]
+        list = part == 'properties' ? @properties : @parameters
+        ydoc[part].each_with_index do |prop, i|
           opts = {}
           prop.keys.each do |k| opts[k.to_s] = prop[k] if k.is_a?(Symbol) end
           prop.each do |name, val|
             next unless name.is_a?(String)
-            vkey = name[-1] == ?* ? 'expr' : 'value'
+            linenum = parser.path_linenum("/#{part}/#{i}/#{name}")
+            vkey = name[-1] == ?* ? 'value*' : 'value'
             #name[-1,1] = '' if name[-1] == ?*   # TypeError: can't modify frozen string
             name = name[0, name.length-1] if name[-1] == ?*
-            h = { 'name'=>name, vkey=>val }
+            h = { 'name'=>name, vkey=>val, 'linenum'=>linenum }
             h.update(opts)
             list << h
           end
         end
-        ydoc[key] = list
       end
+      # materials
+      if list = ydoc['materials']
+        @materials += list
+      end
+      # recipes
+      if list = ydoc['recipes']
+        list.each_with_index do |hash, i|
+          if hash['method*']
+            linenum = parser.path_linenum("/recipes/#{i}/method*")
+            hash['linenum'] = linenum+1
+          end
+          if hash['params']
+            list = []
+            hash['params'].each_with_index do |params, n|
+              params.each do |name, val|
+                linenum = parser.path_linenum("/recipes/#{i}/params/#{n}/#{name}")
+                list << { 'name'=>name, 'value'=>val, 'linenum'=>linenum }
+              end
+            end
+            hash['params'] = list
+          end
+          @recipes << hash
+        end
+      end
+    end
+
+
+    def validate_rubycode
+      lines = []
+      @preparations.each do |hash|
+        _add_code(lines, hash, 'code')
+      end if @preparations
+      @properties.each do |hash|
+        _add_code(lines, hash, 'value*') if hash.key?('value*')
+      end if @properties
+      @parameters.each do |hash|
+        _add_code(lines, hash, 'value*') if hash.key?('value*')
+      end if @parameters
+      @recipes.each do |hash|
+        _add_code(lines, hash, 'method*') if hash.key?('method*')
+        hash['params'].each do |h|
+          name = h['name']
+          _add_code(lines, h, 'value') if name[-1] == ?*
+        end if hash.key?('params')
+      end if @recipes
       #
-      @precookings += _load_section(ydoc['precookings'], 'code', parser, 1) { |h, i| "/precooking" }
-      @recipes     += _load_section(ydoc['recipes'],  'method', parser, 1) { |h, i| "/recipes/#{i}/method" }
-      @properties  += _load_section(ydoc['properties*'], 'expr', parser, 0) { |h, i| "/properties*/#{i}/expr" }
-      @variables   += _load_section(ydoc['variables*'], 'expr', parser, 0) { |h, i| "/variables*/#{i}/expr" }
-      @properties  += _load_section(ydoc['properties'], 'expr', parser, 0) { |h, i| "/properties/#{i}/#{h['name']}*" }
-      @variables   += _load_section(ydoc['variables'], 'expr', parser, 0) { |h, i| "/variables/#{i}/#{h['name']}*" }
-      #
-      list = ydoc['materials']
-      @materials += list if list
+      lines.shift      # ignore first item
+      code = ''
+      lines.each do |line|
+        code << (line || "") << "\n"
+      end
+      tmpfilename = "#{@bookname}."   # or user tmpfile library
+      begin
+        File.open(tmpfilename, 'w') { |f| f.write(code) }
+        #case RUBY_PLATFORM
+        #when /linux/, /bsd/, /darwin/, /cygwin/
+          out = `ruby -wc #{tmpfilename} 2>&1`
+          puts out.gsub(/^#{tmpfilename}/, bookname)
+        #else
+        #  system "ruby -wc #{tmpfilename}"
+        #end
+      ensure
+        File.unlink(tmpfilename) if test(?f, tmpfilename)
+      end
+
     end
 
 
-    def _load_section(section, attr, parser, delta)
-      list = []
-      section.each_with_index do |hash, i|
-        if parser && hash[attr]
-          path = yield(hash, i)
-          hash['linenum'] = parser.path_linenum(path) + delta
-        end
-        list << hash
-      end if section
-      return list
+    def _add_code(lines, hash, key)
+      if hash.key?(key)
+        code = hash[key]
+        n    = hash['linenum'] - 1
+        code.each_line { |line| lines[n += 1] = line.chomp }
+        lines[n] = lines[n] + ';'
+      end
     end
-    private :_load_section
-
-
-    #--
-    #def load_dsl(ruby_code)
-    #  eval(ruby_code, binding(), @bookname, 1)
-    #end
-    #++
-
-
-    #--
-    #def self.load_yamlfile(bookname, tab_expand=true)
-    #  str = File.read(bookname)
-    #  str = Util.untabify(str) if tab_expand
-    #  return load_yamlstr(str, bookname)
-    #end
-    #
-    #
-    #def self.load_yamlstr(yaml_str, bookname)
-    #  parser = Kwalify::YamlParser.new(yaml_str)
-    #  ydocs = []
-    #  errors = []
-    #  books = []
-    #  while parser.has_next?
-    #    ydoc = parser.parse()
-    #    errs = @@validator.validate(ydoc)
-    #    if errs && !errs.empty?
-    #      errors += errs
-    #    else
-    #      cookbook = self.new
-    #      cookbook.bookname = bookname
-    #      cookbook.load_ydoc(ydoc, parser)
-    #      books << cookbook
-    #    end
-    #  end
-    #  errors.empty?  or raise CookbookError.new("invalid cookbook", errors)
-    #  return books
-    #end
-    #++
 
 
   end

data/lib/rook/helper/bz2.rb

@@ -1,6 +1,6 @@
 ##
 ## $Rev: 20 $
-## $Release: 0.1.0 $
+## $Release: 0.2.0 $
 ## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 

data/lib/rook/helper/digest.rb

@@ -1,6 +1,6 @@
 ##
 ## $Rev$
-## $Release: 0.1.0 $
+## $Release: 0.2.0 $
 ## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 

data/lib/rook/helper/enumerable.rb

@@ -1,6 +1,6 @@
 ##
 ## $Rev: 20 $
-## $Release: 0.1.0 $
+## $Release: 0.2.0 $
 ## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 

data/lib/rook/helper/file.rb

@@ -1,6 +1,6 @@
 ##
-## $Rev: 20 $
-## $Release: 0.1.0 $
+## $Rev: 37 $
+## $Release: 0.2.0 $
 ## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 
@@ -18,20 +18,45 @@ class File
   ##   File.edit('file.txt') do |content|
   ##     content.gsub!(/\$Release\$/, '1.0.0')
   ##     content.gsub!(/\$Copyright\$/, '(c)kuwata-lab')
+  ##     content
   ##   end
   ##
   def self.edit(filename, &block)
     File.open(filename, 'r+') do |f|
       content = f.read()
       #yield(content)
-      block.arity == 1 ? yield(content) : yield(content, filename)
+      result = block.arity == 1 ? yield(content) : yield(content, filename)
       f.rewind()
       f.truncate(0)
+      #f.write(result)
       f.write(content)
     end if test(?f, filename)
   end
 
 
+  ##
+  ## replace file content with the result of block.
+  ##
+  ## ex.
+  ##   File.replace('file.txt') do |content|
+  ##     s = content
+  ##     s = s.gsub(/\$Release\$/, '1.0.0')
+  ##     s = s.gsub(/\$Copyright\$/, '(c)kuwata-lab')
+  ##     s
+  ##   end
+  ##
+  def self.replace(filename, &block)
+    File.open(filename, 'r+') do |f|
+      content = f.read()
+      #yield(content)
+      s = block.arity == 1 ? yield(content) : yield(content, filename)
+      f.rewind()
+      f.truncate(0)
+      f.write(s)
+    end if test(?f, filename)
+  end
+
+
   ##
   ## write file
   ##

data/lib/rook/helper/fileutils.rb

@@ -1,6 +1,6 @@
 ##
 ## $Rev: 26 $
-## $Release: 0.1.0 $
+## $Release: 0.2.0 $
 ## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 

data/lib/rook/helper/kernel.rb

@@ -1,6 +1,6 @@
 ##
 ## $Rev: 20 $
-## $Release: 0.1.0 $
+## $Release: 0.2.0 $
 ## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 

data/lib/rook/kitchen.rb

@@ -1,6 +1,6 @@
 ##
-## $Rev: 32 $
-## $Release: 0.1.0 $
+## $Rev: 35 $
+## $Release: 0.2.0 $
 ## copyright(c) 2006 kuwata-lab.com all rights reserved.
 ##
 
@@ -52,36 +52,36 @@ module Rook
     end
 
     #--
-    #abstract_method 'hash', :add_property, :add_variable
+    #abstract_method 'hash', :add_property, :add_parameter
     #++
 
     def add_property(hash)
       not_implemented
     end
 
-    def add_variable(hash)
+    def add_parameter(hash)
       not_implemented
     end
 
 
     ##
-    ## define a variable in Rookbook.rb
+    ## define a parameter in Rookbook.rb
     ##
     ## ex. (in Rookbook.rb)
-    ##   variable :srcdir,  'src'
-    ##   variable :files,   Dir.glob('src/*.rb')
-    ##   variable :rook_product,  :all
+    ##   parameter :srcdir,  'src'
+    ##   parameter :files,   Dir.glob('src/*.rb')
+    ##   parameter :rook_product,  :all
     ##
     ## the above code is equivalent to the following in Rookbook.yaml:
-    ##   variables:
+    ##   parameters:
     ##     - srcdir  :  src
     ##     - files*  :  Dir.glob('src/*.rb')
     ##     - rook_product : :all
     ##
-    def variable(name, value, options={})    # :doc:
+    def parameter(name, value, options={})    # :doc:
       hash = { 'name'=>name.to_s, 'value'=>value }
       options.each { |name, value| hash[name.to_s] = value }
-      add_variable(hash)
+      add_parameter(hash)
     end
 
 
@@ -139,7 +139,7 @@ module Rook
     ## define a recipe in Rookbook.rb
     ##
     ## ex. (in Rookbook.rb)
-    ##   recipe '*.o'  , '$(1).c', :options=>['$(1).h'], :desc=>'compile *.c' do
+    ##   recipe '*.o'  , '$(1).c', :toppings=>['$(1).h'], :desc=>'compile *.c' do
     ##     sys "gcc -c #{@ingreds[0]}"
     ##   end
     ##
@@ -147,7 +147,7 @@ module Rook
     ##   recipes:
     ##     - product:   *.o
     ##       ingreds:   [ $(1).c ]
-    ##       options:   [ $(1).h ]
+    ##       toppings:   [ $(1).h ]
     ##       desc:      compile *.c
     ##       method: |
     ##         sys "gcc -c #{@ingreds[0]}"
@@ -191,19 +191,19 @@ module Rook
   end
 
 
-  class Parameters
+  class ValueTable
 
     def initialize
       @_property_table = {}
-      @_variable_table = {}
+      @_parameter_table = {}
     end
 
     def has_property?(name)
       return @_property_table.key?(name.to_s)
     end
 
-    def has_variable?(name)
-      return @_variable_table.key?(name.to_s)
+    def has_parameter?(name)
+      return @_parameter_table.key?(name.to_s)
     end
 
     def set_property(name, value)
@@ -213,44 +213,50 @@ module Rook
       instance_variable_set("@#{name}", value)
     end
 
-    def set_variable(name, value)
-      @_variable_table[name.to_s] = value
+    def set_parameter(name, value)
+      @_parameter_table[name.to_s] = value
     end
 
     def get_property(name)
       return @_property_table[name.to_s]
     end
 
-    def get_variable(name)
-      return @_variable_table[name.to_s]
+    def get_parameter(name)
+      return @_parameter_table[name.to_s]
     end
 
     def get_value(name)
       name = name.to_s
-      return get_property(name) if has_property?(name)  # allow overwrite variable by property
-      return get_variable(name) if has_variable?(name)
-      #if has_property?(name) || has_variable?(name)
+      return get_property(name) if has_property?(name)  # allow overwrite parameter by property
+      return get_parameter(name) if has_parameter?(name)
+      #if has_property?(name) || has_parameter?(name)
       #  return _get(name)
       #end
-      msg = "'$(#{name})': no such property nor variable."
+      msg = "$(#{name}): no such property nor parameter."
       #raise UndefinedPropertyError.new(msg, name)
       raise RookError.new(msg)
     end
 
-    def evaluate_value(value)
+    def expand_value(value, filename=nil, linenum=nil)
       case value
       when String
-        if value =~ /\A\$\(([a-zA-Z_]\w*)\)\z/
-          val = get_value($1)
-        else
-          val = value.gsub(/\$\(([a-zA-Z_]\w*)\)/) { get_value($1) }
+        begin
+          if value =~ /\A\$\(([a-zA-Z_]\w*)\)\z/
+            val = get_value($1)
+          else
+            val = value.gsub(/\$\(([a-zA-Z_]\w*)\)/) { get_value($1) }
+          end
+        rescue RookError => ex
+          #ex.filename = filename
+          #ex.linenum = linenum
+          raise ex
         end
       when Array
-        list = value.collect { |val| evaluate_value(val) }
+        list = value.collect { |val| expand_value(val) }
         val = list
       when Hash
         hash = {}
-        value.each { |key, val| hash[key] = evaluate_value(val) }
+        value.each { |key, val| hash[key] = expand_value(val) }
         val = hash
       else
         val = value
@@ -259,17 +265,17 @@ module Rook
     end
 
     def evaluate_expr(expr, filename='(expr)', linenum=1)
-      code = @_variable_table.keys.collect { |name| "#{name}=@_variable_table['#{name}'];" }
+      code = @_parameter_table.keys.collect { |name| "#{name}=@_parameter_table['#{name}'];" }
       code << expr
-      return self.instance_eval(code.join, filename, linenum)
+      return self.instance_eval(code.join, filename.to_s, linenum)
     end
 
     def property_names
       return @_property_table.keys
     end
 
-    def variable_names
-      return @_variable_table.keys
+    def parameter_names
+      return @_parameter_table.keys
     end
 
   end
@@ -292,41 +298,70 @@ module Rook
 
 
     def initialize(properties={}, options={})
-      @parameters = Parameters.new
+      @value_table = ValueTable.new
       @properties = []
-      @variables = []
+      @parameters = []
       properties.each do |name, value|
         add_property({'name'=>name.to_s, 'value'=>value})
       end
       @recipes = []
       @recipe_table = {}
       @materials = []
-      @precookings = []
+      @preparations = []
       @forced  = options[:forced]
       #@verbose = options[:verbose]
-      #@noexec  = options[:noexec]
+      @noexec  = options[:noexec]
     end
-    attr_reader :properties, :variables
-    attr_reader :materials, :precookings, :recipes
+    attr_reader :properties, :parameters
+    attr_reader :materials, :preparations, :recipes
     #attr_reader :forced, :quiet, :noexec
 
 
     def has_property?(name)
-      return @parameters.has_property?(name)
+      return @value_table.has_property?(name)
     end
 
-    def has_variable?(name)
-      return @parameters.has_variable?(name)
+    def has_parameter?(name)
+      return @value_table.has_parameter?(name)
     end
 
     def get_property(name)
-      return @parameters.get_property(name)
+      return @value_table.get_property(name)
+    end
+
+    def get_parameter(name)
+      return @value_table.get_parameter(name)
+    end
+
+    def set_property(name, value)
+      @value_table.set_property(name, value)
+    end
+
+    def set_parameter(name, value)
+      @value_table.set_parameter(name, value)
+    end
+
+    def get_value(name)
+      return @value_table.get_value(name)
     end
 
-    def get_variable(name)
-      return @parameters.get_variable(name)
+    def property_names
+      return @value_table.property_names
+    end
+
+    def parameter_names
+      return @value_table.parameter_names
+    end
+
+    def _expand_value(value, linenum=nil)
+      return @value_table.expand_value(value, @filename, linenum)
+    end
+
+    def _evaluate_expr(expr, linenum=nil)
+      return @value_table.evaluate_expr(expr, @filename, linenum)
     end
 
+
     def load_books(cookbooks)
       cookboos.each do |cookbook| load_book(cookbook) end
     end
@@ -334,27 +369,27 @@ module Rook
 
     def load_book(cookbook)
       b = cookbook
-      # precooking
-      b.precookings.each do |hash|
-        add_precooking(hash['code'], b.bookname, hash['linenum'])
-      end if b.precooking
+      # preparation
+      b.preparations.each do |hash|
+        add_preparation(hash['code'], b.bookname, hash['linenum'])
+      end if b.preparation
       # properties
       b.properties.each do |hash|
         hash['bookname'] = b.bookname
         add_property(hash, b.bookname)
       end if b.properties
-      # variables
-      b.variables.each do |hash|
+      # parameters
+      b.parameters.each do |hash|
         hash['bookname'] = b.bookname
-        add_variable(hash, b.bookname)
-      end if b.variables
+        add_parameter(hash, b.bookname)
+      end if b.parameters
       # materials
       b.materials.each do |nonprod|
-        add_nonproduct(nonprod)
+        add_material(nonprod)
       end if b.materials
       # recipes
       b.recipes.each do |hash|
-        hash = @parameters.evaluate_value(hash)
+        hash = @value_table.expand_value(hash)
         hash['bookname'] = b.bookname
         recipe = Recipe.new(hash)
         add_recipe(recipe)
@@ -371,8 +406,8 @@ module Rook
     end
 
 
-    def add_precooking(code_str, bookname='', linenum=1)
-      @precookings << [code_str, bookname, linenum]
+    def add_preparation(code_str, bookname='', linenum=1)
+      @preparations << [code_str, bookname, linenum]
       Util.evaluate(code_str, bookname, linenum)    # or instance_eval?
     end
 
@@ -380,69 +415,71 @@ module Rook
     def add_property(hash, bookname='')
       hash['access'] ||= 'public'
       name = hash['name']
-      if @parameters.has_property?(name)
-        value = @parameters.get_property(name)
+      if has_property?(name)
+        value = get_property(name)
       else
         if hash.key?('value')
-          value = @parameters.evaluate_value(hash['value'])
+          value = _expand_value(hash['value'])
         elsif hash.key?('expr') || hash.key?('value*')
-          expr = hash.key?('expr') ? hash['expr'] : hash['value*']
-          expr = @parameters.evaluate_value(expr)
-          value = @valuemap.evaluate_expr(expr, bookname, hash['linenum'])
+          code = hash.key?('expr') ? hash['expr'] : hash['value*']
+          code = _expand_value(code)
+          value = _evaluate_expr(code, hash['linenum'])
         else
           raise RookError.new("property '#{name}': no value.")
         end
-        @parameters.set_property(name, value)
+        set_property(name, value)
         hash['value'] = value
         @properties << hash
       end
       #eval "$#{name} = value"
+      instance_variable_set("@#{name}", value)
     end
 
 
-    def add_variable(hash, bookname='')
+    def add_parameter(hash, bookname='')
       name = hash['name']
-      if @parameters.has_variable?(name)
-        @variables.delete_if { |h| h['name'] == name }
+      if has_parameter?(name)
+        @parameters.delete_if { |h| h['name'] == name }
       end
       if hash.key?('value')
-        value = @parameters.evaluate_value(hash['value'])
-      elsif hash.key?('expr') || hash.key?('value*')
-        expr = hash.key?('expr') ? hash['expr'] : hash['value*']
-        linenum = hash['linenum'] || 1
-        expr = @parameters.evaluate_value(expr)
-        value = @parameters.evaluate_expr(expr, bookname, linenum)
+        value = _expand_value(hash['value'])
+      elsif hash.key?('value*')
+        code = hash['value*']
+        linenum = hash['linenum']
+        code = _expand_value(code)
+        value = _evaluate_expr(code, linenum)
       else
-        raise RookError.new("variable '#{name}': no value.")
+        raise RookError.new("parameter '#{name}': no value.")
       end
-      @parameters.set_variable(name, value)
+      set_parameter(name, value)
       hash['value'] = value
-      @variables << hash
+      @parameters << hash
     end
 
 
     def add_material(material_str)
-      mat_str = @parameters.evaluate_value(material_str)
+      mat_str = _expand_value(material_str)
       @materials << mat_str
     end
 
 
-    def add_recipe_hash(hash)
-      %w[ingreds byprods coprods options].each do |key|
-        if hash.key?("#{key}*")
-          val = hash.delete("#{key}*")
-          assert val.is_a?(String), "val.class=#{val.class}"
-          val = @parameters.evaluate_expr(val)
-          val = [ val ] unless val.is_a?(Array)
-          hash[key] = val
-        elsif hash.key?(key)
-          val = @parameters.evaluate_expr(val)
-          hash[key] = val
-        end
-      end
-      r = Recipe.new(hash['product'])
-      add_recipe(r)
-    end
+#    def add_recipe_hash(hash)
+#      %w[ingreds byprods coprods toppings].each do |key|
+#        if hash.key?("#{key}*")
+#          val = hash.delete("#{key}*")
+#          assert val.is_a?(String), "val.class=#{val.class}"
+#          val = _evaluate_expr(val)
+#          val = [ val ] unless val.is_a?(Array)
+#          hash[key] = val
+#        elsif hash.key?(key)
+#          val = _evaluate_expr(val)
+#          hash[key] = val
+#        end
+#      end
+#      r = Recipe.new(hash['product'])
+#      add_recipe(r)
+#    end
+
 
     def add_recipe(recipe)
       @recipes.delete_if { |r| r.product == recipe.product } if @recipe_table[recipe.product]
@@ -515,7 +552,7 @@ module Rook
 
       ## ingredients
       ingreds = recipe.ingreds ? recipe.ingreds.dup : []
-      ingreds.concat(recipe.options.find_all { |f| test(?e, f) }) if recipe.options
+      ingreds.concat(recipe.toppings.find_all { |f| test(?e, f) }) if recipe.toppings
 #      ingreds.each do |ingred|
 #        flag = cook(ingred, cooking, level+1, recipe.verbose?, recipe.fingerprint)
 #        flag_exec = true if flag
@@ -545,7 +582,7 @@ module Rook
 
       ## invoke ingredients' recipe
       #ingreds = recipe.ingreds ? recipe.ingreds.dup : []
-      #ingreds.concat(recipe.options.find_all { |f| test(?e, f) }) if recipe.options
+      #ingreds.concat(recipe.toppings.find_all { |f| test(?e, f) }) if recipe.toppings
       ingreds.each do |ingred|
         flag = cook(ingred, cooking, level+1, recipe.verbose?, recipe.fingerprint)
         flag_exec = true if flag
@@ -564,7 +601,8 @@ module Rook
         end
         report(product, level, recipe.verbose?)
         begin
-          recipe.invoke(@parameters)
+          #recipe.invoke(@value_table)
+          recipe.invoke(self)
         rescue => ex
           prods = [ recipe.product ]
           prods += recipe.coprods if recipe.coprods
@@ -578,7 +616,7 @@ module Rook
       end
 
       ## validate whether product is generated
-      unless recipe.symbolic? || test(?e, product)
+      unless recipe.symbolic? || @noexec || test(?e, product)
         raise RookError.new("product '#{Util.to_str(product)}': not generated")
       end