bahuvrihi-tap 0.11.0 → 0.11.1

data/bin/rap

@@ -12,10 +12,11 @@ begin
   env = Tap::Exe.instantiate
   env.unshift(Tap::Declarations.env)
 
-  task_file = File.expand_path('Tapfile')
-  if File.exists?(task_file)
+  Dir.glob('[TtRr]apfile{,.rb}').each do |task_file|
+    task_file  = File.expand_path(task_file)
+    next unless File.file?(task_file)
+    
     env.loads.unshift(task_file)
-    env.tasks.register(Dir.pwd, 'Tapfile')
   end
   
 rescue(Tap::Env::ConfigError)
@@ -71,12 +72,13 @@ begin
 <% end %>
 <% entries.each do |name, const| %>
 <%   desc = if const.require_path == nil # should be a declaration %>
-<%     manifest = const.constantize.lazydoc[const.name]['manifest'] %>
-<%     next if manifest == nil || manifest.subject.empty? %>
-<%     manifest.subject %>
+<%     manifest = const.constantize.manifest %>
+<%     next if manifest == nil || manifest.subject.to_s.empty? %>
+<%     manifest %>
 <%   else %>
 <%     const.document[const.name]['manifest'] %>
 <%   end %>
+<%   desc = desc.subject.to_s if desc.kind_of?(Tap::Support::Lazydoc::Comment) %>
   <%= name.ljust(width) %><%= desc.empty? ? '' : '  # ' %><%= desc %>
 <% end %>}
 

data/cgi/run.rb

@@ -14,9 +14,19 @@ module Tap
     module Server
       module_function
       
+      def parse_schema(params)
+        argh = pair_parse(params)
+
+        parser = Parser.new
+        parser.parse(argh['nodes'] || [])
+        parser.parse(argh['joins'] || [])
+        parser.schema
+      end
+      
       def pair_parse(params)
         pairs = {}
         params.each_pair do |key, values|
+          next if key == nil
           key = key.chomp("%w") if key =~ /%w$/
 
           slot = pairs[key] ||= []
@@ -40,28 +50,48 @@ cgi = CGI.new("html3")  # add HTML generation methods
 cgi.out() do
   case cgi.request_method
   when /GET/i
-    env.render('run.erb', :env => env, :tascs => [] )
-    
+    schema = Tap::Support::Server.parse_schema(cgi.params).compact
+    env.render('run.erb', :env => env, :schema => schema)
+  
   when /POST/i
     action = cgi.params['action'][0]
     case action
     when 'add'
       index = cgi.params['index'][0].to_i - 1
-      cgi.params['selected_tasks'].collect do |task|
+      sources = cgi.params['sources'].flatten.collect {|source| source.to_i }
+      targets = cgi.params['targets'].flatten.collect {|target| target.to_i }
+      
+      lines = []
+      cgi.params['tasc'].select do |name|
+        name && !name.empty?
+      end.each do |name|
         index += 1
-        tasc = env.tasks.search(task).constantize
-        env.render('run/task.erb', :tasc => tasc, :index => index )
-      end.join("\n")
+        targets << index
+        lines << env.render('run/node.erb', :env => env, :node => Tap::Support::Node.new([name]), :index => index )
+      end
       
+      join = case
+      when sources.length > 1 && targets.length == 1
+        Tap::Support::Schema::Utils.format_merge(sources, targets, {})
+      when sources.length == 1 && targets.length > 0
+        Tap::Support::Schema::Utils.format_fork(sources, targets, {})
+      else nil
+      end
+      
+      lines << env.render('run/join.erb', :env => env, :join => join) if join
+      lines.join("\n")
+    
     when 'remove'
-    when 'update'
+
     else
+      # run
       cgi.pre do
-        argh = Tap::Support::Server.pair_parse(cgi.params)
-        Tap::Support::Schema.parse(argh['schema']).dump.to_yaml
+        schema = Tap::Support::Server.parse_schema(cgi.params)
+        schema.compact.dump.to_yaml
+        #env.build(schema)
       end
     end
   else 
     raise ArgumentError, "unhandled request method: #{cgi.request_method}"
   end
