tap 0.10.1 → 0.11.0

data/lib/tap/support/declarations.rb

@@ -1,111 +0,0 @@
-module Tap
-  module Support
-    module Declarations
-      def self.set_declaration_base(base)
-        # TODO -- warn if base is Object -- conflict with Rake
-        declaration_base = base.to_s
-        declaration_base = "" if ["Object", "Tap"].include?(declaration_base)
-
-        base.instance_variable_set(:@tap_declaration_base, declaration_base.underscore)
-      end
-
-      def self.included(base)
-        set_declaration_base(base)
-      end
-
-      def self.extended(base)
-        set_declaration_base(base)
-      end
-
-      def tasc(name, configs={}, options={}, &block)
-        Tap::Task.subclass(nest(name), configs, options, &block)
-      end
-
-      def task(name, configs={}, options={}, &block)
-        options[:arity] = arity(block)
-        tasc(name, configs, options, &task_block(block)).new
-      end
-
-      def file_tasc(name, configs={}, options={}, &block)
-        Tap::FileTask.subclass(nest(name), configs, options, &block)
-      end
-
-      def file_task(name, configs={}, options={}, &block)
-        options[:arity] = arity(block)
-        file_tasc(nest(name), configs, options, &task_block(block)).new
-      end
-
-      def worcflow(name, configs={}, options={}, &block)
-        Tap::Workflow.subclass(nest(name), configs, options, &block)
-      end
-
-      def workflow(name, configs={}, options={}, &block)
-        options[:arity] = arity(block)
-        worcflow(name, configs, options, &task_block(block)).new
-      end
-
-      protected
-
-      def config(key, value=nil, options={}, &block)
-        caller.each do |line|
-          case line
-          when /^(([A-z]:)?[^:]+):(\d+)/
-            options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
-            break
-          end
-        end if options[:desc] == nil
-
-        [:config, key, value, options, block]
-      end
-
-      def config_attr(key, value=nil, options={}, &block)
-        caller.each do |line|
-          case line
-          when /^(([A-z]:)?[^:]+):(\d+)/
-            options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
-            break
-          end
-        end if options[:desc] == nil
-
-        [:config_attr, key, value, options, block]
-      end
-
-      def c
-        Support::Validation
-      end
-
-      private
-
-      def nest(name)
-        # use self if self is a Module or Class, 
-        # or self.class if self is an instance.
-        File.join((self.kind_of?(Module) ? self : self.class).instance_variable_get(:@tap_declaration_base), name.to_s)
-      end
-      
-      def arity(block)
-        arity = block.arity
-        
-        case
-        when arity > 0 then arity -= 1
-        when arity < 0 then arity += 1
-        end
-        
-        arity
-      end
-
-      def task_block(block)
-        lambda do |*inputs|
-          inputs.unshift(self)
-
-          arity = block.arity
-          n = inputs.length
-          unless n == arity || (arity < 0 && (-1-n) <= arity) 
-            raise ArgumentError.new("wrong number of arguments (#{n} for #{arity})")
-          end
-
-          block.call(*inputs)
-        end
-      end
-    end
-  end
-end

data/lib/tap/support/framework.rb

@@ -1,83 +0,0 @@
-require 'tap/support/batchable'
-require 'tap/support/executable'
-require 'tap/support/framework_class'
-
-module Tap
-  module Support
-    
-    # Framework encapsulates the basic framework functionality (batching,
-    # configuration, documentation, etc) used by Task and Workflow. Note 
-    # that Framework does NOT encapsulate the functionality needed to
-    # make a class useful in workflows, such as enq and on_complete.
-    module Framework
-      include Batchable
-      include Configurable
-    
-      def self.included(mod)
-        mod.extend Support::BatchableClass
-        mod.extend Support::ConfigurableClass
-        mod.extend Support::FrameworkClass
-        mod.lazy_attr :manifest
-        mod.lazy_attr :args
-      end
-    
-      # The application used to load config_file templates 
-      # (and hence, to initialize batched objects).
-      attr_reader :app
-      
-      # The name of self.
-      #--
-      # Currently names may be any object.  Audit makes use of name
-      # via to_s, as does app when figuring configuration filepaths. 
-      attr_accessor :name
-      
-      # Initializes a new instance and associated batch objects.  Batch
-      # objects will be initialized for each configuration template 
-      # specified by app.each_config_template(config_file) where 
-      # config_file = app.config_filepath(name).  
-      def initialize(config={}, name=nil, app=App.instance)
-        super()
-        @app = app
-        @name = name || self.class.default_name
-        
-        case config
-        when InstanceConfiguration 
-          @config = config
-          config.bind(self)
-        else 
-          initialize_config(config)
-        end
-      end
-      
-      # Creates a new batched object and adds the object to batch. The batched object 
-      # will be a duplicate of the current object but with a new name and/or 
-      # configurations.
-      def initialize_batch_obj(overrides={}, name=nil)
-        obj = super().reconfigure(overrides)
-        obj.name = name if name
-        obj 
-      end
-      
-      # Logs the inputs to the application logger (via app.log)
-      def log(action, msg="", level=Logger::INFO)
-        # TODO - add a task identifier?
-        app.log(action, msg, level)
-      end
-
-      # Raises a TerminateError if app.state == State::TERMINATE.
-      # check_terminate may be called at any time to provide a 
-      # breakpoint in long-running processes.
-      def check_terminate
-        if app.state == App::State::TERMINATE
-          raise App::TerminateError.new
-        end
-      end
-      
-      # Returns self.name
-      def to_s
-        name.to_s
-      end
-      
-    end
-  end
-end

