taskinator 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ff47c5ba6191572ca259138c60f044e730a3a0a
-  data.tar.gz: 1f99e1305ad76fdb20e607effd127cd47bb52580
+  metadata.gz: d0f77cfa37c2c81aeafdfc15dc008d1189a85e14
+  data.tar.gz: 0a297360345128af32a48ce6ff4ffdac386aba01
 SHA512:
-  metadata.gz: ad2dfc3e17c739644a8142150424af3fbd7c5138fe8d07d276592e34360ee969add8ad1c6cbfcf4cf2ab76bb08206bc45374a443c8d0e9ad7cca348431367269
-  data.tar.gz: ac28863f5a8e0a244d2121eb1507dd68189657f35ec36ea9661f461254003a947551974b7dc758d021d05f5b93b6f94d1079dd164785bee73f670aecefd2e2ba
+  metadata.gz: a65f2d17d83e86d083e3c1343972a46e13a68e693af433290251f2d3aba340a80c13620c8184bd5f644a0d7399435a327ff064afb3e0f0403edef84c8d0611bf
+  data.tar.gz: 132c02957ff6e96fe6ae620685f2168569595bc9becda49e26ed0665403598e0cb08927a962c7a689bea87ab908d72f83ad7d8b45cd677e10a35a103d3a6da71

data/Gemfile.lock

@@ -8,7 +8,7 @@ GIT
 PATH
   remote: .
   specs:
-    taskinator (0.0.1)
+    taskinator (0.0.2)
       connection_pool (>= 2.0.0)
       json (>= 1.8.1)
       redis (>= 3.0.6)

data/README.md

@@ -77,8 +77,8 @@ module MyProcess
   extend Taskinator::Definition
 
   define_process do
-    task 'Step A', :first_work_step
-    task 'Step B', :second_work_step
+    task :first_work_step
+    task :second_work_step
   end
 
   def first_work_step
@@ -100,14 +100,14 @@ module MyProcess
   define_process do
     concurrent do
       # these tasks will be executed concurrently
-      task 'Step A1', :work_step_1
-      task 'Step A2', :work_step_2
+      task :work_step_1
+      task :work_step_2
     end
 
     sequential do
       # thes tasks will be executed sequentially
-      task 'Step B1', :work_step_3
-      task 'Step B2', :work_step_4
+      task :work_step_3
+      task :work_step_4
     end
   end
 
@@ -134,7 +134,7 @@ module MyProcess
 
   define_process do
     for_each :yield_data_elements do
-      task 'Data Element Step', :work_step
+      task :work_step
     end
   end
 
@@ -164,8 +164,8 @@ module MyProcess
   extend Taskinator::Definition
 
   define_process do
-    sub_process 'Process A', MySubProcessA
-    sub_process 'Process B', MySubProcessB
+    sub_process MySubProcessA
+    sub_process MySubProcessB
   end
 end
 ```
@@ -178,27 +178,28 @@ module MyProcess
 
   define_process do
     for_each :data_elements do
-      task '...', :work_step_begin
+      task :work_step_begin
 
       concurrent do
         for_each :sub_data_elements do
-          task '...', :work_step_all_at_once
+          task :work_step_all_at_once
         end
       end
 
-      sub_process '...', MySubProcess
+      sub_process MySubProcess
 
       sequential do
         for_each :sub_data_elements do
-          task '...', :work_step_one_by_one
+          task :work_step_one_by_one
         end
       end
 
-      task '...', :work_step_end
+      task :work_step_end
     end
   end
 
   # "task" and "iterator" methods omitted for brevity
+
 end
 ```
 
@@ -215,6 +216,10 @@ process = MyProcess.create_process
 process.enqueue!
 ```
 
+#### Arguments
+
+_TBD_
+
 ### Monitoring
 
 To monitor the state of the processes, use the `Taskinator::Api::Processes` class. This is still a work in progress.
@@ -224,11 +229,6 @@ processes = Taskinator::Api::Processes.new()
 processes.each do |process|
   # => output the unique process identifier and current state
   puts [:process, process.uuid, process.current_state.name]
-
-  process.tasks.each do |task|
-    # => output the task name and current state
-    puts [:task, task.name, task.current_state.name]
-  end
 end
 ```
 

