tap 0.12.4 → 0.17.0

data/lib/tap/generator/destroy.rb

@@ -1,60 +0,0 @@
-module Tap
-  module Generator
-    
-    # A mixin defining how to run manifest actions in reverse.
-    module Destroy
-      
-      # Iterates over the actions in reverse, and collects the results.
-      def iterate(actions)
-        results = []
-        actions.reverse_each {|action| results << yield(action) }
-        results
-      end
-      
-      # Removes the target directory if it exists.  Missing, non-directory and 
-      # non-empty targets are simply logged and not removed.  When pretend is
-      # true, removal is logged but does not actually happen.
-      #
-      # No options currently affect the behavior of this method. 
-      def directory(target, options={})
-        target = File.expand_path(target)
-        
-        case
-        when !File.exists?(target)
-          log_relative :missing, target
-        when !File.directory?(target)
-          log_relative 'not a directory', target
-        when !Root.empty?(target)
-          log_relative 'not empty', target
-        else
-          log_relative :rm, target
-          FileUtils.rmdir(target) unless pretend
-        end
-        
-        target
-      end
-      
-      # Removes the target file if it exists.  Missing and non-file and targets
-      # are simply logged and not removed.  When pretend is true, removal is 
-      # logged but does not actually happen.
-      #
-      # No options currently affect the behavior of this method.
-      def file(target, options={})
-        target = File.expand_path(target)
-        
-        case
-        when File.file?(target)
-          log_relative :rm, target
-          FileUtils.rm(target) unless pretend
-        when File.directory?(target)
-          log_relative 'not a file', target
-        else
-          log_relative :missing, target
-        end
-        
-        target
-      end
-      
-    end
-  end
-end

data/lib/tap/generator/generate.rb

@@ -1,93 +0,0 @@
-autoload(:Tempfile, 'tempfile')
-
-module Tap
-  module Generator
-    
-    # A mixin defining how to run manifest actions.
-    module Generate
-      
-      # Creates the target directory if it doesn't exist.  When pretend is
-      # true, creation is logged but does not actually happen.
-      #
-      # No options currently affect the behavior of this method.
-      def directory(target, options={})
-        target = File.expand_path(target)
-        
-        case
-        when File.exists?(target)
-          log_relative :exists, target
-        else
-          log_relative :create, target
-          FileUtils.mkdir_p(target) unless pretend
-        end
-        
-        target
-      end
-      
-      # Creates the target file; content may be added to the file by providing
-      # block.  If the target file already exists, the new and existing content
-      # is compared and the user will be prompted for how to handle collisions.
-      # All activity is logged.  When pretend is true, creation is logged but
-      # does not actually happen.
-      #
-      # No options currently affect the behavior of this method.
-      def file(target, options={})
-        source_file = Tempfile.new('generate')
-        yield(source_file) if block_given?
-        source_file.close
-        
-        source = source_file.path
-        target = File.expand_path(target)
-        
-        copy_file = true
-        msg = case
-        when !File.exists?(target)
-          :create
-        when FileUtils.cmp(source, target)
-          :exists
-        when force_file_collision?(target)
-          :force
-        else
-          copy_file = false
-          :skip
-        end
-        
-        log_relative msg, target
-        if copy_file && !pretend
-          dir = File.dirname(target)
-          FileUtils.mkdir_p(dir) unless File.exists?(dir) 
-          FileUtils.mv(source, target, :force => true)
-        end
-        
-        target
-      end
-      
-      protected
-      
-      # Ask the user interactively whether to force collision.
-      def force_file_collision?(target)
-        return false if skip
-        return true if force
-        
-        prompt_out.print "overwrite #{target}? [Ynaiq] "
-        prompt_out.flush
-        case prompt_in.gets.strip
-        when /^y(es)?$/i
-          true
-        when /^n(o)?$/i
-          false
-        when /^a(ll)?$/i
-          self.force = true
-          true
-        when /^i(gnore)?$/i
-          self.skip = true
-          false
-        when /^q(uit)?$/i
-          prompt_out.puts "aborting"
-          raise SystemExit
-        else force_file_collision?(target)
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Tap::Generator::Generators
-  
-  # :startdoc: Tap::Generator::Generators::CommandGenerator::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 path('cmd')
-      
-      template_files do |source, target|
-        m.template path('cmd', "#{command_name}.rb"), source, :command_name => command_name
-      end
-    end
-    
-  end
-end

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

@@ -1,32 +0,0 @@
-# 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
-#
-
-ConfigParser.new do |opts|
-  opts.separator ""
-  opts.separator "options:"
-
-  opts.on("-h", "--help", "Show this message") do
-    puts Lazydoc.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

