sundae 0.9.0

data/Copying.txt

@@ -0,0 +1,20 @@
+(The MIT License)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.9.0 / 2008-10-18
+
+* Initial release.
+
+
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+Copying.txt
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/sundae
+setup.rb
+lib/sundae.rb
+test/test_sundae.rb

data/README.txt

@@ -0,0 +1,108 @@
+= Sundae
+
+== Synopsis
+
+(Re)generates directories by mixing the file hierarchies contained
+in various 'mounted' directories.  The generated directories contain
+symbolic links to the mounted files.  Combined with other tools,
+this scheme allows you to create separate collections of files
+(work, personal, reference, linux, osx, etc.), choose which of these
+you want to mount on each of your computers, and then build a
+hierarchy that allows you to work on them side by side.
+
+== Install
+
+  sudo gem install sundae
+
+== Usage
+
+The first time you run Sundae, it will create a template config file
+in your home directory.  This file, <tt>.sundae</tt>, needs to be
+customized.  It is in YAML format and defines the following:
+
+[+paths+]          
+  array; where the collections are stored
+[+collection_links+] 
+  +true+ or +false+; if true, links are created in generated
+  directories to the analogous location in mounted directories
+[+collection_link_prefix+] 
+  string; the prefix applied to collection links, if they are to be
+  created
+[+ignore_rules+]
+  array; each line is a Regexp and becomes a rule that prevents
+  links to files or directories that match the Regexp
+
+The hierarchy in <em>path</em> should look something like
+this:
+
+  path/
+  |-- collection1/
+  |   |-- mnt1/
+  |   |   |-- real_files_and_dirs
+  |   |   ` ...
+  |   |-- mnt2/
+  `-- collection2/
+      ` ...
+
+For example, the hierarchy in my <em>path</em> looks sort of like this:
+
+  ~/mnt/              <-- "path"
+  |-- osx/            <-- "collection"
+  |   |-- home/       <-- "mnt"
+  |   |   |-- .emacs
+  |   |   |-- doc/
+  |   |   ` ...
+  |   |-- home_library/
+  |   |   |-- .sundae_path
+  |   |   `-- Library-Keyboard_Layouts/
+  |   |       `-- Keyboard Layouts/
+  |   |           ` Colemak.keylayout
+  |   ` ... 
+  |-- personal
+  |   `-- home/
+  |       |-- doc/
+  |       |   ` ...
+  |       ` ... 
+  ` ...    
+
+Sundae will act on all of the <em>mnt</em>s--subdirectories of the
+<em>collection</em>s, that is, the sub-subdirectories of the
+<em>path</em>.  The "collections" are only there to facilitate
+grouping common files and syncronizing them between computers.
+
+By default, all of the contents in each of the <em>mnt</em>s are
+placed in the user's home directory.  This can be altered by
+creating a file called <tt>.sundae_path</tt> in the top of the
+<em>mnt</em>; the file should contain one line, which is the
+absolute path to where that directory should be "mounted."
+
+And that's it.  When called, Sundae creates links so that you can
+work on your files from seperate parts of life as if they were side
+by side.
+
+== Author
+<don@ohspite.net>
+
+== Copyright
+Copyright (c) 2008 <don@ohspite.net>.  
+Licensed under the MIT License.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,18 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/sundae.rb'
+
+Hoe.new('sundae', Sundae::VERSION) do |p|
+  p.developer('Don', 'don@ohspite.net')
+  p.email = 'don@ohspite.net'
+  p.description = "Mix collections of files while maintaining complete separation. Synchronize any combination of your documents and configuration settings between all of your computers."
+  p.summary = "Mix collections of files while maintaining complete separation."
+  p.url = "http://rubyforge.org/projects.sundae"
+#  p.changes = p.paragraphs_of('CHANGELOG', 0..1).join("\n\n")
+  p.remote_rdoc_dir = ''
+  p.extra_deps = ['configatron']
+end
+
+# vim: syntax=Ruby