data/lib/taskinator/definition/builder.rb

@@ -14,24 +14,24 @@ module Taskinator
       end
 
       # defines a sub process of tasks which are executed sequentially
-      def sequential(name, options={}, &block)
+      def sequential(options={}, &block)
         raise ArgumentError, 'block' unless block_given?
 
-        sub_process = Process.define_sequential_process_for(name, @definition, options)
-        Builder.new(define_sub_process_task(name, @process, sub_process, options), @definition, @args).instance_eval(&block)
+        sub_process = Process.define_sequential_process_for(@definition, options)
+        Builder.new(define_sub_process_task(@process, sub_process, options), @definition, @args).instance_eval(&block)
       end
 
       # defines a sub process of tasks which are executed concurrently
-      def concurrent(name, complete_on=CompleteOn::Default, options={}, &block)
+      def concurrent(complete_on=CompleteOn::Default, options={}, &block)
         raise ArgumentError, 'block' unless block_given?
 
-        sub_process = Process.define_concurrent_process_for(name, @definition, complete_on, options)
-        Builder.new(define_sub_process_task(name, @process, sub_process, options), @definition, @args).instance_eval(&block)
+        sub_process = Process.define_concurrent_process_for(@definition, complete_on, options)
+        Builder.new(define_sub_process_task(@process, sub_process, options), @definition, @args).instance_eval(&block)
       end
 
       # dynamically defines tasks, using the given @iterator method
       # the definition will be evaluated for each yielded item
-      def for_each(name, iterator_method, options={}, &block)
+      def for_each(iterator_method, options={}, &block)
         raise ArgumentError, 'iterator_method' if iterator_method.nil?
         raise NoMethodError, iterator_method unless @executor.respond_to?(iterator_method)
         raise ArgumentError, 'block' unless block_given?
@@ -42,37 +42,37 @@ module Taskinator
       end
 
       # defines a task which executes the given @method
-      def task(name, method, options={})
+      def task(method, options={})
         raise ArgumentError, 'method' if method.nil?
         raise NoMethodError, method unless @executor.respond_to?(method)
 
-        define_step_task(name, @process, method, @args, options)
+        define_step_task(@process, method, @args, options)
       end
 
       # defines a sub process task, for the given @definition
       # the definition specified must have input compatible arguments
       # to the current definition
-      def sub_process(name, definition, options={})
+      def sub_process(definition, options={})
         raise ArgumentError, 'definition' if definition.nil?
         raise ArgumentError, "#{definition.name} does not extend the #{Definition.name} module" unless definition.kind_of?(Definition)
 
         # TODO: decide whether the sub process to dynamically receive arguments
 
         sub_process = definition.create_process(*@args)
-        Builder.new(define_sub_process_task(name, @process, sub_process, options), definition, @args)
+        Builder.new(define_sub_process_task(@process, sub_process, options), definition, @args)
       end
 
     private
 
-      def define_step_task(name, process, method, args, options={})
+      def define_step_task(process, method, args, options={})
         define_task(process) {
-          Task.define_step_task(name, process, method, args, options)
+          Task.define_step_task(process, method, args, options)
         }
       end
 
-      def define_sub_process_task(name, process, sub_process, options={})
+      def define_sub_process_task(process, sub_process, options={})
         define_task(process) {
-          Task.define_sub_process_task(name, process, sub_process, options)
+          Task.define_sub_process_task(process, sub_process, options)
         }
         sub_process
       end

data/lib/taskinator/definition.rb

@@ -3,9 +3,9 @@ module Taskinator
     class UndefinedProcessError < RuntimeError; end
 
     # defines a process
-    def define_process(name=self.name, &block)
+    def define_process(&block)
       define_singleton_method :_create_process_ do |*args|
-        process = Process.define_sequential_process_for(name, self)
+        process = Process.define_sequential_process_for(self)
         Builder.new(process, self, args).instance_eval(&block)
         process.save
         process

data/lib/taskinator/process.rb

@@ -4,12 +4,12 @@ module Taskinator
     include ::Workflow
 
     class << self
-      def define_sequential_process_for(name, definition, options={})
-        Process::Sequential.new(name, definition, options)
+      def define_sequential_process_for(definition, options={})
+        Process::Sequential.new(definition, options)
       end
 
