resque-async 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 82a081a18ff934bada8285c11636890167dabebc
-  data.tar.gz: ed7c2763ac18fb93febfd05f501603bb0fd831f7
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmE0NzRhYWZlMmQ4YThhZGQzZDgwY2I4MjU2MThiMGVhNTU0MWVkNg==
+  data.tar.gz: !binary |-
+    NzVkYjJiOTYyZThlYjBmYWNjMTk5MWZkMDNjNzhmZWYzN2NhY2RiMA==
 SHA512:
-  metadata.gz: ced53755853e7c5b82a8fb3586ea2dcc9a2e6ff4da0cc7a87f83a03dc73501344a7bc25034b17cba323a74257f0f056351a44d2b34042e4756acdb10fd8ad4f1
-  data.tar.gz: 5f1532534f510bd6f11b98f0f141d60a7b320aa9987da58b39c82fa2cddfac04a975f57a087a66dd92d1c06bb02faedae033977603faa090146e58f464baffea
+  metadata.gz: !binary |-
+    NDdmZjg4ZmEwYmRiZDdmOGQ3NjY0OTBlZGMwYTNlNDZiYjhhMTUyYWZhMzBk
+    N2ZhOTMxZTc5ZmQxZWI4MGFkMTg3MjM0MzMyNmYyODUzNDRiZGJjZGU2ZmZi
+    MTVjNWI4NzNlMDZmMmVjYzUwZTJhN2M1ODg5OGY1ZmY3OTliNjA=
+  data.tar.gz: !binary |-
+    YzQwMDMwMmM4NTNlMWIyNTYxM2ZjYjA5YjY4OTcwY2VhYTcyNmEzZTY2NmYz
+    MjAwZThiZWYyZjgwZDhkYTlkYzYwYTkxODRhOWEzMGU3NDQwZTRhMjc2NzIw
+    ZDg1ZDEyNGEwZTcyMjRkZWIzMGM2MjM1MTYwN2M1NThjNzA5ODU=

data/README.md

@@ -1,7 +1,7 @@
 # ResqueAsync
 
 A simple way to invoke methods asynchronously using Resque. There are a few gems that provide similar functionality.
-However We like the more declarative syntax with this implementation. As it gives the caller control over the invocation
+However this this implementation provides more expressive syntax that it gives the caller control over the invocation.
 
 ## Installation
 
@@ -21,19 +21,43 @@ Or install it yourself as:
 
 ## Usage
 
+Assuming
+
+```ruby
+class MyObject < ActiveRecord::Base
+    def self.slow_class_method
+    end
+    def slow_instance_method
+    end
+end
+```
+
 Supports Class Methods and ActiveRecord instance methods
 
 ```ruby
 MyObject.async(:high).slow_class_method
-record_instance.async(:medium).slow_instance_method
+
+# ActiveRecord instances will be queued/loaded/invoked asynchronously
+MyObject.new.async(:medium).slow_instance_method
 ```
 
-Support high, medium, low priority out of the box. As well as custom work/queue
+Natural synchronous invocation
+```ruby
+    MyObject.slow_class_method
+    MyObject.new.slow_instance_method
+```
+
+Support high, medium, low priority out of the box. As well as custom worker/queue
 
 ```ruby
-MyObject.async(:high).high_priority
-MyObject.async(:medium).medium_priority
-MyObject.async(:low).low_priority
+# slow_class_method queued/invoked on 'high' queue
+MyObject.async(:high).slow_class_method
+
+# slow_class_method queued/invoked on 'medium' queue
+MyObject.async(:medium).slow_class_method
+
+# slow_class_method queued/invoked on 'low' queue
+MyObject.async(:low).slow_class_method
 ```
 OR
 ```ruby
@@ -44,10 +68,37 @@ end
 MyObject.async(MyCustomerWorker).crazy_priority
 ```
 
+## What about resque-async-method?
+
+[resque-async-method](https://github.com/nragaz/resque-async-method) hides the fact that a method may be invoked asynchronously. 
+From the caller's perspective things can get really confusing.
+
+With resque-async-method
+```ruby
+class MyObject < ActiveRecord::Base
+    def slow_method
+    end
+    async_method :slow_method
+end
+
+# is this async or not? What does result equal? Better check the implementation of MyObject
+result = MyObject.new.slow_method 
+```
+
+With resque-async
+```ruby
+class MyObject < ActiveRecord::Base
+    def slow_method
+    end
+end
+
+# this should be pretty obvious, even years later, that slow_method is invoked async
+d = MyObject.new.async(:low).slow_method
+```
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/resque-async/fork )
+1. Fork it ( https://github.com/exitround/resque-async/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/resque-async/enqueuers.rb

@@ -23,6 +23,8 @@ module ResqueAsync
             worker = Workers::MediumPriorityClassMethod
           when :low
             worker = Workers::LowPriorityClassMethod
+          when :realtime
+            return args.empty? ? @host_class.send(methId.id2name) : @host_class.send(methId.id2name, *args)
           else
             raise StandardError('Unknown priority')
         end

data/lib/resque-async/version.rb

@@ -1,3 +1,3 @@
 module ResqueAsync
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resque-async
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Greg Dean
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2015-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -128,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Simple way of invoking methods asynchronously using resque.
@@ -142,4 +142,3 @@ test_files:
 - spec/support/mock_host.rb
 - spec/support/worker.rb
 - spec/workers_spec.rb
-has_rdoc: