tap 0.7.9

data/lib/tap/file_task.rb

@@ -0,0 +1,354 @@
+module Tap
+  
+  # FileTask provides methods for making files 
+  
+  # FileTask process adds error handling code to restore any files marked
+  # for backup or files that were made (using make or mkdir) if an unhandled
+  # error occurs during processing.  Set +restore_on_error+ to false to 
+  # turn off automatic restore.  In addtion, backed-up files can be removed
+  # when process completes by setting +remove_backed_up_files+ to true.
+  class FileTask < Task
+    set_default_config({
+      :backup_dir => :backup,
+      :backup_timestamp => "%Y%m%d_%H%M%S",
+      :restore_on_error => true,
+      :remove_backed_up_files => false},
+      :make_accessors => true)
+      
+    attr_reader :inference_block, :backed_up_files, :made_files
+    attr_accessor :dirname
+    
+    def initialize(*args)
+      super
+      
+      batch.each do |task|
+        task.dirname = task.default_dirname
+        task.backed_up_files = {}
+        task.made_files = []
+      end
+    end
+    
+    # Sets a block to perform path inference.  Raises an error if inference_block 
+    # is already set, unless override = true.    
+    def inference(override=false, &block) # :yields: app[dir], dirname, *paths
+      raise "Inference block for task already set: #{name}" unless inference_block.nil? || override
+      self.inference_block = block
+    end
+    
+    # Infers a path using the inference block, or by using app.filepath if
+    # no inference block is given.  Note the actual inputs to the inference
+    # block are the application directory identified by dir, the dirname
+    # for the task, and the provided paths.
+    #
+    #   t = FileTask.new 
+    #   t.app[:data]                        # => "/data"
+    #   t.dirname                           # => "tap/file_task"
+    #   t.infer_filepath(:data, "result.txt")   # => "/data/tap/file_task/result.txt"
+    #
+    #   t.inference do |root, dir, path|
+    #     File.join(root, dir, path.chomp(".txt") + ".yml")
+    #   end
+    #
+    #   t.infer_filepath(:data, "result.txt")   # => "/data/tap/file_task/result.yml"
+    #
+    def infer_filepath(dir, *paths) # :yields: app[dir], dirname, *paths
+      inference_block ? 
+        inference_block.call(app[dir], dirname, *paths) : 
+        app.filepath(dir, dirname, *paths)
+    end
+    
+    # Makes a backup filepath for input filepath by doing the following:
+    # - insert a timestamp between the basename and extname of the filepath
+    # - identify a backup path as the part of the filepath relative to 
+    #   dirname, or the basename if the filepath is not relative to dirname
+    # - infer_filepath using the backup_dir and this backup path
+    #
+    #   t = FileTask.new("dir/name", :backup_dir => :backup, :backup_timestamp => "%Y%m%d")
+    #   t.app[:backup]                                 # => "/backup"
+    #   Date.today.to_s                                # => "2007-08-08"
+    #
+    #   t.backup_filepath("path/to/folder/file.txt")   # => "/backup/file_20070808.txt"
+    #   t.backup_filepath("dir/name/folder/file.txt")  # => "/backup/folder/file_20070808.txt"
+    #   
+    def backup_filepath(filepath)
+      extname = File.extname(filepath)
+      backup_path = File.expand_path("#{filepath.chomp(extname)}_#{Time.now.strftime(backup_timestamp)}#{extname}")
+      
+      split_index = backup_path.index(dirname + "/")
+      backup_path = split_index ? 
+        backup_path[(split_index + dirname.length + 1)..-1] : 
+        File.basename(backup_path)
+
+      infer_filepath(backup_dir, backup_path)
+    end
+    
+    # A batch File.open method.  If a block is given, each file in the list will be 
+    # opened the open files passed to the block.  Files are automatically closed when 
+    # the block returns.  If no block is given, the open files are returned.
+    def open(list, mode="rb")
+      open_files = []
+      begin
+        fu_list(list).each do |filepath| 
+          open_files << File.open(filepath, mode)
+        end
+        
+        block_given? ? yield(open_files) : open_files
+      ensure
+        open_files.each {|file| file.close } if block_given?
+      end
+    end
+
+    # Returns true if all of the targets are up to date relative to all of the sources
+    # AND the task config_file (if it exists). Single values or arrays can be provided 
+    # for both targets and sources.  
+    #
+    # Returns false if +force?+ is true.
+    def uptodate?(targets, sources=[])
+      if app.options.force
+        log_filepaths(:force, *targets)
+        false
+      else
+        targets = [targets] unless targets.kind_of?(Array)
+        sources = [sources] unless sources.kind_of?(Array)
+        sources << config_file 
+        targets.each do |target|
+          return false unless FileUtils.uptodate?(target, sources)
+        end 
+        true
+      end
+    end
+    
+    # Makes a backup of each file in list to backup_filepath(file) and registers 
+    # the files so that they can be restored using restore.  If copy is true, the 
+    # files will be copied to backup_filepath, otherwise the file is moved to 
+    # backup_filepath.  Raises an error if the file is already backed up.
+    #
+    # Returns a list of the backup_filepaths.
+    def backup(list, copy=true)
+      fu_list(list).collect do |filepath|
+        next unless File.exists?(filepath)
+        
+        filepath = File.expand_path(filepath)
+        if backed_up_files.include?(filepath)
+          raise "Backup for #{filepath} already exists." 
+        end
+        
+        target = File.expand_path(backup_filepath(filepath))
+        dir = File.dirname(target)
+        mkdir(dir)
+
+        if copy
+          log :cp, "#{filepath} to #{target}", Logger::DEBUG
+          FileUtils.cp(filepath, target)
+        else
+          log :mv, "#{filepath} to #{target}", Logger::DEBUG
+          FileUtils.mv(filepath, target)
+        end
+
+        # track the target for restores
+        backed_up_files[filepath] = target
+        target
+      end
+    end
+    
+    # Restores a backed-up file to its original location and removes the
+    # directory of the backup if it is empty.  Returns the restored files.
+    def restore(list)
+      fu_list(list).collect do |filepath|
+        filepath = File.expand_path(filepath)
+        raise "No backed up file for: #{filepath}" unless backed_up_files.has_key?(filepath)
+        
+        target = backed_up_files.delete(filepath)
+      
+        dir = File.dirname(filepath)
+        mkdir(dir)
+        
+        log :restore, "#{target} to #{filepath}", Logger::DEBUG
+        FileUtils.mv(target, filepath, :force => true)
+
+        dir = File.dirname(target)
+        rmdir(dir)
+        
+        filepath
+      end
+    end
+    
+    # Creates the directories in list if they do not exist and adds
+    # them to made_files so they can be removed using rmdir.
+    #
+    # Returns the made directories.
+    def mkdir(list)
+      fu_list(list).each do |dir|
+        dir = File.expand_path(dir)
+        
+        make_paths = []
+        while !File.exists?(dir)
+          make_paths << dir
+          dir = File.dirname(dir)
+        end
+      
+        make_paths.reverse_each do |dir|
+          log :mkdir, dir, Logger::DEBUG 
+          FileUtils.mkdir(dir) 
+          made_files << dir 
+        end
+      end
+    end
+    
+    # Removes each directory in the input list, provided the directory is in
+    # made_files and the directory is empty.  When checking if the directory
+    # is empty, rmdir checks for regular files and hidden files.  Removed
+    # directories are removed from made_files.
+    #
+    # Returns a list of the removed directories.
+    def rmdir(list) 
+      removed = []
+      fu_list(list).each do |dir|  
+        dir = File.expand_path(dir)
+      
+        # remove directories and parents until the
+        # directory was not made by the task 
+        while made_files.include?(dir)
+          break unless Dir.entries(dir).delete_if {|d| d == "." || d == ".."}.empty?
+          
+          if File.exists?(dir)
+            log :rmdir, dir, Logger::DEBUG
+            FileUtils.rmdir(dir) 
+          end
+        
+          removed << made_files.delete(dir)
+          dir = File.dirname(dir)
+        end
+      end
+      removed
+    end
+    
+    # Make prepares the input list of files by backing them up (if they exist),
+    # ensuring that the parent directory for the file exists, and adds each file
+    # to made_files.  As a result the files can be removed using rm, and 
+    # the original files restored using restore.  
+    #
+    # Returns the made files.
+    def make(list) # :yields: list
+      list = fu_list(list)
+      existing_files, non_existant_files = list.partition do |filepath| 
+        File.exists?(filepath)
+      end
+      
+      # backup existing files
+      existing_files.each do |filepath|
+        backup(filepath, false)
+        made_files << File.expand_path(filepath)
+      end
+      
+      # ensure the parent directory exists  
+      # for non-existant files 
+      non_existant_files.each do |filepath| 
+        dir = File.dirname(filepath)
+        mkdir(dir)
+        made_files << File.expand_path(filepath)
+      end
+   
+      yield list if block_given?
+      
+      list
+    end
+    
+    # Removes each file in the input list, provided the file is in made_files.  
+    # The parent directory of each file is removed using rmdir. Removed files 
+    # are removed from made_files.
+    #
+    # Returns the removed files and directories.
+    def rm(list) 
+      removed = []
+      fu_list(list).each do |filepath|  
+        filepath = File.expand_path(filepath)
+        next unless made_files.include?(filepath)
+        
+        # if the file exists, remove it
+        if File.exists?(filepath)
+          log :rm, filepath, Logger::DEBUG
+          FileUtils.rm(filepath, :force => true) 
+        end
+
+        removed << made_files.delete(filepath)
+        removed.concat rmdir(File.dirname(filepath))
+      end
+      removed
+    end
+    
+    # Logs the given action, with the basenames of the input filepaths.  
+    def log_filepaths(action, *filepaths)
+      msg = filepaths.collect {|filepath| File.basename(filepath) }.join(',')
+      log(action , msg)
+    end
+     
+    protected
+
+    attr_writer :inference_block, :backed_up_files, :made_files
+  
+    # The default_dirname is based on the name of the task, and the
+    # index of the task in batch (if the task is batched):
+    #
+    #   t = FileTask.new "name"
+    #   t.default_dirname           # => "name"
+    #
+    #   t = FileTask.new "batched"
+    #   t.batch[0].default_dirname  # => "name_0"
+    #   t.batch[1].default_dirname  # => "name_1"
+    def default_dirname
+      batched? ? "#{name}_#{batch_index}" : name
+    end
+    
+    def after_execute
+      backed_up_files.values.each do |filepath|
+        # the filepath needs to be added to made_files
+        # before it can be removed by rm
+        made_files << filepath
+        rm(filepath)
+      end if remove_backed_up_files
+    end
+    
+    def on_execute_error(original_error)
+      restore_errors = []
+      
+      if restore_on_error
+        made_files.dup.each do |filepath| 
+          begin
+            case
+            when File.file?(filepath)
+              rm(filepath)
+            when File.directory?(filepath)
+              rmdir(filepath)
+            end
+          rescue
+            restore_errors << $!
+          end
+        end
+        
+        backed_up_files.keys.each do |filepath|
+          begin
+            restore(filepath)
+          rescue
+            restore_errors << $!
+          end
+        end
+      end
+
+      # Re-raise an error unless the original error was due
+      # to task termination and no restore errors occured
+      if restore_errors.empty?
+        raise original_error
+      else
+        raise Support::RunError.new(original_error, restore_errors)
+      end
+    end
+    
+    private
+    
+    # Lifted from FileUtils
+    def fu_list(arg)  
+      [arg].flatten.map {|path| path.to_str }
+    end
+  end
+end