data/bin/sundae

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+# == Synopsis
+#
+# (Re)generates directories by mixing the file hierarchies contained
+# in various 'mounted' directories.  
+#
+# == Usage
+#
+#    sundae [--config-path PATH]
+#
+# For command line details see 
+#    sundae --help
+#
+# == Author
+# <don@ohspite.net>
+#
+# == Copyright
+# Copyright (c) 2008 <don@ohspite.net>.  
+# Licensed under the MIT License.
+
+require 'rdoc/usage'
+require 'optparse'
+
+$:.unshift File.join(File.dirname(__FILE__), "../lib")
+
+require 'sundae'
+
+class App # :nodoc:
+  def initialize
+    parse_commandline(ARGV)
+
+    Sundae.load_config_file(@options[:config_path])
+    
+    Sundae.remove_dead_links
+    Sundae.remove_generated_directories
+    Sundae.create_filesystem
+  end
+  
+  private
+  
+  def parse_commandline(option_line)
+    options = {:verbose => false}
+    option_parser = OptionParser.new do |opts|
+      opts.banner = "Usage: #{File.basename(__FILE__)} [options] "
+      opts.separator ""
+      opts.separator "Specific options:"
+      opts.on('-c', 
+              '--config-path PATH',
+              'specify the path to the \'.sundae\' directory (default is \'~/.sundae\')') do |path|
+        options[:config_path] = File.expand_path(path)
+      end
+#       opts.on('-v', 
+#               '--verbose',
+#               'verbose output') do
+#         options[:verbose] = true
+#       end
+      opts.separator ""
+      opts.separator "Common options:"
+      opts.on('-h', 
+              '--help',
+              'show the help message') do
+        puts opts
+        exit
+      end
+      opts.on('-a', 
+              '--about', 
+              'show the about message') do
+        RDoc::usage
+      end
+    end
+    
+    argv = Array.new
+    begin
+      option_parser.order!(option_line) do |command|
+        case command
+        when "some_value"
+          
+        else
+          argv << command
+        end
+      end
+    rescue 
+      RDoc::usage('usage')
+    end
+    argv.each { |a| option_line << a }
+    
+    @options = options
+  end
+end
+
+
+App.new

data/lib/sundae.rb

