observed 0.2.0.rc1 → 0.2.0.rc2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjAzODY3YWFkYmE3ZWM3MGFmYzkzY2Y4ZjI4MTExNmQyYjRmZTJjOQ==
+    YjRlMjYwYzAwNDlkNzZiM2RkNzllNGRhYjgxMGQyNGEzMjFiMzBiNw==
   data.tar.gz: !binary |-
-    YzdlNTAyYWNmNzZmNWNlODNmYTA0MDY4ZjFjM2RlMWFlNTFhNjFlMw==
+    NDg2OTI4MDVjNzcxNTczMGE3YWNhZmM5Zjk3M2RlYjc1MWYzZjllNg==
 SHA512:
   metadata.gz: !binary |-
-    Y2UzMWZiYjliOGE0MDRiMGVhZTE1ZGExOWQzNzBjYjU5YzM4MDM3OWE0MWRh
-    OWJjYWRlNDc5YjhjMGRmNTY1NGI0Yzg0MWMxY2Q1NjdjZjA1MGZjNjYzODU0
-    MDA1ZGM4MjE5MDQzYTMxNWYwNjExYzYzMmUyOTFkYzBjNzFlYTM=
+    NzkyMGY1NzMzOWM3NTJmZDlhMTE3OTQyYzk1MTU4N2U5ZWU3YTY4NzRlNDc5
+    ZmM0ZTIxNDQ5ODFiNGIxN2Y4NDhkZjFhM2ViMjhkNWMzNjFiY2ZhY2U4MWE5
+    NzIzMmI1NjNkNTUzY2FhMWE1NjlmOTMyMDY4OTRjY2QxZTZlYTc=
   data.tar.gz: !binary |-
-    NTZhM2U0Nzg3M2ViMjMzNDM1NTI3YTZlOTUwOWE1NDk0OGNiMGM3Y2MwNWVi
-    MGZhOTZkY2YxMzBkYzZhNWJhM2M2MmQyMWFjYzE2YWY3YTRmM2Y2ZGViYjEx
-    ZDg5YzM5YmQzZTY4MDg0NTE3YTJlNTRhNWMwNTAzOGYzYWUxNmY=
+    OTdkODQ1YzhhOWRlMzA1NGY1OGFjY2UzOWU5NjA2OTU2NjBiZWU4Y2RjNmE0
+    Y2I0MDJkNzdhNzZhOGQ3ZWUzOTExZDI2ODMwM2M2MmE0YzFiYTAwN2JmOWI1
+    ZGM2ZDNiNTQzZmIyMWEwYjIzNGJhNmVlNjVlZTVmMjU0M2E4NGE=

data/lib/observed/basic_event_bus.rb

@@ -0,0 +1,32 @@
+require 'thread'
+require 'monitor'
+
+module Observed
+  class BasicEventBus
+    def initialize
+      @monitor = ::Monitor.new
+      @subscribers = []
+    end
+    def emit(tag, *params)
+      handle_event(tag, *params)
+    end
+
+    def on_receive(pattern, &block)
+      @monitor.synchronize do
+        @subscribers.push [pattern, block]
+      end
+    end
+
+    private
+
+    def handle_event(tag, *params)
+      @monitor.synchronize do
+        @subscribers.each do |pattern, s|
+          if pattern.match(tag)
+            s.call *params
+          end
+        end
+      end
+    end
+  end
+end

data/lib/observed/config_builder.rb

@@ -6,7 +6,7 @@ require 'observed/configurable'
 require 'observed/default'
 require 'observed/hash'
 require 'observed/translator'
-require 'observed/execution_job_factory'
+require 'observed/observed_task_factory'
 
 module Observed
 
@@ -110,7 +110,7 @@ module Observed
                  end
 
       reporters << reporter
-      report_it = convert_to_job(reporter)
+      report_it = convert_to_task(reporter)
       if tag_pattern
         receive(tag_pattern).then(report_it)
       end
@@ -167,7 +167,7 @@ module Observed
                  else
                    fail "No args valid args (in args=#{args}) or a block given"
                  end
-      observe_that = convert_to_job(observer)
+      observe_that = convert_to_task(observer)
       result = if tag
         a = observe_that.then(emit(tag))
         group tag, (group(tag) + [a])
@@ -176,6 +176,7 @@ module Observed
         observe_that
       end
       observers << result
+      result.name = "observe"
       result
     end
 
@@ -191,15 +192,19 @@ module Observed
                    else
                      Observed::ProcTranslator.new &block
                  end
-      convert_to_job(translator)
+      task = convert_to_task(translator)
+      task.name = "translate"
+      task
     end
 
     def emit(tag)
-      @context.jobbed_event_bus.pipe_to_emit(tag)
+      e = @context.event_bus.emit(tag)
+      e.name = "emit to #{tag}"
+      e
     end
 
     def receive(pattern)
-      @context.jobbed_event_bus.receive(pattern)
+      @context.event_bus.receive(pattern)
     end
 
     # Updates or get the observations belongs to the group named `name`
@@ -212,7 +217,7 @@ module Observed
     end
 
     def run_group(name)
-      @context.job_factory.parallel(group(name))
+      @context.task_factory.parallel(group(name))
     end
 
     def reporters
@@ -225,9 +230,9 @@ module Observed
 
     private
 
-    def convert_to_job(underlying)
-      @execution_job_factory ||= @context.execution_job_factory
-      @execution_job_factory.convert_to_job(underlying)
+    def convert_to_task(underlying)
+      @observed_task_factory ||= @context.observed_task_factory
+      @observed_task_factory.convert_to_task(underlying)
     end
   end
 