-end
+end

data/cmd/manifest.rb

@@ -27,8 +27,8 @@ end.parse!(ARGV)
 
 env = Tap::Env.instance
 env_names = {}
-env.manifest(:envs, true).minimize.each do |name, environment|
-  env_names[environment] = name
+env.minimap.each do |env_name, environment|
+  env_names[environment] = env_name
 end
 
 filter = case
@@ -57,15 +57,13 @@ width = 10
 summary = env.inspect(template) do |templater, share|
   current = templater.env
   next unless filter.include?(current)
-  
-  manifest_keys = (Tap::Env.manifests.keys + current.manifests.keys).uniq 
-  manifests = manifest_keys.collect do |name|
-    next if name == :envs
-    
-    manifest = current.manifest(name, true)
-    next if manifest.empty?
+
+  manifests = []
+  [:commands, :generators, :tasks].each do |name|
+    manifest = current.send(name)
+    next if manifest.build.empty?
     
-    entries = manifest.minimize.collect do |(entry, path)|
+    entries = manifest.minimap.collect do |(entry, path)|
       path = case path
       when Tap::Support::Constant then path.require_path
       else path
@@ -75,7 +73,7 @@ summary = env.inspect(template) do |templater, share|
       [entry, current.root.relative_filepath(:root, path) || path]
     end
     
-    [name, entries]
+    manifests << [name, entries]
   end
   templater.manifests = manifests.compact
   templater.env_name = env_names[current]

data/doc/Tutorial

@@ -27,7 +27,7 @@ Now from the command line:
   --------------------------------------------------------------------------------
     Says goodnight with a configurable message.
   --------------------------------------------------------------------------------
-  usage: tap run -- goodnight obj
+  usage: rap goodnight OBJ
 
   configurations:
           --message MESSAGE
@@ -45,7 +45,7 @@ The declaration syntax is obviously similar to rake; configurations are new but
   
   # make the declarations available everywhere
   # (normally they're accessed via Tap, as above)
-  extend Tap::Declarations
+  include Tap::Declarations
   
   namespace :example do
     task(:say, :message) do |task, args|
