tap-gen 0.3.1 → 0.7.0

data/History

@@ -1,3 +1,7 @@
+== 0.7.0 / 2010-05-02
+
+Updated to Tap-1.3.0.  Reworked generate/destroy as task proxies.
+
 == 0.3.1 / 2009-12-09
 
 * updated Base to determine template directory from

data/MIT-LICENSE

@@ -1,6 +1,6 @@
 Copyright (c) 2009, Regents of the University of Colorado.
 
-Copyright (c) 2009, Simon Chiang.
+Copyright (c) 2009-2010, Simon Chiang.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README

@@ -8,9 +8,6 @@ Generators for Tap.
 
 Provides generators for Tap. Generators are subclasses of Task are therefore
 easy to configure, subclass, and distribute.
-{Tap-Generator}[http://tap.rubyforge.org/tap-gen] is a part of the
-{Tap-Suite}[http://tap.rubyforge.org/tap-suite]. Check out these links for
-documentation, development, and bug tracking.
 
 * Website[http://tap.rubyforge.org]
 * Github[http://github.com/bahuvrihi/tap/tree/master]
@@ -23,7 +20,7 @@ Get started:
   % tap generate root sample
   % cd sample
   % tap generate task goodnight
-  % tap run -- goodnight moon
+  % tap goodnight moon
 
 Get some help:
 

data/lib/tap/generator/base.rb

@@ -1,8 +1,11 @@
-require 'tap'
+require 'tap/task'
+require 'tap/templater'
 require 'tap/generator/manifest'
 require 'tap/generator/arguments'
 require 'tap/generator/generate'
 require 'tap/generator/destroy'
+require 'tap/generator/helpers'
+require 'tap/tasks/list'
 
 module Tap
   module Generator
@@ -71,40 +74,82 @@ module Tap
     #
     # :startdoc:::+
     class Base < Tap::Task
-      lazy_attr :manifest, 'generator'
+      class << self
+        def parse_as(mixin, argv=ARGV, app=Tap::App.current, &block)
+          if argv.empty?
+            raise "no generator specified"
+          end
+          
+          if argv[0] == '--help'
+            desc = mixin.desc
+            lines = ["#{mixin}#{desc.empty? ? '' : ' -- '}#{desc.to_s}"]
+            lines << '-' * 80
+            lines.concat desc.wrap(77, 2, nil).collect {|line| "  #{line}"}
+            lines << '-' * 80
+            lines << "usage: tap #{mixin.to_s.underscore} generator *args"
+            lines << ''
+            lines.concat Tasks::List.new(:types => ['generator']).manifest
+            raise lines.join("\n")
+          end
+          
+          argv = argv.dup
+          generator = argv.shift
+          argv.unshift mixin
+          app.env.constant(generator, 'generator').parse(argv, app, &block)
+        end
+        
+        def build(spec={}, app=Tap::App.current)
+          obj = new(spec['config'] || {}, app)
+          
+          if mixin = spec['mixin']
+            obj.extend app.env.constant(mixin)
+          end
+          
+          obj
+        end
+        
+        def convert_to_spec(parser, args)
+          {
+            'config' => parser.nested_config,
+            'mixin'  => args.shift
+          }
+        end
+      end
+      
+      extend Helpers
+      
+      lazy_attr :desc, 'generator'
       lazy_attr :args, :manifest
       lazy_register :manifest, Arguments
       
-      config :destination_root, Dir.pwd,      # The destination root directory
+      config_attr :destination_root, nil,     # The destination root directory
         :long => :destination,
-        :short => :d
+        :short => :d do |root|
+        root ||= default_destination_root
+        @destination_root = root.kind_of?(Root) ? root : Root.new(root)
+      end
+      
+      config_attr :template_root, nil,        # The template root directory
+        :long => :template,
+        :short => :t do |root|
+        root ||= default_template_root
+        @template_root = root.kind_of?(Root) ? root : Root.new(root)
+      end
+      
       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.
       
-      signal :set                             # Set this generator to generate or destroy
-      
-      # The generator-specific templates directory.  By default:
-      # 'templates/path/to/name' for 'lib/path/to/name.rb'
-      attr_accessor :template_dir
-      
       # The IO used to pull prompt inputs (default: $stdin)
       attr_accessor :prompt_in
       
       # The IO used to prompt users for input (default: $stdout)
       attr_accessor :prompt_out
       
-      def initialize(config={}, app=Tap::App.instance)
+      def initialize(config={}, app=Tap::App.current)
         super
         @prompt_in = $stdin
         @prompt_out = $stdout
-        @template_dir = app.env.path(:templates, self.class.to_s.underscore) {|dir| File.directory?(dir) } || File.expand_path("templates/#{self.class.to_s.underscore}")
-      end
-      
-      def set(mod)
-        mod = app.env[mod] unless mod.class == Module
-        extend(mod)
-        self
       end
       
       # Builds the manifest, then executes the actions of the manifest.
@@ -116,7 +161,7 @@ module Tap
         
         iterate(actions) do |action, args, block|
           send(action, *args, &block)
-        end
+        end.compact
       end
       
       # Overridden in subclasses to add actions to the input Manifest.
@@ -134,7 +179,7 @@ module Tap
       
       # Constructs a path relative to destination_root.
       def path(*paths)
-        File.expand_path(File.join(*paths), destination_root)
+        destination_root.path(*paths)
       end
       
       # Peforms a directory action (ex generate or destroy).  Must be
@@ -163,28 +208,28 @@ module Tap
       
       # Makes (or destroys) the target by templating the source using
       # the specified attributes.  Source is expanded relative to
-      # template_dir.  Options are passed onto file.
+      # template_root.  Options are passed onto file.
       def template(target, source, attributes={}, options={})
-        raise "no template dir is set" unless template_dir
-        
-        template_path = File.expand_path(source, template_dir)
+        template_path = template_root.path(source)
         templater = Templater.new(File.read(template_path), attributes)
         
+        (options[:helpers] || self.class.helpers).each do |helper|
+          templater.extend(helper)
+        end
+        
         file(target, options) do |file| 
           file << templater.build(nil, template_path)
         end
       end
       
-      # Yields each source file under template_dir to the block, with
-      # a target path of the source relative to template_dir.
+      # Yields each source file under template_root to the block, with
+      # a target path of the source relative to template_root.
       def template_files
-        raise "no template dir is set" unless template_dir
-        
         targets = []
-        Dir.glob(template_dir + "/**/*").sort.each do |source|
+        template_root.glob('**/*').sort.each do |source|
           next unless File.file?(source)
           
-          target = Tap::Root::Utils.relative_path(template_dir, source)
+          target = template_root.relative_path(source)
           yield(source, target)
           targets << target
         end
@@ -205,10 +250,31 @@ module Tap
         raise NotImplementedError
       end
       
-      # Logs the action with the relative filepath from Dir.pwd to path.
+      # Logs the action with the relative filepath from destination_root to path.
       def log_relative(action, path)
-        relative_path = Tap::Root::Utils.relative_path(Dir.pwd, path)
-        log(action, relative_path || path)
+        relative_path = destination_root.relative_path(path)
+        app.log(action, relative_path || path)
+      end
+      
+      protected
+      
+      def default_destination_root
+        Root.new
+      end
+      
+      def default_template_root
+        class_path = self.class.to_s.underscore
+        
+        template_dir = nil
+        app.env.path(:templates).each do |dir|
+          path = File.join(dir, class_path)
+          if File.directory?(path)
+            template_dir = path
+            break
+          end
+        end
+        
+        Root.new(template_dir || "templates/#{class_path}")
       end
     end
   end

data/lib/tap/generator/destroy.rb

@@ -1,8 +1,18 @@
+require 'tap/generator/base'
+
 module Tap
   module Generator
     
-    # :startdoc::module A mixin defining how to run manifest actions in reverse.
+    # ::mixin run generators in reverse
+    #
+    # A mixin defining how to run manifest actions in reverse.
     module Destroy
+      extend Lazydoc::Attributes
+      lazy_attr(:desc, 'mixin')
+      
+      def self.parse(argv=ARGV, app=Tap::App.current, &block)
+        Base.parse_as(self, argv, app, &block)
+      end
       
       # Iterates over the actions in reverse, and collects the results.
       def iterate(actions)
@@ -17,14 +27,15 @@ module Tap
       #
       # No options currently affect the behavior of this method. 
       def directory(target, options={})
-        target = File.expand_path(target)
+        target = path(target)
         
         case
         when !File.exists?(target)
           log_relative :missing, target
         when !File.directory?(target)
           log_relative 'not a directory', target
-        when !Root::Utils.empty?(target)
+        when target == Dir.pwd
+        when !Root.empty?(target)
           log_relative 'not empty', target
         else
           log_relative :rm, target
@@ -40,7 +51,7 @@ module Tap
       #
       # No options currently affect the behavior of this method.
       def file(target, options={})
-        target = File.expand_path(target)
+        target = path(target)
         
         case
         when File.file?(target)
@@ -60,6 +71,11 @@ module Tap
         :destroy
       end
       
+      def to_spec
+        spec = super
+        spec['mixin'] = 'Tap::Generator::Destroy'
+        spec
+      end
     end
   end
 end

data/lib/tap/generator/generate.rb

@@ -1,19 +1,29 @@
 require 'tempfile'
+require 'tap/generator/base'
 
 module Tap
   module Generator
     
-    # :startdoc::module A mixin defining how to run manifest actions.
+    # ::mixin run generators
+    #
+    # A mixin defining how to run manifest actions.
     module Generate
+      extend Lazydoc::Attributes
+      lazy_attr(:desc, 'mixin')
+      
+      def self.parse(argv=ARGV, app=Tap::App.current, &block)
+        Base.parse_as(self, argv, app, &block)
+      end
       
       # 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)
+        target = path(target)
         
         case
+        when target == Dir.pwd
         when File.exists?(target)
           log_relative :exists, target
         else
@@ -37,7 +47,7 @@ module Tap
         source_file.close
         
         source = source_file.path
-        target = File.expand_path(target)
+        target = path(target)
         
         copy_file = true
         msg = case
@@ -67,6 +77,12 @@ module Tap
         :generate
       end
       
+      def to_spec
+        spec = super
+        spec['mixin'] = 'Tap::Generator::Generate'
+        spec
+      end
+      
       protected
       
       # Ask the user interactively whether to force collision.
@@ -77,7 +93,7 @@ module Tap
         prompt_out.print "overwrite #{target}? [Ynaiq] "
         prompt_out.flush
         case prompt_in.gets.strip
-        when /^y(es)?$/i
+        when /^y(es)?$/i, ''
           true
         when /^n(o)?$/i
           false

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

@@ -72,36 +72,24 @@ module Tap::Generator::Generators
     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
-    config :type, 'task'                # Specify the resource type
-    
-    # Lookup the named resource.  Lookup happens through the active Env 
-    # instance, specifically using:
-    #
-    #   Env.instance[type][name]
-    #
-    # Raises an error if the name cannot be resolved to a resource.
-    def lookup(name)
-      env = Tap::Env.instance
-      env[type][name] or raise "unknown #{type}: #{name}"
-    end
-    
+
     def manifest(m, name, config_name=nil)
       # setup
-      tasc = lookup(name)
-      config_name ||= tasc.to_s.underscore
+      clas = app.env.constant(name)
+      config_name ||= clas.to_s.underscore
       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,
+        clas.configurations,
         config_file, 
         nest, 
         true, 
         &format_block)
       
       # now put the dumps to the manifest
-      m.directory(path('config'))
+      m.directory 'config'
       
       dumps.each do |path, content|
         next if content.empty? && !blanks

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

@@ -0,0 +1,106 @@
+require 'tap/generator/base'
+
+module Tap
+  module Generator
+    module Generators
+      # :startdoc::generator generate a tapenv file
+      class Env < Tap::Generator::Base
+        
+        config :pattern, '**/*.rb', &c.string   # the glob pattern under each path
+        config :lib, 'lib', &c.string           # the lib dir
+        config :pathfile, 'tap.yml', &c.string  # the pathfile
+        config :register, true, &c.switch       # register resource paths
+        config :load_paths, true, &c.switch     # set load paths
+        config :set, true, &c.switch            # set constants
+        config :gems, [], 
+          :long => :gem, 
+          &c.list                               # gems to add
+        config :tapenv, 'tapenv', &c.string     # the tapenv file name
+        config :use_organize, true,
+          :long => :organize,
+          &c.switch                             # organize results a bit
+        
+        def manifest(m, *paths)
+          lines = []
+          paths.each do |path|
+            lines.concat Tap::Env.generate(options(path))
+          end
+          
+          gem_options.each do |options|
+            lines.concat Tap::Env.generate(options)
+          end
+          
+          lines.uniq!
+          
+          if use_organize
+            lines = organize(lines)
+          end
+          
+          m.file(tapenv) do |io|
+            lines.each {|line| io.puts line }
+          end
+        end
+        
+        def options(path)
+          config.to_hash.merge(:dir => path)
+        end
+        
+        def gem_options
+          specs = []
+          gems.each do |gem_name|
+            gem_name =~ /\A(.*?)([\s<>=~].+)?\z/
+            dependency = Gem::Dependency.new($1, $2)
+            collect_specs(dependency, specs)
+          end
+          
+          most_recent_specs = {}
+          specs.sort_by do |spec|
+            spec.version
+          end.reverse_each do |spec|
+            most_recent_specs[spec.name] ||= spec
+          end
+          
+          most_recent_specs.values.collect do |spec|
+            pathfile = File.join(spec.full_gem_path, 'tap.yml')
+            map = Tap::Env::Path.load(pathfile)
+            map.merge!('lib' => spec.require_paths)
+            
+            {
+              :dir => spec.full_gem_path,
+              :lib => 'lib',
+              :map => map,
+              :set => File.exists?(pathfile)
+            }
+          end
+        end
+        
+        def organize(lines)
+          sets, everything_else = lines.partition {|line| line.index('set ') == 0 }
+          sets.collect! {|set| set.split(' ', 4) }
+          
+          cmax = sets.collect {|set| set[1].length }.max
+          rmax = sets.collect {|set| set[2].length }.max
+          format = "%s %-#{cmax}s %-#{rmax}s %s"
+          sets.collect! {|set| format % set }
+          
+          lines = everything_else + sets
+          lines.sort!
+          lines
+        end
+        
+        protected
+        
+        def collect_specs(dependency, specs) # :nodoc:
+          Gem.source_index.search(dependency).each do |spec|
+            unless specs.include?(spec)
+              specs << spec
+              spec.runtime_dependencies.each do |dep|
+                collect_specs(dep, specs)
+              end
+            end
+          end
+        end
+      end 
+    end
+  end
+end