-      def define_concurrent_process_for(name, definition, complete_on=CompleteOn::Default, options={})
-        Process::Concurrent.new(name, definition, complete_on, options)
+      def define_concurrent_process_for(definition, complete_on=CompleteOn::Default, options={})
+        Process::Concurrent.new(definition, complete_on, options)
       end
 
       def base_key
@@ -18,19 +18,17 @@ module Taskinator
     end
 
     attr_reader :uuid
-    attr_reader :name
     attr_reader :definition
     attr_reader :options
 
     # in the case of sub process tasks, the containing task
     attr_accessor :parent
 
-    def initialize(name, definition, options={})
+    def initialize(definition, options={})
       raise ArgumentError, 'definition' if definition.nil?
       raise ArgumentError, "#{definition.name} does not extend the #{Definition.name} module" unless definition.kind_of?(Definition)
 
       @uuid = SecureRandom.uuid
-      @name = name
       @definition = definition
       @options = options
     end
@@ -42,7 +40,6 @@ module Taskinator
     def accept(visitor)
       visitor.visit_attribute(:uuid)
       visitor.visit_task_reference(:parent)
-      visitor.visit_attribute(:name)
       visitor.visit_type(:definition)
       visitor.visit_tasks(tasks)
       visitor.visit_args(:options)
@@ -53,7 +50,7 @@ module Taskinator
     end
 
     def to_s
-      "#<#{self.class.name}:#{uuid} @name=\"#{name}>\">"
+      "#<#{self.class.name}:#{uuid}>"
     end
 
     workflow do
@@ -84,11 +81,11 @@ module Taskinator
       state :failed
 
       on_transition do |from, to, event, *args|
-        Taskinator.logger.debug("PROCESS: #{self.class.name}:#{uuid} (#{name}) :: #{from} => #{to}")
+        Taskinator.logger.debug("PROCESS: #{self.class.name}:#{uuid} :: #{from} => #{to}")
       end
 
       on_error do |error, from, to, event, *args|
-        Taskinator.logger.error("PROCESS: #{self.class.name}:#{uuid} (#{name}) :: #{error.message}")
+        Taskinator.logger.error("PROCESS: #{self.class.name}:#{uuid} :: #{error.message}")
         fail!(error)
       end
     end
@@ -142,8 +139,8 @@ module Taskinator
     class Concurrent < Process
       attr_reader :complete_on
 
-      def initialize(name, definition, complete_on=CompleteOn::Default, options={})
-        super(name, definition, options)
+      def initialize(definition, complete_on=CompleteOn::Default, options={})
+        super(definition, options)
         @complete_on = complete_on
       end
 

data/lib/taskinator/task.rb

@@ -4,12 +4,12 @@ module Taskinator
     include ::Workflow
 
     class << self
-      def define_step_task(name, process, method, args, options={})
-        Step.new(name, process, method, args, options)
+      def define_step_task(process, method, args, options={})
+        Step.new(process, method, args, options)
       end
 
-      def define_sub_process_task(name, process, sub_process, options={})
-        SubProcess.new(name, process, sub_process, options)
+      def define_sub_process_task(process, sub_process, options={})
+        SubProcess.new(process, sub_process, options)
       end
 
       def base_key
@@ -19,25 +19,22 @@ module Taskinator
 
     attr_reader :process
     attr_reader :uuid
-    attr_reader :name
     attr_reader :options
 
     # the next task in the sequence
     attr_accessor :next
 
-    def initialize(name, process, options={})
+    def initialize(process, options={})
       raise ArgumentError, 'process' if process.nil? || !process.is_a?(Process)
 
       @uuid = SecureRandom.uuid
       @process = process
-      @name = name
       @options = options
     end
 
     def accept(visitor)
       visitor.visit_attribute(:uuid)
       visitor.visit_process_reference(:process)
-      visitor.visit_attribute(:name)
       visitor.visit_task_reference(:next)
       visitor.visit_args(:options)
     end
@@ -47,7 +44,7 @@ module Taskinator
     end
 
     def to_s
-      "#<#{self.class.name}:#{uuid} @name=\"#{name}\">"
+      "#<#{self.class.name}:#{uuid}>"
     end
 
     workflow do