data/lib/tap/support/framework_class.rb

@@ -1,180 +0,0 @@
-require 'tap/support/command_line'
-
-module Tap
-  module Support
-  
-    # FrameworkClass encapsulates class methods related to Framework.
-    module FrameworkClass
-       
-      # Returns the default name for the class: to_s.underscore
-      attr_accessor :default_name
-      
-      def self.extended(base)
-        caller.each do |line|
-          case line
-          when /\/framework.rb/ then next
-          when /^(([A-z]:)?[^:]+):(\d+)/
-            base.instance_variable_set(:@source_file, File.expand_path($1))
-            break
-          end
-        end
-        
-        base.instance_variable_set(:@default_name, base.to_s.underscore)
-      end
-      
-      def inherited(child)
-        unless child.instance_variable_defined?(:@source_file)
-          caller.first =~ /^(([A-z]:)?[^:]+):(\d+)/
-          child.instance_variable_set(:@source_file, File.expand_path($1)) 
-        end
-        
-        child.instance_variable_set(:@default_name, child.to_s.underscore)
-        super
-      end
-
-      def subclass(const_name, configs={}, options={}, &block)
-        # Generate the nesting module
-        current, constants = const_name.to_s.constants_split
-        raise ArgumentError, "#{current} is already defined!" if constants.empty?
-         
-        subclass_const = constants.pop
-        constants.each {|const| current = current.const_set(const, Module.new)}
-        
-        # Generate the subclass
-        subclass = Class.new(self)
-        configs = configs[0] if configs.kind_of?(Array) && configs.length == 1 && configs[0].kind_of?(Hash)
-        
-        case configs
-        when Hash
-          subclass.send(:attr_accessor, *configs.keys)
-          configs.each_pair do |key, value|
-            subclass.configurations.add(key, value)
-          end
-        when Array
-          configs.each do |method, key, value, opts, config_block| 
-            subclass.send(method, key, value, opts, &config_block)
-          end
-        end
-        
-        block_method = options[:block_method] || :process
-        subclass.send(:define_method, block_method, &block)
-        subclass.default_name = const_name
-
-        const_name = current == Object ? subclass_const : "#{current}::#{subclass_const}"
-        caller.each_with_index do |line, index|
-          case line
-          when /\/tap\/support\/declarations.rb/ then next
-          when /^(([A-z]:)?[^:]+):(\d+)/
-            subclass.source_file = File.expand_path($1)
-            lzd = subclass.lazydoc(false)
-            lzd[const_name, false]['manifest'] = lzd.register($3.to_i - 1)            
-            break
-          end
-        end
-        
-        arity = options[:arity] || block.arity
-        comment = Comment.new
-        comment.subject = case
-        when arity > 0
-          Array.new(arity, "INPUT").join(' ')
-        when arity < 0
-          array = Array.new(-1 * arity - 1, "INPUT")
-          array << "INPUTS..."
-          array.join(' ')
-        else ""
-        end
-        subclass.lazydoc(false)[const_name, false]['args'] ||= comment
-        
-        # Set the subclass constant
-        current.const_set(subclass_const, subclass)
-      end
-      
-      DEFAULT_HELP_TEMPLATE = %Q{<% manifest = task_class.manifest %>
-<%= task_class %><%= manifest.subject.to_s.strip.empty? ? '' : ' -- ' %><%= manifest.subject %>
-
-<% unless manifest.empty? %>
-<%= '-' * 80 %>
-
-<% manifest.wrap(77, 2, nil).each do |line| %>
-  <%= line %>
-<% end %>
-<%= '-' * 80 %>
-<% end %>
-
-}
-
-      def instantiate(argv, app=Tap::App.instance) # => instance, argv
-        opts = OptionParser.new
- 
-        # Add configurations
-        config = {}
-        unless configurations.empty?
-          opts.separator ""
-          opts.separator "configurations:"
-        end
-
-        configurations.each do |receiver, key, configuration|
-          opts.on(*CommandLine.configv(configuration)) do |value|
-            config[key] = value
-          end
-        end
-
-        # Add options on_tail, giving priority to configurations
-        opts.separator ""
-        opts.separator "options:"
-
-        opts.on_tail("-h", "--help", "Print this help") do
-          opts.banner = "#{help}usage: tap run -- #{to_s.underscore} #{args.subject}"
-          puts opts
-          exit
-        end
-
-        # Add option for name
-        name = default_name
-        opts.on_tail('--name NAME', /^[^-].*/, 'Specify a name') do |value|
-          name = value
-        end
-
-        # Add option to add args
-        use_args = []
-        opts.on_tail('--use FILE', /^[^-].*/, 'Loads inputs from file') do |value|
-          obj = YAML.load_file(value)
-          case obj
-          when Hash 
-            obj.values.each do |array|
-              # error if value isn't an array
-              use_args.concat(array)
-            end
-          when Array 
-            use_args.concat(obj)
-          else
-            use_args << obj
-          end
-        end
-
-        opts.parse!(argv)
-        obj = new({}, name, app)
-
-        path_configs = load_config(app.config_filepath(name))
-        if path_configs.kind_of?(Array)
-          path_configs.each_with_index do |path_config, i|
-            obj.initialize_batch_obj(path_config, "#{name}_#{i}") unless i == 0
-          end
-          path_configs = path_configs[0]
-        end
-
-        [obj.reconfigure(path_configs).reconfigure(config), argv + use_args]
-      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).build
-      end
-    end
-  end
-end

