rook 0.0.2 → 0.1.0

data/README.txt

@@ -1,73 +1,160 @@
-.=title:	README
-.?release:	$Release: 0.0.2$
-.?lastupdated:	$Date: 2005-04-30 11:16:15 +0900 (Sat, 30 Apr 2005) $
+= README
 
+release::    $Release: 0.1.0 $
+copyright::  copyright(c) 2006 kuwata-lab.com all rights reserved.
 
-.$ About
+
+
+== Introduction
 
 Rook is a tool for SCM such as Make, Rake, Ant, and so on.
-Rook is inspired by Cook which is made by Peter Miller.
+Rook has inspired by Cook which is made by Peter Miller.
 http://www.canb.auug.org.au/~millerp/cook/cook.html
 
+Features:
+* Liken software build process to cooking.
+* Two-style approach support: YAML-style and Ruby-style.
+* Natural notation for production rule and optional ingredients.
+* 'tar.gz', 'tar.bz2', and '.zip' support
+  (requires 'minitar', 'bz2', and 'rubyzip' libraries.)
+* Able to invoke build command forcedly
+
 Attention!  Rook is under alpha version and specification
 may change frequently.
 
 
-.$ Installation
 
-Just copy bin/rook file into a proper directory such as 
-/usr/local/bin or /usr/bin.
+== Installation
 
+If you have installed RubyGems, just stype 'gem install -r rook'.
+  $ sudo gem install -r rook
 
-.$ Usage
+Otherwise download ruby_X.X.X.tar.bz2 and install with setup.rb.
+  $ tar xjf rook_X.X.X.tar.bz2
+  $ cd rook_X.X.X/
+  $ sudo setup.rb
 
-Install Rook and type `rook --help'.
+(Must) If you have installed rook without RubyGems, the following
+libraries must be installed.
+* abstract.rb (>= 1.0.0) (http://www.rubyforge.org/projects/abstract)
+* kwalify (>= 0.6.0) (http://www.rubyforge.org/projects/kwalify)
 
+(Optional) If you want to handle *.tar.gz, *.tar.bz2, or *.zip
+files, you must install the following libraries.
+* minitar - http://raa.ruby-lang.org/project/minitar/
+* bz2     - http://raa.ruby-lang.org/project/bz2/
+* rubyzip - http://raa.ruby-lang.org/project/rubyzip/
 
-.$ Terms
+(Optional) Helper script 'ruby_X.X.X/contrib/inline_require.rb'
+merges 'bin/rook' and rook libraries into a file.
+  $ cd rook_X.X.X/
+  $ unset RUBYLIB
+  $ ruby contrib/inline_require.rb -I lib bin/rook > contrib/rook
 
-.[ Product ]
-	Product is an output of cooking.
 
-.[ Ingredient ]
-	Ingredient is materials needed for cooking.
 
-.[ Recipe ]
-	Recipe is a method how to cook product.
+== Examples
 
-.[ Generic recipe ]
-	Generic recipe is a recipe whose product is
-	specified as regular expression.
+The following is an example of Rookbook.yaml to cook *.c files.
+(Rookbook is the equivarent to Makefile in Make or Rakefile in Rake.)
 
-.[ Specific recipe ]
-	Specific recipe is a recipe whose product is
-	specified as filename.
+  properties:
+    - project:  hello
+    - c_flags:  '-g -Wall -O2'
 
-.[ Symbolic recipe ]
-	Symbolic recipe is a recipe whose product is
-	specified as Symbol.
+  variables:
+    - command:     $(project)
+    - objfiles*:   Dir.glob('*.c').collect{|f| f.sub(/\.c$/, '.o')}
 
+  recipes:
+    - product:  $(command)
+      ingreds:  [ $(objfiles) ]
+      desc:     create '$(command)' command
+      method: |
+          sys "gcc #{@c_flags} -o #{@product} #{@ingreds.join(' ')}"
 
-.$ Example
+    - product:  *.o
+      ingreds:  [ $(1).c ]
+      options:  [ $(1).h ]
+      method: |
+          sys "gcc #{@c_flags} -c #{@ingred}"
 
-See `examples/' directory.
+    - product:  :clean
+      method: |
+          rm_f Dir.glob("*.o")
 
 
-.$ To Do
+Rook supports two style of Rookbook: YAML-style and Ruby-style.
+The following ('Rookbook.rb') is the Ruby-style example of Rookbook
+which is equivarent to the above YAML-style example.
 
