tap 0.11.1 → 0.12.0

data/bin/rap

@@ -1,118 +0,0 @@
-#!/usr/bin/env ruby
-# usage: rap taskname {options} [args]
-
-$:.unshift "#{File.dirname(__FILE__)}/../lib"
-require 'tap/declarations'
-
-# setup the environment
-begin
-  
-  # handle super options
-  $DEBUG = true if ARGV.delete('-d-')
-  env = Tap::Exe.instantiate
-  env.unshift(Tap::Declarations.env)
-
-  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)
-  end
-  
-rescue(Tap::Env::ConfigError)
-  # catch errors and exit gracefully
-  # (errors usu from gem loading errors)
-  puts $!.message
-  exit(1)
-end
-
-#
-# setup after script
-#
-
-at_exit do
-  begin
-    eval(env.after) if env.after != nil
-  rescue(Exception)
-    puts "Error in after script."
-    env.handle_error($!)
-    exit(1)
-  end
-end
-
-#
-# run before script
-#
-
-begin
-  eval(env.before) if env.before != nil
-rescue(Exception)
-  puts "Error in before script."
-  env.handle_error($!)
-  exit(1)
-end 
-
-#
-# run rap
-#
-
-module Tap
-  module Tasks
-    autoload(:Rake, 'tap/tasks/rake')
-  end
-end
-
-begin
-  env.activate
-  
-  case ARGV[0]
-  when '--help', nil, '-T'
-    rap_template = %Q{<% if count > 1 && !entries.empty? %>
-<%= env_name %>:
-<% end %>
-<% entries.each do |name, const| %>
-<%   desc = if const.require_path == nil # should be a declaration %>
-<%     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 %>}
-
-    puts Tap::Support::Lazydoc.usage(__FILE__)
-    puts
-    puts "===  tap tasks ==="
-    puts env.summarize(:tasks, rap_template)
-    puts
-    puts "=== rake tasks ==="
-    Tap::Tasks::Rake.new.enq('-T')
-    Tap::App.instance.run
-    
-    # this is not currently reached as rake exits on -T
-    puts
-    puts "version #{Tap::VERSION} -- #{Tap::WEBSITE}"
-    exit
-  else
-    queues = env.build(ARGV) do |args|
-      warn "warning: implict rake for [#{args.join(' ')}]"
-      Tap::Tasks::Rake
-    end
-    ARGV.clear
-
-    if queues.empty?
-      puts "no task specified"
-      exit
-    end
-  
-    env.set_signals
-    env.run(queues)
-  end
-  
-rescue
-  env.handle_error($!)
-end
-
-exit(0)

data/cgi/run.rb

@@ -1,97 +0,0 @@
-# ::summary
-# runs a task
-#
-# ::description
-# 
-############################
-require 'cgi'
-require "#{File.dirname(__FILE__)}/../vendor/url_encoded_pair_parser"
-
-env = Tap::Env.instance
-
-module Tap
-  module Support
-    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] ||= []
-          values.each do |value|
-            value = value.respond_to?(:read) ? value.read : value
-            if $~ 
-              slot.concat(Shellwords.shellwords(value))
-            else 
-              slot << value
-            end
-          end
-        end
-
-        UrlEncodedPairParser.new(pairs).result   
-      end
-    end
-  end
-end
-
-cgi = CGI.new("html3")  # add HTML generation methods
-cgi.out() do
-  case cgi.request_method
-  when /GET/i
-    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
-      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
-        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'
-
-    else
-      # run
-      cgi.pre do
-        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

data/lib/tap/declarations.rb