data/lib/tap/support/run_error.rb

@@ -1,39 +0,0 @@
-module Tap
-  module Support
-    # Raised when an exception is raised during App#run.  All errors generated during
-    # termination are collected into the RunError.
-    class RunError < RuntimeError
-      attr_reader :errors
-  
-      def initialize(errors)
-        @errors = errors
-        @backtrace = nil
-      end
-      
-      #The join of all the error messages.
-      def message
-        lines = []
-        errors.each_with_index do |error, i| 
-          lines << "\nRunError [#{i}] #{error.class} #{error.message}"
-        end
-        lines.join + "\n"
-      end
-      
-      #The join of all the error backtraces.
-      def backtrace
-        # backtrace gets called every time RunError is re-raised, leading to multiple
-        # repeats of the error backtraces.  This ensures the additional backtrace 
-        # information is only added once.
-        return @backtrace unless @backtrace == nil
-        return nil unless @backtrace = super
-        
-        errors.each_with_index do |error, i| 
-          @backtrace [-1] += "\n\n---------------------- RunError [#{i}] ----------------------\n#{error.class} #{error.message}"
-          @backtrace.concat(error.backtrace ||  ["missing backtrace"])
-        end
-        @backtrace
-      end
-    
-    end
-  end
-end

data/lib/tap/support/summary.rb

@@ -1,30 +0,0 @@
-module Tap
-  module Support
-    class Summary
-      def initialize
-        @map = []
-        @width = 10
-      end
-      
-      def add(env_key, env, map)
-        unless map.empty?
-          @map << [env_key, env, map]
-          map.each {|(key, path)| @width = key.length if @width < key.length }
-        end
-      end
-      
-      def lines
-        lines = []
-        @map.each do |(env_lookup, env, map)|
-          lines <<  "#{env_lookup}:" if @map.length > 1
-          map.each do |(key, path)|
-            desc = block_given? ? (yield(path) || '') : ''
-            desc = "  # #{desc}" unless desc.empty?
-            lines << ("  %-#{@width}s%s" % [key, desc])
-          end
-        end
-        lines
-      end
-    end
-  end
-end