rmtree 2.2.3

data/README

@@ -0,0 +1,89 @@
+NAME
+
+  rmtree - save and restore permissions of objects in a directory
+
+SYNOPSIS
+
+  rmtree save  [-C working_dir] [--files] [--dirs]
+  rmtree apply [-C working_dir] [--files] [--dirs] [--dry-run]
+  rmtree diff  [-C working_dir] [--files] [--dirs]
+  rmtree load
+  rmtree help
+
+DESCRIPTION
+
+  `rmtree` is a simple version of known tool `mtree` on *BSD system. The
+  primary purpose of the tool is to save some basic attributes of objects
+  in a directory to a text file and/or restore objects' properties from
+  a standard input of attributes.
+
+  The tool only works on file system that supports following attributes:
+
+    - File mode (like 0644 on Linux)
+    - File owner
+    - File group
+
+  When the action `save` is used, the tool will scan the working directory
+  for all files and directories, and read their properties and print in
+  YAML format -- the readable format used by the action `apply` (or `load`.)
+
+EXAMPLES
+
+  To back up objects' attributes to a file
+
+    rmtree save -C /path/to/working/dir | gzip -9c > backup.gz
+
+  To restore file permissions
+
+    zcat backup.gz | rmtree apply -C /path/to/working/dir
+
+  Save and load at the same time
+
+    rmtree save -C /this/dir/ | rmtree apply -C /that/dir/
+
+  To compare this directory with another one
+
+    rmtree save -C /this/dir | rmtree diff -C /that/dir
+
+OPTIONS
+
+  Actions
+
+    help    Print some help messages
+    save    Scan for objects' attributes
+    apply   Apply attributes to objects in working directory
+    load    Load attribute data and print to STDOUT
+    diff    Compare STDIN with the working directory
+
+  Options
+
+    -d  --dry-run   Execute `apply` in dry-run mode
+
+    -C  --directory Set the working directory. The program will change
+                    to this directory before scanning/applying attributes.
+                    Default: current directory
+
+    -F  --files     Only work on files. When being used with 'diff',
+                    all directories in working directory are ignored.
+
+    -D  --dirs      Only work on directories. When being used with 'diff',
+                    all regular files in working directory are ignored.
+
+    --full-path     Print absolute path when 'saving'. As the output has
+                    the full paths, you may use the output for the action
+                    'apply' without specifying the working directory.
+                    (This also means that you can't apply the output to
+                    another directory.) By default, the program prints
+                    the relative paths.
+
+    -h  --help      Print help message
+
+INSTALLATION
+
+  This ruby tool requires the rubygem 'slop' (for arguments parsing.)
+  To build a rubygem, try `gem build rmtree.gemspec`.
+
+  To use this tool, simply make it executable (by `chmod 755 rmtree.rb`.)
+  If the rubygem 'rmtree-x.y.z' was installed, the binary can be found
+  in the binary directory of your gem environment. (Please run the command
+  `gem env | grep EXECUTABLE` for details.)

data/bin/rmtree