@@ -1,98 +0,0 @@
-module Tap::Generator::Generators
-  
-  # :startdoc: Tap::Generator::Generators::ConfigGenerator::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
-    
-    # Dumps a nested configuration.
-    DUMP_DELEGATES = lambda do |leader, delegate, block|
-      nested_delegates = delegate.default(false).delegates
-      indented_dump = Configurable::Utils.dump(nested_delegates, &block).gsub(/^/, "  ")
-      "#{leader}: \n#{indented_dump}"
-    end
-    
-    # Dumps configurations as YAML with documentation,
-    # used when the doc config is true.
-    DOC_FORMAT = lambda do |key, delegate|
-      # get the description
-      desc = delegate.attributes[:desc]
-      doc = desc.to_s
-      doc = desc.comment if doc.empty?
-    
-      # wrap as lines
-      lines = Lazydoc::Utils.wrap(doc, 50).collect {|line| "# #{line}"}
-      lines << "" unless lines.empty?
-      
-      if delegate.is_nest?
-        leader = "#{lines.join("\n")}#{key}"
-        DUMP_DELEGATES[leader, delegate, DOC_FORMAT]
-      else
-        default = delegate.default
-        
-        # setup formatting
-        leader = default == nil ? '# ' : ''
-        config = YAML.dump({key => default})[5..-1]
-        "#{lines.join("\n")}#{leader}#{config.strip}\n\n"
-      end
-    end
-    
-    # Dumps configurations as YAML without documentation, 
-    # used when the doc config is false.
-    NODOC_FORMAT = lambda do |key, delegate|
-      if delegate.is_nest?
-        DUMP_DELEGATES[key, delegate, NODOC_FORMAT]
-      else
-        default = delegate.default
-      
-        # setup formatting
-        leader = default == nil ? '# ' : ''
-        config = YAML.dump({key => default})[5..-1]
-        "#{leader}#{config.strip}\n"
-      end
-    end
-    
-    config :doc, true, &c.switch        # include documentation in the config
-    config :nest, false, &c.switch      # generate nested config files
-    config :blanks, true, &c.switch     # allow generation of empty config files
-    
-    # Lookup the named task class.  Lookup happens through the active Env 
-    # instance, specifically using:
-    #
-    #   Env.instance.tasks.search(name)
-    #
-    # Raises an error if the name cannot be resolved to a task.
-    def lookup(name)
-      const = Tap::Env.instance.tasks.search(name) or raise "unknown task: #{name}"
-      const.constantize
-    end
-    
-    def manifest(m, name, config_name=nil)
-      # setup
-      tasc = lookup(name)
-      config_name ||= tasc.default_name
-      config_file = path('config', config_name)
-      config_file += ".yml" if File.extname(config_file).empty?
-      
-      # generate the dumps
-      dumps = Configurable::Utils.dump_file(tasc.configurations, config_file, nest, true, &format_block)
-      
-      # now put the dumps to the manifest
-      m.directory(path('config'))
-      
-      dumps.each do |path, content|
-        next if content.empty? && !blanks
-        m.file(path) do |file|
-          file << content
-        end
-      end
-    end
-    
-    # A hook to set a formatting block.  By default format_blocks
-    # returns DOC_FORMAT or NODOC_FORMAT as per the doc config.
-    def format_block
-      doc ? DOC_FORMAT : NODOC_FORMAT
-    end
-  end
-end

data/lib/tap/generator/generators/generator/generator_generator.rb

@@ -1,37 +0,0 @@
-module Tap::Generator::Generators
-  
-  # :startdoc: Tap::Generator::Generators::GeneratorGenerator::generator a generator task and test
-  #
-  # Generates a new generator.
-  class GeneratorGenerator < Tap::Generator::Base
-    
-    config :test, true, &c.switch  # specifies creation of a test file
-    
-    def manifest(m, const_name)
-      const = Tap::Support::Constant.new(const_name.camelize)
-      dir = path('lib', const.path)
-      
-      # make the directory
-      m.directory dir
-      
-      # make the generator
-      m.template path(dir, "#{const.basename}_generator.rb"), "task.erb", :const => const
-      
-      # make the templates directory
-      m.directory path(dir, 'templates')
-      
-      # make a template file
-      # (note it's easier to do this as a file since erb is
-      # added, and would have to be escaped in a template)
-      m.file path(dir, 'templates', 'template_file.erb') do |file|
-        file << "# A sample template file.\nkey: <%= key %>\n"
-      end
-      
-      if test
-        test_path = path('test', "#{const.path}_generator_test.rb")
-        m.directory File.dirname(test_path)
-        m.template test_path, "test.erb", :const => const
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-<% redirect do |target| %># <%= const.name %>::generator <replace with manifest summary>
-# <replace with command line description>
-
-# <%= const.const_name %> Documentation
-class <%= const.const_name %>Generator < Tap::Generator::Base
-
-  config :key, 'value'           # a sample config
-  
-  # The generator will receive the inputs on the command line, and
-  # m, a Manifest object that records the actions of this method.
-  def manifest(m, *inputs)
-
-    # make a directory
-    # m.directory path
-
-    # make a file
-    # m.file path do |file|
-    #   file << contents
-    # end
-
-    # template a file in the templates directory using ERB.
-    # The (key, value) pairs will be available in the 
-    # template as local variables.
-    m.template "<%= const.const_name.underscore %>_file.txt", "template_file.erb", config.to_hash
-
-  end
-end <% module_nest(const.nesting, '  ') { target } end %>

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