data/lib/observed/context.rb

@@ -3,8 +3,8 @@ require 'logger'
 require 'observed/system'
 require 'observed/config_builder'
 require 'observed/config_dsl'
-require 'observed/job'
-require 'observed/jobbed_event_bus'
+require 'observed/task'
+require 'observed/event_bus'
 
 module Observed
   # The run context of an Observed system.
@@ -46,19 +46,19 @@ module Observed
     end
 
     def executor
-      @executor ||= Observed::BlockingJobExecutor.new
+      @executor ||= Observed::BlockingExecutor.new
     end
 
-    def jobbed_event_bus
-      @event_bus ||= Observed::JobbedEventBus.new(job_factory: job_factory)
+    def event_bus
+      @event_bus ||= Observed::EventBus.new(task_factory: task_factory)
     end
 
-    def job_factory
-      @job_factory ||= Observed::JobFactory.new(executor: executor)
+    def task_factory
+      @task_factory ||= Observed::TaskFactory.new(executor: executor)
     end
 
-    def execution_job_factory
-      @execution_job_factory ||= Observed::ExecutionJobFactory.new(job_factory: job_factory)
+    def observed_task_factory
+      @observed_task_factory ||= Observed::ObservedTaskFactory.new(task_factory: task_factory)
     end
 
     def config_builder

data/lib/observed/event_bus.rb

@@ -1,31 +1,28 @@
 require 'thread'
+require 'observed/basic_event_bus'
 
 module Observed
   class EventBus
-    def initialize
+    def initialize(args={})
+      @bus = Observed::BasicEventBus.new
+      @receives = {}
+      @task_factory = args[:task_factory] || fail("The parameter :task_factory is missing in args(#{args}")
       @mutex = ::Mutex.new
-      @subscribers = []
     end
     def emit(tag, *params)
-      handle_event(tag, *params)
+      @task_factory.task { |*params|
+        @bus.emit tag, *params
+        params
+      }
     end
-
-    def on_receive(pattern, &block)
-      @mutex.synchronize do
-        @subscribers.push [pattern, block]
-      end
-    end
-
-    private
-
-    def handle_event(tag, *params)
-      @mutex.synchronize do
-        @subscribers.each do |pattern, s|
-          if pattern.match(tag)
-            s.call *params
-          end
-        end
+    def receive(pattern)
+      task = @task_factory.mutable_task {|data, options|
+        [data, options]
+      }
+      @bus.on_receive(pattern) do |*params|
+        task.now(*params)
       end
+      task
     end
   end
 end

data/lib/observed/{execution_job_factory.rb → observed_task_factory.rb}

@@ -1,7 +1,7 @@
 require 'observed/observer'
 require 'observed/reporter'
 require 'observed/translator'
-require 'observed/job'
+require 'observed/task'
 
 module Observed
   # An yet another cushion from the deprecated plugin interface to the new plugin interface
@@ -38,16 +38,16 @@ module Observed
     end
   end
 
-  class ExecutionJobFactory
+  class ObservedTaskFactory
 
     def initialize(args={})
-      @job_factory = args[:job_factory] || Observed::JobFactory.new(executor: Observed::BlockingJobExecutor.new)
+      @task_factory = args[:task_factory] || Observed::TaskFactory.new(executor: Observed::BlockingExecutor.new)
     end
 
-    # Convert the observer/translator/reporter to a job
-    def convert_to_job(underlying)
+    # Convert the observer/translator/reporter to a task
+    def convert_to_task(underlying)
       if underlying.is_a? Observed::Observer
