async_io 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e768d314c92eac6b9cfc337526f1ac1ae05f11f6
-  data.tar.gz: 8bf2812033baa2729bfc2e1ba980b10f3fa0a759
+  metadata.gz: 589bbfd6ddea54eacdcfb7d11444a98c69ebb135
+  data.tar.gz: 420bbac2e0bebdfd57aa1b18d90194cdcabd2b15
 SHA512:
-  metadata.gz: a21e691691577890b5bbcb3a05dcda8356a3d420a675d337ebbfa3704b686e4a6b7eabc29e962d8ee6a42bc79cb9540ce18c54803334dd4eed7d341a86b838e1
-  data.tar.gz: b10b690d35df4cea199cb0be527d054bdb1582c36fa95db246f7949a51d105de6868019cbdc9616b64e64489d1c922dc1833aee88cd9f395dffd4c357be60a9a
+  metadata.gz: 6abe1c74a64b278ae7a0752177099f51863a25bd2e09890c54332e69259c2eed1ea3b269ecc1707c27054784ff160d4b81995fdb480919d94284daa9a5a3c210
+  data.tar.gz: ccc8233103beacdace8692b3eb379f7dca07b3f434b9a21d57aa3f132a47a2370c65cdaea7f5cafacad2fbd16f18d9744018132e405f99707cb23c34f666520a

data/lib/async_io.rb

@@ -26,12 +26,12 @@ module AsyncIO
   # how it is available within a block later on.
   # NOTE: You must pass a job ( i.e ruby block ).
   #
-  def self.async(payload = proc{}, &job)
-    async_creator.worker(payload, &job)
+  def self.async(task = proc {}, &payload)
+    async_creator.worker(payload, task)
   end
 
-  def self.async_with(job)
-    async_creator.async_with(job)
+  def self.async_with(task)
+    async_creator.async_with(task)
   end
 
 end

data/lib/async_io/base.rb

@@ -42,8 +42,8 @@ module AsyncIO
 
     ##
     # It creates a new Worker, pushes it onto the queue,
-    # whenever a 'job' (i.e a Ruby object ) is finished
-    # it calls the payload and passes the result of job
+    # whenever a 'task' (i.e a Ruby object ) is finished
+    # it calls the payload and passes the result of that task
     # to it.
     #
     # For example:
@@ -54,45 +54,41 @@ module AsyncIO
     #   end
     # end
     #
-    # It returns the worker created for a particular job
+    # It returns the worker created for this particular task
     # which you could send message +done+ to it in order
-    # to retrieve its job done.
-    # see prediction_io/worker.rb
+    # to retrieve its completed task.
+    # see async_io/worker.rb
     #
     # For example:
     # result = aget_user(1) { |u| Logger.info(u.name) }
     #
-    # # job may take a while to be done...
+    # # task may take a while to be done...
     #
     # user = result.done
     # user.name
     # => "John"
     #
-    # NOTE: Whenever you use the snippet above, if the job
+    # NOTE: Whenever you use the snippet above, if the task
     # has not been finished yet you will get +false+
-    # whenever you send a message +job+ to it. Once
-    # job is finished you will be able to get its result.
+    # whenever you send a message +task+ to it. Once
+    # task is finished you will be able to get its result.
     #
-    def worker(payload, job)
-      rescuer do
-        Worker.new(payload, job).tap { |w|
-          queue.push(w)
-        }
-      end
+    def worker(payload, task)
+      Worker.new(payload, task).tap { |w| queue.push(w) }
     end
 
     ##
     # Perform any sort of task that needs to be
     # asynchronously done.
     # NOTE: It does not return anything, as it receives
-    # and empty job. ( i.e empty block of code )
+    # and empty task. ( i.e empty block of code )
     #
     def async(&payload)
       worker(payload, proc {})
     end
 
-    def async_with(job)
-      worker(proc {}, job)
+    def async_with(task)
+      worker(proc {}, task)
     end
 
     ##

data/lib/async_io/version.rb

@@ -1,3 +1,3 @@
 module AsyncIo
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/async_io/worker.rb