@@ -0,0 +1,176 @@
+#!/usr/bin/env ruby
+
+# Purpose: Backup & Restore attributes of objects in a directory
+# Author : Anh K. Huynh
+# License: GPL2
+# Date   : 2012 May 15th
+
+begin
+  require 'rubygems'
+  require 'slop'
+  require 'find'
+  require 'fileutils'
+  require 'yaml'
+rescue LoadError => e
+  STDERR.puts ":: Error: Can't load some of libraries with error '#{e}'"
+  exit(1)
+end
+
+# Raise and message and exit
+def _raise(msg)
+  STDERR.puts(":: #{msg}")
+  exit(1)
+end
+
+def _chdir(cwd, options)
+  begin
+    if options[:verbose]
+      STDERR.puts(":: Set working directory to #{cwd}")
+    end
+    FileUtils.chdir(cwd)
+  rescue => e
+    _raise "Error: Can't set working directory #{cwd} with error '#{e}'"
+  end
+end
+
+# Scan a directory and print objects attributes
+# * `source`:  The source direction
+# * `options`: Options for scanning
+# FIXME: source may not work with working directory
+def _fetch(options)
+  ret = []
+  path_prefix = options[:fullpath] ? "#{File.expand_path("./")}/" : ""
+  begin
+    Find.find("./") do |file|
+      next if file.match(/^\.\.?\/$/)
+      next if options[:files] && File.directory?(file)
+      next if options[:dirs]  && File.file?(file)
+      begin
+        stat = File.stat(file)
+        ret << sprintf("%s%s:\n  mode: %s\n  uid: %s\n  gid: %s",
+                  path_prefix, file.slice(2,file.size), stat.mode.to_s(8), stat.uid, stat.gid)
+      rescue => e
+        ret << sprintf("%s%s:\n  error: #{e}", path_prefix, file.slice(2,file.size))
+      end
+    end
+  rescue => e
+    _raise("Error in _fetch(#{source}): #{e}")
+  end
+  ret = ret.join("\n")
+  if options[:to_stdout]
+    puts ret
+  else
+    YAML.load(ret)
+  end
+end
+
+# Load YAML data from STDIN and return the hash
+# FIXME: we should check the format of the input
+def _load(options)
+  begin
+    yaml = YAML.load(STDIN.read)
+  rescue Psych::SyntaxError => e
+    _raise "Error: Can't load Rmtree data with error '#{e}'"
+  end
+  puts YAML.dump(yaml) if options[:to_stdout]
+  yaml
+end
+
+def _apply(yaml, options = nil)
+  yaml.each do |file, data|
+    next if options[:files] && File.directory?(file)
+    next if options[:dirs]  && File.file?(file)
+    if not data["error"]
+      mode, uid, gid = data["mode"].to_s, data["uid"], data["gid"]
+      mode = mode.slice(mode.size - 4, mode.size)
+      if options[:dryrun]
+        puts "chown #{uid}:#{gid} '#{file}'" if uid or gid
+        puts "chmod #{mode} '#{file}'"       # FIXME
+      else
+        begin
+          FileUtils.chown uid, gid, file      if uid or gid
+          FileUtils.chmod mode.to_i(8), file  # FIXME
+        rescue => e
+          STDERR.puts "Error: Can't apply attribute to file #{file}, error => '#{e}'"
+        end
+      end
+    else
+      # Print some warning message
+    end
+  end
+end
+
+# Compare STDIN with current working directory
+def _diff(this, that, options)
+  that = _fetch(options) unless that
+  this_keys = this.keys
+  that_keys = that.keys
+
+  common_keys = this_keys & that_keys
+  this_only = this_keys - common_keys
+  that_only = that_keys - common_keys
+
+  this_only.each {|k| puts "Only in source: #{k}" }
+  that_only.each {|k| puts "Only in working directory: #{k}" }
+  common_keys.each do |k|
+    this_data = %w{mode uid gid}.map{|v| this[k][v]}
+    that_data = %w{mode uid gid}.map{|v| that[k][v]}
+    next if this_data == that_data
+    puts "#{k}:"
+    puts "< #{this_data.join(", ")}"
+    puts "> #{that_data.join(", ")}"
+  end
+end
+
+########################################################################
+# main routine
+########################################################################
+
+valid_actions = %w{help save load apply diff}
+
+action = ARGV.shift
+_raise "Usage: rmtree #{valid_actions.join("|")} <options>" unless valid_actions.include?(action)
+
+options = {:files => false, :dirs => false}
+
+begin
+  opts = Slop.parse do
+    banner "Backup, restore or compare attributes of objects in two directories.
+Syntax: rmtree.rb #{valid_actions.join("|")} [options]\n"
+
+    on "C", "directory=",'Set working directory'
+    on "F", "files",     'Only work on files'
+    on "D", "dirs",      'Only work on directories'
+    on "d", "dry-run",   'Apply with dry-run mode'
+    on "full-path",      'Print absolute paths when "saving"'
+    on "v", "verbose",   'Verbose output'
+    on "h", "help",      'Print help message'
+  end
+rescue Slop::MissingArgumentError => e
+  _raise "Error: #{e}"
+end
+
+if opts.present?(:help) or action == "help"
+  puts opts.help
+  exit(0)
+end
+
+# Set up file options
+_raise "Error: You can only use one of two options `--files`, `--dirs`" \
+  if opts.present?(:files) and opts.present?(:dirs)
+
+options.merge!(:files => true) if opts.present?(:files)
+options.merge!(:dirs => true) if opts.present?(:dirs)
+options.merge!(:dryrun => true) if opts.present?(:"dry-run")
+options.merge!(:verbose => true) if opts.present?(:verbose)
+options.merge!(:fullpath => true) if opts.present?(:"full-path")
+
+cwd = opts.present?(:directory) ? opts[:directory] : "./"
+_chdir(cwd, options)
+
+case action
+  when "save"  then _fetch(options.merge(:to_stdout => true))
+  when "diff"  then _diff(_load(options), nil, options)
+  when "load"  then _load(options.merge(:to_stdout => true))
+  when "apply" then _apply(_load(options), options)
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: rmtree
+version: !ruby/object:Gem::Version
+  version: 2.2.3
+  prerelease: 
+platform: ruby
+authors:
+- Anh K. Huynh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: &9582440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *9582440
+description: Backup & Restore attributes of objects in a directory
+email: kyanh@viettug.org
+executables:
+- rmtree
+extensions: []
+extra_rdoc_files: []
+files:
+- README
+- bin/rmtree
+homepage: https://github.com/icy/rmtree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: ! '`rmtree` is a simple version of known tool `mtree` on *BSD system. The
+  primary purpose of the tool is to save some basic attributes of objects in a directory
+  to a text file and/or restore objects'' properties from a standard input of attributes.'
+test_files: []