dirmangle 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4e785caf27f388cd1f1bf8ed22afae13d55646a6
+  data.tar.gz: 391573317c143d119ade15d0e9ee57e795ac8ff9
+SHA512:
+  metadata.gz: d362686353e2d04b8493adad07a3cdd77306c79135d8beff514695d45a7819287f4341a11aa667451503484a6cda61d09b563a4733c6c6e754490d7c0673682e
+  data.tar.gz: 7a635bd09cd365676fc5e2687cb14fb58e49dcfa3c1731d9f3a63a57e1542937979d86389b673a0048b846e6cf7ef95f1b47dd82e1388a59c18f169058baf78f

data/bin/dirmangle

@@ -0,0 +1,337 @@
+#!/usr/bin/env ruby
+#
+# dirmangle - mirror and mangle path components of a directory tree
+#
+# DESCRIPTION
+#        This script creates a mirror of a source directory, manipulating
+#        path components based on rules defined in dirmangle.yaml.  The
+#        purpose of this is to provide links to (or copies of) data using
+#        an alternative directory tree.
+#
+#        -C, --config FILE
+#                The location of the configuration YAML to load
+#
+#        -n, --noop
+#                Do everything but actually modify the filesystem
+#
+#        -r, --rules RULES
+#                Only execute the comma separated list of rules
+#
+#        -v, --verbosity LEVEL
+#                Set the log verbosity level [debug, info (default), warn, error, fatal]
+#
+# AUTHOR
+#        Gary Hetzel <garyhetzel@gmail.com>
+#
+require 'yaml'
+require 'logger'
+require 'fileutils'
+
+DEFAULT_CONF=['~/.config/dirmangle/dirmangle.yaml', '/etc/dirmangle.yaml']
+
+class String
+  def to_bool
+    return true if self == true || self =~ (/(true|t|yes|y|1)$/i)
+    return false if self == false || self.blank? || self =~ (/(false|f|no|n|0)$/i)
+    raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+  end
+
+  def titleize
+    downcase.split.map{|i| exceptions.include?(i) ? i : i.capitalize }.join(' ').sentencecase
+  end
+
+  def sentencecase
+    self[0,1].upcase + self[1,length-1]
+  end
+
+  private
+  def exceptions
+    %w{a an and at but by for from if in nor of on or out over the to}
+  end
+end
+
+class Dirmangle
+  def initialize(options={})
+    @options = options
+    @writecount = 0
+    @paths = []
+
+  # initialize logging
+    setup_logger()
+
+  # alert on no-op
+    Dirmangle.log('No-op mode: nothing will actually be modified') if @options[:noop]
+
+  # load and process config
+    process_config()
+
+  # make changes
+    create_paths()
+
+  # yay we're done!
+    Dirmangle.log("Operation complete. #{@writecount} entries written.")
+    Dirmangle.log('No-op mode: nothing actually happened') if @options[:noop]
+  end
+
+  private
+  def setup_logger()
+    @@logger = Logger.new($stderr)
+
+    @@logger.formatter = proc do |severity, datetime, progname, msg|
+      "[%s] %5s: %s\n" % [datetime, severity, msg]
+    end
+
+  # normalize loglevel option
+    @options[:loglevel] ||= :info
+
+    case @options[:loglevel].to_s.to_sym
+      when :debug
+        @@logger.level = Logger::DEBUG
+      when :warn
+        @@logger.level = Logger::WARN
+      when :error
+        @@logger.level = Logger::ERROR
+      when :fatal
+        @@logger.level = Logger::FATAL
+      else
+        @@logger.level = Logger::INFO
+    end
+  end
+
+
+  def process_config()
+    confFile = (@options[:confPath] || DEFAULT_CONF)
+
+    [*confFile].each do |c|
+      c = File.expand_path(c)
+      if File.exists?(c)
+        @config = YAML.load_file(c)
+        break
+      end
+    end
+
+    raise "Could not find configuration file" if not @config
+
+    if @config['mangle']
+      @config['mangle']['rules'].each do |title, config|
+        if not (@options[:rules].empty? || @options[:rules].include?(title))
+          Dirmangle.log("Rule '#{title}' not being processed", :debug)
+          next
+        end
+
+        if not (config.has_key?('source') and config.has_key?('destination') and config.has_key?('action'))
+          Dirmangle.log("Rule configuration for '#{title}' requires a source, destination, and action; skipping", :debug)
+        end
+
+        Dirmangle.log("Processing rule '#{title}'...")
+        @source_root = File.expand_path(config['root'] || @config['mangle']['root'] || File.dirname(__FILE__)).sub(/\/$/, '')
+        @destination_root = File.expand_path(config['destination_root'] || @source_root)
+        @source = config['source']
+
+      # change to root directory
+        begin
+          Dir.chdir(@source_root)
+        rescue
+          Dirmangle.log("No such directory #{@source_root}, skipping rule #{title}")
+          next
+        end
+
+        source_rx = %r|#{@source}|
+        parts = @source.split(%r|(?!\\)/|).reject{|i| i.empty? }
+        source_glob = File.join("", parts.collect{|i| (i =~ /\W+/ ? '*' : i) })
+
+      # recursively list all files and mangle their paths
+        Dir[File.join(@source_root, source_glob)].each do |path|
+          if path =~ source_rx
+            source_match = $~
+
+          # for one or more destination paths
+            [*config['destination']].uniq.each do |d|
+              destination = d.gsub(%r|%\((?<name>\w+)(?:\.(?<eval>[^\)]+))?(?:\:(?<format>[^\)]+))?\)|) do |match|
+                eval_stack = ($~[:eval].split('.').reject{|i| i.empty? } rescue [])
+                rv = source_match[$~[:name]]
+
+              # evaluate methods
+                eval_stack.each do |e|
+                  rv = rv.send(e)
+                end rescue nil
+
+                ($~[:format] ? "%#{$~[:format]}" % rv : rv)
+              end
+
+              source = File.expand_path(path)
+              destination = File.join(@destination_root, destination)
+
+            # add this path translation rule to the processing stack
+              add_path(title, source, destination, config)
+            end
+          end
+        end
+      end
+    end
+  end
+
+
+  def create_paths()
+  # step through paths array in triples
+    @paths.each do |path|
+      tdir = File.dirname(path[:destination])
+
+      if not File.directory?(tdir)
+        Dirmangle.log("Creating directory #{tdir}", :debug)
+        FileUtils.mkdir_p(tdir, {
+          :noop => @options[:noop]
+        })
+      end
+
+    # remove trailing slash from destination (if present) so link gets created at
+    # that path, not *in* it
+      path[:destination] = path[:destination].sub(/\/$/,'')
+
+      begin
+        print_source      = path[:source].sub(@source_root,'').sub(/^\//,'')
+        print_destination = path[:destination].sub(@destination_root,'').sub(/^\//,'')
+
+      # perform the specified operations on processed files
+        case path[:operation]
+        when :copy
+          Dirmangle.log("Copying #{print_source} -> #{print_destination}")
+          FileUtils.cp(path[:source], path[:destination], {
+            :noop     => @options[:noop],
+            :preserve => true
+          })
+
+        when :move
+          Dirmangle.log("Moving #{print_source} -> #{print_destination}")
+          FileUtils.mv(path[:source], path[:destination], {
+            :noop     => @options[:noop],
+            :preserve => true
+          })
+
+        when :hardlink
+          Dirmangle.log("Hard linking #{print_source} -> #{print_destination}", :debug)
+          FileUtils.ln(path[:source], path[:destination], {
+            :noop     => @options[:noop]
+          })
+
+        when :link
+          Dirmangle.log("Linking #{print_source} -> #{print_destination}", :debug)
+          FileUtils.ln_s(path[:source], path[:destination], {
+            :noop     => @options[:noop]
+          })
+
+        else
+          Dirmangle.log("Unknown operation #{path[:operation]} for rule #{path[:rule]}, skipping execution")
+          break
+        end
+
+        @writecount += 1
+
+      rescue Errno::EEXIST
+        #Dirmangle.log("Destination path #{print_destination} already exists, skipping", :error)
+        next
+      end
+    end
+
+  # prune empty directories from target
+    prune_empty_directories(@destination_root)
+  end
+
+
+  def prune_empty_directories(root, options={})
+    root = File.expand_path(root)
+
+  # proc for removing an empty directory
+    remover = Proc.new do |dir|
+      if File.directory?(dir)
+        if Dir.entries(dir).empty?
+          Dirmangle.log("Pruning empty directory #{dir}", :debug)
+          FileUtils.rmdir(dir, {
+            :noop => @options[:noop]
+          })
+        end
+      end
+    end
+
+  # remove all empty subdirectories
+    Dir[File.join(root, '**', '*')].sort.reverse.each do |entry|
+      remover.call(entry)
+    end
+
+  # remove an empty root directory (if specified)
+    if options[:remove_root]
+      remover.call(root)
+    end
+  end
+
+
+  def add_path(rule, source, destination, options={})
+  # push a new path pair to have some operation performed upon it
+    if source && destination
+      options[:operation] = :link if not options[:operation]
+
+      Dirmangle.log("Adding #{options[:operation]} operation from #{source} -> #{destination}", :debug)
+
+      @paths << {
+        :rule        => rule,
+        :source      => source,
+        :destination => destination,
+        :operation   => options[:operation].to_s.strip.to_sym,
+        :force       => (options[:force] ? true : false)
+      }
+    end
+  end
+
+
+  def Dirmangle.log(message, severity = :info)
+    severity = :info unless [:debug, :info, :warn, :error, :fatal].include?(severity.to_sym)
+    @@logger.send(severity, message)
+  end
+end
+
+
+require 'optparse'
+
+options = {}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: dirmangle [options]"
+
+# -----------------------------------------------------------------------------
+  opts.on('-C', '--config FILE', 'Configuration YAML location') do |file|
+    options[:confPath] = file
+  end
+
+# -----------------------------------------------------------------------------
+  options[:noop] = false
+  opts.on('-n', '--noop', 'Dry run (do not modify filesystem)') do
+    options[:noop] = true
+  end
+
+# -----------------------------------------------------------------------------
+  opts.on('-v', '--verbosity LEVEL', 'Logging verbosity') do |level|
+    level = level.to_s.downcase
+
+    if ['debug', 'info', 'warn', 'error', 'fatal'].include?(level)
+      options[:loglevel] = level.to_sym
+    end
+  end
+
+# -----------------------------------------------------------------------------
+  options[:rules] = []
+  opts.on('-r', '--rules RULES', 'Only execute the comma separated list of rules') do |rules|
+    options[:rules] = rules.split(',')
+  end
+end
+
+parser.parse!
+
+# begin
+   Dirmangle.new(options)
+# rescue Exception => e
+#   Dirmangle.log(e.message, :fatal)
+
+#   e.backtrace.each do |m|
+#     Dirmangle.log(m, :debug)
+#   end
+# end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: dirmangle
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gary Hetzel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-09 00:00:00.000000000 Z
+dependencies: []
+description: dirmangle is a tool for copying, moving, or creating symlinks to sets
+  of files using regular expressions
+email: garyhetzel@gmail.com
+executables:
+- dirmangle
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/dirmangle
+homepage: https://github.com/ghetzel/dirmangle
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Batch directory clone, move, and link tool
+test_files: []