data/lib/tap/generator.rb

@@ -0,0 +1,29 @@
+require 'active_record'            # required by rails_generator, for some reason
+require 'rails_generator'
+require 'tap/generator/options'
+require 'tap/generator/usage'
+
+module Tap
+  module Generator 
+    module Generators  # :nodoc:
+    end
+  end
+end
+      
+# These modifications are to make the rails generators work for Tap
+module Rails # :nodoc:
+  module Generator # :nodoc:  
+    class Base # :nodoc:
+      include Tap::Generator::Options
+      
+      # Used to discover generators within tap.  Adapted from code
+      # in 'rails/rails_generator/lookup.rb'
+      def self.use_tap_sources!
+        reset_sources
+        sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generator/generators")
+        sources << PathSource.new(:builtin, Tap::App.instance.filepath(:generators))
+      end
+    end
+  end
+end
+

data/lib/tap/generator/generators/config/config_generator.rb

@@ -0,0 +1,23 @@
+module Tap::Generator::Generators
+  class ConfigGenerator < Rails::Generator::NamedBase # :nodoc:
+    attr_accessor :default_config
+
+    def initialize(*args)
+      super(*args)    
+      @destination_root  = Tap::App.instance[:root]
+      @app = Tap::App.instance
+  	end
+
+    def manifest
+      record do |m|
+        task_name = class_path.empty? ? class_name : File.join(class_path, class_name)
+        task = @app.task(task_name)
+        self.default_config = task.class.default_config
+    
+        config_path = @app.relative_filepath(:root, @app[:config])
+        m.directory File.join(config_path, class_path)
+        m.template "config.erb", File.join(config_path, class_name.underscore + ".yml")
+      end
+    end
+  end
+end

