newbamboo-proto_processor 0.3.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ismael Celis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,150 @@
+## proto_processor
+
+A couple of modules to ease the creation of background processors or any kind of delegated task or tasks for which you want flow control and error reporting.
+
+## Install
+
+    sudo gem install ismasan-proto_processor
+
+## Examples
+
+### Strategies
+
+You start by defining a *strategy*. A strategy defines the sequence of tasks your program will carry out.
+
+    require 'rubygems'
+    require 'proto_processor'
+
+    class ImageStrategy
+      include ProtoProcessor::Strategy
+     
+      # :process runs you strategy
+      #
+      def process
+        
+        options = {:width => 300, :height => 200}
+
+        # set the initial input
+        with_input File.open('some_file.jpg')
+  
+        # Run the file though a resize task
+        run_task ResizeTask, options
+
+        # store the modified file
+        run_task StoreFileTask
+      end
+       
+    end
+
+Run it:
+
+    strategy = ImageStrategy.new
+    report = strategy.run
+    puts report.inspect
+
+The Strategy module just adds a few methods to run your tasks in a declarative manner. The :process method sets an input to be used as a starting point with *with_input*, and declares the sequence of tasks to be run on that input with *run_task*, which takes the task class and an options hash as arguments.
+
+Strategy#run captures the output of tasks and gives you a Report object, with information about the tasks run, their output and possible errors.
+
+Apart from the *process* method, Strategies are normal Ruby classes so you can go ahead and add whatever functionality you want to them, including, for example, an *initialize* method, or a factory.
+
+### Tasks
+
+Tasks do the real work. They also implement a *process* method where you can put you image resizing, file storing, email sending or whatever code you want.
+
+    require 'mini_magick'
+    class ResizeTask
+      include ProtoProcessor::Task
+      
+      expects_options_with :width
+      expects_options_with :height
+
+      def process
+        image = MiniMagick::Image.new(input.path)
+        image.resize "#{options[:width]}x#{options[:height]}"
+      end
+    end
+
+That's pretty much it. Any exceptions raised within *process* will be captured, logged and stored in the task report which will be available as part of the Strategy-wide Report object.
+
+Every task has an *options* hash available.
+
+### Validating task options
+
+The previous example shows a simple way of checking that a task was passed required parameters as part of the options hash.
+
+   expects_options_with :width
+
+If parameters declared in this way are not present in the options, a ProtoProcessor::MissingParametersError exception will be raised and logged in the task report (your task won't blow up though). The process method won't be run.
+
+You can also raise manually in the process method.
+
+    def process
+      raise ArgumentError, ":width option must be > 0" if options[:width] < 1
+    end
+
+Tasks also have *before_process* and *after_process* callbacks that will run if defined. You can guess what they do :)
+
+Lastly, you can define your own *validate* method which will be run before processing. If validate returns false, the task won't process and I ProtoProcessor::TaskInvalidError will be logged in the error report
+
+    def validate
+      (1..500).include? options[:width]
+    end
+
+### Chaining tasks in strategies
+
+    run_task [CropTask, ResizeTask, ZipTask, EmailTask], options
+
+Tasks can be chained and run sequentially as a unit. The input, options and report will be passed down the chain to the last task. The final, composed output and report is then returned to the main strategy and available in the strategy Report.
+
+You can use task chains to process elements in a collection:
+
+    BIG = {:width => 500, :height => 500}
+    MEDIUM = {:width => 200, :height => 200}
+    SMALL = {:width => 100, :height => 100}
+
+    with_input some_file_here
+
+    # Crop the original
+    run_task CropTask, {:square => true}
+
+    # Produce resized versions and store them somewhere
+    [BIG, MEDIUM, SMALL].each do |dimensions|
+      run_task [ResizeTask, ZipTask, StorageTask], dimensions
+    end
+
+If any task in the chain fails the error will be logged. The following tasks will not be processed.
+
+### Stand alone tasks
+
+Tasks are quite simple objects. They expect an array with an input, an options hash and a report hash as an argument and return the same.
+
+    resize = ResizeTask.new([some_file, {:width => 100, :height => 100}, {}])
+    resize.run # => [input, options, report]
+
+The task report (just a hash) is populated by tasks and passed along to the next task in the chain, if any. This is a good place to put data resulting from your processing that you want to make available for the next task. You do this with the *report!* shortcut within the process method or any other method you define in your task.
+
+    # ... do some processing
+    report! :some_key, 'Some value'
+
+If a task expects a certain key in the report passed from a previous task in a chain, you can make it explicit just like with options:
+
+    expects_report_with :some_key
+
+If :some_key doesn't exist in the passed report, the task will not process and halt any chain it is in.
+
+### Logging
+
+Default to STDOUT. Just add your own logger and logger level.
+
+    ProtoProcessor.logger = Logger.new('my_processor.log')
+    ProtoProcessor.logger.level = Logger::ERROR
+
+## TODO
+
+* Improve DSL in strategies
+* Better log formatting?
+
+## Copyright
+
+Copyright (c) 2009 Ismael Celis. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "proto_processor"
+    gem.summary = %Q{TODO}
+    gem.email = "ismaelct@gmail.com"
+    gem.homepage = "http://github.com/ismasan/proto_processor"
+    gem.authors = ["Ismael Celis"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "proto_processor #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 3
+:patch: 0

data/lib/proto_processor.rb

@@ -0,0 +1,16 @@
+require 'logger'
+module ProtoProcessor
+  ROOT = File.dirname(__FILE__)
+  $: << File.join(ROOT, 'proto_processor')
+  
+  autoload :Task, 'task'
+  autoload :Strategy, 'strategy'
+  autoload :TaskRunner, 'task_runner'
+  autoload :Report, 'report'
+  
+  class << self
+    attr_accessor :logger
+  end
+end
+ProtoProcessor.logger = Logger.new(STDOUT)
+ProtoProcessor.logger.level = Logger::ERROR

data/lib/proto_processor/report.rb

@@ -0,0 +1,77 @@
+module ProtoProcessor
+  class Report
+    include Enumerable
+    
+    attr_reader :chain_outputs, :chain_tasks, :error, :chain_statuses
+    
+    def initialize
+      @chain_outputs = {}
+      @chain_tasks = {}
+      
+      @chain_statuses = []
+      @error = nil
+    end
+    
+    # == Store tasks and output after running task chain
+    #
+    def report(chain_key, tasks, output)
+      report_output(chain_key, output)
+      report_tasks(chain_key, tasks)
+    end
+    
+    def each(&block)
+      @chain_outputs.each &block
+    end
+    
+    def [](chain_key)
+      @chain_outputs[chain_key]
+    end
+    
+    # Major fail at strategy level
+    #
+    def fail!(exception)
+      @error = exception
+    end
+    
+    def successful?
+      @error.nil?
+    end
+    
+    def run_report
+      @run_report ||= begin
+        rep = {}
+        @chain_tasks.each do |task_name, runs|
+          runs.each_with_index do |r, i|
+            rep[:"#{task_name}_#{i}"] = r.map{|t| "#{t.class.name}: #{t.report[:status]}"}
+          end
+        end
+        rep
+      end
+    end
+    
+    protected
+    
+    # {
+    #   :FooTask => [out1,out2],
+    #   :BarTask => [out1,out2]
+    # }
+    def report_output(chain_key, output)
+      @chain_outputs[chain_key] ||= []
+      @chain_outputs[chain_key] << output
+    end
+    
+    # {
+    #   :FooTask => [[task1,task2],[task1,task2]],
+    #   :BarTask => [[task1,task2],[task1,task2]]
+    # }
+    
+    
+    def report_tasks(chain_key, tasks)
+      @chain_tasks[chain_key] ||= []
+      @chain_tasks[chain_key] << [*tasks]
+      
+      @chain_statuses << tasks.map{|t|t.successful?}
+    end
+    
+  end
+end

data/lib/proto_processor/strategy.rb

@@ -0,0 +1,51 @@
+module ProtoProcessor::Strategy
+  
+  def report
+    @report ||= ProtoProcessor::Report.new
+  end
+  
+  def runner
+    @task_runner ||= ProtoProcessor::TaskRunner.new(report)
+  end
+  
+  def run
+    begin
+      ProtoProcessor.logger.info "Running strategy #{self.class.name}"
+      process
+    rescue StandardError => e
+      report.fail!(e)
+      ProtoProcessor.logger.error e.class.name
+      ProtoProcessor.logger.debug e.message + "\n" + e.backtrace.join("\n")
+    end
+    yield report if block_given?
+    report
+  end
+  
+  def process
+    raise NotImplementedError, "You must implement #process in your strategies"
+  end
+  
+  def with_input(input)
+    @current_input = input#.dup # dup so we don't overwrite passed input later on
+  end
+  
+  def current_input
+    @current_input ||= ''
+  end
+  
+  # === Run a task and update input and report (but don't update options)
+  # If passed and array of options, run task for each option hash
+  #
+  def run_task(task_class, options = nil, &block)
+    return false if options.nil?
+    run_task_chain([*task_class], options, &block)
+  end
+  
+  protected
+  
+  def run_task_chain(task_classes, options, &block)
+    chain_key = task_classes.first.name.split('::').last.to_sym
+    @current_input, temp_options, task_report = runner.run_chain(chain_key, task_classes,current_input, options, {}, &block)
+  end
+  
+end

data/lib/proto_processor/task.rb

@@ -0,0 +1,158 @@
+require 'set'
+module ProtoProcessor
+  
+  module Task
+    
+    FAILURE = 'FAILURE'
+    SUCCESS = 'SUCCESS'
+    
+    class InvalidTaskError < StandardError
+      def message
+        "Invalid task"
+      end
+    end
+    
+    class MissingParametersError < InvalidTaskError
+      def initialize(errors)
+        @errors = errors
+        super
+      end
+      
+      def message
+        "Missing parameters: #{@errors.inspect}"
+      end
+    end
+    
+    def self.included(base)
+      base.class_eval do
+        attr_reader :input, :options, :report, :error
+        extend Validations
+      end
+      #base.extend Validations
+    end
+    
+    # new([input, options, report])
+    def initialize(args)
+      raise ArgumentError, "You must provide an Enumerable object as argument" unless args.respond_to?(:each)
+      raise ArgumentError, "You must provide an array with input, options and report" if args.size < 3
+      raise ArgumentError, "A task report must be or behave like a Hash" unless args.last.respond_to?(:[]=)
+      @input, @options, @report = args[0], args[1].dup, args[2].dup
+      @success = false
+      @error = nil
+    end
+    
+    # class HaltedChainError < StandardError
+    #       def message
+    #         "Task not run because previous task failed"
+    #       end
+    #     end
+    
+    def run
+      begin
+        log_halt_task and return false if report[:status] == FAILURE
+        run_validations!
+        before_process
+        process
+        report!(:status, SUCCESS)
+        @success = true
+        after_process
+      rescue StandardError => e
+        # horrible horrible hack to allow Rspec exceptions to bubble up.
+        # we can't rescue them because RSpec is only included when running specs
+        raise if e.class.name =~ /Spec/
+        report!(:status, FAILURE)
+        report!(:error, {:name => e.class.name, :message => e.message})
+        @error = e
+        ProtoProcessor.logger.error "#{self.class.name}: #{e.class.name} => #{e.message}"
+        ProtoProcessor.logger.debug e.backtrace.join("\n")
+      end
+      [@input, @options, @report]
+    end
+    
+    def successful?
+      @success
+    end
+    
+    # === Validate in subclasses
+    # Example:
+    # def validate
+    #   options[:some].nil?
+    # end
+    #
+    def valid?
+      run_validations!
+      true
+    rescue InvalidTaskError => e
+      false
+    end
+    
+    # Abstract
+    #
+    def process
+      raise NotImplementedError, "You need to implement #process in you tasks"
+    end
+    
+    def before_process
+      true
+    end
+    
+    def after_process
+      true
+    end
+    
+    # Update input so it's passed to the next task
+    #
+    def update_input!(new_input)
+      @input = new_input
+    end
+    
+    protected
+    
+    def log_halt_task
+      ProtoProcessor.logger.info "#{self.class.name} not run because previous task failed"
+    end
+    
+    def validate
+      # implement this in subclasses if needed
+      true
+    end
+    
+    def run_validations!
+      raise InvalidTaskError unless validate
+      errors = []
+      self.class.validations.each do |key, required|
+        provided = send(key).keys
+        missing = required - provided
+        errors << "#{key} => #{missing.inspect}" unless required.to_set.subset?(provided.to_set)
+      end
+      raise MissingParametersError.new(errors) unless errors.empty?
+    end
+    
+    def report!(key, value)
+      @report[key] = value
+    end
+    
+    module Validations
+      def expects_options_with(*args)
+        store_validations_for(:options, args)
+      end
+      
+      def expects_report_with(*args)
+        store_validations_for(:report, args)
+      end
+      
+      # {
+      #  :options => [:field1, :field2],
+      #  :report => [:field1, :field2]
+      # }
+      def store_validations_for(key, args)
+        validations[key] ||= []
+        validations[key] += args
+      end
+      
+      def validations
+        @validations ||= {}
+      end
+    end
+  end
+end

data/lib/proto_processor/task_runner.rb

@@ -0,0 +1,24 @@
+module ProtoProcessor
+  class TaskRunner
+    
+    attr_reader :report
+    
+    def initialize(report)
+      @report = report
+    end
+    
+    def run_chain(run_key, task_classes, initial_input, options, initial_report, &block)
+      tasks = []
+      output = task_classes.inject([initial_input, options, initial_report]) do |args, task_class|
+        task = task_class.new(args)
+        tasks << task
+        task.run
+      end
+      block.call(tasks, output.first, output.last) if block_given?
+      @report.report(run_key, tasks, output)
+      output
+    end
+    
+    
+  end
+end

data/spec/base_strategy_spec.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module BAS
+  class BAS::FooTask
+    include ProtoProcessor::Task
+    def process
+      @input << 'FOO'
+      report!(:hello, @input)
+    end
+  end
+
+  class BAS::BarTask
+    include ProtoProcessor::Task
+    def process
+      @input << 'BAR'
+      report!(:hello, @input)
+    end
+  end
+end
+
+class FooBarStrategy
+  include ProtoProcessor::Strategy
+  
+  def options
+    options = {
+      "original" => 'sample_image.jpg',
+      "type" => "FooBar",
+      "rotate" => 90,
+      "crop" => 'crop_options',
+      "sizes" => [{'width' => 100}, {'width' => 200}, {'width' => 300}]
+    }
+  end
+  
+  def process
+    run_task BAS::FooTask, options
+    run_task BAS::BarTask, options
+    options['sizes'].each do |size_params|
+      run_task BAS::FooTask, size_params
+    end
+    
+  end
+  
+end
+
+describe "Strategy" do
+  before do
+    @strategy = FooBarStrategy.new
+    @options = @strategy.options
+  end
+  describe 'running tasks with #run_task' do
+    before do
+      @mock_task = mock('task', :run => true, :valid? => true, :successful? => true)
+    end
+    
+    it "should have a task runner" do
+      @strategy.runner.should be_kind_of(ProtoProcessor::TaskRunner)
+    end
+    
+    it "should have an initial report" do
+      @strategy.report.should be_kind_of(ProtoProcessor::Report)
+    end
+    
+    it "should delegate to Task Runner with run key, array of one task, input, options and report" do
+      @strategy.runner.should_receive(:run_chain).with(:FooTask, [BAS::FooTask], @strategy.current_input, @options, {})
+      @strategy.run_task BAS::FooTask, @options
+    end
+    
+    it "should be able to change the input for upcoming tasks" do
+      new_input = 'a different input'
+      @strategy.runner.should_receive(:run_chain).with(:FooTask, [BAS::FooTask], new_input, @options, {})
+      @strategy.with_input new_input
+      @strategy.run_task BAS::FooTask, @options
+    end
+    
+    it "should run a task with default input, options and report" do
+      BAS::FooTask.should_receive(:new).with([@strategy.current_input,@options,{}]).and_return @mock_task
+      @strategy.run_task BAS::FooTask, @options
+    end
+    
+    it "should not run a task if passed options are NIL" do
+      BAS::FooTask.should_not_receive(:new)
+      @strategy.run_task BAS::FooTask
+    end
+    
+    it "should run a task with passed options" do
+      opts = {:blah => 1}
+      BAS::FooTask.should_receive(:new).with([@strategy.current_input,opts,{}]).and_return @mock_task
+      @strategy.run_task BAS::FooTask, opts
+    end
+    
+  end
+  
+  describe 'running main process' do
+    before do
+      @mock_task = mock('task', :run => [@input, @options, {}], :valid? => true)
+    end
+    
+    it "should accumulate result of tasks" do
+      pending 'this belongs in the task runner'
+      BAS::FooTask.should_receive(:new).exactly(4).and_return @mock_task
+      BAS::BarTask.should_receive(:new).exactly(1).and_return @mock_task
+      @strategy.run
+    end
+    
+    it "should update values" do
+      report = @strategy.run
+      @strategy.current_input.should == 'FOOBARFOOFOOFOO'
+    end
+    
+  end
+  
+end

data/spec/base_task_spec.rb

@@ -0,0 +1,181 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class FooTask
+  include ProtoProcessor::Task
+  def process
+    @input << 'a'
+    report! :foo, 'foo'
+  end
+end
+
+class InvalidTask
+  include ProtoProcessor::Task
+  def process
+    @input = "I got here"
+  end
+  
+  def validate
+    false
+  end
+end
+
+describe "Task" do
+  before do
+    @input = ''
+    @options = {}
+    @report = {}
+    @task = FooTask.new([@input, @options, @report])
+  end
+  
+  it "should raise if less than 3 arguments" do
+    lambda {
+      FooTask.new(['bar'])
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise if argument is not enumerable" do
+    lambda {
+      FooTask.new(1)
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise if report does not cuack like a Hash" do
+    lambda {
+      FooTask.new(['',{},10])
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should be valid by default" do
+    @task.valid?.should be_true
+  end
+  
+  it "should have input, options and report" do
+    @task.input.should == @input
+    @task.options.should == @options
+    @task.report.should == @report
+  end
+  
+  it "should not be successful before running" do
+    @task.successful?.should_not be_true
+  end
+  
+  it "should update input with #update_input!" do
+    @task.input.should == ''
+    @task.update_input!(2)
+    @task.input.should == 2
+  end
+  
+  describe "invalid tasks" do
+    before do
+      @invalid_task = InvalidTask.new(['', {}, @report])
+    end
+    
+    it "should be invalid (duh!)" do
+      @invalid_task.valid?.should be_false
+    end
+    
+    it "should not process if not valid" do
+      # if the input is modified, it means that it did run #process
+      # we can't use expectations because I'm rescueing exceptions, including RSpec ones!
+      output = @invalid_task.run
+      output.first.should be_empty
+    end
+    
+  end
+  
+  describe 'task receiving failed report' do
+    before do
+      @task = FooTask.new([@input, @options, {:status => 'FAILURE'}])
+    end
+    
+    it "should halt processing" do
+      @task.should_not_receive(:process)
+      @task.run
+      @task.should_not be_successful
+      @task.report[:status].should == 'FAILURE'
+    end
+  end
+  
+  describe "running" do
+    
+    it "should invoke :process" do
+      @task.should_receive(:process)
+      @task.run
+    end
+    
+    it "should return modified input" do
+      output = @task.run
+      output[0].should == 'a'
+    end
+    
+    it "should return options" do
+      output = @task.run
+      output[1].should == @options
+    end
+    
+    it "should add stuff to report" do
+      output = @task.run
+      output[2].should == {:status => 'SUCCESS', :foo => 'foo'}
+    end
+    
+    it "should be successful after running (successfully)" do
+      @task.run
+      @task.successful?.should be_true
+    end
+    
+  end
+  
+  describe 'process callbacks' do
+    before :all do
+      class ATask
+        include ProtoProcessor::Task
+        def before_process
+          @input.before
+        end
+        def process
+          @input.process
+        end
+        def after_process
+          @input.after
+        end
+      end
+      @input = mock('input', :before =>1, :process => 2, :after => 3)
+      
+    end
+    
+    it "should invoke after and before process callbacks" do
+      @input.should_receive(:before)
+      @input.should_receive(:process)
+      @input.should_receive(:after)
+      ATask.new([@input, {}, {}]).run
+    end
+  end
+  
+end
+
+class BarTask
+  include ProtoProcessor::Task
+  def process
+    @input << 'b'
+    report! :bar, 'bar'
+  end
+end
+
+describe "decorating the same or other tasks" do
+  
+  it "should iteratively process" do
+    input, options, report = '', {}, {}
+    1.upto(5) do |i|
+      task = FooTask.new([input, options, report])
+      old_input = input
+      input, options, report = task.run
+      old_input.object_id.should == input.object_id
+    end
+    
+    task = BarTask.new([input, options, report])
+    input, options, report = task.run
+    
+    input.should == 'aaaaab'
+    report.should == {:bar=>"bar", :status=>"SUCCESS", :foo=>"foo"}
+  end
+end

data/spec/report_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'Report' do
+  before do
+    @report = ProtoProcessor::Report.new
+  end
+  
+  it "should"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'proto_processor'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/task_validations_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module TVS
+  class MockTask
+    include ProtoProcessor::Task
+  end
+  class FooTask < MockTask
+    
+    expects_options_with :id, :name
+    
+    expects_report_with :url, :path
+    
+    def process
+      puts options[:id]
+    end
+    
+  end
+end
+
+describe 'Task validations' do
+  describe "with valid parameters" do
+    before do
+      @task = TVS::FooTask.new(['',{:id => 1, :name => 'bar'},{:url => 'abc', :path => 'aaa'}])
+    end
+    
+    it "should be valid" do
+      @task.should be_valid
+    end
+  end
+  
+  describe "with missing parameters" do
+    before do
+      @task = TVS::FooTask.new(['',{:id => 1},{:path => 'aaa'}])
+    end
+    
+    it "should not be valid" do
+      @task.should_not be_valid
+    end
+    
+    it "should not run" do
+      @task.should_not_receive(:process)
+      @task.run
+    end
+    
+    it "should pass status report = FAILURE" do
+      @task.run
+      @task.report[:status].should == ProtoProcessor::Task::FAILURE
+    end
+    
+    it "should have error information" do
+      @task.run
+      @task.report[:error].should_not be_nil
+    end
+  end
+end

data/spec/tasks_runner_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module RunnerSpecHelper
+  class Task1
+    include ProtoProcessor::Task
+    def process
+      report! :common, 1
+      report! :a, 1
+      @input << 'a'
+    end
+  end
+  class Task2
+    include ProtoProcessor::Task
+    def process
+      report! :common, 2
+      report! :b, 2
+      @input << 'b'
+    end
+  end
+  class Task3
+    include ProtoProcessor::Task
+    def process
+      report! :common, 3
+      report! :c, 3
+      @input << 'c'
+    end
+  end
+end
+include RunnerSpecHelper
+include ProtoProcessor
+
+describe '@runner' do
+  before do
+    @input, @options, @task_report = '', {}, {}
+    @report = mock('report', :report => true)
+    @runner = TaskRunner.new(@report)
+  end
+  describe 'running tasks with #run_chain' do
+    
+    before do
+      @task1 = mock('task1', :run => [@input, @options, {:common => 1}])
+      @task2 = mock('task2', :run => [@input, @options, {:common => 2}])
+      @task3 = mock('task3', :run => [@input, @options, {:common => 3}])
+    end
+    
+    it "should run one task" do
+      Task1.should_receive(:new).with([@input, @options, @task_report]).and_return @task1
+      @runner.run_chain(:foo,[Task1], @input, @options, @task_report).should == ["", {}, {:common=>1}]
+    end
+    
+    it "should register task and output with report object" do
+      Task1.stub!(:new).and_return @task1
+      @report.should_receive(:report).with(:foo, [@task1], ["", {}, {:common=>1}])
+      @runner.run_chain(:foo,[Task1], @input, @options, @task_report)
+    end
+    
+    it "should run sequence of nested tasks" do
+      Task1.should_receive(:new).with([@input, @options, @task_report]).and_return @task1
+      Task2.should_receive(:new).with([@input, @options, @task_report.merge(:common => 1)]).and_return @task2
+      Task3.should_receive(:new).with([@input, @options, @task_report.merge(:common => 2)]).and_return @task3
+      
+      @runner.run_chain(:foo,[Task1, Task2, Task3], @input, @options, @task_report)
+      
+    end
+    
+  end
+  
+  it "should call an optional block with run tasks, final output and consolidated report" do 
+    collaborator = mock('collaborator')
+    collaborator.should_receive(:do_something!).with(2, "ab", {:b=>2, :status=>"SUCCESS", :common=>2, :a=>1})
+    @runner.run_chain(:foo,[Task1, Task2], @input, @options, @task_report) do |tasks, output, report|
+      collaborator.do_something!(tasks.size, output, report)
+    end
+  end
+  
+  it "verifies that result is merged hash" do
+    @runner.run_chain(:foo,[Task1, Task2, Task3], @input, @options, @task_report)\
+      .should == ['abc', @options, {:common => 3, :status => 'SUCCESS', :a =>1, :b =>2, :c => 3}]
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: newbamboo-proto_processor
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Ismael Celis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-26 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ismaelct@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION.yml
+- lib/proto_processor.rb
+- lib/proto_processor/report.rb
+- lib/proto_processor/strategy.rb
+- lib/proto_processor/task.rb
+- lib/proto_processor/task_runner.rb
+- spec/base_strategy_spec.rb
+- spec/base_task_spec.rb
+- spec/report_spec.rb
+- spec/spec_helper.rb
+- spec/task_validations_spec.rb
+- spec/tasks_runner_spec.rb
+has_rdoc: true
+homepage: http://github.com/ismasan/proto_processor
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- spec/base_strategy_spec.rb
+- spec/base_task_spec.rb
+- spec/report_spec.rb
+- spec/spec_helper.rb
+- spec/task_validations_spec.rb
+- spec/tasks_runner_spec.rb