@@ -1,26 +0,0 @@
-require File.join(File.dirname(__FILE__), '<%= '../' * const.nesting_depth %>tap_test_helper.rb') 
-require '<%= const.path %>'
-require 'tap/generator/preview.rb'
-
-class <%= const.name %>Test < Test::Unit::TestCase
-
-  # Preview fakes out a generator for testing
-  Preview = Tap::Generator::Preview
-  
-  acts_as_tap_test 
-  
-  def test_<%= const.basename %>
-    g = <%= const.name %>.new.extend Preview
-    
-    # check the files and directories
-    assert_equal %w{
-      <%= const.const_name.underscore %>_file.txt
-    }, g.process
-    
-    # check the content as necessary
-    assert_equal %q{
-# A sample template file.
-key: value
-}, "\n" + g.builds['<%= const.const_name.underscore %>_file.txt']
-  end
-end

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

@@ -1,84 +0,0 @@
-require 'tap/generator/base'
-
-module Tap::Generator::Generators
-  
-  # :startdoc: Tap::Generator::Generators::RootGenerator::generator a basic tap directory structure
-  #
-  # Generates a tap root directory structure.  Use the switches to turn on or
-  # off the creation of various files:
-  #
-  #   project
-  #   |- MIT-LICENSE
-  #   |- README
-  #   |- Rakefile
-  #   |- lib
-  #   |- project.gemspec
-  #   |- tap.yml
-  #   `- test
-  #       `- tap_test_helper.rb
-  #
-  class RootGenerator < Tap::Generator::Base
-    
-    config :config_file, false, &c.switch  # Create a full tap.yml file
-    config :license, true, &c.switch       # Create an MIT-LICENSE
-    config :history, true, &c.switch       # Create History file
-    config :rapfile, false, &c.switch      # Create a Rapfile
-    
-    # ::args ROOT, PROJECT_NAME=basename(ROOT)
-    def manifest(m, root, project_name=nil)
-      r = Tap::Root.new(root)
-      project_name = File.basename(r.root) if project_name == nil
-      
-      m.directory r.root
-      m.directory r['lib']
-      m.directory r['test']
-      
-      template_files do |source, target|
-        case
-        when File.directory?(source)
-          m.directory r[target]
-          next
-        when source =~ /gemspec$/
-          m.template r[project_name + '.gemspec'], source, {
-            :project_name => project_name, 
-            :config_file => config_file, 
-            :license => license,
-            :history => history
-          }
-          next
-        when source =~ /Rapfile$/
-          next unless rapfile
-        when source =~ /MIT-LICENSE$/
-          next unless license
-        end
-        
-        m.template r[target], source, :project_name => project_name, :license => license
-      end
-      
-      m.file(r['History']) if history
-      m.file(r['tap.yml']) do |file|
-        Configurable::Utils.dump(Tap::Env.configurations, file) do |key, delegate|
-          default = delegate.default(false)
-          
-          # get the description
-          desc = delegate.attributes[:desc]
-          doc = desc.to_s
-          doc = desc.comment if doc.empty?
-          
-          # wrap as lines
-          lines = Lazydoc::Utils.wrap(doc, 78).collect {|line| "# #{line}"}
-          lines << "" unless lines.empty?
-          
-          # note: this causes order to be lost...
-          default = default.to_hash if delegate.is_nest?
-
-          # setup formatting
-          leader = key == 'root' || default == nil ? '# ' : ''
-          config = YAML.dump({key => default})[5..-1].strip.gsub(/\n+/, "\n#{leader}")
-          "#{lines.join("\n")}#{leader}#{config}\n\n"
-        end if config_file
-      end
-    end
-    
-  end
-end