-.* [_] Documentation
-.* [_] Fingerprint support
-.* [_] Dependency Tree
-.* [_] Plugin architecture
+  property :project,  'hello'
+  property :c_flags,  '-g -Wall -O2'
 
+  command = @project
+  objfiles = Dir.glob('*.c').collect{|f| f.sub(/\.c$/, '.o')}
 
-.$ License
+  desc  "create '#{command}' command"
+  recipe command,	objfiles	do |r|
+    sys "gcc #{@c_flags} -o #{@product} #{@ingreds.join(' ')}"
+  end
 
-GPL ver2
+  recipe "*.o",		'$(1).c', :options=>['$(1).h']  do |r|
+    sys "gcc #{@c_flags} -c #{@ingred}"
+  end
+
+  recipe :clean				do |r|
+    rm_f Dir.glob("*.o")
+  end
+
+
+See 'examples/' directory for more examples.
+
+
+== Documents
+
+Sorry, there is no documentation.
+
+
+== Terms
+
+[ Product ]
+	Output of cooking.
 
+[ Ingredient ]
+	Materials needed for cooking.
 
-.$ Copyright
+[ Byproduct ]
+	Garbages produced in cooking.
 
-Copyright(c) makoto kuwata all rights reserved
+[ Recipe ]
+	Method how to cook product.
+
+[ Generic recipe ]
+	Recipe which product is specified by pattern.
+	This is equivarent to 'rule' in Rake.
+
+[ Specific recipe ]
+	Recipe which product is specified by name.
+	This is equivarent to 'file' in Rake.
+
+[ Symbolic recipe ]
+	Recipe which product is specified by Symbol.
+	This is equivarent to 'task' in Rake.
+
+
+
+== To Do
+
+* [_] Documentation
+* [_] Fingerprint support
+* [_] Dependency Tree
+* [_] Plugin architecture
+
+
+
+== License
+
+GPL ver2
 
 

data/bin/rook

@@ -1,906 +1,12 @@
 #!/usr/bin/env ruby
 
-###
-### rook - a SCM(Software Cooking Method) tool, like `make', `cook', or `rake'
-###
-### copryright(c) 2005 makoto kuwata all rights reserverd
-###
-### $Id: rook 14 2005-04-30 02:16:15Z kwatch $
-### $Release: 0.0.2$
-###
+##
+## $Rev: 18 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
 
-require 'fileutils'
+require 'rook'
+require 'rook/main'
 
