rook 0.0.2 → 0.1.0

data/lib/rook/helper/file.rb

@@ -0,0 +1,50 @@
+##
+## $Rev: 20 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+##
+## extends File class
+##
+class File
+
+
+  ##
+  ## edit file content
+  ##
+  ## ex.
+  ##   File.edit('file.txt') do |content|
+  ##     content.gsub!(/\$Release\$/, '1.0.0')
+  ##     content.gsub!(/\$Copyright\$/, '(c)kuwata-lab')
+  ##   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)
+      f.rewind()
+      f.truncate(0)
+      f.write(content)
+    end if test(?f, filename)
+  end
+
+
+  ##
+  ## write file
+  ##
+  ## ex.
+  ##   content = <<END
+  ##   foo
+  ##   bar
+  ##   END
+  ##   File.write('file.txt', content)
+  ##
+  def self.write(filename, content)
+    File.open(filename, 'w') { |f| f.write(content) }
+  end
+
+
+end

data/lib/rook/helper/fileutils.rb

@@ -0,0 +1,340 @@
+##
+## $Rev: 26 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+require 'fileutils'
+
+
+
+##
+## extends FileUtils
+##
+## requires 'rubyzip', 'bz2', and 'minitar' library.
+## * rubyzip - http://raa.ruby-lang.org/project/rubyzip/
+## * bz2 - http://raa.ruby-lang.org/project/bz2/
+## * minitar - http://raa.ruby-lang.org/project/minitar/
+##
+module FileUtils
+
+
+  ##
+  ## copy files into dest with timestamp preserved
+  ##
+  ## ex1.
+  ##   cp_p('file1', 'file2')
+  ## ex2.
+  ##   cp_p(['file1', 'file2', 'file3'], 'dir')
+  ##
+  def cp_p(src, dest, options={})
+    (options ||= {})[:preserve] = true
+    cp(src, dest, options)
+  end
+  module_function :cp_p
+
+
+  ##
+  ## copy files into dest recursively with timestamp preserved
+  ##
+  ## ex1.
+  ##   cp_pr('file1', 'file2')
+  ## ex2.
+  ##   cp_pr(['file1', 'file2', 'file3'], 'dir')
+  ##
+  def cp_pr(src, dest, options={})
+    (options ||= {})[:preserve] = true
+    cp_r(src, dest, options)
+  end
+  module_function :cp_pr
+
+
+  ##
+  ## copy files into dest keeping file type (symbolic link, device file, etc)
+  ##
+  ## ex1.
+  ##   cp_a('file1', 'file2')
+  ## ex2.
+  ##   cp_a(['file1', 'file2', 'file3'], 'dir')
+  ##
+  def cp_a(src, dest, options={})
+    fu_check_options(options, :preserve, :verbose, :noop)
+    if options[:verbose]
+      opt_str = options[:preserve] ? ' -ap' : ' -p'
+      arg_str = [src, dest].flatten.join(' ')
+      fu_output_message("cp#{opt_str} #{arg_str}")
+    end
+    return if options[:noop]
+    dereference_root = false #options[:dereference_root]
+    (src.is_a?(Array) ? src : [src]).each do |item|
+      Dir.glob(item).each do |filename|
+        copy_entry(item, dest, options[:preserve], dereference_root)
+      end
+    end
+  end
+  module_function :cp_a
+
+
+  ##
+  ## copy files to dest with keeping it's filepath
+  ##
+  ## ex1. copy 'lib/rook/rook.rb' into 'tmp/lib/rook/rook.rb'
+  ##   store('lib/rook/rook.rb', 'tmp')
+  ## ex2. copy all 'lib/**/*.rb' into 'tmp/lib/**/*.rb'
+  ##   cp_a(Dir.glob('lib/**/*.rb'), 'tmp')
+  ##
+  def store(src, dest, options={})
+    _store(:cp, src, dest, options)
+  end
+  module_function :store
+
+
+  ##
+  ## copy files to dest with keeping it's filepath and timestamp
+  ##
+  def store_p(src, dest, options={})
+    _store(:cp_p, src, dest, options)
+  end
+  module_function :store_p
+
+
+  ##
+  ## copy files to dest with keeping it's filepath and file type
+  ##
+  def store_a(src, dest, options={})
+    _store(:cp_a, src, dest, options)
+  end
+  module_function :store_a
+
+
+  def _store(cp_cmd, src, dest, options={})  # :nodoc:
+    fu_check_options(options, :preserve, :verbose, :noop)
+    if options[:verbose]
+      opt_str = options[:preserve] ? ' -p' : ''
+      arg_str = [src, dest].flatten.join(' ')
+      fu_output_message("store#{opt_str} #{arg_str}")
+    end
+    return if options[:noop]
+    options.delete(:verbose)
+    options.delete(:noop)
+    mkdir_options = options.dup
+    cp_options    = options.dup
+    (src.is_a?(Array) ? src : [ src ]).each do |filename|
+      if test(?d, filename)
+        path = "#{dest}/#{filename}"
+        mkdir_p(path, mkdir_options) unless test(?d, path)
+      else
+        dir  = File.dirname(filename)
+        base = File.basename(filename)
+        path = "#{dest}/#{dir}"
+        mkdir_p(path, mkdir_options) unless test(?d, path)
+        __send__(cp_cmd, filename, path, cp_options)
+      end
+    end
+  end
+  module_function :_store
+
+
+  ##
+  ## create *.zip file
+  ##
+  ## requires 'rubyzip' library.
+  ##
+  ## ex1.
+  ##   zip 'file.zip', Dir.glob('*.txt')
+  ## ex2.
+  ##   zip 'file.zip', Dir.glob('*.txt'), :basedir=>'path'
+  ##
+  def zip(zipfilename, filenames, options={})
+    require 'zip/zip'
+    basedir = options[:basedir]
+    filenames = [ filenames ] unless filenames.is_a?(Array)
+    if options[:verbose]
+      opt_str = ''
+      opt_str << 'r' if options[:recursive]
+      opt_str = ' -' + opt_str unless opt_str.empty?
+      fu_output_message("zip#{opt_str} #{zipfilename} #{filenames.join(' ')}")
+    end
+    return if options[:noop]
+    ::Zip::ZipFile.open(zipfilename, true) do |zipfile|
+      filenames.each do |fname|
+        list = test(?d, fname) && options[:recursive] ? Dir.glob("#{fname}/**/*") : [fname]
+        list.each do |filename|
+          entry = basedir ? "#{basedir}/#{fname}" : filename
+          zipfile.add(entry, filename)
+        end
+      end
+    end
+  end
+  module_function :zip
+
+
+  ##
+  ## create *.zip file with keeping filepath
+  ##
+  ## requires 'rubyzip' library.
+  ##
+  def zip_r(zipfilename, filenames, options={})
+    (options ||= {})[:recursive] = true
+    zip(zipfilename, filenames, options)
+  end
+  module_function :zip_r
+
+
+  ##
+  ## unzip *.zip file
+  ##
+  ## requires 'rubyzip' library.
+  ##
+  ## ex1.
+  ##   unzip 'foo-1.1.zip', :basedir=>'foo'
+  ## ex2.
+  ##   unzip 'foo-1.1.zip', ['foo1.txt', 'foo2.txt']
+  ##
+  def unzip(zipfilename, filenames=nil, options={})
+    require 'zip/zip'
+    basedir = options[:basedir]
+    filenames = [ filenames ] if filenames && !filenames.is_a?(Array)
+    if options[:verbose]
+      opt_str = ''
+      opt_str << " -r #{basedir}" if options[:basedir]
+      fu_output_message("unzip#{opt_str} #{zipfilename} #{filenames ? filenames.join(' ') : ''}")
+    end
+    return if options[:noop]
+    ::Zip::ZipFile.open(zipfilename) do |zipfile|
+      zipfile.each do |entry|   # entry.class == Zip::ZipEntry
+        next unless filenames.nil? || filenames.include?(entry.name)
+        filename = basedir ? "#{basedir}/#{entry}" : "#{entry}"
+        if test(?e, filename)
+          FileUtils.rm_rf(filename) # if entry.file? || !test(?d, filename)
+        else
+          FileUtils.mkdir_p(File.dirname(filename))
+        end
+        zipfile.extract(entry, filename)
+      end
+    end
+  end
+  module_function :unzip
+
+
+  ##
+  ## create *.tar file
+  ##
+  ## requires 'minitar' library.
+  ##
+  ## ex1.
+  ##   tar_cf 'foo.tar', Dir.glob('*.txt')
+  ##
+  def tar_cf(tarfilename, filenames, options={})
+    _tar_cf(tarfilename, filenames, options, '-cf', null)
+  end
+  module_function :tar_cf
+
+
+  ##
+  ## extract *.tar file
+  ##
+  ## requires 'minitar' library.
+  ##
+  ## ex1.
+  ##   tar_xf 'foo.tar'
+  ## ex2.
+  ##   tar_xf 'foo.tar', ['file1.txt', 'file2.txt']
+  ##
+  def tar_xf(tarfilename, filenames=[], options={})
+    _tar_xf(tarfilename, filenames, options, '-xf', null)
+  end
+  module_function :tar_xf
+
+
+  ##
+  ## create *.tar.gz file
+  ##
+  ## requires 'minitar' library.
+  ##
+  ## ex1.
+  ##   tar_czf 'foo.tar.gz', Dir.glob('*.txt')
+  ##
+  def tar_czf(tarfilename, filenames, options={})
+    require 'zlib'
+    _tar_cf(tarfilename, filenames, options, '-czf', ::Zlib::GzipWriter)
+  end
+  module_function :tar_czf
+
+
+  ##
+  ## extract *.tar.gz file
+  ##
+  ## requires 'minitar' library.
+  ##
+  ## ex1.
+  ##   tar_xzf 'foo.tar.gz'
+  ## ex2.
+  ##   tar_xzf 'foo.tar', ['file1.txt', 'file2.txt']
+  ##
+  def tar_xzf(tarfilename, filenames=[], options={})
+    require 'zlib'
+    _tar_xf(tarfilename, filenames, options, "-xzf", ::Zlib::GzipReader)
+  end
+  module_function :tar_xzf
+
+
+  ##
+  ## create *.tar.bz2 file
+  ##
+  ## requires 'bz2' and 'minitar' library.
+  ##
+  ## ex1.
+  ##   tar_cjf 'foo.tar.bz2', Dir.glob('*.txt')
+  ##
+  def tar_cjf(tarfilename, filenames, options={})
+    require 'bz2'
+    require 'rook/helper/bz2'
+    _tar_cf(tarfilename, filenames, options, '-cjf', ::BZ2::Writer)
+  end
+  module_function :tar_cjf
+
+
+  ##
+  ## extract *.tar.bz2 file
+  ##
+  ## requires 'bz2' and 'minitar' library.
+  ##
+  ## ex1.
+  ##   tar_xjf 'foo.tar.bz2'
+  ## ex2.
+  ##   tar_xjf 'foo.tar.bz2', ['file1.txt', 'file2.txt']
+  ##
+  def tar_xjf(tarfilename, filenames=[], options={})
+    require 'bz2'
+    require 'rook/bz2-helper'
+    _tar_xf(tarfilename, filenames, options, "-xjf", ::BZ2::Writer)
+  end
+  module_function :tar_xjf
+
+
+  def _tar_cf(tarfilename, filenames, options, taropt, writer_class)  # :nodoc:
+    require 'archive/tar/minitar'
+    puts "tar #{taropt} #{tarfilename} #{filenames.to_a.join(' ')}" if options[:verbose]
+    return if options[:noop]
+    f = File.open(tarfilename, 'wb')
+    writer = writer_class ? writer_class.new(f) : f
+    ::Archive::Tar::Minitar.pack(filenames, writer)  # Warning: writer will be closed!
+  end
+  module_function :_tar_cf
+
+
+  def _tar_xf(tarfilename, filenames, options, taropt, reader_class)  #:nodoc:
+    require 'archive/tar/minitar'
+    puts "tar #{taropt} #{tarfilename} #{filenames.to_a.join(' ')}" if options[:verbose]
+    return if options[:noop]
+    basedir = options[:basedir] || '.'
+    f = File.open(tarfilename, 'rb')
+    reader = reader_class ? reader_class.new(f) : f
+    ::Archive::Tar::Minitar.unpack(reader, basedir)  # Warning: reader will be closed!
+  end
+  module_function :_tar_xf
+
+
+end