@@ -69,16 +66,16 @@ module Taskinator
       state :failed
 
       on_transition do |from, to, event, *args|
-        Taskinator.logger.debug("TASK: #{self.class.name}:#{uuid} (#{name}) :: #{from} => #{to}")
+        Taskinator.logger.debug("TASK: #{self.class.name}:#{uuid} :: #{from} => #{to}")
       end
 
       on_error do |error, from, to, event, *args|
-        Taskinator.logger.error("TASK: #{self.class.name}:#{uuid} (#{name}) :: #{error.message}")
+        Taskinator.logger.error("TASK: #{self.class.name}:#{uuid} :: #{error.message}")
         fail!(error)
       end
     end
 
-    def can_complete_task?
+    def can_complete_task?(*args)
       # subclasses must implement this method
       raise NotImplementedError
     end
@@ -115,8 +112,8 @@ module Taskinator
       attr_reader :method
       attr_reader :args
 
-      def initialize(name, process, method, args, options={})
-        super(name, process, options)
+      def initialize(process, method, args, options={})
+        super(process, options)
         @definition = process.definition  # for convenience
 
         raise ArgumentError, 'method' if method.nil?
@@ -153,8 +150,8 @@ module Taskinator
     class SubProcess < Task
       attr_reader :sub_process
 
-      def initialize(name, process, sub_process, options={})
-        super(name, process, options)
+      def initialize(process, sub_process, options={})
+        super(process, options)
         raise ArgumentError, 'sub_process' if sub_process.nil? || !sub_process.is_a?(Process)
 
         @sub_process = sub_process

data/lib/taskinator/version.rb

@@ -1,3 +1,3 @@
 module Taskinator
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/taskinator.rb

@@ -32,7 +32,6 @@ module Taskinator
   LICENSE = 'See LICENSE.txt for licensing details.'
 
   DEFAULTS = {
-    :environment => nil
   }
 
   class << self

data/spec/examples/process_examples.rb

@@ -9,7 +9,6 @@ shared_examples_for "a process" do |process_type|
 
   it { expect(process.definition).to eq(definition)  }
   it { expect(process.uuid).to_not be_nil }