data/lib/tap/generator/generators/config/templates/config.erb

@@ -0,0 +1,2 @@
+# Configurations for <%= class_name %>
+<%= default_config.stringify_keys.to_yaml %>

data/lib/tap/generator/generators/file_task/file_task_generator.rb

@@ -0,0 +1,21 @@
+module Tap::Generator::Generators
+  class FileTaskGenerator < Rails::Generator::NamedBase # :nodoc:
+    def initialize(*args)
+      super(*args)    
+      @destination_root  = Tap::App.instance[:root]
+      @app = Tap::App.instance
+  	end
+
+    def manifest
+      record do |m|
+        lib_path = @app.relative_filepath(:root, @app[:lib])
+        m.directory File.join(lib_path, class_path)
+        m.template "task.erb", File.join(lib_path, class_name.underscore + ".rb")
+     
+        test_path = @app.relative_filepath(:root, @app[:test])
+        m.directory File.join(test_path, class_path)
+        m.template "test.erb", File.join(test_path, class_name.underscore + "_test.rb")
+      end
+    end
+  end
+end

data/lib/tap/generator/generators/file_task/templates/task.erb

@@ -0,0 +1,27 @@
+# == Documentation
+#
+# === Command Line Usage
+# Replace with your command line usage instructions
+#
+class <%= class_name %> < Tap::FileTask
+
+  def process(input)
+    # The process logic goes here.  You don't have to use transform.  
+    # Do whatever works!
+    output = infer_filepath(:data, input)
+
+    make(output) 
+
+    File.open(input) do |source|
+      File.open(output, "w") do |target|
+        target.write "<root>\n"
+        while line = source.gets
+          next unless line =~ /(\w+): (\w+)/
+          target.write "  <#{$1}>#{$2}</#{$1}>\n"
+        end
+        target.write "</root>"
+      end
+    end
+  end
+  
+end