bahuvrihi-tap 0.10.0

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

data/lib/tap/generator/generators/command/command_generator.rb

@@ -0,0 +1,21 @@
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a new tap command
+  #
+  # Generates a new tap command under the cmd directory. The  
+  # new command can be run from the command line using:
+  # 
+  #   % tap <command>
+  #
+  class CommandGenerator < Tap::Generator::Base
+    
+    def manifest(m, command_name)
+      m.directory app['cmd']
+      
+      template_files do |source, target|
+        m.template app.filepath('cmd', "#{command_name}.rb"), source, :command_name => command_name
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,32 @@
+# tap <%= command_name %> {options} ARGS...
+#
+# The default command simply prints the input arguments 
+# and application information, then exits.
+#
+
+env = Tap::Env.instance
+app = Tap::App.instance
+
+#
+# handle options
+#
+
+OptionParser.new do |opts|
+  opts.separator ""
+  opts.separator "options:"
+
+  opts.on("-h", "--help", "Show this message") do
+    opts.banner = Tap::Support::CommandLine.usage(__FILE__)
+    puts opts
+    exit
+  end
+  
+end.parse!(ARGV)
+
+
+#
+# add your script code here
+#
+
+puts "Received: #{ARGV.join(', ')}"
+puts app.info

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

@@ -0,0 +1,26 @@
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a config file for a task
+  # 
+  # Generates a new config file for a task.  The configurations, defaults, 
+  # and documentation is determined from the task source file.
+  class ConfigGenerator < Tap::Generator::Base
+    
+    config :doc, true, &c.switch  # include documentation in the config
+    
+    def env
+      Tap::Env.instance
+    end
+
+    def manifest(m, name, config_name=name)
+      const = env.search(:tasks, name) or raise "unknown task: #{name}"
+      task_class = const.constantize or raise "unknown task: #{name}"
+      
+      m.directory app['config']
+      m.file app.filepath('config', config_name + '.yml') do |file|
+        task_class.configurations.format_str((doc ? :doc : :nodoc), file)
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,12 @@
+###############################################################################
+# <%= receiver %> configuration<%= configurations.length > 1 ? 's' : '' %>
+###############################################################################
+<% configurations.each do |key, config| %>
+
+<% Comment.wrap(config.desc.to_s.split(/\r?\n/), 50, 2).each do |line|  %>
+# <%=  line %>
+<% end %>
+<%= config.default == nil ? '#' : '' %><%= yamlize({key.to_s => config.default}) %>
+
+<% end %>
+

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

@@ -0,0 +1,8 @@
+###############################################################################
+# <%= receiver %> configuration<%= configurations.length > 1 ? 's' : '' %>
+###############################################################################
+<% configurations.each do |key, config| %>
+<%= config.default == nil ? '#' : ''%><%= yamlize({key.to_s => config.default}) %>
+
+<% end %>
+

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

@@ -0,0 +1,27 @@
+require 'tap/generator/generators/task/task_generator'
+
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a file_task and test
+  #
+  # Generates a new Tap::FileTask and associated test files.
+  class FileTaskGenerator < TaskGenerator
+    
+    def manifest(m, const_name)
+      const = super
+      
+      if test
+        test_dir = app.filepath('test', const.path, "test_#{const.basename}")
+        
+        m.directories test_dir, %W{
+          input
+          expected
+        }
+        
+        m.template File.join(test_dir, 'input/file.txt'), "file.txt", :const => const, :test_dir => test_dir
+        m.template File.join(test_dir, 'expected/result.yml'), "result.yml", :const => const, :test_dir => test_dir
+      end
+    end
+    
+  end
+end

data/lib/tap/generator/generators/file_task/templates/file.txt

@@ -0,0 +1,11 @@
+absquatulate - verb: This amusing, vivid, and expressive word is a bit of a jocular, contrived slang.  To absquatulate is to decamp, to scram, to take off in a hell of a hurry like a fugitive heading into the woods.
+
+algorism - noun: This is the name of the Arabic numbering system, using the figures 1 to 9 plus the zero.  The derivation is from Middle Latin algorismus, from the Arabic al (the) plus Khuwarizmi, the surname of a ninth-century Arabic mathematician.  Algorithm is sometimes used as a synonym, but is also used to designate a set of rules for the solution of a mathematical problem in a finite number of steps.  These words are entirely unrelated to algolagnia, with its very different meaning and derivation.
+
+defenestration - verb: Defenestration is the act of throwing someone (yes, someone!) or something out of a window.  To defenestrate a person or thing is to engage in this activity - a strange one indeed, since these words are more commonly applied to situations where what is thrown out of the window is a person, rather than a thing.  It is surprising, in view of what must be the infrequency of this type of activity, that there exists word for it, but then, there exists a word for just about everything.
+
+macaronic - adj: This peculiar word, a jocular concoction from macaroni, is applied, in a narrow sense, to language characterized by a mixture of Latin and non-Latin words, or by non-Latin words given phony Latin endings; in a broader sense, to prose or verse composed of any mixture of languages; in its broadest sense, to anything mixed or jumbled.
+
+trumpery - noun: Trumpery is worthless stuff.  
+
+usufruct - noun: Usufruct is a term used in law primarily, to denote one's right to enjoy the use and benefits flowing from the use of another's property, without the ownership of it and without the right to harm or waste or destroy it.

