rook 0.0.2 → 0.1.0

data/examples/project/test/test.rb

@@ -0,0 +1,27 @@
+##
+## $Id$
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+$LOAD_PATH << 'lib' if test(?f, 'lib/example.rb')
+
+require 'test/unit'
+require 'example'
+
+class ExampleTest < Test::Unit::TestCase
+ 
+
+  def test1
+    expected = <<END
+1: foo
+2: bar
+3: baz
+END
+    argv = ['foo', 'bar', 'baz']
+    actual = Example.new(argv).execute()
+    assert_equal(expected, actual)
+  end
+
+end
+ 

data/lib/rook.rb

@@ -0,0 +1,50 @@
+##
+## $Rev: 29 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+begin
+  require 'rubygems'
+rescue LoadError => ex
+  # nothing
+end
+
+require 'abstract'
+require 'kwalify'
+require 'fileutils'
+
+# !NOTICE! RubyGems not support autoload!
+#autoload :Zlib, 'zlib'
+#autoload :Zip, 'zip/zip'                  # http://raa.ruby-lang.org/project/rubyzip/
+#autoload :BZ2, 'rook/helper/bz2'          # http://raa.ruby-lang.org/project/bz2/
+#autoload :Archive, 'archive/tar/minitar'  # http://raa.ruby-lang.org/project/minitar/
+
+
+##
+module Rook
+
+  class RookError < StandardError
+  end
+
+  class AssertionError < Exception
+  end
+
+  module Assertion
+    def assert(expr, message)
+      raise AssertionError.new(message) unless expr
+    end
+    def assert_failed(message)
+      raise AssertionError.new(message)
+    end
+  end
+
+end
+
+
+require 'rook/util'
+require 'rook/commands'
+require 'rook/cookbook'
+require 'rook/recipe'
+require 'rook/kitchen'

data/lib/rook/commands.rb