@@ -6,20 +6,20 @@ module AsyncIO
   class Worker
     include AsyncIO::Rescuer
 
-    attr_reader :payload, :job
+    attr_reader :payload, :task
     attr_reader :finished, :done
 
-    def initialize(payload, job)
+    def initialize(payload, task)
       @payload  = payload
-      @job      = job
+      @task     = task
       @done     = false
       @finished = false
     end
 
     ##
     # It sends payload a message +call+
-    # and passes the result of a job, by sending
-    # job a message +call+ as well, as its argument.
+    # and passes the result of task, by sending
+    # task a message +call+ as well, as its argument.
     # This allows us to do:
     #
     # aget_user(1) { |u| print u.name }
@@ -35,7 +35,7 @@ module AsyncIO
     # payload = Object.new
     # def payload.call(result); warn(result); end
     #
-    # job is pre-definied inside a method, it can
+    # task is pre-definied inside a method, it can
     # be anything, for example:
     # worker(payload) do
     #   User.find(uid)
@@ -43,14 +43,13 @@ module AsyncIO
     #
     def call
       try do
-        @finished = true
-        @done = job.call
-        payload.call(done)
+        @done = task.call
+        payload.call(done).tap { @finished = true }
       end
     end
 
     ##
-    # Tries to get the first job done, when an exception
+    # Tries to get the first task done, when an exception
     # is raised it then calls payload again passing a
     # fallback as its argument.
     #
@@ -70,7 +69,7 @@ module AsyncIO
       # from being raised.
       # It returns an instance of OpenStruct object with the
       # exception rescued ( i.e notice ) and the worker that
-      # was assigned to this particular job.
+      # was assigned to this particular task.
       #
       def fallback(notice)
         OpenStruct.new({ notice: notice, worker: self })

data/spec/async_io/base_spec.rb

@@ -71,19 +71,16 @@ describe AsyncIO::Base do
     # closures while using blocks.
     # The following might be helpul:
     # robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas
-
+    #
+    #
+    # See the link below for a better understading how to
+    # pass/call blocks of code in Ruby.
+    # pragdave.pragprog.com/pragdave/2005/11/symbolto_proc.html
     #
     it "should pass this payload block onto Worker" do
-      payload = -> { :im_an_async_job }
-
+      payload = -> { :im_a_payload }
       worker = double
       alien.stub(:worker).and_return(worker)
-
-      ##
-      # See the link below for a better understading how to
-      # pass/call blocks of code in Ruby.
-      # pragdave.pragprog.com/pragdave/2005/11/symbolto_proc.html
-      #
       alien.async(&payload)
 
       alien.should have_received(:worker).with( payload, kind_of(Proc) )
@@ -91,7 +88,7 @@ describe AsyncIO::Base do
   end
 
   context "#interval" do
-    it "executes a job in a given interval" do
+    it "executes a task within a given interval" do
       alien.should_receive(:new_interval?)
       alien.interval(0.0001) { sleep(10) }
     end

data/spec/async_io/worker_spec.rb

@@ -9,33 +9,21 @@ module AsyncIO
   describe Worker do
 
     let(:payload) { ->(r) { r } }
-    let(:job)     { -> { :am_a_dog } }
-    let(:worker)  { Worker.new(payload, job) }
-
-    context "initialising" do
-
-      it "must take a payload" do
-        worker.payload.should be_kind_of Proc
-      end
-
-      it "must take a job" do
-        worker.job.should be_kind_of Proc
-      end
-
-    end
+    let(:task)    { -> { :am_a_dog } }
+    let(:worker)  { Worker.new(payload, task) }
 
     it { worker.should respond_to :done }
 
-    it "should not be done as job is not finished" do
+    it "should not be done as task is not finished" do
       worker.done.should be_false
     end
 
-    it "must call payload and pass job as its argument" do
+    it "must call payload and pass task as its argument" do
       worker.call.should eq(:am_a_dog)
     end
 
-    context "Getting a job done" do
-      it "should set done to its last finished job" do
+    context "Getting a task done" do
+      it "should set done to its last finished task" do
         worker.call
         worker.done.should eq(:am_a_dog)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async_io
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Antonio C Nalesso