-## force FileUtils to print message to $stdout
-FileUtils.instance_eval "@fileutils_output = $stdout"
-
-module Rook
-
-   VERSION     = ('$Rev: 14 $' =~ /(\d+)/) && $1
-   LAST_UPDATE = ('$Date: 2005-04-30 11:16:15 +0900 (Sat, 30 Apr 2005) $' =~ /([-\d]+)/) && $1
-   RELEASE     = ('$Release: 0.0.2$' =~ /([\.\d]+)/) && $1
-
-   $rook_defaults = {
-      :bookname => 'Rookbook',			# or 'Cookbook.rb'
-      :target   => :default,			# or :start
-      :descriptions => {
-         :all     => 'create all products',
-         :clean   => 'remove by-products',
-         :clear   => 'remove all products and by-products',
-         :deploy  => 'deploy products',
-         :config  => 'configure',
-         :setup   => 'setup',
-         :install => 'install products',
-         #:start   => 'start cooking',
-         :default => 'default recipe to start'
-      },
-   }
-   $rook_prompt = "rook$ "
-   $rook_current_recipe = nil
-   $rook_properties = {}
-   $rook_context = {}
-   $rook_recipe_desc = nil
-
-
-   class RookError < StandardError
-   end
-
-   class RecipeNotFoundError < RookError
-   end
-
-   class CommandOptionError < RookError
-   end
-
-   class GenericRecipeExecutionError < RookError
-   end
-
-   class RecipeExecutionError < RookError
-   end
-
-   class RecipeError < RookError
-   end
-
-   class IngredientNotFoundError < RookError
-   end
-
-   class CookbookNotFoundError < RookError
-   end
-
-   class AssersionError
-   end
-
-
-   ##
-   ##
-   ##
-   class Cookbook
-      def initialize(bookname)
-         @bookname = bookname
-         @specific_recipes = []
-         @generic_recipes = []
-         @symbolic_recipes = []
-         #
-         #unless test(?f, @bookname)
-         #   raise CookbookNotFoundError.new("`#{@bookname}': cookbook not found.")
-         #end
-         #load(@bookname)			## load cookbook
-      end
-      attr_reader :bookname
-      attr_reader :specific_recipes, :generic_recipes, :symbolic_recipes
-
-      def add_specific_recipe(recipe)
-         @specific_recipes.unshift(recipe)
-         recipe.cookbook = self
-      end
-
-      def add_generic_recipe(recipe)
-         @generic_recipes.unshift(recipe)
-         recipe.cookbook = self
-      end
-
-      def add_symbolic_recipe(recipe)
-         @symbolic_recipes.unshift(recipe)
-         recipe.cookbook = self
-      end
-
-      def add_recipe(recipe)
-         recipe.add_to_cookbook(self)
-      end
-
-      def lookup(product, index=0)
-         if product.is_a?(String) && product[0] == ?:
-            product = product[1, product.length-1].intern
-         end
-         recipe = nil
-         if index == 0
-            case product
-            when Symbol
-               recipe = @symbolic_recipes.find { |r| r.product === product }
-            when String
-               recipe = @specific_recipes.find { |r| r.product === product }
-               if !recipe
-                  recipe = @generic_recipes.find { |r| r.product === product }
-                  recipe = recipe.specify(product) if recipe
-               end
-            end
-         else
-            case product
-            when Symbol
-               recipes = @symbolic_recipes.find_all { |r| r.product === product }
-               recipe = recipes[index]
-            when String
-               recipes  = @specific_recipes.find_all { |r| r.product === product }
-               recipes2 = @generic_recipes.find_all { |r| r.product === product }
-               recipes.concat(recipes2)
-               recipe = recipe[index]
-               recipe = specify(product) if recipe
-            end
-         end
-         return recipe
-      end
-
-      def create_context()
-         context = {
-            :cookbook => self,
-            :dress_level => 0,
-         }
-         return context
-      end
-
-      def _execute()
-         ## prework
-         rook_context_bkup = $rook_context
-         $rook_context = create_context()
-         unless test(?f, @bookname)
-            raise CookbookNotFoundError.new("`#{@bookname}': cookbook not found.")
-         end
-         load(@bookname)			## load cookbook
-         ## main body
-         yield()
-         ## postwork
-         $rook_context = rook_context_bkup
-      end
-      private :_execute
-
-      def start(targets)
-         _execute() do
-            if targets == nil || targets.empty?
-               target = $rook_defaults[:target]
-               recipe = lookup(target)
-               raise AssertionError.new("recipe.class=#{recipe.class.name}")  if recipe.kind_of?(GenericRecipe)
-               if recipe
-                  recipe.execute()
-               else
-                  #raise RecipeNotFoundError.new("#{target}: recipe not found.")
-                  puts "*** target is not specified."
-                  listup()
-               end
-            else
-               targets.each do |target|
-                  target = target[1,target.length-1].intern if target.is_a?(String) && target[0] == ?:
-                  recipe = lookup(target)
-                  raise RecipeNotFoundError.new("#{target}: recipe not found.") unless recipe
-                  raise AssertionError.new("recipe.class=#{recipe.class.name}") if recipe.kind_of?(GenericRecipe)
-                  recipe.execute()
-               end
-            end
-         end
-      end
-
-      def listup()
-         _listup(@symbolic_recipes, false)
-         _listup(@specific_recipes, false)
-         _listup(@generic_recipes, false)
-      end
-
-      def listup_all()
-         _listup(@symbolic_recipes, true)
-         _listup(@specific_recipes, true)
-         _listup(@generic_recipes, true)
-      end
-
-      def _listup(recipe_list, flag_all=true)
-         _execute() do
-            list = [];  hash = {}
-            recipe_list.each do |recipe|
-               next if hash.key?(recipe.product)
-               next unless flag_all || recipe.desc
-               hash[recipe.product] = true
-               list << recipe
-            end
-            list.reverse.each do |recipe|
-               product = recipe.product
-               display_name = recipe.display_name
-               #display_name = product.is_a?(String) ? product : product.inspect
-               description  = recipe.desc || '(no description)'
-               puts("  %-20s - %s" % [ display_name, description ])
-            end
-         end
-      end
-
-   end
-
-
-   ##
-   ##
-   ##
-   class Recipe
-
-      def add_to_cookbook
-         raise AssertionError.new("Recipe#add_to_cookbook() not implemented.")
-      end
-
-      def initialize(product, *ingredients, &steps)
-         @product = product
-         @ingredients = []
-         ingredients.each do |ingred|
-            add_ingredient(ingred)
-         end if ingredients
-         @steps = steps
-         @matched = nil
-         @cookbook = nil
-         @desc = nil
-      end
-
-      def self.create(product, *ingredients, &steps)
-         self.new(product, *ingredients, &steps)
-      end
-
-      attr_accessor :product, :ingredients, :steps, :matched, :cookbook, :desc
-
-      alias :prod :product
-      alias :ingreds :ingredients
-      def ingredient
-         return @ingredients[0]
-      end
-      alias :ingred :ingredient
-
-      attr_writer :display_name
-      def display_name
-         return @display_name || @product
-      end
-
-      def add_ingredient(ingred)
-         case ingred
-         when String, Symbol, Proc, Hash
-            @ingredients << ingred
-         when Array
-            ingred.each do |ingred2|
-               add_ingredient(ingred2)
-            end
-         when Regexp
-            raise ReicpeError.new("#{ingred.to_s}: regexp is not avairable as ingredient.")
-         else
-            raise RecipeError.new("`#{ingred.to_s}'(class #{ingred.class.name}): ingredient is invalid object.")
-         end
-      end
-
-      def execute(depth=0)
-         bkup = $rook_current_recipe
-         $rook_current_recipe = self
-         puts "### #{self.product.to_s}" unless $rook_properties[:QUIET]
-         @steps.call(self) if @steps
-         $rook_current_recipe = bkup
-         return true
-      end
-
-      def specify(product)
-         raise AssertionError.new("Root#specify() is called.")
-      end
-
-   end
-
-
-   ##
-   ##
-   ##
-   class SpecificRecipe < Recipe
-
-      def add_to_cookbook(cookbook)
-         cookbook.add_specific_recipe(self)
-      end
-
-      def initialize(product, *ingredients, &steps)
-         super(product, *ingredients, &steps)
-      end
-
-      def self.create(product, *ingredients, &steps)
-         recipe = self.new(product, *ingredients, &steps)
-         if ingredients.find { |ingred| ingred.is_a?(Hash) }
-            raise RecipeError.new("`#{product}': specific recipe can't take a hash as an ingredient.")
-         end
-         return recipe
-      end
-
-      def specify(product)
-         return self
-      end
-
-      def execute(depth=0)
-         flag_execute = false
-         if @ingredients.empty?
-            flag_execute = true
-         else
-            if test(?e, @product)
-               prod_mtime = File.mtime(@product)
-            else
-               prod_mtime = nil
-               flag_execute = true
-            end
-            @ingredients.each do |ingred|
-               ingred_recipe = cookbook().lookup(ingred)
-               if ingred_recipe
-                  flag = ingred_recipe.execute(depth+1)
-                  flag_execute = true if flag
-               end
-               if !flag_execute && _ingred_newer?(ingred, prod_mtime)
-                  flag_execute = true
-               end
-            end
-            unless $rook_properties[:noact]
-               @ingredients.each do |ingred|
-                  if ingred.is_a?(String) && !test(?e, ingred)
-                     raise IngredientNotFoundError.new("`#{ingred}': ingredient not found (required by `#{@product}').")
-                  end
-               end
-            end
-         end
-         if flag_execute || $rook_properties[:FORCE] || (depth == 0 && $rook_properties[:force])
-            begin
-               super(depth)
-            rescue RecipeExecutionError => ex
-               File.delete(@product) if test(?f, @product)
-               raise ex
-            end
-         end
-         return flag_execute
-      end
-
-      def _ingred_newer?(ingred, prod_mtime)
-         return ingred.is_a?(String) && test(?e, ingred) && prod_mtime && prod_mtime < File.mtime(ingred)
-      end
-
-   end
-
-
-   ##
-   ##
-   ##
-   class GenericRecipe < Recipe
-      def add_to_cookbook(cookbook)
-         cookbook.add_generic_recipe(self)
-      end
-
-      def initialize(product_pattern, *ingredients, &steps)
-         super(product_pattern, *ingredients, &steps)
-      end
-
-      def self.create(product_pattern, *ingredients, &steps)
-         recipe = self.new(product_pattern, *ingredients, &steps)
-         return recipe
-      end
-
-      def display_name
-         return @display_name || @product.inspect
-      end
-
-      ## generates specific recipe
-      def specify(product)
-         ingred_list = []
-         pattern = @product
-         pattern =~ product
-         m = [ $&, $1, $2, $3, $4, $5 ]
-         @ingredients.each do |ingred|
-            case ingred
-            when String
-               ingred2 = expand_matched(ingred, m)
-               ingred_list << ingred2
-            when Symbol
-               ingred_list << ingred
-            when Proc
-               result = ingred.call(product)
-               ingred_list << result if result
-            when Hash
-               ingred.each do |key, val|
-                  case key
-                  when :if_exists
-                     ingred2 = expand_matched(val, m)
-                     ingred_list << ingred2 if test(?e, ingred2)
-                  else
-                     raise RecipeError.new("`:#{key.id2name}': invalid keyword.")
-                  end
-               end
-            else
-               raise RecipeError.new("#{product.to_s}(class #{product.class.name}): invalid product.")
-            end
-         end if @ingredients
-         recipe = SpecificRecipe.new(product, *ingred_list, &@steps)
-         recipe.matched = m
-         recipe.cookbook = self.cookbook()
-         return recipe
-      end
-
-      def execute(depth=0)
-         raise GenericRecipeExecutionError.new("cannot execute generic recipe.")
-      end
-
-   end
-
-
-   ##
-   ##
-   ##
-   class SymbolicRecipe < Recipe
-
-      def add_to_cookbook(cookbook)
-         cookbook.add_symbolic_recipe(self)
-      end
-
-      def initialize(product_pattern, *ingredients, &steps)
-         super(product_pattern, *ingredients, &steps)
-      end
-
-      def self.create(product, *ingredients, &steps)
-         recipe = self.new(product, *ingredients, &steps)
-         if ingredients.find { |ingred| ingred.is_a?(Hash) }
-            raise RecipeError.new("`#{product}': symbolic recipe can't take a hash as an ingredient.")
-         end
-         return recipe
-      end
-
-      def display_name
-         return @display_name || @product.inspect
-      end
-
-      def execute(depth=0)
-         @ingredients.each do |ingred|
-            recipe = cookbook().lookup(ingred)
-            if recipe
-               flag = recipe.execute(depth+1)
-               flag_execute = true if flag
-            end
-         end
-         super(depth)
-         return true
-         #flag_execute = false
-         #if @ingredients.empty?
-         #   flag_execute = true
-         #else
-         #   @ingredients.each do |ingred|
-         #      recipe = cookbook().lookup(ingred)
-         #      if recipe
-         #         flag = recipe.execute(depth+1)
-         #         flag_execute = true if flag
-         #      end
-         #   end
-         #end
-         #if flag_execute
-         #   super(depth)
-         #end
-         #return flag_execute
-      end
-
-      def specify(product)
-         raise AssertionError.new("SymbolicRecipe#specify is called.")
-      end
-   end
-end
-
-
-module RookCommand
-
-   ##
-   ##
-   ##
-   def desc(description=nil)
-      $rook_recipe_desc = description
-   end
-
-   def recipe(product, *ingredients, &steps)
-      cookbook = $rook_context[:cookbook]
-      case product
-      when String
-         recipe = Rook::SpecificRecipe.create(product, *ingredients, &steps)
-         cookbook.add_specific_recipe(recipe)
-      when Regexp
-         recipe = Rook::GenericRecipe.create(product, *ingredients, &steps)
-         cookbook.add_generic_recipe(recipe)
-      when Symbol
-         recipe = Rook::SymbolicRecipe.create(product, *ingredients, &steps)
-         cookbook.add_symbolic_recipe(recipe)
-      end
-      ## set description
-      if $rook_recipe_desc == nil
-         recipe.desc = $rook_defaults[:descriptions][product]
-      elsif $rook_recipe_desc == false
-         recipe.desc = nil
-      else
-         recipe.desc = $rook_recipe_desc
-      end
-      $rook_recipe_desc = nil
-      return recipe
-   end
-
-   def grecipe(product, *ingredients, &steps)
-      ## convert wildcard ('*', '?', and '{}') into Regexp
-      s = product.to_s
-      s = Regexp::quote(s)
-      s.gsub!(/(\\\?+)/) { |m| '(' + ('.' * m.length) + ')' }
-      s.gsub!(/(\\\*)/, '(.*?)')
-      s.gsub!(/(\\\{(.*?)\\\})/) { '(' + $2.gsub(/\\\|/, '|') + ')' }
-      s.gsub!(/%/, '(.*?)')
-      regexp = Regexp::compile("^#{s}$")
-      r = recipe(regexp, *ingredients, &steps)
-      r.display_name = product
-      return r
-   end
-
-   def rook(*targets)
-      bookname = $rook_context[:cookbook].bookname
-      cookbook = Rook::Cookbook.new(bookname)
-      targets = expand_matched(targets, m()) if m()
-      cookbook.start(targets)
-   end
-
-   def dress(product=nil)
-      product = $rook_current_recipe.product if !product
-      $rook_context[:dress_level] += 1
-      recipe = $root_context[:cookbook].lookup(product, $rook_context[:dress_level])
-      recipe.execute()
-      $rook_context[:dress_level] -= 1
-   end
-
-   def set_prompt(prompt)
-      $rook_prompt = prompt
-   end
-
-   def get_prompt()
-      $rook_prompt
-   end
-
-
-   def expand_matched(obj, m=nil)
-      m = $rook_current_recipe.matched unless m
-      return obj unless m
-      case obj
-      when String
-         if m
-            obj = obj.dup
-            obj.gsub!(/\{0\}/, m[0]) if m[0]
-            obj.gsub!(/\{1\}/, m[1]) if m[1]
-            obj.gsub!(/\{2\}/, m[2]) if m[2]
-            obj.gsub!(/\{3\}/, m[3]) if m[3]
-            obj.gsub!(/\{4\}/, m[4]) if m[4]
-            obj.gsub!(/\{5\}/, m[5]) if m[5]
-         end
-      when Array
-         obj = obj.collect { |item| expand_matched(item, m) }
-      end
-      return obj
-   end
-   private :expand_matched
-
-   def m()
-      return $rook_current_recipe.matched
-   end
-
-   def _cmd(cmd_str, prompt, ignore_error)
-      cmd_str = expand_matched(cmd_str, m()) if m()
-      print get_prompt(), cmd_str, "\n" unless $rook_properties[:quiet]
-      unless $rook_properties[:noact]
-         result = system(cmd_str)
-      else
-         result = true
-      end
-      unless result || ignore_error
-         raise Rook::RecipeExecutionError.new("command failed: `#{cmd_str}'")
-      end
-      return result
-   end
-   private :_cmd
-
-   def cmd(cmd_str, prompt=$rook_prompt)
-      _cmd(cmd_str, prompt, false)
-   end
-   alias :sh :cmd
-   alias :cmd :cmd
-   #alias :do :cmd
-
-   def cmd!(cmd_str, prompt=$rook_prompt)
-      cmd(cmd_str, prompt, true)
-   end
-   alias sh! cmd!
-   #alias do! cmd!
-
-   def echo(*args)
-      args = expand_matched(args, m()) if m()
-      unless $rook_properties[:noact]
-         echo_n(*args)
-         puts
-      end
-   end
-
-   def echo_n(*args)
-      unless $rook_properties[:noact]
-         print args.flatten.join(" ")
-      end
-   end
-
-
-   def chdir(dir, &block)
-      dir = expand_matched(dir, m()) if m()
-      opts = {}
-      opts[:noop] = true    if $rook_properties[:noact]
-      opts[:verbose] = true if ! $rook_properties[:quiet]
-      print get_prompt() if opts[:verbose]
-      FileUtils.chdir(dir, opts, &block)
-   end
-   alias :cd :chdir
-
-   def _command1(command, args)
-      args = args.flatten
-      args = expand_matched(args, m()) if m()
-      opts = {}
-      opts[:noop] = true    if $rook_properties[:noact]
-      opts[:verbose] = true if ! $rook_properties[:quiet]
-      print get_prompt() if opts[:verbose]
-      FileUtils.__send__(command, args, opts)
-   end
-   private :_command1
-
-   def mkdir(*dirs)
-      _command1(:mkdir, dirs)
-   end
-
-   def mkdir_p(*dirs)
-      _command1(:mkdir_p, dirs)
-   end
-
-   def rmdir(*dirs)
-      _command1(:rmdir, dirs)
-   end
-
-   def remove(*files)
-      _command1(:rm, files)
-   end
-   alias :rm :remove
-
-   def remove_r(*files)
-      _command1(:rm_r, files)
-   end
-   alias :rm_r :remove_r
-
-   def remove_rf(*files)
-      _command1(:rm_rf, files)
-   end
-   alias :rm_rf :remove_rf
-
-
-   def _command1_ifexists(command, files)
-      list = files.flatten.find_all { |f| test(?e, f) }
-      _command1(command, list) unless list.empty?
-   end
-
-   def delete(*files)
-      _command1_ifexists(:rm, files)
-   end
-   alias :del :delete
-
-   def delete_r(*files)
-      _command1_ifexists(:rm_r, files)
-   end
-   alias :del_r :delete_r
-
-   def delete_rf(*files)
-      _command1_ifexists(:rm_rf, files)
-   end
-   alias :del_rf :delete_rf
-
-
-   def _command2(command, args)
-      args = args.flatten
-      args = expand_matched(args, m()) if m()
-      src = dest = nil
-      if args.length == 1
-         src = args[0]
-      elsif args.length > 1
-         dest = args.pop
-         src  = args
-      end
-      opts = {}
-      opts[:noop]    = true if  $rook_properties[:noact]
-      opts[:verbose] = true if !$rook_properties[:quiet]
-      print get_prompt() if opts[:verbose]
-      FileUtils.__send__(command, src, dest, opts)
-   end
-   private :_command2
-
-   def copy(*args)
-      _command2(:cp, args)
-   end
-   alias :cp :copy
-
-   def copy_r(*args)
-      _command2(:cp_r, args)
-   end
-   alias :cp_r :copy_r
-
-   def move(*args)
-      _command2(:mv, args)
-   end
-   alias :mv :move
-
-   def store(*args, &filter)
-      args = args.flatten
-      args = expand_matched(args, m()) if m()
-      store_to = args.pop
-      src_files = []
-      args.each do |file|
-         src_files.concat Dir.glob(file)
-      end
-      src_files.delete_if { |f| !filter.call(f) } if filter
-      if ! $rook_properties[:quiet]
-         print get_prompt()
-         print "store #{args.join(' ')} #{store_to}"
-         puts
-      end
-      if ! $rook_properties[:noact]
-         src_files.each do |f|
-            srcdir = File::dirname(f)
-            destdir = "#{store_to}/#{srcdir}"
-            FileUtils.mkdir_p(destdir) unless test(?d, destdir)
-            FileUtils.cp_r(f, destdir) unless test(?d, f)
-         end
-      end
-   end
-
-end
-
-
-module Rook
-   ##
-   ##
-   ##
-   class Main
-      def initialize(argv = ARGV)
-         @argv = argv
-      end
-
-      def execute
-         options, properties = parse_argv(@argv)
-         if properties[:help]
-            properties.delete(:help)
-            options[?h] = true
-         end
-         if properties[:version]
-            properties.delete(:version)
-            options[?v] = true
-         end
-         if options[?h] || options[?v]
-            command = File::basename($0)
-            puts "#{command} - a SCM (Software Cooking Method) tool" if options[?h]
-            puts version() if options[?v]
-            puts usage()   if options[?h]
-            return
-         end
-         properties[:noact] = true  if options[?n]
-         properties[:quiet] = true  if options[?q]
-         properties[:quiet] = properties[:QUIET] = true  if options[?Q]
-         properties[:force] = true  if options[?f]
-         properties[:force] = properties[:FORCE] = true  if options[?F]
-         $rook_properties = properties
-         $rook_prompt = options[?p] if options[?p]
-         #
-         bookname = options[?b] || $rook_defaults[:bookname]
-         cookbook = Cookbook.new(bookname)
-         if options[?l] || options[?T]
-            cookbook.listup()
-         elsif options[?L]
-            cookbook.listup_all()
-         else
-            targets = @argv
-            cookbook.start(targets)
-         #elsif !@argv.empty?
-         #   targets = @argv
-         #   cookbook.start(targets)
-         #elsif cookbook.lookup($rook_defaults[:target]) == nil
-         #   puts "*** target is not specified."
-         #   cookbook.listup()
-         #else
-         #   target = $rook_defaults[:target]
-         #   cookbook.start([target])
-         end
-      end
-
-      def usage()
-         command = File::basename($0)
-         s =  ""
-         s << "usage: #{command} [options] target-product\n"
-         s << "  -h          :  help\n"
-         s << "  -v          :  version\n"
-         s << "  -b cookbook :  cookbook (default `#{$rook_defaults[:bookname]}')\n"
-         s << "  -p prompt   :  set prompt\n"
-         s << "  -n          :  no execute\n"
-         s << "  -q          :  quiet\n"
-         s << "  -Q          :  more quiet\n"
-         s << "  -l          :  list described recipes\n"
-         s << "  -L          :  list all recipes\n"
-         s << "  -f          :  force\n"
-         s << "  -F          :  force strongly\n"
-      end
-
-      def version()
-         return "Release: #{Rook::RELEASE} (Revision: #{Rook::VERSION})"
-      end
-
-      def parse_argv(argv)
-         options = []
-         properties = {}
-         while argv[0] && argv[0][0] == ?-
-            optstr = argv.shift.dup
-            optstr.gsub!(/\A-/, '')
-            if optstr[0] == ?-
-               optstr.gsub!(/\A-/, '')
-               if optstr =~ /\A([-\w]+)(=(.*))?\z/
-                  prop_name  = $1.gsub(/-/, '_')
-                  prop_value = $3
-                  properties[prop_name.intern] = prop_value == nil ? true : parse_value(prop_value)
-               end
-            else
-               while optstr && !optstr.empty?
-                  optchar = optstr[0]
-                  optstr.gsub!(/\A./, '')
-                  case optchar
-                  when ?h, ?v, ?n, ?q, ?Q, ?f, ?F, ?l, ?L
-                     options[optchar] = true
-                  when ?b, ?p
-                     arg = optstr.empty? ? ARGV.shift : opstr
-                     optstr = nil
-                     unless arg
-                        case optchar
-                        when ?f  ; msg = "-#{optchar.chr}: cookbook required."
-                        when ?p  ; msg = "-#{optchar.chr}: prompt required."
-                        end
-                        raise CommandOptionError.new(msg)
-                     end
-                     options[optchar] = arg
-                  else
-                     raise CommandOptionError.new("-#{optchar.chr}: invalid option.")
-                  end
-               end
-            end
-         end
-         return options, properties
-      end
-
-      def parse_value(value)
-         case value
-         when 'true', 'yes'      ;  return true
-         when 'false', 'no'      ;  return false
-         when 'nil', 'null'      ;  return nil
-         when /\A\d+\z/          ;  return value.to_i          # eval(value)
-         when /\A\d+\.\d+\z/     ;  return value.to_f          # eval(value)
-         when /\A\/(.*)\/\z/     ;  return Regexp.compile($1)  # eval(value)
-         when /\A:(.*)\z/        ;  return $1.intern           # eval(value)
-         when /\A'.*'\z/         ;  return eval(value)
-         when /\A".*"\z/         ;  return eval(value)         # unsafe?
-         else                    ;  return value
-         end
-      end
-   end
-
-end
-
-
-#if __FILE__ == $0
-   include RookCommand
-   begin
-      main = Rook::Main.new(ARGV)
-      main.execute
-   rescue Rook::RookError => ex
-      $stderr.puts "[ERROR] #{ex.message}"
-      #if ex.class == CommandOptionError
-      #  $stderr.puts main.usage()
-      #end
-   end
-#end
+Rook::Main.main(ARGV)