@@ -0,0 +1,426 @@
+##
+## $Rev: 29 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+require 'rook/helper/file'
+require 'rook/helper/fileutils'
+
+
+
+module Rook
+
+
+
+  ##
+  ## commands for recipe method
+  ##
+  module Commands
+
+
+    private
+
+
+    def _prompt(str)
+      puts "rook$ #{str}" unless $rook_verbose == false
+    end
+
+
+    def _log(mesg)
+      #$rook_logger.print(mesg) if $rook_logger
+      puts("rook> " + mesg) if $rook_verbose == true || @verbose
+    end
+
+
+    def comment(str)  # :doc:
+      puts "### " + str unless $rook_verbose == false
+    end
+
+
+    def _glob(args)   # :nodoc:
+      args2 = []
+      args.each do |arg|
+        if arg.nil?
+          # should warn?
+        elsif (list = Dir.glob(arg)).empty?
+          args2 << arg
+        else
+          args2.concat(list)
+        end
+      end
+      return args2
+    end
+
+
+    def _handle_args(method_name, args, prompt_optstr=nil, log_optstr=nil)   # :nodoc:
+      # command
+      method = method_name.to_s
+      command = method.sub(/_(\w+)\z/, '')
+      opt_str = $1 ? " -#{$1}" : ''
+      # options
+      opts = args.pop if args[-1].is_a?(Hash)
+      opts.each do |name, value|
+        len = name.to_s.length
+        opt_str << (len == 1 ? " -#{name}" : " --#{name}")
+        opt_str << " #{value}" unless value == true
+        #opt_str << (len == 1 ? " #{value}" : "=#{value}") unless val == true
+      end if opts
+      # args
+      args = args.flatten
+      _prompt("#{command}#{opt_str}#{prompt_optstr} #{args.join(' ')}")
+      args = _glob(args)
+      #arg_str = args.collect { |arg| arg.inspect }.join(', ')
+      arg_str = args.inspect
+      arg_str.chop! ;  arg_str[0,1] = ''    # "[...]" => "..."
+      arg_str << ", #{opts.inspect}" if opts
+      _log("#{method}(#{log_optstr}#{arg_str})")
+      #
+      return args, opts
+    end
+
+
+ #--
+ #   def _install(command, args, options={})   # :nodoc:
+ #     args = args.flatten
+ #     if $flag_verbose
+ #       optstr = ''
+ #       optstr = << " -m #{options[:mode]}"
+ #       _prompt("#{command}#{optstr} #{args}")
+ #     end
+ #     return if $rook_noexec
+ #     Kernel.system(str)
+ #     unless $? == 0 || forced
+ #       raise RookError.new("command '#{str}' failed.")  #'
+ #     end
+ #   end
+ #++
+
+
+    def _system(command, str, forced)   # :nodoc:
+      _prompt(str)
+      minus = forced ? '-' : ''
+      if command == :'`'
+        _log("`#{minus}#{str}`")
+      else
+        _log("#{minus}#{command}(#{str.inspect})")
+      end
+      return if $rook_noexec
+      Kernel.system(str)
+      unless $? == 0 || forced
+        raise RookError.new("command '#{str}' failed.")  #'
+      end
+    end
+
+    def cmd(str)  # :doc:
+      _system(:cmd, str, false)
+    end
+
+    def cmd!(str)  # :doc:
+      _system(:'cmd!', str, true)
+    end
+
+    def system(str)  # :doc:
+      _system(:system, str, false)
+    end
+
+    def system!(str)  # :doc:
+      _system(:'system!', str, true)
+    end
+
+    def sys(str)  # :doc:
+      _system(:sys, str, false)
+    end
+
+    def sys!(str)
+      _system(:'sys!', str, true)
+    end
+
+    #--
+    #def `(str)                #`
+    #  _cmd(:'`', str, false)
+    #end
+    #++
+
+    def _echo(method_name, args, newline=true)   # :nodoc:
+      args, opts = _handle_args(method_name, args)
+      print args.join(' ')
+      print "\n" if newline
+    end
+
+    def echo(*args)  # :doc:
+      _echo(:echo, args, true)
+    end
+
+    def echo_n(*args)  # :doc:
+      _echo(:echo_n, args, false)
+    end
+
+
+    def _chdir(method_name, dir, &block)   # :nodoc:
+      args, opts = _handle_args(method_name, [dir])
+      dir = args[0]
+      cwd = FileUtils.pwd
+      FileUtils.chdir(dir)
+      if block
+        begin
+          instance_eval(&block)
+        ensure
+          _prompt("#{method_name} -   # #{cwd}")
+          _log("#{method_name}(#{cwd.inspect})")
+          FileUtils.chdir(cwd)
+        end
+      end
+    end
+
+    def cd(dir, &block)  # :doc:
+      _chdir(:ch, dir, &block)
+    end
+
+    def chdir(dir, &block)  # :doc:
+      _chdir(:chdir, dir, &block)
+    end
+
+
+    def _chmod(method_name, mode, args)   # :nodoc:
+      mode_str = '%#o' % mode
+      opts = args[-1].is_a?(Hash) ? args.pop : {}
+      args, opts_dummy = _handle_args(method_name, args, " #{mode_str}", "#{mode_str}, ")
+      return if $rook_noexec
+      if opts[:filetype]
+        testch = nil
+        case opts[:filetype]
+        when 'file', :file    ;  testch = ?f
+        when 'dir' , :dir     ;  testch = ?d
+        end
+        args = args.select { |arg| test(testch, arg) }
+      end
+      FileUtils.__send__(method_name, mode, args)
+    end
+
+    def chmod(mode, *args)  # :doc:
+      _chmod(:chmod, mode, args)
+    end
+
+    def chmod_R(mode, *args)  # :doc:
+      _chmod(:chmod_R, mode, args)
+    end
+
+
+    def _chown(method_name, user, group, args, &block)   # :nodoc:
+      args, opts = _handle_args(method_name, args, " #{user}:#{group}", "#{user}, #{group}, ")
+      return if $rook_noexec
+      args = args.select(&block) if block
+      FileUtils.__send__(method_name, user, group, args)
+    end
+
+    def chown(user, group, *args, &block)  # :doc:
+      _chown(:chown, user, group, args, &block)
+    end
+
+    def chown_R(user, group, *args, &block)  # :doc:
+      _chown(:chown_R, user, group, args, &block)
+    end
+
+
+    def _command_arg1(method_name, args, options={})   # :nodoc:
+      args, opts = _handle_args(method_name, args)
+      return if $rook_noexec
+      options.merge!(opts) if opts
+      args.each do |arg|
+        FileUtils.__send__(method_name, arg, options)
+      end
+    end
+
+    def mkdir(*args)  # :doc:
+      _command_arg1(:mkdir, args)
+    end
+
+    def mkdir_p(*args)  # :doc:
+      _command_arg1(:mkdir_p, args)
+    end
+
+
+    def _command_arg2(method_name, args, options={}, &block)   # :nodoc:
+      args, opts = _handle_args(method_name, args)
+      return if $rook_noexec
+      options.merge!(opts) if opts
+      dest = args.pop
+      args = args.select { |filename| yield(filename) } if block
+      args.each do |arg|
+        FileUtils.__send__(method_name, arg, dest, options)
+      end
+    end
+
+
+    def _command_args(method_name, args, options={}, &block)   # :nodoc:
+      args, opts = _handle_args(method_name, args)
+      return if $rook_noexec
+      options.merge!(opts) if opts
+      args = args.select { |filename| yield(filename) } if block
+      FileUtils.__send__(method_name, args, options)
+    end
+
+    def rm(*args)  # :doc:
+      _command_args(:rm, args)
+    end
+
+    def rm_f(*args)  # :doc:
+      _command_args(:rm_f, args)
+    end
+
+    def rm_r(*args)  # :doc:
+      _command_args(:rm_r, args)
+    end
+
+    def rm_rf(*args)  # :doc:
+      _command_args(:rm_rf, args)
+    end
+
+    def touch(*args)  # :doc:
+      _command_args(:touch, args)
+    end
+
+
+    def _command_srcdest(method_name, args, options={}, &block)   # :nodoc:
+      args, opts = _handle_args(method_name, args)
+      return if $rook_noexec
+      options.merge!(opts) if opts
+      if args.length == 2
+        return if block && !yield(args[0])
+        FileUtils.__send__(method_name, args[0], args[1], options)
+      else
+        dest = args.pop
+        args = args.find_all { |filename| yield(filename) } if block
+        FileUtils.__send__(method_name, args, dest, options)
+      end
+    end
+
+    def cp(*args, &block)  # :doc:
+      _command_srcdest(:cp, args, &block)
+    end
+
+    def cp_p(*args, &block)  # :doc:
+      _command_srcdest(:cp_p, args, &block)
+    end
+
+    def cp_r(*args, &block)  # :doc:
+      _command_srcdest(:cp_r, args, &block)
+    end
+
+    def cp_pr(*args, &block)  # :doc:
+      _command_srcdest(:cp_pr, args, &block)
+    end
+
+    def cp_a(*args, &block)  # :doc:
+      _command_srcdest(:cp_a, args, &block)
+    end
+
+    def mv(*args, &block)  # :doc:
+      _command_srcdest(:mv, args, &block)
+    end
+
+    def ln(*args, &block)  # :doc:
+      _command_srcdest(:ln, args, &block)
+    end
+
+    def ln_s(*args, &block)  # :doc:
+      _command_srcdest(:ln_s, args, &block)
+    end
+
+    def ln_sf(*args, &block)  # :doc:
+      _command_srcdest(:ln_s, args, &block)
+    end
+
+    def store(*args, &block)  # :doc:
+      _command_srcdest(:store, args, &block)
+    end
+
+    def store_p(*args, &block)  # :doc:
+      _command_srcdest(:store_p, args, &block)
+    end
+
+    def store_a(*args, &block)  # :doc:
+      _command_srcdest(:store_p, args, &block)
+    end
+
+
+    def edit(*args, &block)  # :doc:
+      args, opts = _handle_args(:edit, args)
+      return if $rook_noexec
+      args.each do |filename|
+        File.edit(filename, &block) if test(?f, filename)
+      end
+    end
+
+
+    def _zip(method_name, args)   # :nodoc:
+      args, opts = _handle_args(method_name, args)
+      return if $rook_noexec
+      zipfilename = args.shift
+      FileUtils.__send__(method_name, zipfilename, args, (opts || {}))
+    end
+
+    def zip(*args)  # :doc:
+      _zip(:zip, args)
+    end
+
+    def zip_r(*args)  # :doc:
+      _zip(:zip_r, args)
+    end
+
+
+    def _unzip(method_name, args)   # :nodoc:
+      #if (opts = args[-1]).is_a?(Hash)
+      #  opts[:d] = opts.delete(:basedir) if opts.key?(:basedir)
+      #end
+      args, opts = _handle_args(method_name, args)
+      return if $rook_noexec
+      zipfilename = args.shift
+      args = nil if args.empty?
+      FileUtils.__send__(method_name, zipfilename, args, (opts || {}))
+    end
+
+    def unzip(*args)  # :doc:
+      _unzip(:unzip, args)
+    end
+
+
+    def _tar(command, *args)   # :nodoc:
+      args, opts = _handle_args(command, args)
+      return if $rook_noexec
+      tarfilename = args.shift
+      FileUtils.__send__(command, tarfilename, args, (opts||{}))
+    end
+
+    def tar_cf(*args)  # :doc:
+      _tar(:tar_cf, args)
+    end
+
+    def tar_xf(*args)  # :doc:
+      _tar(:tar_xf, args)
+    end
+
+    def tar_czf(*args)  # :doc:
+      _tar(:tar_czf, args)
+    end
+
+    def tar_xzf(*args)  # :doc:
+      _tar(:tar_xzf, args)
+    end
+
+    def tar_cjf(*args)  # :doc:
+      _tar(:tar_cjf, args)
+    end
+
+    def tar_xjf(*args)  # :doc:
+      _tar(:tar_xjf, args)
+    end
+
+
+  end
+
+
+
+end