@@ -0,0 +1,326 @@
+require 'rubygems'
+require 'configatron'
+require 'fileutils'
+require 'find'
+
+# A collection of methods to mix the contents of several directories
+# together using symbolic links.
+#
+module Sundae
+  VERSION = "0.9.0"
+
+  DEFAULT_CONFIG_FILE = File.expand_path(File.join(ENV['HOME'], '.sundae'))
+ 
+  @config_file = DEFAULT_CONFIG_FILE
+
+  # Read configuration from <tt>.sundae</tt>.
+  #
+  def self.load_config_file(config_file = DEFAULT_CONFIG_FILE)
+    config_file ||= DEFAULT_CONFIG_FILE
+    config_file = File.join(config_file, '.sundae') unless File.basename(config_file) == '.sundae' 
+
+    create_template_config_file(config_file) unless File.file?(config_file)
+
+    configatron.set_default(:collection_links, false)
+    configatron.set_default(:collection_link_prefix, '_')
+
+    configatron.configure_from_yaml(config_file)
+    configatron.paths.map! { |p| File.expand_path(p) }
+    configatron.ignore_rules.map! { |a| Regexp.new(a) }
+
+    # An array which lists the directories where mnts are stored.
+    @paths = configatron.paths
+    # These are the rules that are checked to see if a file in a mnt
+    # should be ignored.
+    @ignore_rules = configatron.ignore_rules
+
+    @collection_links = configatron.collection_links
+    @collection_link_prefix = configatron.collection_link_prefix
+  end
+
+  # Create a template configuration file at <em>config_file</em> after
+  # asking the user.
+  #
+  def self.create_template_config_file(config_file)
+    loop do
+      print "#{config_file} does not exist.  Create template there? (y/n): "
+      ans = gets.downcase.strip
+      if ans == "y" || ans == "yes"
+        File.open(config_file, "w") do |f|
+          f.puts ":paths:"
+          f.puts "- ~/mnt"
+          f.puts ":collection_links:"
+          f.puts "  false"
+          f.puts ":collection_link_prefix:"
+          f.puts "  '_'"
+          f.puts ":ignore_rules: # Ruby Regexps"
+          f.puts "- \\.svn"
+          f.puts "- \\.bzr"
+          f.puts "- \\.DS_Store"
+        end
+        puts 
+        puts "Okay then."
+        puts "#{config_file} template created, but it needs to be customized."
+        exit
+      elsif ans == "n" || ans == "no"
+        exit
+      end
+    end
+  end
+
+  # Use the array of Regexp to see if a certain file should be
+  # ignored (i.e., no link will be made pointing to it).
+  #
+  def self.ignore_file?(file) # :doc:
+    return true if File.basename(file) =~ /^\.\.?$/
+    return true if File.basename(file) == ".sundae_path"
+    @ignore_rules.each { |r| return true if File.basename(file) =~ r }
+    return false
+  end
+
+  # Read the <tt>.sundae_path</tt> file in the root of a mnt to see
+  # where in the file system links should be created for this mnt.
+  #
+  def self.install_location(mnt) 
+    mnt_config = File.join(mnt, '.sundae_path')
+    if File.exist?(mnt_config)
+      location = File.readlines(mnt_config)[0].strip
+    end
+
+    location ||= ENV['HOME']
+  end
+
+  # Return an array of all paths in the file system where links will
+  # be created.
+  #
+  def self.install_locations 
+    locations = []
+
+    all_mnts.each do |mnt|
+      locations << install_location(mnt)
+    end
+    return locations.sort.uniq
+  end
+
+  # Given _path_, return all mnts (i.e., directories two levels down)
+  # as an array.
+  #
+  def self.mnts_in_path(path) 
+    mnts = []
+    collections = Dir.entries(path).delete_if {|a| a=~/^\./}
+    collections.each do |c|
+      collection_mnts = Dir.entries(File.join(path, c)).delete_if {|a| a=~/^\./}
+      collection_mnts.map! { |mnt| File.join(c, mnt) }
+      mnts |= collection_mnts
+    end
+
+    return mnts.sort.uniq
+  end
+
+  # Return all mnts for every path as an array.
+  #
+  def self.all_mnts 
+    mnts = []
+
+    @paths.each do |path| 
+      next unless File.exist?(path)
+      mnts |= mnts_in_path(path).map { |mnt| File.join(path, mnt) }
+    end
+
+    return mnts
+  end
+
+  # Return all subdirectories of the mnts returned by all_mnts.  These
+  # are the 'mirror' directories that are generated by sundae.
+  #
+  def self.generated_directories 
+    dirs = Array.new
+
+    all_mnts.each do |mnt|
+      mnt_dirs = Dir.entries(mnt).delete_if { |e| ignore_file?(e) }
+      mnt_dirs.each do |dir|
+        dirs << File.join(install_location(mnt), dir)
+      end
+    end
+
+    return dirs.sort.uniq
+  end
+  
+  # Check for symlinks in the base directories that are missing their
+  # targets.
+  #
+  def self.remove_dead_links
+    removed_list = []
+    install_locations.each do |location|
+      next unless File.exist?(location)
+      files = Dir.entries(location).map {|f| File.join(location, f)}
+      files.each do |file|
+        next unless File.symlink?(file)
+        next if File.exist? File.readlink(file)
+        FileUtils.rm(file)
+        removed_list << file
+      end
+    end
+    return removed_list
+  end
+  
+  # Delete each generated directory if there aren't any real files in
+  # them.
+  #
+  def self.remove_generated_directories
+    removed_list = []
+    generated_directories.each do |dir| 
+      next if File.basename(dir) == ('.sundae')
+
+      # Do a quick search to make sure no non-symlink file is being
+      # deleted. That would suck.
+      if sf = find_static_file(dir)
+        puts "found static file: #{sf}"
+      else
+        FileUtils.rmtree(dir) 
+        removed_list << dir
+      end
+    end
+    return removed_list
+  end
+
+  # Search through _directory_ and return the first static file found,
+  # nil otherwise.
+  #
+  def self.find_static_file(directory)
+    Find.find(directory) do |path|
+      return path if File.exist?(path) && File.ftype(path) == 'file' 
+    end
+    return nil
+  end
+
+  # Call minimally_create_links for each mnt.
+  #
+  def self.create_filesystem
+    mnt_list = []
+    all_mnts.each do |mnt|
+      minimally_create_links(mnt, install_location(mnt))
+      mnt_list << mnt 
+    end
+    return mnt_list
+  end
+
+  # For each directory and file in _target_, create a link at <em>link_name</em>.  If
+  # there is currently no file at <em>link_path</em>, create a symbolic link there.
+  # If there is currently a symbolic link, combine the contents at the
+  # link location and _target_ in a new directory and proceed
+  # recursively.
+  #
+  def self.minimally_create_links(target, link_path) 
+    target = File.expand_path(target)
+    link_path = File.expand_path(link_path)
+
+    unless File.exist?(target)
+      raise "attempt to create links from missing directory: " + target
+    end
+
+    Find.find(target) do |path|
+      next if path == target
+      Find.prune if ignore_file?(File.basename(path))
+
+      rel_path = path.gsub(target, '')
+      link_name = File.join(link_path, rel_path)
+      create_link(path, link_name)
+
+      Find.prune if File.directory?(path) 
+    end
+    create_collection_links(target, link_path)
+  end
+
+  # Create links in a generated mirror directory to the analogous
+  # location in the mounted directories.
+  #
+  def self.create_collection_links(target, link_name)
+    return unless @collection_links
+
+    collection_name = File.basename(root_path(target))
+    collection_link = File.join(link_name, @collection_link_prefix + collection_name)
+    create_link(target, collection_link) unless File.exist? collection_link
+  end
+
+  # Starting at _dir_, walk up the directory hierarchy and return the
+  # directory that is contained in _@paths_.
+  #
+  def self.root_path(dir)
+    raise ArgumentError if dir == '/'
+
+    parent = File.expand_path(File.join(dir, '..'))
+    if @paths.include? parent
+      return dir
+    else
+      root_path parent
+    end
+  end
+
+  # Dispatch calls to create_directory_link and create_file_link.
+  #
+  def self.create_link(target, link_name) 
+    if File.directory?(target) 
+      begin
+        create_directory_link(target, link_name)
+      rescue => message
+        puts message
+      end
+    elsif File.file?(target) 
+      create_file_link(target, link_name)
+    end
+  end
+
+  # Create a symbolic link to <em>target</em> from <em>link_name</em>.
+  #
+  def self.create_file_link(target, link_name) 
+    raise ArgumentError unless File.file?(target)
+    unless File.exist?(link_name)
+      FileUtils.ln_s(target, link_name)
+    else
+      unless (File.symlink?(link_name) && 
+              (File.readlink(link_name) == target || (not File.exist?(File.readlink(link_name)))))
+        raise "Could not link #{target} to #{link_name}"
+      end
+    end
+  end
+
+  # Create a symbolic link to the directory at <em>target</em> from
+  # <em>link_name</em>, unless <em>link_name</em> already exists.  In that case,
+  # create a directory and recursively run minimally_create_links.
+  #
+  def self.create_directory_link(target, link_name) 
+    raise ArgumentError unless File.directory?(target)
+    unless File.exist?(link_name)
+      FileUtils.ln_s(target, link_name)
+    else
+      case File.ftype(link_name)
+      when 'file'
+        raise "Could not link #{target} to #{link_name}"
+      when 'directory'
+        minimally_create_links(target, link_name)
+      when 'link'
+        case File.ftype(File.readlink(link_name))
+        when 'file'
+          raise "Could not link #{target} to #{link_name}"
+        when 'directory'
+          combine_directories(link_name, target, File.readlink(link_name))          
+        end
+      end
+    end
+  end
+
+  # Create a directory and create links in it pointing to
+  # <em>target_path1</em> and <em>target_path2</em>.
+  #
+  def self.combine_directories(link_name, target_path1, target_path2) 
+    return if target_path1 == target_path2
+    
+    FileUtils.rm(link_name)
+    FileUtils.mkdir_p(link_name)
+    minimally_create_links(target_path1, link_name)
+    minimally_create_links(target_path2, link_name)
+  end
+
+end
+