tap 0.9.1 → 0.10.0

data/lib/tap/file_task.rb

@@ -1,10 +1,10 @@
+require 'tap/support/shell_utils'
+autoload(:FileUtils, "fileutils")
+
 module Tap
   
-  # == Overview
-  #
   # FileTask provides methods for creating/modifying files such that you can
-  # rollback changes if an error occurs.  In addition, FileTask provides a 
-  # method to infer filepaths within the standard Tap directory structure.  
+  # rollback changes if an error occurs.
   #
   # === Creating Files/Rolling Back Changes
   #
@@ -46,11 +46,6 @@ module Tap
   class FileTask < Task
     include Tap::Support::ShellUtils
     
-    autoload(:FileUtils, "fileutils")
-    
-    # A block used to infer filepaths. (see FileTask#filepath)
-    attr_reader :inference_block
-    
     # A hash of backup (source, target) pairs, such that the
     # backed-up files are backed_up_files.keys and the actual
     # backup files are backed_up_files.values.  All filepaths
@@ -59,40 +54,37 @@ module Tap
     
     # An array of files added during task execution.  
     attr_reader :added_files
+ 
+    # The backup directory, defaults to the class backup_dir
+    config_attr :backup_dir, 'backup'            # the backup directory
     
-    # The directory name used when infering filepaths.  By
-    # default dirname for an unbatched task is task.name,
-    # or "#{task.name}_#{batch_index}" for a batched task.
-    # (see FileTask#default_dirname)
-    attr_accessor :dirname
+    # A timestamp format used to mark backup files, defaults
+    # to the class backup_timestamp
+    config :timestamp, "%Y%m%d_%H%M%S"           # the backup timestamp format
     
-    # The backup directory, defaults to the class backup_dir 
-    config :backup_dir, :backup
+    # A flag indicating whether or not to rollback changes on
+    # error, defaults to the class rollback_on_error
+    config :rollback_on_error, true, &c.switch   # rollback changes on error
     
-    # A timestamp format used to mark backup files, defaults 
-    # to the class backup_timestamp 
-    config :backup_timestamp, "%Y%m%d_%H%M%S"
-    
-    # A flag indicating whether or not to rollback changes on 
-    # error, defaults to the class rollback_on_error 
-    config :rollback_on_error, true
-    
-    def initialize(*args)
+    def initialize(config={}, name=nil, app=App.instance, &task_block)
       super
       
-      batch.each do |task|
-        task.dirname = task.default_dirname
-        task.backed_up_files = {}
-        task.added_files = []
-        task.inference_block = nil
-      end
+      @backed_up_files = {}
+      @added_files = []
+    end
+    
+    def initialize_copy(orig)
+      super
+      @backed_up_files = {}
+      @added_files = []
     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.
     #
-    #   task.open(["one.txt", "two.txt"], "w") do |one, two|
+    #   t = FileTask.new
+    #   t.open(["one.txt", "two.txt"], "w") do |one, two|
     #     one << "one"
     #     two << "two"
     #   end
@@ -104,11 +96,12 @@ module Tap
     # a single argument, it will be translated into an Array, and passed AS AN ARRAY
     # to the block.
     #
-    #   task.open("file.txt", "w") do |array|
+    #   t.open("file.txt", "w") do |array|
     #     array.first << "content"
     #   end
     #
     #   File.read("file.txt")                # => "content"
+    #
     def open(list, mode="rb")
       open_files = []
       begin
@@ -125,8 +118,10 @@ module Tap
     # Returns the basename of path, exchanging the extension 
     # with extname, if provided.
     #
-    #   task.basename('path/to/file.txt')           # => 'file.txt'
-    #   task.basename('path/to/file.txt', '.html')  # => 'file.html'
+    #   t = FileTask.new
+    #   t.basename('path/to/file.txt')           # => 'file.txt'
+    #   t.basename('path/to/file.txt', '.html')  # => 'file.html'
+    #
     def basename(path, extname=nil)
       basename = File.basename(path)
       unless extname == nil
@@ -136,78 +131,49 @@ module Tap
       basename
     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.
+    # Constructs a filepath using the dir, name, and the specified paths.
     #
     #   t = FileTask.new 
-    #   t.app[:data]                        # => "/data"
-    #   t.dirname                           # => "tap/file_task"
+    #   t.app[:data, true] = "/data" 
+    #   t.name                              # => "tap/file_task"
     #   t.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.filepath(:data, "result.txt")     # => "/data/tap/file_task/result.yml"
-    #
     def filepath(dir, *paths) 
-      inference_block ? 
-        inference_block.call(app[dir], dirname, *paths) : 
-        app.filepath(dir, dirname, *paths)
+      app.filepath(dir, name, *paths)
     end
     
