proutils 0.3.0

data/lib/proutils/mint/copier.rb

@@ -0,0 +1,324 @@
+# TITLE:
+#
+#   Scaffold Controller
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2007 7rans
+#
+# TODOs:
+#
+#   - Need to make actions lazy and only commit when
+#     everything is acknowledged.
+
+require 'rbconfig'
+require 'proutils/mint/fileutils'
+
+
+module Mint
+
+#   def self.lookup(type)
+#     globs = []
+#     paths.each do |path|
+#       parts = type.split(/[\/\\]/)
+#       if File.basename(path) == parts.first
+#         globs << File.join(File.dirname(path), type)
+#       end
+#     end
+#     globs.collect{ |g| Dir.glob(g) }.flatten
+#   end
+
+  def self.paths
+    @paths ||= (
+      builtin = Dir.glob(File.join(datadir, '*'))
+      paths = ENV['MINT_PATH'].to_s.split(/[:;]/) + builtin
+      paths.inject({}) do |hash, path|
+        dir, type = *File.split(path)
+        hash[type] = dir
+        hash
+      end
+    )
+  end
+
+  # TODO Better way to support RubyGems and Rolls?
+
+  def self.datadir
+    dir = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), 'data', 'mint')
+    if File.directory?(dir)
+      dir
+    else
+      File.join(File.join(Config::CONFIG['datadir'], 'mint'))
+    end
+  end
+
+  # = Mint Copier
+
+  class Copier
+
+    IGNORE = [ '.', '..', '.svn']
+
+    attr_reader :sources, :destination, :options
+
+    attr_reader :actions
+
+    def initialize(sources, destination, options=nil)
+      @sources     = [sources].flatten
+      @destination = destination
+      @options     = options || {}
+
+      @special     = options[:special]
+
+      @dryrun      = options[:dryrun]
+      @force       = options[:force]
+      @skip        = options[:skip]
+
+      if special?
+        @sources = special_lookup(*sources)
+      else
+        @sources = general_lookup(*sources)
+      end
+
+      @actions     = []
+    end
+
+    def special? ; @special; end
+    def dryrun?  ; @dryrun ; end
+    def force?   ; @force  ; end
+    def skip?    ; @skip   ; end
+
+    # Lookup in special mint locations.
+
+    def special_lookup(*sources)
+      # First lets make sure there are not bad requests.
+      missing = requested_locations(*sources) - Mint.paths.keys
+      unless missing.empty?
+        puts "Missing special sources -- #{missing.join(', ')}"
+        exit 0
+      end
+      #
+      sources.collect do |source|
+        type = *source.split(/[\/\\]/).first
+        [Mint.paths[type], source]
+      end
+    end
+
+    #
+
+    def requested_locations(*sources)
+      sources.collect do |source|
+        source.split(/[\/\\]/).first
+      end
+    end
+
+    #
+
+    def general_lookup(*sources)
+      sources.collect do |source|
+        [ '.', source ]
+      end
+    end
+
+    # Copy files.
+
+    def copy
+      puts "KEY: (d)iff (r)eplace (s)kip skip(a)ll (q)uit"
+      sources.each do |dir, file|
+        path = File.join(dir, file)
+        if File.file?(path)
+          copy_file(dir, file)
+        else
+          dirs, files = *partition_path(path)
+          # make empty directories
+          dirs.each do |d|
+            if File.directory?(d)
+              skip_dir(d)
+            else
+              pth = File.join(path,d)
+              entries = Dir.entries(pth) - IGNORE
+              make_dir(d) if entries.empty?
+            end
+          end
+          # copy files in directories
+          files.each do |f|
+            copy_file(path, f)
+          end
+        end
+      end
+      commit
+    end
+
+  private
+
+    # List of source files.
+
+    #def source_paths
+    #  Dir.glob(File.join(@source, '**/*'))
+    #end
+
+    # Partition a path's contents between dirs and files.
+
+    def partition_path(path)
+      dirs, files  = [], []
+      chdir(path) do
+        paths = Dir.glob('**/*')
+        dirs, files = *paths.partition do |f|
+          File.directory?(f)
+        end
+      end
+      return dirs, files
+    end
+
+    # Make a directory.
+
+    def make_dir(dir)
+      dst = File.join(destination, dir)
+      if File.file?(dst)
+        puts "Directory to replace file..."
+        action = query(file) || 'skip'
+      else
+        action = 'make'
+      end
+      @actions << [action, dst]
+      action_print(action, dst + '/')
+    end
+
+    # Copy a file.
+
+    def copy_file(source, file)
+      src = File.join(source, file)
+      dst = File.join(destination, file)
+
+      action = 'skip'
+
+      if File.directory?(dst)
+        puts "File to replace directory..."
+        action = query(file)
+      elsif File.file?(dst)
+        unless FileTest.identical?(src, dst)
+          action = query(file)
+        end
+      else
+        action = 'copy'
+      end
+
+      @actions << [action, [src, dst]]
+
+      #if action == 'copy' or action == 'replace'
+      #  rm_r(dst) if File.directory?(dst)
+      #  cp(src, dst)
+      #end
+
+      action_print(action, dst) #, file)
+    end
+
+    # Skip directory.
+
+    def skip_dir(dst)
+      @actions << ['skip', dst]
+      action_print('skip', dst + '/')
+    end
+
+    # Skip file.
+
+    def skip_file(src, dst)
+      @actions << ['skip', [src, dst]]
+      action_print('skip', dst)
+    end
+
+    # Show diff of files.
+
+    def diff(file)
+      src = File.join(source, file)
+      dst = File.join(destination, file)
+      diff = FileTest.diff(src, dst)
+      puts diff unless diff.empty?
+    end
+
+    # Query about file.
+
+    def query(file)
+      return 's' if @safe
+      return 'o' if @force
+      action = nil
+      #msg = "#{file} -- (d)iff (r)eplace (s)kip (a)ll (q)uit?"
+      msg = "       ? #{file} "
+      until action
+        ans = ask(msg).strip[0,1]
+        case ans
+        when 'd', 'D'
+          diff(file)
+        when 'r', 'R'
+          action = 'replace'
+        when 's', 'S'
+          action = 'skip'
+        when 'a', 'A'
+          @safe = true
+          action = 'skip'
+        when 'q', 'Q'
+          exit 0
+        end
+      end
+      return action
+    end
+
+    # Get user input
+
+    def ask(msg)
+      print "#{msg} "
+      until inp = $stdin.gets ; sleep 1 ; end
+      inp.chomp
+    end
+
+    # Action print
+    def action_print(action, file)
+      file = file.sub(/^[.]\//,'')
+      action = (' ' * (8 - action.size)) + action
+      puts "#{action} #{file}"
+    end
+
+    def commit
+      ans = ask("Commit y/N?")
+      case ans.downcase
+      when 'y', 'yes'
+        commit!
+      end
+    end
+
+    def commit!
+      @actions.each do |action, path|
+        case action
+        when 'make'
+          rm(path) unless File.directory?(path)
+          mkdir_p(path)
+        when 'copy'
+          src, dst = *path
+          rm_r(dst) if File.directory?(dst)
+          mkdir_p(File.dirname(dst))
+          cp(src, dst)
+        when 'replace'
+          src, dst = *path
+          rm_r(dst) if File.directory?(dst)
+          #mkdir_p(File.dirname(dst))
+          cp(src, dst)
+        else # skip
+          #
+        end
+      end
+    end
+
+    # Delegate to fileutils.
+
+    def fu
+      @dryrun ? FileUtils::DryRun : FileUtils
+    end
+
+    def chdir(*a,&b)   ; fu.chdir(*a,&b)   ; end
+    def rm(*a,&b)      ; fu.rm(*a,&b)      ; end
+    def rm_r(*a,&b)    ; fu.rm_r(*a,&b)    ; end
+    def cp(*a,&b)      ; fu.cp(*a,&b)      ; end
+    def cp_r(*a,&b)    ; fu.cp_r(*a,&b)    ; end
+    def mkdir(*a,&b)   ; fu.mkdir(*a,&b)   ; end
+    def mkdir_p(*a,&b) ; fu.mkdir_p(*a,&b) ; end
+
+  end
+end

data/lib/proutils/mint/fileutils.rb

@@ -0,0 +1,47 @@
+require 'fileutils'
+require 'digest/md5'
+
+module FileTest
+  module_function
+
+  BUF_SIZE = 1024*1024
+
+  # Are two files identical? This compares size and then checksum.
+  def identical?(file1, file2)
+    size(file1) == size(file2) && md5(file1) == md5(file2)
+  end
+
+  # Return an md5 checkum. If a directory is given, will
+  # return a nested array of md5 checksums for all entries.
+
+  def md5(path)
+    if File.directory?(path)
+      md5_list = []
+      crt_dir = Dir.new(path)
+      crt_dir.each do |file_name|
+        next if file_name == '.' || file_name == '..'
+        md5_list << md5("#{crt_dir.path}#{file_name}")
+      end
+      md5_list
+    else
+      hasher = Digest::MD5.new
+      open(path, "r") do |io|
+        counter = 0
+        while (!io.eof)
+          readBuf = io.readpartial(BUF_SIZE)
+          counter+=1
+          #putc '.' if ((counter+=1) % 3 == 0)
+          hasher.update(readBuf)
+        end
+      end
+      return hasher.hexdigest
+    end
+  end
+
+  # Show diff of two files.
+
+  def diff(file1, file2)
+    `diff #{file1} #{file2}`.strip
+  end
+
+end

data/lib/proutils/rtar/rtar.rb

@@ -0,0 +1,309 @@
+
+require 'zlib'
+require 'tmpdir'
+require 'fileutils'
+
+require 'proutils/rtar/vendor/archive/tar/minitar'
+
+
+class NilClass
+
+  # Nil#status makes it possible to pass messages through
+  # a "failure" chain.
+
+  def status( *status )
+    if status.empty?
+      return @status
+    else
+      @status = status
+      self
+    end
+  end
+
+  # Check status.
+
+  def status?
+    return unless @status
+    return false if @status.empty?
+    return true
+  end
+
+end
+
+
+class File
+
+  # Is a file a gzip file?
+
+  def self.gzip?( file )
+    File.open(file,'rb') { |f|
+      return false unless f.getc == 0x1f
+      return false unless f.getc == 0x8b
+    }
+    true
+  end
+
+end
+
+
+module Rock
+
+  class Package
+
+    def initialize()
+    end
+
+    # Pack rock archive.
+
+    def pack(folder)
+      basename = File.basename(folder)
+      return unless write_okay?(basename + ".rock")
+      temp_folder = tmpdir()
+      temp_locale = File.join(temp_folder,basename)
+      #FileUtils.rm_r( temp_locale ) if File.exist?( temp_locale )
+      FileUtils.cp_r(folder,temp_folder)
+      file = nil
+      Dir.chdir(temp_folder) do
+        file = pack_rec(basename)
+      end
+      raise "unexpect compression error" unless file
+      FileUtils.cp(File.join(temp_folder, file), "./#{basename}.rock")
+    end
+
+    # Recursive packing.
+
+    def pack_rec(folder)
+      puts "<< #{folder}" if $VERBOSE
+      Dir.chdir(folder) do
+        files = Dir.entries('.') - ['.', '..']
+        files.each do |f|
+          if File.directory?(f)
+            pack_rec(f)
+          else
+            gzip(f)
+          end
+        end
+      end
+      seal(folder) #gzip(tar(folder),'.rock')
+    end
+
+    # Unpack rock archive.
+
+    def unpack(file)
+      return unless gzip?(file)
+      basename = File.basename(file)
+      barename = basename.chomp('.rock')
+      rock_ext = (basename != barename)
+      rockname = barename + '.rock'
+      unless rock_ext or $FORCE
+        return nil.status(:no_rock_ext)
+      end
+      temp_folder = tmpdir()
+      to_file = File.join(temp_folder, rockname)
+      if rock_ext
+        return unless write_okay?(barename)
+        FileUtils.cp_r(file, to_file)
+      elsif $FORCE
+        FileUtils.mv(file, to_file)
+      end
+      Dir.chdir(temp_folder) do
+        unpack_rec(rockname)
+      end
+      FileUtils.mv(File.join(temp_folder,barename), '.')
+    end
+
+    # Recursive unpacking.
+
+    def unpack_rec(file)
+      puts ">> #{file}" if $VERBOSE
+      folder = unseal(file) #untar(gunzip(file))
+      Dir.chdir( folder ) do
+        files = Dir.entries('.') - ['.','..']
+        files.each do |f|
+          if f =~ /\.rock$/
+            unpack_rec(f)
+          else
+            gunzip(f)
+          end
+        end
+      end
+    end
+
+    # Extract a particular file from the archive.
+
+    def extract(file)
+      puts "NOT WORKING YET"
+      return
+      # TODO
+    end
+
+    # List contents of rock archive.
+
+    def list(file)
+      puts "NOT WORKING YET"
+      return
+      name = File.basename(file)
+      temp_folder = Dir.tmpdir
+      FileUtils.cp_r(file,temp_folder)
+      Dir.chdir(temp_folder) do
+        unpack_rec(name)
+      end
+      folder = name.chomp('.tar')
+      Dir.glob(File.join(temp_folder,folder,'**/*'))
+    end
+
+  private
+
+    # Tar and gzip file.
+
+    def seal(folder)
+      puts "seal: #{folder}" if $VERBOSE
+
+      to_file = folder + '.rock'
+      begin
+        gzIO = Zlib::GzipWriter.new(File.open(to_file, 'wb'))
+        tarIO = Archive::Tar::Minitar::Output.new(gzIO)
+        Dir.chdir(folder) do
+          files = Dir.entries('.') - ['.', '..']
+          files.each do |file|
+            #puts "#{folder}/#{file}" if $VERBOSE
+            Archive::Tar::Minitar.pack_file(file, tarIO)
+          end
+        end
+      ensure
+        tarIO.close # automatically does gzIO.close
+      end
+      FileUtils.rm_r(folder)
+      return to_file
+    end
+
+    # Untar and gunzip file.
+
+    def unseal(file)
+      puts "unseal: #{file}" if $VERBOSE
+
+      to_file = file.chomp('.rock')
+      tgz = Zlib::GzipReader.new(File.open(file, 'rb'))
+      Archive::Tar::Minitar.unpack(tgz, to_file)
+      FileUtils.rm(file)
+      return to_file
+    end
+
+    # Tar a folder.
+
+    def tar(folder)
+      puts "tar: #{folder}" if $VERBOSE
+
+      begin
+        fileIO = File.open("#{folder}.tar", 'wb')
+        tarIO = Archive::Tar::Minitar::Output.new(fileIO)
+        Dir.chdir(folder) do
+          files = Dir.entries('.') - ['.', '..']
+          files.each do |file|
+            Archive::Tar::Minitar.pack_file(file, tarIO)
+          end
+        end
+      ensure
+        tarIO.close # automatically does fileIO.close
+      end
+      FileUtils.rm_r(folder)
+      return "#{folder}.tar"
+    end
+
+    # Untar a folder.
+
+    def untar(file)
+      puts "untar: #{file}" if $VERBOSE
+
+      to_file = file.chomp('.tar')
+      FileUtils.mkdir_p(to_file)
+      #FileUtils.mv(file,unfile)
+      #Dir.chdir(tofile) do
+        Archive::Tar::Minitar.unpack(file,to_file)
+        FileUtils.rm(file)
+      #end
+      return to_file
+    end
+
+    # Compress file with gzip.
+
+    def gzip(file)
+      puts "gzip: #{file}" if $VERBOSE
+
+      Zlib::GzipWriter.open("#{file}.gz") do |gz|
+        gz.write File.read(file)
+      end
+      FileUtils.rm(file)
+      return "#{file}.gz"
+    end
+
+    # Uncompress a gzip file.
+
+    def gunzip(file)
+      puts "gunzip: #{file}" if $VERBOSE
+
+      to_file = file.chomp('.gz')
+      Zlib::GzipReader.open(file) do |gz|
+        File.open(to_file,'wb') do |f|
+          f << gz.read
+        end
+      end
+      FileUtils.rm(file)
+      return to_file
+    end
+
+    # Is gzip file with message.
+
+    def gzip?(file)
+      unless File.gzip?(file)
+        return nil.status(:not_rock_archive)
+      end
+      return true
+    end
+
+    # Is it okay to overwrite this file?
+
+    def write_okay?(file)
+      if File.exist?(file)
+        if $FORCE
+          FileUtils.rm_r(file)
+        else
+          return nil.status(:already_exists, file)
+        end
+      end
+      true
+    end
+
+    # Reserve a temproray file space.
+
+    def tmpdir
+      temp_folder = File.join(Dir.tmpdir,'rock')
+      FileUtils.rm_r( temp_folder )
+      FileUtils.mkdir_p( temp_folder )
+      temp_folder
+    end
+
+  end
+
+end
+
+
+  # Errors module.
+
+module Rock::Errors
+
+  extend self
+
+  def not_rock_archive
+    "file is not a rock archive"
+  end
+
+  def already_exists( file )
+    "'#{file}' already exits. Use -f to overwrite"
+  end
+
+  def no_rock_ext
+    "no .rock extension, either rename or use -f to replace"
+  end
+
+end #module Errors