@@ -110,7 +110,7 @@ Simple enough; the name corresponds to the class, configurations (and dependenci
 
 Totally straightforward.  Goodnight stores the default configurations, each instance has accessors to the configurations, and the defaults may be overridden during initialization, or later.  Class definitions allow validation/transformation blocks to be specified for configurations.  These blocks process inputs (ex the string inputs from the command line), quite literally defining the writer for a configuration accessor.  A set of standard blocks are available through +c+, an alias for the Tap::Support::Validation module.
 
-  [Tapfile]
+  [lib/goodnight.rb]
   
   # Goodnight::manifest a fancy goodnight moon task
   # Says goodnight with a configurable message.
@@ -154,7 +154,7 @@ Now from the command line:
   --------------------------------------------------------------------------------
     Says goodnight with a configurable message.
   --------------------------------------------------------------------------------
-  usage: tap run -- goodnight OBJECTS...
+  usage: rap goodnight OBJECTS...
 
   configurations:
           --message MESSAGE            a goodnight message

data/lib/tap/constants.rb

@@ -1,7 +1,7 @@
 module Tap
   MAJOR = 0
   MINOR = 11
-  TINY = 0
+  TINY = 1
   
   VERSION="#{MAJOR}.#{MINOR}.#{TINY}" 
   WEBSITE="http://tap.rubyforge.org"

data/lib/tap/declarations.rb

@@ -2,16 +2,25 @@ require File.dirname(__FILE__) + "/../tap"
 autoload(:OpenStruct, 'ostruct')
 
 module Tap
+  #--
+  # more thought needs to go into extending Tap with Declarations
+  # and there should be some discussion on why include works at
+  # the top level (for main/Object) while extend should be used
+  # in all other cases.
   module Declarations
     Lazydoc = Tap::Support::Lazydoc
+    include Tap::Support::ShellUtils
     
     module Lazydoc
       class Declaration < Comment
+        attr_accessor :desc
+        
         def resolve(lines)
           super
           
           @subject = case
-          when content.empty? || content[0][0].to_s !~ /^::desc(.*)/ then ""
+          when content.empty? || content[0][0].to_s !~ /^::desc(.*)/
+            desc.to_s
           else
             content[0].shift
             $1.strip
@@ -42,16 +51,24 @@ module Tap
     end
     
     def self.env
-      @env ||= Tap::Env.new(:load_paths => [], :command_paths => [], :generator_paths => [])
+      @env ||= Tap::Env.instance_for(Dir.pwd)
+    end
+    
+    def declaration_env
+      @declaration_env ||= Declarations.env
     end
     
-    def env
-      @env ||= Declarations.env
+    attr_writer :declaration_base
+    
+    def declaration_base
+      @declaration_base ||= ''
     end
     
-    attr_accessor :declaration_base
+    attr_writer :current_desc
     
-    attr_accessor :current_desc
+    def current_desc
+      @current_desc ||= nil
+    end
     
     def task(*args, &block)
       const_name, configs, dependencies, arg_names = resolve_args(args)
@@ -93,8 +110,7 @@ module Tap
     end
     
     def desc(str)
-      self.current_desc = Lazydoc::Comment.new
-      current_desc.subject = str
+      self.current_desc = str
     end
     
     protected
@@ -179,12 +195,12 @@ module Tap
       end
       
       # register the subclass in the manifest
-      manifest = env.tasks
+      manifest = declaration_env.tasks
       const_name = subclass.to_s
-      unless manifest.find {|const| const.name == const_name }
+      unless manifest.entries.any? {|const| const.name == const_name }
         manifest.entries << Tap::Support::Constant.new(const_name)
       end
-
+      
       subclass
     end
     
@@ -193,16 +209,18 @@ module Tap
       # register documentation
       caller[1] =~ Lazydoc::CALLER_REGEXP
       task_class.source_file = File.expand_path($1)
-      lazydoc = task_class.lazydoc(false)
-      lazydoc[task_class.to_s]['manifest'] = current_desc || lazydoc.register($3.to_i - 1, Lazydoc::Declaration)
+      manifest = task_class.lazydoc(false).register($3.to_i - 1, Lazydoc::Declaration)
+      manifest.desc = current_desc
+      task_class.manifest = manifest
+      
+      self.current_desc = nil
       
       if arg_names
         comment = Lazydoc::Comment.new
-        comment.subject = arg_names.join(' ')
-        lazydoc[task_class.to_s]['args'] = comment
+        comment.subject = arg_names.collect {|name| name.to_s.upcase }.join(' ')
+        task_class.args = comment
       end
-      
-      self.current_desc = nil
+
       task_class
     end
   end

data/lib/tap/exe.rb

@@ -74,7 +74,8 @@ module Tap
     end
 
     def build(argv=ARGV)
-      Support::Schema.parse(argv).compact.build(app) do |args|
+      schema = argv.kind_of?(Support::Schema) ? argv : Support::Schema.parse(argv)
+      schema.compact.build(app) do |args|
         task = args.shift
         const = tasks.search(task) 
         

data/lib/tap/support/constant_manifest.rb

@@ -71,7 +71,7 @@ module Tap
         
         search_paths[search_path_index, search_paths.length - search_path_index].each do |(path_root, paths)|
           paths[path_index, paths.length - path_index].each do |path|
-            new_entries = resolve(path_root, path) - entries
+            new_entries = resolve(path_root, path)
             entries.concat(new_entries)
             
             @path_index += 1
@@ -95,17 +95,24 @@ module Tap
       # filepath from path_root to path.
       def resolve(path_root, path)
         entries = []
-        if document = Lazydoc.scan_doc(path, const_attr)
-          if document.default_const_name.empty?
-            relative_path = Root.relative_filepath(path_root, path).chomp(File.extname(path))
-            document.default_const_name = relative_path.camelize
+        lazydoc = nil
+        
+        Lazydoc.scan(File.read(path), const_attr) do |const_name, attr_key, comment|
+          if lazydoc == nil
+            lazydoc = Lazydoc[path]
+            
+            if lazydoc.default_const_name.empty?
+              relative_path = Root.relative_filepath(path_root, path).chomp(File.extname(path))
+              lazydoc.default_const_name = relative_path.camelize
+            end
           end
           
-          document.const_attrs.each_pair do |const_name, attrs|
-            if attrs.has_key?(const_attr)
-              entries << Constant.new(const_name, path)
-            end
+          if const_name.empty? 
+            const_name = lazydoc.default_const_name
           end
+          
+          lazydoc[const_name][attr_key] = comment
+          entries << Constant.new(const_name, path)
         end
         
         entries

data/lib/tap/support/executable.rb

@@ -204,19 +204,22 @@ module Tap
       # Adds the dependency to each member in batch (and implicitly self).
       # The dependency will be resolved with the input arguments during 
       # _execute, using resolve_dependencies.
-      def depends_on(dependency)
+      def depends_on(*dependencies)
         batch.each do |e| 
-          e.unbatched_depends_on(dependency)
+          e.unbatched_depends_on(*dependencies)
         end
         self
       end
       
       # Like depends_on, but only adds the dependency to self.
-      def unbatched_depends_on(dependency)
-        raise ArgumentError, "cannot depend on self" if dependency == self
+      def unbatched_depends_on(*dependencies)
+        raise ArgumentError, "cannot depend on self" if dependencies.include?(self)
+        
+        dependencies.each do |dependency|
+          app.dependencies.register(dependency)
+          self.dependencies << dependency unless self.dependencies.include?(dependency)
+        end
         
-        app.dependencies.register(dependency)
-        dependencies << dependency unless dependencies.include?(dependency)
         self
       end
       

data/lib/tap/support/lazy_attributes.rb

@@ -29,17 +29,17 @@ module Tap
         lazydoc
       end
       
-      # Creates a lazy attribute reader for the specified attribute.
+      # Creates a lazy attribute accessor 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) # :nodoc:
-        lazydoc[self.to_s][attribute] ||= Lazydoc::Comment.new
+        instance_eval %Q{
+        def #{key}
+          lazydoc[to_s]['#{attribute}'] ||= Lazydoc::Comment.new
+        end
+
+        def #{key}=(comment)
+          Lazydoc[source_file][to_s]['#{attribute}'] = comment
+        end}
       end
-      
     end 
   end
 end

data/lib/tap/support/lazydoc/method.rb

@@ -15,7 +15,7 @@ module Tap
             end
           end
 
-          @subject = args.join(', ')
+          @subject = args.join(' ')
           self
         end
       end

data/lib/tap/support/schema.rb

@@ -259,7 +259,7 @@ module Tap
 
         # build the workflow
         joins.each_pair do |join, (source_node, target_nodes)|
-          raise "unassigned join: #{join}" if source_node == nil
+          raise "unassigned join: #{join}" if source_node == nil || target_nodes.empty?
 
           targets = target_nodes.collect do |target_node|
             tasks[target_node][0]

data/lib/tap/support/shell_utils.rb

@@ -15,9 +15,7 @@ module Tap
     # Commands longer than these limits fail, usually with something like: 'the input
     # line is too long'
     module ShellUtils
-      
-      module_function
-      
+
       # Run the system command +cmd+, passing the result to the block, if given.
       # Raises an error if the command fails. Uses the same semantics as 
       # Kernel::exec and Kernel::system.

data/lib/tap/task.rb

@@ -196,7 +196,12 @@ module Tap
         opts.separator "options:"
 
         opts.on_tail("-h", "--help", "Print this help") do
-          opts.banner = "#{help}usage: tap run -- #{to_s.underscore} #{args.subject}"
+          prg = case $0
+          when /rap$/ then 'rap'
+          else 'tap run --'
+          end
+          
+          opts.banner = "#{help}usage: #{prg} #{to_s.underscore} #{args.subject}"
           if block_given? 
             yield(opts.to_s)
           else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bahuvrihi-tap
 version: !ruby/object:Gem::Version 
-  version: 0.11.0
+  version: 0.11.1
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-09 00:00:00 -07:00
+date: 2008-10-27 00:00:00 -07:00
 default_executable: tap
 dependencies: []