-    # Makes a backup filepath relative to backup_dir by translating the input
-    # filepath and inserting a timestamp formatted using backup_timestamp.
-    # The filepath used during translation will be the filepath relative
-    # to dirname (if the input filepath is relative to dirname) or just 
-    # the basename of the filepath.  
-    #
-    #   t = FileTask.new("dir/name", :backup_dir => :backup, :backup_timestamp => "%Y%m%d")
-    #   t.dirname                                        # => "dir/name"
-    #   t.app[:backup]                                   # => "/backup"
-    #   Date.today.to_s                                  # => "2007-08-08"
-    #
-    #   # uses path relative to dirname, if possible
-    #   t.backup_filepath("dir/name/folder/file.txt")    # => "/backup/folder/file_20070808.txt"
-    #
-    #   # otherwise uses basename
-    #   t.backup_filepath("path/to/folder/file.txt")     # => "/backup/file_20070808.txt"
+    # Makes a backup filepath relative to backup_dir by using self.name, the 
+    # basename of filepath plus a timestamp. 
+    #
+    #   t = FileTask.new({:timestamp => "%Y%m%d"}, 'name')
+    #   t.app['backup', true] = "/backup"
+    #   time = Time.utc(2008,8,8)
+    #
+    #   t.backup_filepath("path/to/file.txt", time)     # => "/backup/name/file_20080808.txt"
     #   
-    def backup_filepath(filepath)
+    def backup_filepath(filepath, time=Time.now)
       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)
-
+      backup_path = "#{File.basename(filepath).chomp(extname)}_#{time.strftime(timestamp)}#{extname}"
       filepath(backup_dir, backup_path)
     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.  Used to check if any work needs to be done for
-    # a given set of sources and configurations.
+    # Returns true if all of the targets are up to date relative to all of the listed
+    # sources AND date_reference. Single values or arrays can be provided for both 
+    # targets and sources.
     #
+    #---
     # Returns false (ie 'not up to date') if +force?+ is true.
     def uptodate?(targets, sources=[])
-      if app.options.force
+      if app.force
         log_basename(:force, *targets)
         false
       else
         targets = [targets] unless targets.kind_of?(Array)
         sources = [sources] unless sources.kind_of?(Array)
-        sources << config_file unless config_file == nil
+        
+        # should be able to specify this somehow, externally set
+        # sources << config_file unless config_file == nil
+        
         targets.each do |target|
           return false unless FileUtils.uptodate?(target, sources)
         end 
@@ -379,7 +345,7 @@ module Tap
         # remove directories and parents until the
         # directory was not made by the task 
         while added_files.include?(dir)
-          break unless Dir.entries(dir).delete_if {|d| d == "." || d == ".."}.empty?
+          break unless dir_empty?(dir)
           
           if File.exists?(dir)
             log :rmdir, dir, Logger::DEBUG
@@ -393,6 +359,10 @@ module Tap
       removed
     end
     
+    def dir_empty?(dir)
+      Dir.entries(dir).delete_if {|d| d == "." || d == ".."}.empty?
+    end
+    
     # Prepares the input list of files by backing them up (if they exist),
     # ensuring that the parent directory for the file exists, and adding
     # each file to added_files.  As a result the files can be removed 
@@ -459,7 +429,7 @@ module Tap
     #   File.exists?("path")                  # => false  
     #   FileUtils.mkdir("path")               # will not be removed
     #
-    #   t.make("path/to/file.txt")          
+    #   t.prepare("path/to/file.txt")          
     #   FileUtils.touch("path/to/file.txt") 
     #   File.exists?("path/to/file.txt")      # => true
     #
@@ -541,20 +511,7 @@ module Tap
     
     protected
 
-    attr_writer :inference_block, :backed_up_files, :added_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
+    attr_writer :backed_up_files, :added_files
     
     # Clears added_files and backed_up_files so that  
     # a failure will not affect previous executions

data/lib/tap/generator/base.rb

