tap 0.10.0 → 0.10.1

data/lib/tap/support/framework_class.rb

@@ -8,9 +8,9 @@ module Tap
        
       # Returns the default name for the class: to_s.underscore
       attr_accessor :default_name
-           
+      
       def self.extended(base)
-        caller.each_with_index do |line, index|
+        caller.each do |line|
           case line
           when /\/framework.rb/ then next
           when /^(([A-z]:)?[^:]+):(\d+)/
@@ -66,7 +66,8 @@ module Tap
           when /\/tap\/support\/declarations.rb/ then next
           when /^(([A-z]:)?[^:]+):(\d+)/
             subclass.source_file = File.expand_path($1)
-            subclass.lazydoc[const_name, false]['manifest'] = subclass.lazydoc.register($3.to_i - 1)
+            lzd = subclass.lazydoc(false)
+            lzd[const_name, false]['manifest'] = lzd.register($3.to_i - 1)            
             break
           end
         end
@@ -82,13 +83,14 @@ module Tap
           array.join(' ')
         else ""
         end
-        subclass.lazydoc[const_name, false]['args'] ||= comment
+        subclass.lazydoc(false)[const_name, false]['args'] ||= comment
         
         # Set the subclass constant
         current.const_set(subclass_const, subclass)
       end
       