@@ -1,229 +0,0 @@
-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(.*)/
-            desc.to_s
-          else
-            content[0].shift
-            $1.strip
-          end
-          
-          self
-        end
-      end
-    end
-    
-    module Rakish
-      def new(*args)
-        @instance ||= super
-        @instance.app.dependencies.register(@instance)
-        @instance
-      end
-    end
-    
-    def self.extended(base)
-      declaration_base = base.to_s
-      case declaration_base
-      when "Object", "Tap", "main"
-        declaration_base = ""
-      end
-      
-      base.instance_variable_set(:@declaration_base, declaration_base.underscore)
-      base.instance_variable_set(:@current_desc, nil)
-    end
-    
-    def self.env
-      @env ||= Tap::Env.instance_for(Dir.pwd)
-    end
-    
-    def declaration_env
-      @declaration_env ||= Declarations.env
-    end
-    
-    attr_writer :declaration_base
-    
-    def declaration_base
-      @declaration_base ||= ''
-    end
-    
-    attr_writer :current_desc
-    
-    def current_desc
-      @current_desc ||= nil
-    end
-    
-    def task(*args, &block)
-      const_name, configs, dependencies, arg_names = resolve_args(args)
-      task_class = declare(const_name, configs, dependencies) do |*inputs|
-        # collect inputs to make a rakish-args object
-        args = {}
-        arg_names.each do |arg_name|
-          break if inputs.empty?
-          args[arg_name] = inputs.shift
-        end
-        args = OpenStruct.new(args)
-        
-        # execute each block assciated with this task
-        self.class::BLOCKS.each do |task_block|
-          case task_block.arity
-          when 0 then task_block.call()
-          when 1 then task_block.call(self)
-          else task_block.call(self, args)
-          end
-        end
-        
-        nil
-      end
-      register_doc(task_class, arg_names)
-      
-      # add the block to the task
-      unless task_class.const_defined?(:BLOCKS)
-        task_class.const_set(:BLOCKS, [])
-      end
-      task_class::BLOCKS << block unless block == nil
-      task_class.instance
-    end
-    
-    def namespace(name, &block)
-      current_base = declaration_base
-      @declaration_base = File.join(current_base, name.to_s.underscore)
-      yield
-      @declaration_base = current_base
-    end
-    
-    def desc(str)
-      self.current_desc = str
-    end
-    
-    protected
-    
-    # Resolve the arguments for a task/rule.  Returns an array of
-    # [task_name, configs, needs, arg_names].
-    #
-    # Adapted from Rake 0.8.3
-    # Changes:
-    # - no :needs support for the trailing Hash (which is now config)
-    def resolve_args(args)
-      task_name = args.shift
-      arg_names = args
-      configs = {}
-      needs = []
-      
-      if task_name.is_a?(Hash)
-        hash = task_name
-        task_name = hash.keys[0]
-        needs = hash[task_name]
-      end
-      
-      if arg_names.last.is_a?(Hash)
-        configs = arg_names.pop
-      end
-      
-      needs = needs.respond_to?(:to_ary) ? needs.to_ary : [needs]
-      needs = needs.compact.collect do |need|
-        unless need.kind_of?(Class)
-          name = normalize_name(need).camelize
-          need = Support::Constant.constantize(name) do |base, constants|
-            declare(name)
-          end
-        end
-  
-        unless need.ancestors.include?(Tap::Task)
-          raise ArgumentError, "not a task: #{need}"
-        end
-        
-        need
-      end
-      
-      [normalize_name(task_name), configs, needs, arg_names]
-    end
-    
-    def normalize_name(name)
-      name.to_s.underscore.tr(":", "/")
-    end
-    
-    def declare(name, configs={}, dependencies=[], &block)
-      const_name = File.join(declaration_base, name).camelize
-      
-      # generate the subclass
-      subclass = Support::Constant.constantize(const_name) do |base, constants|
-        constants.each do |const|
-          # nesting Tasks into Tasks is required for
-          # namespaces with the same name as a task
-          base = base.const_set(const, Class.new(Tap::Task))
-        end
-        base
-      end
-
-      subclass.extend Rakish
-      
-      configs.each_pair do |key, value|
-        subclass.send(:config, key, value)
-      end
-      
-      dependencies.each do |dependency|
-        dependency_name = File.basename(dependency.default_name)
-        subclass.send(:depends_on, dependency_name, dependency)
-      end
-      
-      if block_given?
-        subclass.send(:undef_method, :process) if subclass.method_defined?(:process)
-        subclass.send(:define_method, :process, &block)
-      end
-      
-      # update any dependencies in instance
-      subclass.dependencies.each do |dependency|
-        subclass.instance.depends_on(dependency.instance)
-      end
-      
-      # register the subclass in the manifest
-      manifest = declaration_env.tasks
-      const_name = subclass.to_s
-      unless manifest.entries.any? {|const| const.name == const_name }
-        manifest.entries << Tap::Support::Constant.new(const_name)
-      end
-      
-      subclass
-    end
-    
-    def register_doc(task_class, arg_names)
-      
-      # register documentation
-      caller[1] =~ Lazydoc::CALLER_REGEXP
-      task_class.source_file = File.expand_path($1)
-      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.collect {|name| name.to_s.upcase }.join(' ')
-        task_class.args = comment
-      end
-
-      task_class
-    end
-  end
-  
-  extend Declarations
-end

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

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