data/lib/rook/helper/kernel.rb

@@ -0,0 +1,108 @@
+##
+## $Rev: 20 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+##
+## add several global functions.
+##
+## these are convenience for non-ruby user and compatibility with Kook.
+##
+module Kernel
+
+
+  module_function
+
+
+  def array_prefix(array, prefix)
+    return array.collect { |item| "#{prefix}#{item}" }
+  end
+
+
+  #--
+  #def array_prefix!(array, prefix)
+  #  return array.collect! { |item| "#{prefix}#{item}" }
+  #end
+  #++
+
+
+  def array_suffix(array, suffix)
+    return array.collect { |item| "#{item}#{suffix}" }
+  end
+
+
+  #--
+  #def array_prefix!(array, prefix)
+  #  return array.collect! { |item| "#{item}#{suffix}" }
+  #end
+  #++
+
+
+  def array_sandwich(array, prefix, suffix)
+    return array.collect { |item| "#{prefix}#{item}#{suffix}" }
+  end
+
+
+  #--
+  #def array_sandwich!(array, prefix, suffix)
+  #  return array.collect! { |item| "#{prefix}#{item}#{suffix}" }
+  #end
+  #++
+
+
+  def array_delete_suffix(array, suffix=/\.\w+\z/)
+    return array.collect { |item| item.sub(suffix, '') }
+  end
+
+
+  #--
+  #def array_delete_suffix!(array, suffix=/\.\w+\z/)
+  #  return array.collect { |item| item.sub(suffix, '') }
+  #end
+  #++
+
+
+  def array_delete_prefix(array, prefix)
+    return array.collect { |item| item.sub(prefix, '') }
+  end
+
+
+  #--
+  #def array_delete_prefix!(array, prefix)
+  #  return array.collect! { |item| item.sub(prefix, '') }
+  #end
+  #++
+
+
+  def array_join(array, separator)
+    return array.join(separator)
+  end
+
+
+  def array_basenames(array)
+    return array.collect { |item| File.basename(item) }
+  end
+
+
+  #--
+  #def array_basenames!(array)
+  #  return array.collect { |item| File.basename(item) }
+  #end
+  #++
+
+
+  def array_dirnames(array)
+    return array.collect { |item| File.dirname(item) }
+  end
+
+
+  #--
+  #def array_dirnames!(array)
+  #  return array.collect { |item| File.dirname(item) }
+  #end
+  #++
+
+
+end