data/lib/tap/generator/generators/file_task/templates/result.yml

@@ -0,0 +1,6 @@
+--- 
+- 111
+- 155
+- 123
+- 125
+- 56

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

@@ -0,0 +1,33 @@
+<% redirect do |target| %># <%= const.name %>::manifest <replace with manifest summary>
+# <replace with command line description>
+
+# <%= const.const_name %> Documentation
+# This example FileTask counts the specified letters
+# in a source file and writes the counts to a target
+# file as YAML.
+#
+class <%= const.const_name %> < Tap::FileTask
+
+  # <config file documentation>
+  config :letters, ['a','e','i','o','u'], &c.array  # a list of letters to count
+
+  def process(source, target)
+
+    # prepare ensures the parent directory for target
+    # exists and, if necessary, backs up the existing
+    # target file (which is restored on error)
+    prepare(target) 
+
+    # now perform the task...
+    str = File.read(source)
+    letter_count = letters.collect do |letter|
+      str.count(letter)
+    end
+
+    File.open(target, "wb") do |file|
+      file << letter_count.to_yaml
+    end
+
+    target
+  end
+end <% module_nest(const.nesting, '  ') { target } end %>

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

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '<%= '../' * const.nesting_depth %>tap_test_helper.rb') 
+require '<%= const.path %>'
+
+class <%= const.name %>Test < Test::Unit::TestCase
+  acts_as_tap_test 
+  
+  def test_<%= const.basename %>
+    # Use assert_files to test file transform tasks.  The block  
+    # recieves the method input files and compares the results 
+    # to the method expected files.
+  
+    # Generated files are often placed in method output, as it
+    # is cleaned up each test.  To keep output files, set the 
+    # KEEP_OUTPUTS variable:
+    #   % rake test keep_outputs=true
+  
+    t = <%= const.name %>.new 
+    assert_files do |input_files|
+      input_files.each do |source|
+        target = method_filepath(:output, 'result.yml') 
+        t.enq(source, target)
+      end
+    
+      app.run
+      app.results(t)
+    end
+  end
+  
+end

data/lib/tap/generator/generators/root/root_generator.rb

@@ -0,0 +1,55 @@
+require 'tap/root'
+
+module Tap::Generator::Generators
+  
+  # :startdoc::generator a basic tap directory structure
+  #
+  # Generates a tap root directory structure:
+  #
+  #   root
+  #   |- Rakefile
+  #   |- lib
+  #   |- sample.gemspec
+  #   |- tap.yml
+  #   |- tapfile.rb
+  #   `- test
+  #       |- tap_test_helper.rb
+  #       |- tap_test_suite.rb
+  #       `- tapfile_test.rb
+  #
+  class RootGenerator < Tap::Generator::Base
+    
+    # ::args ROOT, PROJECT_NAME=basename(ROOT)
+    def manifest(m, root, project_name=File.basename(root))
+      project_name = 'project' if project_name == '.'
+      r = Tap::Root.new(root)
+      
+      m.directory r.root
+      m.directory r['lib']
+      
+      template_files do |source, target|
+        case
+        when File.directory?(source)
+          m.directory r[target]
+        when target == 'gemspec'
+          m.template r[project_name + '.gemspec'], source, :project_name => project_name
+        when target == 'tapfile'
+          m.template r['tapfile.rb'], source, :project_name => project_name
+        else
+          m.template r[target], source, :project_name => project_name
+        end
+      end
+      
+      # m.file(r['tap.yml']) do |file|
+      #  Tap::App.configurations.format_str(:doc, file) do |templater|
+      #    next unless templater.receiver == Tap::Root
+      #     
+      #    templater.configurations.each do |(key, config)| 
+      #      config.default = nil if key.to_s == 'root'
+      #    end
+      #  end
+      #  Tap::Env.configurations.format_str(:doc, file)
+      # end
+    end
+  end
+end