rook 0.0.2 → 0.1.0

data/lib/rook/kitchen.rb

@@ -0,0 +1,668 @@
+##
+## $Rev: 32 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+require 'abstract'
+require 'rook/util'
+require 'rook/cookbook'
+require 'rook/recipe'
+
+
+
+module Rook
+
+
+
+  ##
+  ## add functions for DSL (ruby-style cookbook)
+  ##
+  module KitchenHelper
+
+    private
+
+
+    ##
+    ## define a property in Rookbook.rb
+    ##
+    ## ex. (in Rookbook.rb)
+    ##   property  'release',  '1.0.0',  :desc=>'release number'
+    ##   property  'project',  'myapp'
+    ##
+    ## the above is equivarent to the following (in Rookbook.yaml):
+    ##   properties:
+    ##     - release : 1.0.0
+    ##       :desc   : 'release number'
+    ##     - project : myapp
+    ##
+    ## this method define a global variable which name is the same as property name.
+    ## for example, global variables $release and $project are defined in above ex.
+    ##
+    ## property value can be overwrited by command-line option.
+    ##
+    ## ex. (in command-line)
+    ##   $ rook --release=1.2.3 --project='myapp2'
+    ##
+    def property(name, value, options={})    # :doc:
+      hash = { 'name'=>name.to_s, 'value'=>value }
+      options.each { |name, value| hash[name.to_s] = value }
+      add_property(hash)
+    end
+
+    #--
+    #abstract_method 'hash', :add_property, :add_variable
+    #++
+
+    def add_property(hash)
+      not_implemented
+    end
+
+    def add_variable(hash)
+      not_implemented
+    end
+
+
+    ##
+    ## define a variable in Rookbook.rb
+    ##
+    ## ex. (in Rookbook.rb)
+    ##   variable :srcdir,  'src'
+    ##   variable :files,   Dir.glob('src/*.rb')
+    ##   variable :rook_product,  :all
+    ##
+    ## the above code is equivalent to the following in Rookbook.yaml:
+    ##   variables:
+    ##     - srcdir  :  src
+    ##     - files*  :  Dir.glob('src/*.rb')
+    ##     - rook_product : :all
+    ##
+    def variable(name, value, options={})    # :doc:
+      hash = { 'name'=>name.to_s, 'value'=>value }
+      options.each { |name, value| hash[name.to_s] = value }
+      add_variable(hash)
+    end
+
+
+    ##
+    ## specify material (= non-products) in Rookbook.rb
+    ##
+    ## ex. (in Rookbook.rb)
+    ##   material 'index.html'
+    ##   material 'readme.html'
+    ##
+    ## the above is equivarent to the following in Rookbook.yaml:
+    ##   materials:
+    ##     - index.html
+    ##     - readme.html
+    ##
+    def material(material_name)    # :doc:
+      add_material(material_name)
+    end
+
+    #--
+    #abstract_method 'material_name', :add_material
+    #++
+
+
+    def add_material(material_name)
+      not_implemented
+    end
+
+
+
+    ##
+    ## specify description of recipe in Rookbook.rb
+    ##
+    ## ex. (in Rookbook.rb)
+    ##   desc 'create *.o from *.c'
+    ##   recipe '*.o',   '$(1).c' do
+    ##     sys "gcc -c #{@ingreds[0]}"
+    ##   end
+    ##
+    ## the above is equivarent to the following in Rookbook.yaml:
+    ##   recipes:
+    ##     - product:   *.o
+    ##       desc:      create *.o from *.c
+    ##       ingreds:   [ $(1).c ]
+    ##       method: |
+    ##         sys "gcc -c #{@ingreds[0]}"
+    ##
+    def desc(text)    # :doc:
+      @_desc = text
+    end
+
+
+
+    ##
+    ## define a recipe in Rookbook.rb
+    ##
+    ## ex. (in Rookbook.rb)
+    ##   recipe '*.o'  , '$(1).c', :options=>['$(1).h'], :desc=>'compile *.c' do
+    ##     sys "gcc -c #{@ingreds[0]}"
+    ##   end
+    ##
+    ## the above is equivarent to the following in Rookbook.yaml:
+    ##   recipes:
+    ##     - product:   *.o
+    ##       ingreds:   [ $(1).c ]
+    ##       options:   [ $(1).h ]
+    ##       desc:      compile *.c
+    ##       method: |
+    ##         sys "gcc -c #{@ingreds[0]}"
+    ##
+    ## return value is a recipe created.
+    ##
+    def recipe(product, *args, &block)    # :doc:
+      hash = {}
+      if args[-1].is_a?(Hash)
+        args.pop.each do |key, val|
+          case key.to_s
+          when 'option', 'coprod', 'byprod'
+            hash[key.to_s + 's'] = [val]
+          else
+            hash[key.to_s] = val
+          end
+        end
+      end
+      hash['product'] = product
+      hash['ingreds'] = args.flatten
+      hash['block']   = block
+      if @_desc != nil
+        hash['desc'] = @_desc
+        @_desc = nil
+      end
+      r = Recipe.new(hash)
+      add_recipe(r)
+      return r
+    end
+
+
+    #--
+    #abstract_method 'product, *args, &block', :add_recipe
+    #++
+
+    def add_recipe(product, *args, &block)
+      not_implemented
+    end
+
+
+  end
+
+
+  class Parameters
+
+    def initialize
+      @_property_table = {}
+      @_variable_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)
+    end
+
+    def set_property(name, value)
+      name = name.to_s
+      return if has_property?(name)   # cannot override
+      @_property_table[name] = value
+      instance_variable_set("@#{name}", value)
+    end
+
+    def set_variable(name, value)
+      @_variable_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]
+    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(name)
+      #end
+      msg = "'$(#{name})': no such property nor variable."
+      #raise UndefinedPropertyError.new(msg, name)
+      raise RookError.new(msg)
+    end
+
+    def evaluate_value(value)
+      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) }
+        end
+      when Array
+        list = value.collect { |val| evaluate_value(val) }
+        val = list
+      when Hash
+        hash = {}
+        value.each { |key, val| hash[key] = evaluate_value(val) }
+        val = hash
+      else
+        val = value
+      end
+      return val
+    end
+
+    def evaluate_expr(expr, filename='(expr)', linenum=1)
+      code = @_variable_table.keys.collect { |name| "#{name}=@_variable_table['#{name}'];" }
+      code << expr
+      return self.instance_eval(code.join, filename, linenum)
+    end
+
+    def property_names
+      return @_property_table.keys
+    end
+
+    def variable_names
+      return @_variable_table.keys
+    end
+
+  end
+
+
+
+
+  ##
+  ## kitchen class
+  ##
+  ## ex.
+  ##   cookbooks, errors = Cookbook.load_yamlfile('Rookbook.yaml')
+  ##   kitchen = Kitchen.new
+  ##   cookbooks.each { |book| kitchen.load_book(book) }
+  ##   kitchen.start_cooking('product_name')
+  ##
+  class Kitchen
+    include Assertion
+    include KitchenHelper
+
+
+    def initialize(properties={}, options={})
+      @parameters = Parameters.new
+      @properties = []
+      @variables = []
+      properties.each do |name, value|
+        add_property({'name'=>name.to_s, 'value'=>value})
+      end
+      @recipes = []
+      @recipe_table = {}
+      @materials = []
+      @precookings = []
+      @forced  = options[:forced]
+      #@verbose = options[:verbose]
+      #@noexec  = options[:noexec]
+    end
+    attr_reader :properties, :variables
+    attr_reader :materials, :precookings, :recipes
+    #attr_reader :forced, :quiet, :noexec
+
+
+    def has_property?(name)
+      return @parameters.has_property?(name)
+    end
+
+    def has_variable?(name)
+      return @parameters.has_variable?(name)
+    end
+
+    def get_property(name)
+      return @parameters.get_property(name)
+    end
+
+    def get_variable(name)
+      return @parameters.get_variable(name)
+    end
+
+    def load_books(cookbooks)
+      cookboos.each do |cookbook| load_book(cookbook) end
+    end
+
+
+    def load_book(cookbook)
+      b = cookbook
+      # precooking
+      b.precookings.each do |hash|
+        add_precooking(hash['code'], b.bookname, hash['linenum'])
+      end if b.precooking
+      # 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|
+        hash['bookname'] = b.bookname
+        add_variable(hash, b.bookname)
+      end if b.variables
+      # materials
+      b.materials.each do |nonprod|
+        add_nonproduct(nonprod)
+      end if b.materials
+      # recipes
+      b.recipes.each do |hash|
+        hash = @parameters.evaluate_value(hash)
+        hash['bookname'] = b.bookname
+        recipe = Recipe.new(hash)
+        add_recipe(recipe)
+      end if b.recipes
+    end
+
+
+    def load_script(filename)
+      self.instance_eval File.read(filename), filename, 1
+    end
+
+    def load_script!(script, filename)
+      self.instance_eval script, filename, 1
+    end
+
+
+    def add_precooking(code_str, bookname='', linenum=1)
+      @precookings << [code_str, bookname, linenum]
+      Util.evaluate(code_str, bookname, linenum)    # or instance_eval?
+    end
+
+
+    def add_property(hash, bookname='')
+      hash['access'] ||= 'public'
+      name = hash['name']
+      if @parameters.has_property?(name)
+        value = @parameters.get_property(name)
+      else
+        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*']
+          expr = @parameters.evaluate_value(expr)
+          value = @valuemap.evaluate_expr(expr, bookname, hash['linenum'])
+        else
+          raise RookError.new("property '#{name}': no value.")
+        end
+        @parameters.set_property(name, value)
+        hash['value'] = value
+        @properties << hash
+      end
+      #eval "$#{name} = value"
+    end
+
+
+    def add_variable(hash, bookname='')
+      name = hash['name']
+      if @parameters.has_variable?(name)
+        @variables.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)
+      else
+        raise RookError.new("variable '#{name}': no value.")
+      end
+      @parameters.set_variable(name, value)
+      hash['value'] = value
+      @variables << hash
+    end
+
+
+    def add_material(material_str)
+      mat_str = @parameters.evaluate_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(recipe)
+      @recipes.delete_if { |r| r.product == recipe.product } if @recipe_table[recipe.product]
+      @recipe_table[recipe.product] = recipe
+      @recipes << recipe
+    end
+
+
+    def find_generic_recipe(product)
+      return @recipes.find { |r| r.kind == 'generic' && r.match?(product) }
+    end
+
+
+    def find_specific_recipe(product)
+      return @recipes.find { |r| r.kind == 'specific' && r.match?(product) }
+    end
+
+
+    def find_recipe(product)
+      return find_specific_recipe(product) || find_generic_recipe(product)
+    end
+
+
+    def start_cooking(product)
+      cooking = Cooking.new(product)
+      begin
+        cook(product, cooking, 0)
+      rescue Exception => ex
+        log(ex.message, 0, nil, '*** ')
+        raise ex
+      end
+    end
+
+
+    ##
+    ## cook product
+    ##
+    ## return true when product recipe is invoked, else return false.
+    ##
+    def cook(product, cooking, level=0, verbose=nil, parent_fingerprint=false)
+      ## check
+      if @materials.include?(product)
+        log("skip '#{Util.to_str(product)}': material.", level, verbose)
+        return false
+      end
+      if cooking.cooked?(product)
+        log("skip '#{Util.to_str(product)}': already cooked.", level, verbose)
+        return false
+      end
+      if cooking.now_cooking?(product)
+        raise RookError.new("'#{Util.to_str(product)}': recipe is recursively looped.")
+      end
+
+      ## find recipe
+      recipe = find_recipe(product)
+      unless recipe
+        if product.is_a?(String) && test(?e, product)
+          log("skip '#{Util.to_str(product)}': raw ingredient.", level, verbose)
+          return false
+        else
+          raise RookError.new("'#{Util.to_str(product)}': recipe not found.")
+        end
+      end
+      recipe = recipe.to_specific(product)
+
+      ## start cooking
+      cooking.start(recipe)
+      log("begin '#{Util.to_str(product)}'", level, recipe.verbose?)
+      flag_exec = @forced
+
+      ## ingredients
+      ingreds = recipe.ingreds ? recipe.ingreds.dup : []
+      ingreds.concat(recipe.options.find_all { |f| test(?e, f) }) if recipe.options
+#      ingreds.each do |ingred|
+#        flag = cook(ingred, cooking, level+1, recipe.verbose?, recipe.fingerprint)
+#        flag_exec = true if flag
+#      end
+
+      ## execute when
+      ## * command-line option -F specified
+      ## * executed at least one recipe of ingredients
+      ## * recipe attribute 'forced' is true
+      ## * recipe is symbolic and has howoto part
+      ## * there isn't product
+      ## * recipe has no ingredient
+      ## * there is any ingredient which is newer than product
+      unless flag_exec
+        flag_exec ||= recipe.forced?
+        flag_exec ||= recipe.symbolic? && (recipe.method || recipe.block)
+        flag_exec ||= !recipe.symbolic? && !test(?e, product)
+        flag_exec ||= ingreds.empty? && (recipe.method || recipe.block)
+      end
+      unless flag_exec || ingreds.empty?
+        prod_mtime = File.mtime(product)
+        flag_exec = ingreds.any? { |f| f.is_a?(String) && test(?e, f) && prod_mtime < File.mtime(f) }
+        #unless flag_exec
+        #  log("skip '#{Util.to_str(product)}': newer than all ingredients.", level, recipe.verbose?)
+        #end
+      end
+
+      ## invoke ingredients' recipe
+      #ingreds = recipe.ingreds ? recipe.ingreds.dup : []
+      #ingreds.concat(recipe.options.find_all { |f| test(?e, f) }) if recipe.options
+      ingreds.each do |ingred|
+        flag = cook(ingred, cooking, level+1, recipe.verbose?, recipe.fingerprint)
+        flag_exec = true if flag
+      end
+
+      unless flag_exec || ingreds.empty?
+        log("skip '#{Util.to_str(product)}': newer than all ingredients.", level, recipe.verbose?)
+      end
+
+      ## execute method part
+      fingerprint_value = nil
+      if flag_exec
+        flag_fp = parent_fingerprint == 'ingreds' || recipe.fingerprint == 'product'
+        if flag_fp && test(?f, product)
+          fingerprint_value = Util.fingerprint(product)
+        end
+        report(product, level, recipe.verbose?)
+        begin
+          recipe.invoke(@parameters)
+        rescue => ex
+          prods = [ recipe.product ]
+          prods += recipe.coprods if recipe.coprods
+          prods.each do |file|
+            next unless file.is_a?(String) && test(?f, file)
+            log("removing '#{file}' because of #{ex.class.name} - #{ex.message}", level, true)
+            File.unlink(file)
+          end
+          raise ex
+        end
+      end
+
+      ## validate whether product is generated
+      unless recipe.symbolic? || test(?e, product)
+        raise RookError.new("product '#{Util.to_str(product)}': not generated")
+      end
+
+      ## fingerprint check
+      if fingerprint_value
+        fp1 = fingerprint_value
+        fp2 = Util.fingerprint(product)
+        op = fp1 == fp2 ? '==' : '!='
+        log("fingerprint of #{product}: #{fp1} #{op} #{fp2}", level, recipe.verbose?)
+        flag_exec = false if fp1 == fp2
+      end
+
+      ## finish cooking
+      log("end '#{Util.to_str(product)}'", level, recipe.verbose?)
+      cooking.finish(recipe)
+      return flag_exec
+
+    end
+
+
+    private
+
+
+    def log(mesg, level, verbose=nil, prompt='# ')
+      #flag = verbose.nil? ? @verbose == true : verbose
+      flag = verbose.nil? ? $rook_verbose == true : verbose
+      _puts(prompt + (' ' * level) + mesg) if flag
+    end
+
+
+    def report(product, level, verbose=nil)
+      #flag = verbose.nil? ? @verbose != false : verbose
+      flag = verbose.nil? ? $rook_verbose != false : verbose
+      str = Util.to_str(product)
+      _puts("### #{'*' * (level+1)} #{str}") if verbose || $rook_verbose != false
+    end
+
+
+    def _puts(str)
+      puts str
+    end
+
+
+  end
+
+
+
+  class Cooking  #:nodoc:
+
+
+    def initialize(goal_product)
+      @goal_product = goal_product
+      @cooked = {}
+      @now_cooking = {}
+    end
+    attr_reader :goal_product, :cooked
+
+
+    def cooked?(product)
+      return @cooked.key?(product)
+    end
+
+
+    def now_cooking?(product)
+      return @now_cooking.key?(product)
+    end
+
+
+    def start(recipe)
+      recipe.all_products.each do |prod|
+        @now_cooking[prod] = recipe
+      end
+    end
+
+
+    def finish(recipe)
+      recipe.all_products.each do |prod|
+        @cooked[prod] = @now_cooking.delete(prod)
+      end
+    end
+
+
+  end
+
+
+
+end