-        @job_factory.job {|data, options|
+        @task_factory.task {|data, options|
           options ||= {}
           m = underlying.method(:observe)
           fake_system = FakeSystem.new(time: options[:time])
@@ -58,19 +58,19 @@ module Observed
           fake_system.reported || result
         }
       elsif underlying.is_a? Observed::Reporter
-        @job_factory.job {|data, options|
+        @task_factory.task {|data, options|
           options ||= {}
           m = underlying.method(:report)
           dispatch_method m, data, options
         }
       elsif underlying.is_a? Observed::Translator
-        @job_factory.job {|data, options|
+        @task_factory.task {|data, options|
           options ||= {}
           m = underlying.method(:translate)
           dispatch_method m, data, options
         }
       else
-        fail "Unexpected type of object which can not be converted to a job: #{underlying}"
+        fail "Unexpected type of object which can not be converted to a task: #{underlying}"
       end
     end
 

data/lib/observed/{job.rb → task.rb}

@@ -2,81 +2,89 @@ require 'logger'
 require 'thread'
 
 module Observed
-  class Job
-    def then(*jobs)
-      next_job = if jobs.size == 1
-                   jobs.first
-                 elsif jobs.size > 1
-                   ParallelJob.new(jobs)
+  class Task
+    attr_accessor :name
+
+    def then(*tasks)
+      next_task = if tasks.size == 1
+                   tasks.first
+                 elsif tasks.size > 1
+                   ParallelTask.new(tasks)
                  else
-                   raise 'No jobs to be executed'
+                   raise 'No tasks to be executed'
                  end
-      SequenceJob.new(self, next_job)
+      SequenceTask.new(self, next_task)
+    end
+
+    def compose(first_task)
+      second_task = self
+
+      first_task.then(second_task)
     end
   end
 
-  class MutableJob
-    def initialize(current_job)
-      @current_job = current_job
+  class MutableTask
+    def initialize(current_task)
+      @current_task = current_task
       @mutex = Mutex.new
     end
     def now(data={}, options=nil)
-      @current_job.now(data, options) do |data, options2|
+      @current_task.now(data, options) do |data, options2|
         yield data, (options2 || options) if block_given?
       end
     end
-    def then(*jobs)
+    def then(*tasks)
       @mutex.synchronize do
-        @current_job = @current_job.then(*jobs)
+        @current_task = @current_task.then(*tasks)
       end
       self
     end
   end
 
-  class SequenceJob < Job
-    attr_reader :base_job
-    def initialize(base_job, next_job)
-      @base_job = base_job
-      @next_job = next_job
+  class SequenceTask < Observed::Task
+    attr_reader :base_task
+    def initialize(base_task, next_task)
+      @base_task = base_task
+      @next_task = next_task
     end
     def now(data={}, options=nil)
-      @base_job.now(data, options) do |data, options2|
-        @next_job.now(data, (options2 || options)) do |data, options3|
+      @base_task.now(data, options) do |data, options2|
+        @next_task.now(data, (options2 || options)) do |data, options3|
           yield data, (options3 || options2 || options) if block_given?
         end
       end
     end
   end
 
-  class ParallelJob < Job
-    def initialize(jobs)
-      @jobs = jobs || fail('jobs missing')
-      @next_job = NoOpJob.instance
+  class ParallelTask < Observed::Task
+    def initialize(tasks)
+      @tasks = tasks || fail('tasks missing')
+      @next_task = NoOpTask.instance
     end
     def now(data={}, options=nil)
-      @jobs.each do |job|
-        job.now(data, options) do |data, options2|
+      @tasks.each do |task|
+        task.now(data, options) do |data, options2|
           yield data, (options2 || options) if block_given?
         end
       end
     end
   end
 
-  class NoOpJob < Job
+  class NoOpTask < Observed::Task
     def now(data={}, options={}); end
     def self.instance
       SINGLETON_INSTANCE
     end
-    SINGLETON_INSTANCE = NoOpJob.new
+    SINGLETON_INSTANCE = NoOpTask.new
   end
 
-  class ProcJob < Job
+  class ProcTask < Observed::Task
     def initialize(args, &block)
       @executor = args[:executor] || fail('Missing a value for :executor')
       @listener = args[:listener] || fail('Missing a value for :listener')
       @logger = args[:logger]
       @block = block
-      @next_job = NoOpJob.instance
+      @next_task = NoOpTask.instance
 
       if @logger.nil?
         @logger = ::Logger.new(STDERR)
@@ -84,7 +92,7 @@ module Observed
       end
     end
     def now(data={}, options=nil)
-      @executor.execute {
+      @executor.submit {
         result = @block.call(data, options)
         yield result if block_given?
         notify_listener(data: data, options: options, result: result)
@@ -118,43 +126,43 @@ module Observed
     end
   end
 
-  class JobListener
+  class TaskListener
     def on_result(data={}, options={})
 
     end
   end
 
-  class JobFactory
+  class TaskFactory
     def initialize(args)
       @executor = args[:executor] || fail('Missing a value for :executor')
-      @listener = args[:listener] || JobListener.new
+      @listener = args[:listener] || TaskListener.new
     end
 
-    def job(&block)
-      ProcJob.new(executor: @executor, listener: @listener, &block)
+    def task(&block)
+      ProcTask.new(executor: @executor, listener: @listener, &block)
     end
 
-    def mutable_job(&block)
-      MutableJob.new(job(&block))
+    def mutable_task(&block)
+      MutableTask.new(task(&block))
     end
 
-    def parallel(jobs)
-      ParallelJob.new(jobs)
+    def parallel(tasks)
+      ParallelTask.new(tasks)
     end
   end
 
-  class JobExecutor
-    def execute; end
+  class Executor
+    def submit; end
   end
 
-  class BlockingJobExecutor
-    def execute
+  class BlockingExecutor
+    def submit
       yield
     end
   end
 
-  class ThreadedJobExecutor
-    def execute
+  class ThreadExecutor
+    def submit
       Thread.start {
         yield
       }

data/lib/observed/version.rb

@@ -1,3 +1,3 @@
 module Observed
-  VERSION = '0.2.0.rc1'
+  VERSION = '0.2.0.rc2'
 end

data/run-integration-tests

@@ -8,6 +8,8 @@
 rvm gemset create observed-test
 rvm gemset use observed-test
 
+gem install bundler
+
 observed_dir=`dirname $0`
 
 cd $observed_dir

data/spec/basic_event_bus_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'observed/basic_event_bus'
+
+describe Observed::BasicEventBus do
+  it 'calls the handler for the emitted event' do
+    handler_one_called = false
+    handler_two_called = false
+    bus = Observed::BasicEventBus.new
+    expect { bus.emit('foo') }.to_not raise_error
+    expect { bus.on_receive(/^bar$/) { handler_one_called = true } }.to_not raise_error
+    expect { bus.on_receive(/^baz$/) { handler_two_called = true } }.to_not raise_error
+    expect { bus.emit('bar') }.to_not raise_error
+    expect(handler_one_called).to be_true
+    expect(handler_two_called).to be_false
+  end
+end

data/spec/event_bus_spec.rb

@@ -1,16 +1,30 @@
 require 'spec_helper'
+
+require 'observed/task'
 require 'observed/event_bus'
 
 describe Observed::EventBus do
-  it 'calls the handler for the emitted event' do
-    handler_one_called = false
-    handler_two_called = false
-    bus = Observed::EventBus.new
-    expect { bus.emit('foo') }.to_not raise_error
-    expect { bus.on_receive(/^bar$/) { handler_one_called = true } }.to_not raise_error
-    expect { bus.on_receive(/^baz$/) { handler_two_called = true } }.to_not raise_error
-    expect { bus.emit('bar') }.to_not raise_error
-    expect(handler_one_called).to be_true
-    expect(handler_two_called).to be_false
+  let(:out) {
+    mock('out')
+  }
+  let(:factory) {
+    executor = Observed::BlockingExecutor.new
+    Observed::TaskFactory.new(executor: executor)
+  }
+  let(:the_task) {
+    factory.task { |data, options|
+      out.write data, options
+    }
+  }
+  let(:bus) {
+    Observed::EventBus.new(task_factory: factory)
+  }
+  it 'should invoke tasks when the corresponding events are emitted' do
+    bus.emit('foo').now
+    bus.receive(/^bar$/).then(the_task)
+    bus.emit('baz').now
+    out.expects(:write).with({a:1}, {b:2})
+    bus.emit('bar').now({a:1}, {b:2})
+    bus.emit('blah').now
   end
 end

data/spec/observed_spec.rb

@@ -79,9 +79,9 @@ describe Observed do
 
   describe 'when included' do
     subject {
-      Module.new do
-        extend Observed
-      end
+      ctx = ::Object.new
+      ctx.extend Observed
+      ctx
     }
     let(:t) {
       Time.now
@@ -91,11 +91,11 @@ describe Observed do
     }
     let(:out) {
       out = mock('out1')
-      out.expects(:write).with(tag:'t', foo:1, foo2:1, bar:2, bar2:2, baz:3, baz2:3, r3:'common', time: t)
-        .at_least_once
       out
     }
     it 'can be used to define components and trigger them immediately' do
+      out.expects(:write).with(tag:'t', foo:1, foo2:1, bar:2, bar2:2, baz:3, baz2:3, r3:'common', time: t)
+        .at_least_once
       report_to_out = subject.report do |data, options|
         out.write data.merge(baz2:data[:baz]).merge(r3: common).merge(options)
       end
@@ -139,6 +139,9 @@ describe Observed do
             out.write data.merge({baz2:data[:baz],r3:common}.merge(options))
           end
         end
+
+        out.expects(:write).with(tag:'t', foo:1, foo2:1, bar:2, bar2:2, baz:3, baz2:3, r3:'common', time: t)
+          .at_least_once
       }
       it 'can be used to define components from plugins and trigger them immediately' do
         observe_then_translate_then_report = (subject.observe via: 'test1')
@@ -148,52 +151,52 @@ describe Observed do
         observe_then_translate_then_report.now({foo:1}, {tag: 't', time: t, out: out})
       end
       it 'can be used to send and receive tagged events' do
-        require 'observed/job'
-        require 'observed/jobbed_event_bus'
-        executor = Observed::BlockingJobExecutor.new
-        job_factory = Observed::JobFactory.new(executor: executor)
-        bus = Observed::JobbedEventBus.new(job_factory: job_factory)
+        require 'observed/task'
+        require 'observed/event_bus'
+        executor = Observed::BlockingExecutor.new
+        task_factory = Observed::TaskFactory.new(executor: executor)
+        bus = Observed::EventBus.new(task_factory: task_factory)
 
         observe_then_send = (subject.observe via: 'test1')
-          .then(bus.pipe_to_emit 'foo')
+          .then(bus.emit 'foo1')
 
-        bus.receive(/foo/)
+        bus.receive(/foo1/)
           .then(subject.translate via: 'test1')
           .then(subject.report via: 'test1', with: {common: common})
 
         observe_then_send.now({foo:1}, {tag: 't', time: t, out: out})
       end
       it 'can be used to send and receive tagged events with the default event bus' do
-        require 'observed/job'
+        require 'observed/task'
 
-        subject.configure executor: Observed::BlockingJobExecutor.new
+        subject.configure executor: Observed::BlockingExecutor.new
 
         observe_then_send = (subject.observe via: 'test1')
-          .then(subject.emit 'foo')
+          .then(subject.emit 'foo2')
 
-        subject.receive(/foo/)
+        subject.receive(/foo2/)
           .then(subject.translate via: 'test1')
           .then(subject.report via: 'test1', with: {common: common})
 
         observe_then_send.now({foo:1}, {tag: 't', time: t, out: out})
       end
       it 'provides the way to send the tagged events with a bit shorter code' do
-        require 'observed/job'
+        require 'observed/task'
 
-        subject.configure executor: Observed::BlockingJobExecutor.new
+        subject.configure executor: Observed::BlockingExecutor.new
 
-        observe_then_send = (subject.observe 'foo', via: 'test1')
+        observe_then_send = (subject.observe 'foo3', via: 'test1')
 
-        subject.receive(/foo/)
+        subject.receive(/foo3/)
           .then(subject.translate via: 'test1')
           .then(subject.report via: 'test1', with: {out: out, common: common})
 
         observe_then_send.now({foo:1}, {tag: 't', time: t, out: out})
       end
       it 'provides the way to receive the tagged events with a bit shorter code' do
-        require 'observed/job'
+        require 'observed/task'
 
-        subject.configure executor: Observed::BlockingJobExecutor.new
+        subject.configure executor: Observed::BlockingExecutor.new
 
         observe_then_send = (subject.observe via: 'test1')
           .then(subject.translate via: 'test1')
@@ -204,9 +207,9 @@ describe Observed do
         observe_then_send.now({foo:1}, {tag: 't', time: t, out: out})
       end
       it 'provides the way to group up observations' do
-        require 'observed/job'
+        require 'observed/task'
 
-        subject.configure executor: Observed::BlockingJobExecutor.new
+        subject.configure executor: Observed::BlockingExecutor.new
 
         subject.group :a, [
           (subject.observe via: 'test1')
@@ -221,9 +224,9 @@ describe Observed do
         end
       end
       it 'provides the way to group up observations by their tags' do
-        require 'observed/job'
+        require 'observed/task'
 
-        subject.configure executor: Observed::BlockingJobExecutor.new
+        subject.configure executor: Observed::BlockingExecutor.new
 
         subject.observe 'hoge', via: 'test1'
 
@@ -236,9 +239,9 @@ describe Observed do
         end
       end
       it 'provides the way to run a group of observations in single method call' do
-        require 'observed/job'
+        require 'observed/task'
 
-        subject.configure executor: Observed::BlockingJobExecutor.new
+        subject.configure executor: Observed::BlockingExecutor.new
 
         subject.observe 'hoge', via: 'test1'
 
@@ -249,9 +252,9 @@ describe Observed do
         subject.run_group('hoge').now({foo:1}, {tag: 't', time: t, out: out})
       end
       it 'provides a short-cut for running a group of observations' do
-        require 'observed/job'
+        require 'observed/task'
 
-        subject.configure executor: Observed::BlockingJobExecutor.new
+        subject.configure executor: Observed::BlockingExecutor.new
 
         subject.observe 'fuga', via: 'test1'
 
@@ -262,9 +265,9 @@ describe Observed do
         subject.run('fuga', {foo:1}, {tag: 't', time: t, out: out})
       end
       it 'provides the default values for the option `tag` and `time`' do
-        require 'observed/job'
+        require 'observed/task'
 
-        subject.configure executor: Observed::BlockingJobExecutor.new
+        subject.configure executor: Observed::BlockingExecutor.new
 
         subject.observe 't', via: 'test1'
 
@@ -276,6 +279,68 @@ describe Observed do
 
         subject.run('t', {foo:1}, {out: out})
       end
+      it 'allows to use emit/receive for subscribing to internal events' do
+        require 'observed/task'
+
+        subject.configure executor: Observed::BlockingExecutor.new
+
+        subject.receive('foo123')
+          .then(
+            (subject.observe via: 'test1')
+              .then(subject.translate via: 'test1')
+              .then(subject.report via: 'test1', with: {out: out, common: common})
+          )
+
+        ::Time.stubs(now: t)
+
+        subject.emit('foo123').now({foo:1}, {out: out, tag: 't', time: Time.now})
+      end
+      it 'allows to use emit/receive for subscribing to internal events to trigger receive/translate/report' do
+        require 'observed/task'
+
+        subject.configure executor: Observed::BlockingExecutor.new
+
+        subject.receive('kuroko1')
+          .then(subject.observe via: 'test1')
+          .then(subject.translate via: 'test1')
+          .then(subject.emit 'kuroko2')
+
+        subject.receive('kuroko2')
+          .then(subject.report via: 'test1', with: {out: out, common: common})
+
+        ::Time.stubs(now: t)
+
+        subject.emit('kuroko1').now({foo:1}, {out: out, tag: 't', time: Time.now})
+      end
+      it 'allows to just report something' do
+        require 'observed/task'
+
+        subject.configure executor: Observed::BlockingExecutor.new
+
+        subject.receive('kuroko3')
+          .then(subject.report via: 'test1', with: {out: out, common: common})
+
+        ::Time.stubs(now: t)
+
+        subject.emit('kuroko3').now({foo:1, foo2:1, bar:2, bar2:2, baz: 3, baz2:3, r3: common}, {out: out, tag: 't', time: Time.now})
+      end
+      it 'allows a kind of reactive programming' do
+        require 'observed/task'
+
+        subject.configure executor: Observed::BlockingExecutor.new
+
+        subject.report(via: 'test1', with: {out: out, common: common}).compose(
+            subject.translate(via: 'test1').compose(
+                subject.observe(via: 'test1').compose(
+                    subject.receive('kuroko4')
+                )
+            )
+        )
+
+        ::Time.stubs(now: t)
+
+        subject.emit('kuroko4').now({foo:1, foo2:1, bar:2, bar2:2, baz: 3, baz2:3, r3: common}, {out: out, tag: 't', time: Time.now})
+      end
     end
 
   end

data/spec/{execution_job_factory_spec.rb → observed_task_factory_spec.rb}

@@ -1,11 +1,11 @@
 require 'spec_helper'
-require 'observed/execution_job_factory'
+require 'observed/observed_task_factory'
 
-describe Observed::ExecutionJobFactory do
+describe Observed::ObservedTaskFactory do
   subject {
-    Observed::ExecutionJobFactory.new
+    Observed::ObservedTaskFactory.new
   }
-  it 'should convert observers, translators, reporters to jobs' do
+  it 'should convert observers, translators, reporters to tasks' do
     output = mock('output')
 
     the_observer = Class.new(Observed::Observer) do
@@ -24,12 +24,12 @@ describe Observed::ExecutionJobFactory do
         data.merge(c:3)
       end
     end.new
-    job = subject.convert_to_job(the_observer)
-      .then(subject.convert_to_job(the_translator))
-      .then(subject.convert_to_job(the_reporter))
+    task = subject.convert_to_task(the_observer)
+      .then(subject.convert_to_task(the_translator))
+      .then(subject.convert_to_task(the_reporter))
     tag = 'the_tag'
     time = Time.now
     output.expects(:write).with(tag: tag, time: time, data: {a:1,b:2,c:3})
-    job.now({a:1}, {tag: tag, time: time})
+    task.now({a:1}, {tag: tag, time: time})
   end
 end

data/spec/{job_factory_spec.rb → task_factory_spec.rb}

@@ -1,16 +1,16 @@
 require 'spec_helper'
-require 'observed/job'
+require 'observed/task'
 
-describe Observed::JobFactory do
+describe Observed::TaskFactory do
   context 'when the executor not given' do
     it 'fails to initialize' do
-      expect { Observed::JobFactory.new() }.to raise_error
+      expect { Observed::TaskFactory.new() }.to raise_error
     end
   end
 
   context 'when a logger given' do
     it 'may prefer the given logger over the default one' do
-      Observed::JobFactory.new(executor: mock('executor'), logger: ::Logger.new(STDERR))
+      Observed::TaskFactory.new(executor: mock('executor'), logger: ::Logger.new(STDERR))
     end
   end
 end

data/spec/{job_spec.rb → task_spec.rb}

@@ -1,46 +1,46 @@
 require 'spec_helper'
-require 'observed/job'
+require 'observed/task'
 
-describe Observed::MutableJob do
+describe Observed::MutableTask do
   let(:factory) {
-    Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+    Observed::TaskFactory.new(:executor => Observed::BlockingExecutor.new)
   }
 
   it 'yields the given block' do
     yielded = nil
-    job = factory.mutable_job { |data|
+    task = factory.mutable_task { |data|
       data
     }
-    job.now({a:1}, {b:2}) do |data, options|
+    task.now({a:1}, {b:2}) do |data, options|
       yielded = [data, options]
     end
     expect(yielded).to eq([{a:1}, {b:2}])
   end
 
-  it 'executes the job regardless of whether or not a block is given' do
+  it 'executes the task regardless of whether or not a block is given' do
     executed = nil
-    job = factory.mutable_job { |data, options|
+    task = factory.mutable_task { |data, options|
       executed = [data, options]
       data
     }
-    job.now({a:1}, {b:2})
+    task.now({a:1}, {b:2})
     expect(executed).to eq([{a:1}, {b:2}])
   end
 end
 
-describe Observed::ParallelJob do
+describe Observed::ParallelTask do
   let(:factory) {
-    Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+    Observed::TaskFactory.new(:executor => Observed::BlockingExecutor.new)
   }
 
   it 'yields the given block' do
-    job1 = factory.job { |data, |
+    task1 = factory.task { |data, |
       data.merge(c:3)
     }
-    job2 = factory.job { |data|
+    task2 = factory.task { |data|
       data.merge(d:4)
     }
-    par = Observed::ParallelJob.new([job1, job2])
+    par = Observed::ParallelTask.new([task1, task2])
     yielded = []
     par.now({a:1}, {b:2}) do |data, options|
       yielded.push([data, options])
@@ -48,37 +48,37 @@ describe Observed::ParallelJob do
     expect(yielded).to eq([[{a:1,c:3},{b:2}], [{a:1,d:4},{b:2}]])
   end
 
-  it 'executes the job regardless of whether or not a block is given' do
+  it 'executes the task regardless of whether or not a block is given' do
     executed = []
-    job1 = factory.job { |data, options|
+    task1 = factory.task { |data, options|
       r = data.merge(c:3)
       executed.push([r, options])
       r
     }
-    job2 = factory.job { |data, options|
+    task2 = factory.task { |data, options|
       r = data.merge(d:4)
       executed.push([r, options])
       r
     }
-    par = Observed::ParallelJob.new([job1, job2])
+    par = Observed::ParallelTask.new([task1, task2])
     par.now({a:1}, {b:2})
     expect(executed).to eq([[{a:1,c:3},{b:2}], [{a:1,d:4},{b:2}]])
   end
 end
 
-describe Observed::SequenceJob do
+describe Observed::SequenceTask do
   let(:factory) {
-    Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+    Observed::TaskFactory.new(:executor => Observed::BlockingExecutor.new)
   }
 
   it 'yields the given block' do
-    job1 = factory.job { |data|
+    task1 = factory.task { |data|
       data.merge(c:3)
     }
-    job2 = factory.job { |data|
+    task2 = factory.task { |data|
       data.merge(d:4)
     }
-    seq = Observed::SequenceJob.new(job1, job2)
+    seq = Observed::SequenceTask.new(task1, task2)
     yielded = []
     seq.now({a:1}, {b:2}) do |data, options|
       yielded.push([data, options])
@@ -86,82 +86,82 @@ describe Observed::SequenceJob do
     expect(yielded).to eq([[{a:1,c:3,d:4},{b:2}]])
   end
 
-  it 'executes the job regardless of whether or not a block is given' do
+  it 'executes the task regardless of whether or not a block is given' do
     executed = []
-    job1 = factory.job { |data, options|
+    task1 = factory.task { |data, options|
       r = data.merge(c:3)
       executed.push([r, options])
       r
     }
-    job2 = factory.job { |data, options|
+    task2 = factory.task { |data, options|
       r = data.merge(d:4)
       executed.push([r, options])
       r
     }
-    seq = Observed::SequenceJob.new(job1, job2)
+    seq = Observed::SequenceTask.new(task1, task2)
     seq.now({a:1}, {b:2})
     expect(executed).to eq([[{a:1,c:3},{b:2}], [{a:1,c:3,d:4},{b:2}]])
   end
 end
 
-describe Observed::Job do
+describe Observed::Task do
   context 'in simple use cases' do
     let(:factory) {
-      Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+      Observed::TaskFactory.new(:executor => Observed::BlockingExecutor.new)
     }
     context 'when the options as input are given' do
       it 'propagates the options from the input' do
-        job1 = factory.job { |data, options|
+        task1 = factory.task { |data, options|
           expect(options).to eq({b:2})
           data
         }
-        job2 = factory.job { |_, options|
+        task2 = factory.task { |_, options|
           expect(options).to eq({b:2})
         }
-        seq = job1.then(job2)
+        seq = task1.then(task2)
         seq.now({a:1}, {b:2})
       end
-      it 'allows to override the options from the input in subsequent jobs' do
-        job1 = factory.job { |data, options|
+      it 'allows to override the options from the input in subsequent tasks' do
+        task1 = factory.task { |data, options|
           expect(options).to eq({b:2})
           [data, {b:3}]
         }
-        job2 = factory.job { |_, options|
+        task2 = factory.task { |_, options|
           expect(options).to eq({b:3})
         }
-        seq = job1.then(job2)
+        seq = task1.then(task2)
         seq.now({a:1}, {b:2})
       end
     end
     context 'when the options as input are not given' do
-      it 'provides nil in the block parameter and allows to override it in subsequent jobs' do
-        job1 = factory.job { |data, options|
+      it 'provides nil in the block parameter and allows to override it in subsequent tasks' do
+        task1 = factory.task { |data, options|
           expect(options).to be_nil
           [data, {b:3}]
         }
-        job2 = factory.job { |_, options|
+        task2 = factory.task { |_, options|
           expect(options).to eq({b:3})
         }
-        seq = job1.then(job2)
+        seq = task1.then(task2)
         seq.now({a:1})
       end
     end
   end
   context 'when used in an immutable way' do
-    it 'propagates the resulting data to next jobs' do
-      factory = Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+    it 'propagates the resulting data to next tasks' do
+      factory = Observed::TaskFactory.new(:executor => Observed::BlockingExecutor.new)
       output = mock('output')
       input_data = { input: 1 }
-      a = factory.job { |data|
+      a = factory.task { |data|
         data.merge(a: 2)
       }
-      b = factory.job { |data, options|
+      b = factory.task { |data, options|
         data.merge(b: 3)
       }
-      c = factory.job { |data, options|
+      c = factory.task { |data, options|
         output.write data.merge(c: 4)
       }
-      d = factory.job { |data|
+      d = factory.task { |data|
         output.write data.merge(d: 5)
       }
       foo = a.then(b).then(c, d)
@@ -172,20 +172,20 @@ describe Observed::Job do
   end
 
   context 'when used in a mutable way' do
-    it 'propagates the resulting data to next jobs' do
-      factory = Observed::JobFactory.new(:executor => Observed::BlockingJobExecutor.new)
+    it 'propagates the resulting data to next tasks' do
+      factory = Observed::TaskFactory.new(:executor => Observed::BlockingExecutor.new)
       output = mock('output')
       input_data = { input: 1 }
-      a = factory.mutable_job { |data|
+      a = factory.mutable_task { |data|
         data.merge(a: 2)
       }
-      b = factory.job { |data, options|
+      b = factory.task { |data, options|
         data.merge(b: 3)
       }
-      c = factory.job { |data, options|
+      c = factory.task { |data, options|
         output.write data.merge(c: 4)
       }
-      d = factory.job { |data|
+      d = factory.task { |data|
         output.write data.merge(d: 5)
       }
       a.then(b).then(c, d)
@@ -199,22 +199,22 @@ describe Observed::Job do
     it 'notifies listeners with resulting data' do
 
       listener = mock('listener')
-      factory = Observed::JobFactory.new(
-          :executor => Observed::BlockingJobExecutor.new,
+      factory = Observed::TaskFactory.new(
+          :executor => Observed::BlockingExecutor.new,
           :listener => listener
       )
       output = mock('output')
       input_data = { input: 1 }
-      a = factory.job { |data|
+      a = factory.task { |data|
         data.merge(a: 2)
       }
-      b = factory.job { |data, options|
+      b = factory.task { |data, options|
         data.merge(b: 3)
       }
-      c = factory.job { |data, options|
+      c = factory.task { |data, options|
         output.write data.merge(c: 4)
       }
-      d = factory.job { |data|
+      d = factory.task { |data|
         output.write data.merge(d: 5)
       }
       foo = a.then(b).then(c, d)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: observed
 version: !ruby/object:Gem::Version
-  version: 0.2.0.rc1
+  version: 0.2.0.rc2
 platform: ruby
 authors:
 - KUOKA Yusuke
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2013-12-26 00:00:00.000000000 Z
+date: 2014-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -176,6 +176,7 @@ files:
 - lib/observed.rb
 - lib/observed/application.rb
 - lib/observed/application/oneshot.rb
+- lib/observed/basic_event_bus.rb
 - lib/observed/builtin_plugins.rb
 - lib/observed/builtin_plugins/file.rb
 - lib/observed/builtin_plugins/stdout.rb
@@ -187,14 +188,12 @@ files:
 - lib/observed/default.rb
 - lib/observed/default/observer.rb
 - lib/observed/event_bus.rb
-- lib/observed/execution_job_factory.rb
 - lib/observed/hash.rb
 - lib/observed/hash/builder.rb
 - lib/observed/hash/fetcher.rb
 - lib/observed/hash/key_path_encoding.rb
-- lib/observed/job.rb
-- lib/observed/jobbed_event_bus.rb
 - lib/observed/logging.rb
+- lib/observed/observed_task_factory.rb
 - lib/observed/observer.rb
 - lib/observed/observer_helpers/timer.rb
 - lib/observed/pluggable.rb
@@ -202,6 +201,7 @@ files:
 - lib/observed/reporter/regexp_matching.rb
 - lib/observed/reporter/report_formatting.rb
 - lib/observed/system.rb
+- lib/observed/task.rb
 - lib/observed/translator.rb
 - lib/observed/version.rb
 - observed.gemspec
@@ -259,13 +259,13 @@ files:
 - plugins/observed-shell/Gemfile
 - plugins/observed-shell/lib/observed/shell.rb
 - run-integration-tests
+- spec/basic_event_bus_spec.rb
 - spec/builtin_plugins/file_spec.rb
 - spec/builtin_plugins/stdout_spec.rb
 - spec/config_builder_spec.rb
 - spec/config_dsl_spec.rb
 - spec/configurable_spec.rb
 - spec/event_bus_spec.rb
-- spec/execution_job_factory_spec.rb
 - spec/fixtures/configure_by_conf/foo_plugin.rb
 - spec/fixtures/configure_by_conf/observed.conf
 - spec/fixtures/configure_by_conf_dot_d/foo_plugin.rb
@@ -275,16 +275,16 @@ files:
 - spec/hash/builder_spec.rb
 - spec/hash/fetcher_spec.rb
 - spec/input_helpers/timer_spec.rb
-- spec/job_factory_spec.rb
-- spec/job_spec.rb
-- spec/jobbed_event_bus_spec.rb
 - spec/observed_spec.rb
+- spec/observed_task_factory_spec.rb
 - spec/observer_helpers/timer_spec.rb
 - spec/observer_spec.rb
 - spec/oneshot_spec.rb
 - spec/reporter_spec.rb
 - spec/spec_helper.rb
 - spec/system_spec.rb
+- spec/task_factory_spec.rb
+- spec/task_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -314,13 +314,13 @@ test_files:
 - features/oneshot.feature
 - features/support/env.rb
 - features/test_in_single_ruby_source.feature
+- spec/basic_event_bus_spec.rb
 - spec/builtin_plugins/file_spec.rb
 - spec/builtin_plugins/stdout_spec.rb
 - spec/config_builder_spec.rb
 - spec/config_dsl_spec.rb
 - spec/configurable_spec.rb
 - spec/event_bus_spec.rb
-- spec/execution_job_factory_spec.rb
 - spec/fixtures/configure_by_conf/foo_plugin.rb
 - spec/fixtures/configure_by_conf/observed.conf
 - spec/fixtures/configure_by_conf_dot_d/foo_plugin.rb
@@ -330,13 +330,13 @@ test_files:
 - spec/hash/builder_spec.rb
 - spec/hash/fetcher_spec.rb
 - spec/input_helpers/timer_spec.rb
-- spec/job_factory_spec.rb
-- spec/job_spec.rb
-- spec/jobbed_event_bus_spec.rb
 - spec/observed_spec.rb
+- spec/observed_task_factory_spec.rb
 - spec/observer_helpers/timer_spec.rb
 - spec/observer_spec.rb
 - spec/oneshot_spec.rb
 - spec/reporter_spec.rb
 - spec/spec_helper.rb
 - spec/system_spec.rb
+- spec/task_factory_spec.rb
+- spec/task_spec.rb

data/lib/observed/jobbed_event_bus.rb

@@ -1,33 +0,0 @@
-require 'thread'
-require 'observed/event_bus'
-
-module Observed
-  class JobbedEventBus
-    def initialize(args={})
-      @bus = Observed::EventBus.new
-      @receives = {}
-      @job_factory = args[:job_factory] || fail("The parameter :job_factory is missing in args(#{args}")
-      @mutex = ::Mutex.new
-    end
-    def pipe_to_emit(tag)
-      @job_factory.job { |*params|
-        self.emit(tag, *params)
-        params
-      }
-    end
-    def emit(tag, *params)
-      @bus.emit tag, *params
-    end
-    def receive(pattern)
-      job = @job_factory.mutable_job {|data, options|
-        [data, options]
-      }
-      @bus.on_receive(pattern) do |*params|
-        @mutex.synchronize do
-          job.now(*params)
-        end
-      end
-      job
-    end
-  end
-end

data/spec/jobbed_event_bus_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-require 'observed/job'
-require 'observed/jobbed_event_bus'
-
-describe Observed::JobbedEventBus do
-  let(:out) {
-    mock('out')
-  }
-  let(:factory) {
-    executor = Observed::BlockingJobExecutor.new
-    Observed::JobFactory.new(executor: executor)
-  }
-  let(:the_job) {
-    factory.job { |data, options|
-      out.write data, options
-    }
-  }
-  let(:bus) {
-    Observed::JobbedEventBus.new(job_factory: factory)
-  }
-  it 'should invoke jobs when the corresponding events are emitted' do
-    bus.emit('foo')
-    bus.receive(/^bar$/).then(the_job)
-    bus.emit('baz')
-    out.expects(:write).with({a:1}, {b:2})
-    bus.emit('bar', {a:1}, {b:2})
-    bus.emit('blah')
-  end
-  it 'should return the job to emit events' do
-    bus.pipe_to_emit('foo').now
-    bus.receive(/^bar$/).then(the_job)
-    bus.pipe_to_emit('baz').now
-    out.expects(:write).with({a:1}, {b:2})
-    bus.pipe_to_emit('bar').now({a:1}, {b:2})
-    bus.pipe_to_emit('blah').now
-  end
-end