@@ -0,0 +1,109 @@
+require 'tap/generator/manifest'
+
+module Tap
+  module Generator 
+    class Base < Tap::Task
+      class << self
+        def lazydoc(resolve=false, args_method=:manifest)
+          if resolve
+            lazydoc = super(false)
+            lazydoc.resolve(nil, /^\s*def\s+#{args_method}(\((.*?)\))?/) do |comment, match|
+              args = match[2].to_s.split(',').collect do |arg|
+                arg = arg.strip.upcase
+                case arg
+                when /^&/ then nil
+                when /^\*/ then arg[1..-1] + "..."
+                else arg
+                end
+              end
+              args.shift
+              
+              comment.subject = args.join(', ')
+              lazydoc.default_attributes['args'] ||= comment
+            end
+          end
+
+          super(false)
+        end
+        
+        def help
+          Tap::Support::Templater.new(DEFAULT_HELP_TEMPLATE, 
+            :task_class => self, 
+            :manifest => lazydoc(true)[to_s]['generator'] || Tap::Support::Comment.new
+          ).build
+        end
+      end
+      
+      Constant = Tap::Support::Constant
+
+      config :pretend, false, &c.flag         # Run but rollback any changes.
+      config :force, false, &c.flag           # Overwrite files that already exist.
+      config :skip, false, &c.flag            # Skip files that already exist.
+      
+      attr_accessor :file_task, :template_dir, :target_dir
+      
+      def initialize(config={}, name=nil, app=App.instance)
+        super(config, name, app)
+
+        @file_task = Tap::FileTask.new
+        @template_dir = File.dirname(self.class.source_file) + '/templates'
+      end
+      
+      def process(*argv)
+        actions = []
+        manifest(Manifest.new(actions), *argv)
+        
+        iterate(actions) do |action, args, block|
+          send(action, *args, &block)
+        end
+        
+        @target_dir = nil
+        file_task.added_files
+      end
+      
+      def log_relative(action, path)
+        log(action, app.relative_filepath(Dir.pwd, path))
+      end
+      
+      def manifest(m, *argv)
+        raise NotImplementedError
+      end
+      
+      def iterate(action)
+        raise NotImplementedError
+      end
+    
+      def directory(target, options={})
+        raise NotImplementedError
+      end
+    
+      def file(target, options={})
+        raise NotImplementedError
+      end
+      
+      def directories(root, targets, options={})
+        directory(root)
+        targets.each do |target|
+          directory(File.join(root, target), options)
+        end
+      end
+      
+      def template(target, source, attributes={}, options={})
+        template_path = File.expand_path(source, template_dir)
+        templater = Support::Templater.new(File.read(template_path), attributes)
+        
+        file(target, options) do |file| 
+          file << templater.build
+        end
+      end
+      
+      def template_files
+        Dir.glob(template_dir + "/**/*").sort.each do |source|
+          target = Tap::Root.relative_filepath(template_dir, source)
+          yield(source, target)
+        end
+      end
+  
+    end
+  end
+end

data/lib/tap/generator/destroy.rb

@@ -0,0 +1,37 @@
+module Tap
+  module Generator
+    module Destroy
+      def iterate(actions)
+        actions.reverse_each {|action| yield(action) }
+      end
+      
+      def directory(target, options={})
+        target = File.expand_path(target, target_dir)
+        
+        case
+        when !File.exists?(target)
+          log_relative :missing, target
+        when !file_task.dir_empty?(target)
+          log_relative 'not empty', target
+        else
+          log_relative :rm, target
+          file_task.added_files << File.expand_path(target)
+          file_task.rmdir(target) unless pretend    
+        end
+      end
+    
+      def file(target, options={})
+        target = File.expand_path(target, target_dir)
+        
+        if File.exists?(target)
+          log_relative :rm, target
+          file_task.added_files << File.expand_path(target)
+          file_task.rm(target) unless pretend
+        else
+          log_relative :missing, target
+        end
+      end
+    end
+    
+  end
+end

data/lib/tap/generator/generate.rb

@@ -0,0 +1,61 @@
+module Tap
+  module Generator 
+    module Generate
+      def iterate(actions)
+        actions.each {|action| yield(action) }
+      end
+  
+      def directory(target, options={})
+        target = File.expand_path(target, target_dir)
+        
+        if File.exists?(target)
+          log_relative :exists, target
+        else
+          log_relative :create, target
+          file_task.mkdir(target) unless pretend
+        end
+      end
+    
+      def file(target, options={})
+        target = File.expand_path(target, target_dir)
+        
+        case
+        when !File.exists?(target)
+          log_relative :create, target
+          # should check for identical...
+        when force_file_collision?(target)
+          log_relative :force, target
+        else
+          log_relative :skip, target
+          return
+        end
+        
+        unless pretend
+          file_task.prepare(target) 
+          File.open(target, "wb") {|file| yield(file) if block_given? }
+        end
+      end
+      
+      # Ask the user interactively whether to force collision.
+      def force_file_collision?(target)
+        return false if skip
+        return true if force
+        
+        $stdout.print "overwrite #{target}? [Ynaiq] "
+        $stdout.flush
+        case $stdin.gets
+        when /a/i
+          self.force = true
+        when /i/i
+          self.skip = true
+        when /q/i
+          $stdout.puts "aborting #{name}"
+          raise SystemExit
+        when /n/i then false
+        when /y/i then true
+        else force_file_collision?(destination)
+        end
+      end
+    end
+  end
+end