-      DEFAULT_HELP_TEMPLATE = %Q{<%= task_class %><%= manifest.subject.to_s.strip.empty? ? '' : ' -- ' %><%= manifest.subject %>
+      DEFAULT_HELP_TEMPLATE = %Q{<% manifest = task_class.manifest %>
+<%= task_class %><%= manifest.subject.to_s.strip.empty? ? '' : ' -- ' %><%= manifest.subject %>
 
 <% unless manifest.empty? %>
 <%= '-' * 80 %>
@@ -122,8 +124,6 @@ module Tap
         opts.separator "options:"
 
         opts.on_tail("-h", "--help", "Print this help") do
-          args = lazydoc(true)[to_s]['args'] || Tap::Support::Comment.new
-
           opts.banner = "#{help}usage: tap run -- #{to_s.underscore} #{args.subject}"
           puts opts
           exit
@@ -166,33 +166,14 @@ module Tap
         [obj.reconfigure(path_configs).reconfigure(config), argv + use_args]
       end
       
-      def lazydoc(resolve=false, args_method=:process)
-        if resolve
-          lazydoc = super(false)
-          lazydoc.resolve(nil, /^\s*def\s+#{args_method}(\((.*?)\))?/) do |comment, match|
-            comment.subject = 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.join(', ')
-
-            lazydoc.default_attributes['args'] ||= comment
-          end
-          
-          super(true)
-        else       
-          super(false)
-        end
+      def lazydoc(resolve=true)
+        lazydoc = super(false)
+        lazydoc.register_method_pattern('args', :process) unless lazydoc.resolved?
+        super
       end
-      
+
       def help
-        Tap::Support::Templater.new(DEFAULT_HELP_TEMPLATE, 
-          :task_class => self, 
-          :manifest => lazydoc(true)[to_s]['manifest'] || Tap::Support::Comment.new
-        ).build
+        Tap::Support::Templater.new(DEFAULT_HELP_TEMPLATE, :task_class => self).build
       end
     end
   end

data/lib/tap/support/gems.rb

@@ -0,0 +1,63 @@
+autoload(:Gem, 'rubygems')
+
+module Tap
+  module Support
+    module Gems
+      module_function
+      
+      # Finds the home directory for the user (method taken from Rubygems).
+      def find_home
+        ['HOME', 'USERPROFILE'].each do |homekey|
+          return ENV[homekey] if ENV[homekey]
+        end
+
+        if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
+          return "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+        end
+
+        begin
+          File.expand_path("~")
+        rescue
+          if File::ALT_SEPARATOR then
+              "C:/"
+          else
+              "/"
+          end
+        end
+      end
+
+      # The home directory for the user.
+      def user_home
+        @user_home ||= find_home
+      end
+      
+      # Returns the gemspec for the specified gem.  A gem version 
+      # can be specified in the name, like 'gem >= 1.2'.  The gem 
+      # will be activated using +gem+ if necessary.
+      def gemspec(gem_name)
+        return gem_name if gem_name.kind_of?(Gem::Specification)
+        
+        # figure the version of the gem, by default >= 0.0.0
+        gem_name.to_s =~ /^([^<=>]*)(.*)$/
+        name, version = $1.strip, $2
+        version = ">= 0.0.0" if version.empty?
+        
+        return nil if name.empty?
+        
+        # load the gem and get the spec
+        gem(name, version)
+        Gem.loaded_specs[name]
+      end
+      
+      def select_gems(latest=true)
+        index = latest ?
+          Gem.source_index.latest_specs :
+          Gem.source_index.gems.collect {|(name, spec)| spec }
+        
+        index.select do |spec|
+          yield(spec)
+        end.sort
+      end
+    end
+  end
+end

data/lib/tap/support/gems/rake.rb

@@ -0,0 +1,90 @@
+require 'rake'
+require 'tap'
+
+module Tap
+  module Support
+    module Gems
+      class RakeManifest < Support::Manifest
+        def initialize(env)
+          @env = env
+          rake = ::Rake.application
+          super(rake.have_rakefile(env.root.root) ? [rake.instance_variable_get(:@rakefile)] : [])
+        end
+      end
+    
+      module Rake
+
+        def self.extended(base)
+          Tap::Env.instance_for(Dir.pwd).activate unless Tap::Env.instance
+          base.env = Tap::Env.instance
+        end
+      
+        attr_accessor :env
+       
+        def collect_tasks
+          ARGV.collect! do |arg|
+            next(arg) unless arg =~ /^:([a-z_\d]+):(.*)$/
+            env_pattern = $1
+            rake_task = $2
+          
+            next(arg) unless entry = env.find(:envs, env_pattern, false)
+          
+            mini_path, env = entry
+            root_path = env.root.root
+          
+            if have_rakefile(root_path)
+              # load sequence echos that in raw_load_rakefile
+              puts "(in #{root_path})" unless options.silent
+              current_global_rakefile = $rakefile
+              $rakefile = @rakefile
+            
+              namespaces = Tap::Root.split(mini_path, false).delete_if do |segment| 
+                segment.empty?
+              end
+            
+              #if @rakefile != ''
+              eval nest_namespace(%Q{load "#{File.join(root_path, @rakefile)}"}, namespaces.dup)
+              #end
+            
+              $rakefile = current_global_rakefile
+              @rakefile = nil
+            
+              namespaces << rake_task
+              namespaces.join(":")
+            else
+              fail "No Rakefile found for '#{env_pattern}' (looking for: #{@rakefiles.join(', ')})"
+            end
+          end
+        
+          super
+        end
+      
+        def have_rakefile(indir=nil)
+          return super() if indir == nil
+          Tap::Root.indir(indir) { super() }
+        end
+
+        protected
+      
+        NAMESPACE_STR = %Q{
+namespace(:'%s') do
+  %s
+end
+}.strip
+      
+        def nest_namespace(nest_str, namespaces)
+          return nest_str if namespaces.empty?
+        
+          NAMESPACE_STR % [
+            namespaces.shift, 
+            namespaces.empty? ? nest_str : nest_namespace(nest_str, namespaces)
+          ]
+        end
+      end
+    end
+  end
+end
+
+Rake.application.extend Tap::Support::Gems::Rake
+Tap::Env.manifests[:rakefiles] = Tap::Support::RakeManifest
+

data/lib/tap/support/instance_configuration.rb

@@ -41,9 +41,9 @@ module Tap
       # The ClassConfiguration specifying config keys
       attr_reader :class_config
       
-      def initialize(class_config, receiver=nil)
+      def initialize(class_config, receiver=nil, store={})
         @receiver = receiver
-        @store = {}
+        @store = store
         @class_config = class_config
       end
       
@@ -54,7 +54,7 @@ module Tap
         raise ArgumentError.new("receiver cannot be nil") if receiver == nil
         
         class_config.each_pair do |key, config|
-          receiver.send(config.writer, store.delete(key))
+          receiver.send(config.writer, store.delete(key)) if config.writer
         end
         @receiver = receiver
         
@@ -70,7 +70,7 @@ module Tap
       # are stored in store.  Returns the unbound receiver.
       def unbind
         class_config.each_pair do |key, config|
-          store[key] = receiver.send(config.reader)
+          store[key] = receiver.send(config.reader) if config.reader
         end
         r = receiver
         @receiver = nil
@@ -92,7 +92,7 @@ module Tap
       def []=(key, value)
         case 
         when bound? && config = class_config.map[key.to_sym]
-          receiver.send(config.writer, value)
+          config.writer ? receiver.send(config.writer, value) : store[key] = value
         else store[key] = value
         end
       end
@@ -103,7 +103,7 @@ module Tap
       def [](key)
         case 
         when bound? && config = class_config.map[key.to_sym]
-          receiver.send(config.reader)
+          config.reader ? receiver.send(config.reader) : store[key]
         else store[key]
         end
       end
@@ -116,7 +116,7 @@ module Tap
       # Calls block once for each key-value pair stored in self.
       def each_pair # :yields: key, value
         class_config.each_pair do |key, config|
-          yield(key, receiver.send(config.reader))
+          yield(key, receiver.send(config.reader)) if config.reader
         end if bound?
         
         store.each_pair do |key, value|
@@ -126,7 +126,7 @@ module Tap
       
       # Equal if the to_hash values of self and another are equal.
       def ==(another)
-        to_hash == another.to_hash
+        another.respond_to?(:to_hash) && to_hash == another.to_hash
       end
       
       # Returns self as a hash. 

data/lib/tap/support/lazy_attributes.rb

@@ -0,0 +1,30 @@
+require 'tap/support/lazydoc'
+
+module Tap
+  module Support
+    module LazyAttributes
+      
+      # The source_file for self.  Must be set independently.
+      attr_accessor :source_file
+      
+      # Returns the lazydoc for source_file
+      def lazydoc(resolve=true)
+        lazydoc = Lazydoc[source_file]
+        lazydoc.resolve if resolve
+        lazydoc
+      end
+      
+      # Creates a lazy attribute reader for the specified attribute.
+      def lazy_attr(key, attribute=key)
+        instance_eval %Q{def #{key}; @#{key} ||= get_lazy_attr('#{attribute}'); end}
+      end
+      
+      private
+      
+      def get_lazy_attr(attribute)
+        lazydoc[self.to_s][attribute] || (lazydoc.attributes(self.to_s)[attribute] = Tap::Support::Comment.new)
+      end
+      
+    end 
+  end
+end

data/lib/tap/support/lazydoc.rb

@@ -10,8 +10,7 @@ module Tap
     #
     # Constant attributes are designated the same as constants in Ruby, but with
     # an extra 'key' constant that must consist of only lowercase letters and/or
-    # underscores.  This format assures that attributes are sytactically invalid
-    # outside of comments.
+    # underscores.  Attributes are only parsed from comment lines.
     #
     # When Lazydoc finds an attribute it parses a Comment value where the subject
     # is the remainder of the line, and comment lines are parsed down until a
@@ -49,6 +48,8 @@ module Tap
     #   # Const::Name::not_parsed
     #   # :::+
     #
+    #   Const::Name::not_parsed
+    #
     #   # Const::Name::parsed subject
     #   }
     #
@@ -127,10 +128,10 @@ module Tap
       # $3:: key
       # $4:: end flag
       #
-      ATTRIBUTE_REGEXP = /(::|([A-Z][A-z]*::)+)([a-z_]+)(-?)/
-      
-      # A regexp matching constants.
-      CONSTANT_REGEXP = /(::|([A-Z][A-z]*::)+)/
+      ATTRIBUTE_REGEXP = /([A-Z][A-z]*(::[A-Z][A-z]*)*)?::([a-z_]+)(-?)/
+    
+      # A regexp matching constants from the ATTRIBUTE_REGEXP leader
+      CONSTANT_REGEXP = /#.*?([A-Z][A-z]*(::[A-Z][A-z]*)*)?$/
       
       class << self
         
@@ -159,7 +160,7 @@ module Tap
         end
         
         # Resolves all lazydocs which include the specified code comments.
-        def resolve(code_comments)
+        def resolve_comments(code_comments)
           registry.each do |doc|
             next if (code_comments & doc.code_comments).empty?
             doc.resolve
@@ -185,14 +186,16 @@ module Tap
         # and <tt>:+</tt>.
         #
         #   str = %Q{
-        #   Const::Name::key value
-        #   ::alt alt_value
+        #   # Const::Name::key value
+        #   # ::alt alt_value
+        #   #
+        #   # Ignored::Attribute::not_matched value
+        #   # :::-
+        #   # Also::Ignored::key value
+        #   # :::+
+        #   # Another::key another value
         #
-        #   Ignored::Attribute::not_matched value
-        #   :::-
-        #   Also::Ignored::key value
-        #   :::+
-        #   Another::key another value
+        #   Ignored::key value
         #   }
         #
         #   results = []
@@ -213,17 +216,17 @@ module Tap
           when String then StringScanner.new(str)
           else raise TypeError, "can't convert #{str.class} into StringScanner or String"
           end
-   
-          regexp = /(#{key})([ \r\t-].*$|$)/
+
+          regexp = /^(.*?)::(:-|#{key})/
           while !scanner.eos?
-            break if scanner.skip_until(CONSTANT_REGEXP) == nil
-            const_name = scanner[1]
-            
-            case
-            when scanner.scan(regexp)
-              yield(const_name.chomp('::'), scanner[1], scanner[2].strip)
-            when scanner.scan(/:-/)
-              scanner.skip_until(/:\+/)
+            break if scanner.skip_until(regexp) == nil
+
+            if scanner[2] == ":-"
+              scanner.skip_until(/:::\+/)
+            else
+              next unless scanner[1] =~ CONSTANT_REGEXP
+              key = scanner[2]
+              yield($1.to_s, key, scanner.matched.strip) if scanner.scan(/[ \r\t].*$|$/)
             end
           end
         
@@ -267,9 +270,9 @@ module Tap
           
           scan(scanner, '[a-z_]+') do |const_name, key, value|
             comment = Comment.parse(scanner, false) do |line|
-              if line =~ /::/ && line =~ ATTRIBUTE_REGEXP
+              if line =~ ATTRIBUTE_REGEXP
                 # rewind to capture the next attribute unless an end is specified.
-                scanner.unscan unless !$4.empty? && $1.chomp("::") == const_name && $3 == key
+                scanner.unscan unless $4 == '-' && $3 == key && $1.to_s == const_name
                 true
               else false
               end
@@ -294,10 +297,13 @@ module Tap
       # attributes resolved or to-be-resolved for self.  Attributes
       # are hashes of (key, comment) pairs.
       attr_reader :const_attrs
-
+      
+      attr_reader :patterns
+      
       def initialize(source_file=nil)
         self.source_file = source_file
         @code_comments = []
+        @patterns = {}
         @const_attrs = {}
         @resolved = false
       end
@@ -364,6 +370,25 @@ module Tap
         comment
       end
       
+      def register_pattern(key, regexp, &block) # :yields: comment, match
+        patterns[key] = [regexp, block]
+      end
+      
+      def register_method_pattern(key, method, range=0..-1)
+        register_pattern(key, /^\s*def\s+#{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
+          
+          comment.subject = args[range].join(', ')
+        end
+      end
+      
       # Returns true if the code_comments for source_file are frozen.
       def resolved?
         @resolved
@@ -371,7 +396,7 @@ module Tap
       
       attr_writer :resolved
       
-      def resolve(str=nil, comment_regexp=nil) # :yields: comment, match
+      def resolve(str=nil)
         return(false) if resolved?
         
         if str == nil 
@@ -384,11 +409,18 @@ module Tap
         end
         
         lines = str.split(/\r?\n/)
-        lines.each_with_index do |line, line_number|
-          next unless line =~ comment_regexp
-          comment = register(line_number)
-          yield(comment, $~) if block_given?
-        end unless comment_regexp == nil
+        
+        patterns.each_pair do |key, (regexp, block)|
+          next if default_attributes.has_key?(key)
+          
+          lines.each_with_index do |line, line_number|
+            next unless line =~ regexp
+            
+            comment = register(line_number)
+            default_attributes[key] = comment
+            break if block.call(comment, $~)
+          end
+        end unless patterns.empty?
           
         code_comments.collect! do |comment|
           line_number = comment.line_number