-  it { expect(process.name).to eq('name')  }
   it { expect(process.to_s).to match(/#{process.uuid}/) }
   it { expect(process.options).to_not be_nil }
   it { expect(process.tasks).to_not be_nil }

data/spec/examples/task_examples.rb

@@ -9,7 +9,6 @@ shared_examples_for "a task" do |task_type|
 
   it { expect(task.process).to eq(process)  }
   it { expect(task.uuid).to_not be_nil }
-  it { expect(task.name).to eq('name')  }
   it { expect(task.to_s).to match(/#{task.uuid}/) }
   it { expect(task.options).to_not be_nil }
 

data/spec/support/test_flow.rb

@@ -2,33 +2,33 @@ module TestFlow
   extend Taskinator::Definition
 
   define_process do
-    task '~', :error_task, :continue_on_error => true
+    task :error_task, :continue_on_error => true
 
-    task 'A', :the_task
+    task :the_task
 
-    for_each 'Items', :iterator do
-      task 'B', :the_task
+    for_each :iterator do
+      task :the_task
     end
 
-    sequential 'C' do
-      task 'C1', :the_task
-      task 'C2', :the_task
-      task 'C3', :the_task
+    sequential do
+      task :the_task
+      task :the_task
+      task :the_task
     end
 
-    task 'D', :the_task
+    task :the_task
 
-    concurrent 'E' do
+    concurrent do
       20.times do |i|
-        task "E#{i+1}", :the_task
+        task :the_task
       end
-      task 'Ennnn', :the_task
+      task :the_task
     end
 
-    task 'F', :the_task
+    task :the_task
 
     # invoke the specified sub process
-    sub_process 'G', TestSubFlow
+    sub_process TestSubFlow
   end
 
   def error_task(*args)
@@ -53,9 +53,9 @@ module TestFlow
     extend Taskinator::Definition
 
     define_process do
-      task 'SubA', :the_task
-      task 'SubB', :the_task
-      task 'SubC', :the_task
+      task :the_task
+      task :the_task
+      task :the_task
     end
 
     def the_task(*args)

data/spec/taskinator/complex_process_spec.rb

@@ -7,7 +7,6 @@ describe TestFlow, :redis => true do
     processB = Taskinator::Process.fetch(processA.uuid)
 
     expect(processB.uuid).to eq(processA.uuid)
-    expect(processB.name).to eq(processA.name)
     expect(processB.definition).to eq(processA.definition)
     expect(processB.options).to eq(processA.options)
 
@@ -18,7 +17,6 @@ describe TestFlow, :redis => true do
     tasks.each do |(taskB, taskA)|
       expect(taskA.process).to eq(taskB.process)
       expect(taskA.uuid).to eq(taskB.uuid)
-      expect(taskA.name).to eq(taskB.name)
       expect(taskA.options).to eq(taskB.options)
     end
   end

data/spec/taskinator/definition/builder_spec.rb

@@ -12,7 +12,7 @@ describe Taskinator::Definition::Builder do
   end
 
   let(:process) {
-    Class.new(Taskinator::Process).new('name', definition)
+    Class.new(Taskinator::Process).new(definition)
   }
 
   let(:args) { [:arg1, :arg2] }
@@ -35,18 +35,18 @@ describe Taskinator::Definition::Builder do
   describe "#sequential" do
     it "invokes supplied block" do
       expect(block).to receive(:call)
-      subject.sequential('name', &define_block)
+      subject.sequential(&define_block)
     end
 
     it "creates a sequential process" do
       allow(block).to receive(:call)
-      expect(Taskinator::Process).to receive(:define_sequential_process_for).with('name', definition, {}).and_call_original
-      subject.sequential('name', &define_block)
+      expect(Taskinator::Process).to receive(:define_sequential_process_for).with(definition, {}).and_call_original
+      subject.sequential(&define_block)
     end
 
     it "fails if block isn't given" do
       expect {
-        subject.sequential('name')
+        subject.sequential()
       }.to raise_error(ArgumentError)
     end
   end
@@ -54,18 +54,18 @@ describe Taskinator::Definition::Builder do
   describe "#concurrent" do
     it "invokes supplied block" do
       expect(block).to receive(:call)
-      subject.concurrent('name', &define_block)
+      subject.concurrent(&define_block)
     end
 
     it "creates a concurrent process" do
       allow(block).to receive(:call)
-      expect(Taskinator::Process).to receive(:define_concurrent_process_for).with('name', definition, Taskinator::CompleteOn::First, {}).and_call_original
-      subject.concurrent('name', Taskinator::CompleteOn::First, &define_block)
+      expect(Taskinator::Process).to receive(:define_concurrent_process_for).with(definition, Taskinator::CompleteOn::First, {}).and_call_original
+      subject.concurrent(Taskinator::CompleteOn::First, &define_block)
     end
 
     it "fails if block isn't given" do
       expect {
-        subject.concurrent('name')
+        subject.concurrent()
       }.to raise_error(ArgumentError)
     end
   end
@@ -87,43 +87,43 @@ describe Taskinator::Definition::Builder do
 
       expect(block).to receive(:call).exactly(3).times
 
-      subject.for_each('name', :iterator_method, &define_block)
+      subject.for_each(:iterator_method, &define_block)
     end
 
     it "fails if iterator method is nil" do
       expect {
-        subject.for_each('name', nil, &define_block)
+        subject.for_each(nil, &define_block)
       }.to raise_error(ArgumentError)
     end
 
     it "fails if iterator method is not defined" do
       expect {
-        subject.for_each('name', :undefined_iterator, &define_block)
+        subject.for_each(:undefined_iterator, &define_block)
       }.to raise_error(NoMethodError)
     end
 
     it "fails if block isn't given" do
       expect {
-        subject.for_each('name', nil)
+        subject.for_each(nil)
       }.to raise_error(ArgumentError)
     end
   end
 
   describe "#task" do
     it "creates a task" do
-      expect(Taskinator::Task).to receive(:define_step_task).with('name', process, :task_method, args, {})
-      subject.task('name', :task_method)
+      expect(Taskinator::Task).to receive(:define_step_task).with(process, :task_method, args, {})
+      subject.task(:task_method)
     end
 
     it "fails if task method is nil" do
       expect {
-        subject.task('name', nil)
+        subject.task(nil)
       }.to raise_error(ArgumentError)
     end
 
     it "fails if task method is not defined" do
       expect {
-        subject.task('name', :undefined_method)
+        subject.task(:undefined_method)
       }.to raise_error(NoMethodError)
     end
   end
@@ -139,14 +139,14 @@ describe Taskinator::Definition::Builder do
 
     it "creates a sub process" do
       expect(sub_definition).to receive(:create_process).with(*args).and_call_original
-      subject.sub_process('name', sub_definition)
+      subject.sub_process(sub_definition)
     end
 
     it "creates a sub process task" do
       sub_process = sub_definition.create_process(:argX, :argY)
       allow(sub_definition).to receive(:create_process) { sub_process }
-      expect(Taskinator::Task).to receive(:define_sub_process_task).with('name', process, sub_process, {})
-      subject.sub_process('name', sub_definition)
+      expect(Taskinator::Task).to receive(:define_sub_process_task).with(process, sub_process, {})
+      subject.sub_process(sub_definition)
     end
   end
 

data/spec/taskinator/persistence_spec.rb

@@ -75,7 +75,7 @@ describe Taskinator::Persistence, :redis => true do
       end
 
       describe "for processes" do
-        let(:process) { TestProcess.new('name', definition) }
+        let(:process) { TestProcess.new(definition) }
 
         it {
           process.save
@@ -84,8 +84,8 @@ describe Taskinator::Persistence, :redis => true do
       end
 
       describe "for tasks" do
-        let(:process) { TestProcess.new('name', definition) }
-        let(:task) { TestTask.new('name', process) }
+        let(:process) { TestProcess.new(definition) }
+        let(:task) { TestTask.new(process) }
 
         it {
           process.tasks << task

data/spec/taskinator/process_spec.rb

@@ -10,11 +10,10 @@ describe Taskinator::Process do
 
   describe "Base" do
 
-    subject { Class.new(Taskinator::Process).new('name', definition) }
+    subject { Class.new(Taskinator::Process).new(definition) }
 
     describe "#initialize" do
       it { expect(subject.uuid).to_not be_nil }
-      it { expect(subject.name).to_not be_nil }
       it { expect(subject.definition).to_not be_nil }
       it { expect(subject.definition).to eq(definition) }
       it { expect(subject.options).to_not be_nil }
@@ -46,6 +45,14 @@ describe Taskinator::Process do
       it { expect(subject.current_state.name).to eq(:initial) }
     end
 
+    describe "#tasks_completed?" do
+      it {
+        expect {
+          subject.tasks_completed?
+        }.to raise_error(NotImplementedError)
+      }
+    end
+
     describe "workflow" do
       describe "#enqueue!" do
         it { expect(subject).to respond_to(:enqueue!) }
@@ -166,7 +173,6 @@ describe Taskinator::Process do
         visitor = double('visitor')
         expect(visitor).to receive(:visit_type).with(:definition)
         expect(visitor).to receive(:visit_attribute).with(:uuid)
-        expect(visitor).to receive(:visit_attribute).with(:name)
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_task_reference).with(:parent)
         expect(visitor).to receive(:visit_tasks)
@@ -179,28 +185,28 @@ describe Taskinator::Process do
   describe Taskinator::Process::Sequential do
 
     it_should_behave_like "a process", Taskinator::Process::Sequential do
-      let(:process) { Taskinator::Process.define_sequential_process_for('name', definition) }
+      let(:process) { Taskinator::Process.define_sequential_process_for(definition) }
     end
 
-    subject { Taskinator::Process.define_sequential_process_for('name', definition) }
+    subject { Taskinator::Process.define_sequential_process_for(definition) }
 
     let(:tasks) {
       [
-        Class.new(Taskinator::Task).new('task1', subject),
-        Class.new(Taskinator::Task).new('task2', subject)
+        Class.new(Taskinator::Task).new(subject),
+        Class.new(Taskinator::Task).new(subject)
       ]
     }
 
     describe ".define_sequential_process_for" do
       it "raise error for nil definition" do
         expect {
-          Taskinator::Process.define_sequential_process_for('name', nil)
+          Taskinator::Process.define_sequential_process_for(nil)
         }.to raise_error(ArgumentError)
       end
 
       it "raise error for invalid definition" do
         expect {
-          Taskinator::Process.define_sequential_process_for('name', Object)
+          Taskinator::Process.define_sequential_process_for(Object)
         }.to raise_error(ArgumentError)
       end
     end
@@ -274,7 +280,6 @@ describe Taskinator::Process do
         visitor = double('visitor')
         expect(visitor).to receive(:visit_type).with(:definition)
         expect(visitor).to receive(:visit_attribute).with(:uuid)
-        expect(visitor).to receive(:visit_attribute).with(:name)
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_task_reference).with(:parent)
         expect(visitor).to receive(:visit_tasks)
@@ -286,30 +291,30 @@ describe Taskinator::Process do
 
   describe Taskinator::Process::Concurrent do
     it_should_behave_like "a process", Taskinator::Process::Concurrent do
-      let(:process) { Taskinator::Process.define_concurrent_process_for('name', definition, Taskinator::CompleteOn::First) }
+      let(:process) { Taskinator::Process.define_concurrent_process_for(definition, Taskinator::CompleteOn::First) }
 
       it { expect(process.complete_on).to eq(Taskinator::CompleteOn::First)  }
     end
 
-    subject { Taskinator::Process.define_concurrent_process_for('name', definition) }
+    subject { Taskinator::Process.define_concurrent_process_for(definition) }
 
     let(:tasks) {
       [
-        Class.new(Taskinator::Task).new('task1', subject),
-        Class.new(Taskinator::Task).new('task2', subject)
+        Class.new(Taskinator::Task).new(subject),
+        Class.new(Taskinator::Task).new(subject)
       ]
     }
 
     describe ".define_concurrent_process_for" do
       it "raise error for nil definition" do
         expect {
-          Taskinator::Process.define_concurrent_process_for('name', nil)
+          Taskinator::Process.define_concurrent_process_for(nil)
         }.to raise_error(ArgumentError)
       end
 
       it "raise error for invalid definition" do
         expect {
-          Taskinator::Process.define_concurrent_process_for('name', Object)
+          Taskinator::Process.define_concurrent_process_for(Object)
         }.to raise_error(ArgumentError)
       end
     end
@@ -344,7 +349,7 @@ describe Taskinator::Process do
     describe "#tasks_completed?" do
 
       describe "complete on first" do
-        let(:process) { Taskinator::Process.define_concurrent_process_for('name', definition, Taskinator::CompleteOn::First) }
+        let(:process) { Taskinator::Process.define_concurrent_process_for(definition, Taskinator::CompleteOn::First) }
 
         it "yields false when no tasks have completed" do
           tasks.each {|t| process.tasks << t }
@@ -363,7 +368,7 @@ describe Taskinator::Process do
       end
 
       describe "complete on last" do
-        let(:process) { Taskinator::Process.define_concurrent_process_for('name', definition, Taskinator::CompleteOn::Last) }
+        let(:process) { Taskinator::Process.define_concurrent_process_for(definition, Taskinator::CompleteOn::Last) }
 
         it "yields false when no tasks have completed" do
           tasks.each {|t| process.tasks << t }
@@ -401,7 +406,6 @@ describe Taskinator::Process do
         visitor = double('visitor')
         expect(visitor).to receive(:visit_type).with(:definition)
         expect(visitor).to receive(:visit_attribute).with(:uuid)
-        expect(visitor).to receive(:visit_attribute).with(:name)
         expect(visitor).to receive(:visit_attribute).with(:complete_on)
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_task_reference).with(:parent)

data/spec/taskinator/task_spec.rb

@@ -10,14 +10,13 @@ describe Taskinator::Task do
 
   describe "Base" do
 
-    let(:process) { Class.new(Taskinator::Process).new('name', definition) }
-    subject { Class.new(Taskinator::Task).new('name', process) }
+    let(:process) { Class.new(Taskinator::Process).new(definition) }
+    subject { Class.new(Taskinator::Task).new(process) }
 
     describe "#initialize" do
       it { expect(subject.process).to_not be_nil }
       it { expect(subject.process).to eq(process) }
       it { expect(subject.uuid).to_not be_nil }
-      it { expect(subject.name).to_not be_nil }
       it { expect(subject.options).to_not be_nil }
     end
 
@@ -43,6 +42,14 @@ describe Taskinator::Task do
       it { expect(subject.current_state.name).to eq(:initial) }
     end
 
+    describe "#can_complete_task?" do
+      it {
+        expect {
+          subject.can_complete_task?
+        }.to raise_error(NotImplementedError)
+      }
+    end
+
     describe "workflow" do
       describe "#enqueue!" do
         it { expect(subject).to respond_to(:enqueue!) }
@@ -128,7 +135,6 @@ describe Taskinator::Task do
       it {
         visitor = double('visitor')
         expect(visitor).to receive(:visit_attribute).with(:uuid)
-        expect(visitor).to receive(:visit_attribute).with(:name)
         expect(visitor).to receive(:visit_process_reference).with(:process)
         expect(visitor).to receive(:visit_task_reference).with(:next)
         expect(visitor).to receive(:visit_args).with(:options)
@@ -140,12 +146,12 @@ describe Taskinator::Task do
 
   describe Taskinator::Task::Step do
     it_should_behave_like "a task", Taskinator::Task::Step do
-      let(:process) { Class.new(Taskinator::Process).new('process', definition) }
-      let(:task) { Taskinator::Task.define_step_task('name', process, :method, {:a => 1, :b => 2}) }
+      let(:process) { Class.new(Taskinator::Process).new(definition) }
+      let(:task) { Taskinator::Task.define_step_task(process, :method, {:a => 1, :b => 2}) }
     end
 
-    let(:process) { Class.new(Taskinator::Process).new('process', definition) }
-    subject { Taskinator::Task.define_step_task('name', process, :method, {:a => 1, :b => 2}) }
+    let(:process) { Class.new(Taskinator::Process).new(definition) }
+    subject { Taskinator::Task.define_step_task(process, :method, {:a => 1, :b => 2}) }
 
     describe "#executor" do
       it { expect(subject.executor).to_not be_nil }
@@ -184,7 +190,6 @@ describe Taskinator::Task do
         visitor = double('visitor')
         expect(visitor).to receive(:visit_type).with(:definition)
         expect(visitor).to receive(:visit_attribute).with(:uuid)
-        expect(visitor).to receive(:visit_attribute).with(:name)
         expect(visitor).to receive(:visit_process_reference).with(:process)
         expect(visitor).to receive(:visit_task_reference).with(:next)
         expect(visitor).to receive(:visit_args).with(:options)
@@ -198,14 +203,14 @@ describe Taskinator::Task do
 
   describe Taskinator::Task::SubProcess do
     it_should_behave_like "a task", Taskinator::Task::SubProcess do
-      let(:process) { Class.new(Taskinator::Process).new('process', definition) }
-      let(:sub_process) { Class.new(Taskinator::Process).new('sub_process', definition) }
-      let(:task) { Taskinator::Task.define_sub_process_task('name', process, sub_process) }
+      let(:process) { Class.new(Taskinator::Process).new(definition) }
+      let(:sub_process) { Class.new(Taskinator::Process).new(definition) }
+      let(:task) { Taskinator::Task.define_sub_process_task(process, sub_process) }
     end
 
-    let(:process) { Class.new(Taskinator::Process).new('process', definition) }
-    let(:sub_process) { Class.new(Taskinator::Process).new('sub_process', definition) }
-    subject { Taskinator::Task.define_sub_process_task('name', process, sub_process) }
+    let(:process) { Class.new(Taskinator::Process).new(definition) }
+    let(:sub_process) { Class.new(Taskinator::Process).new(definition) }
+    subject { Taskinator::Task.define_sub_process_task(process, sub_process) }
 
     describe "#start!" do
       it "delegates to sub process" do
@@ -236,7 +241,6 @@ describe Taskinator::Task do
       it {
         visitor = double('visitor')
         expect(visitor).to receive(:visit_attribute).with(:uuid)
-        expect(visitor).to receive(:visit_attribute).with(:name)
         expect(visitor).to receive(:visit_process_reference).with(:process)
         expect(visitor).to receive(:visit_task_reference).with(:next)
         expect(visitor).to receive(:visit_args).with(:options)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taskinator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Chris Stefano