asynchronize 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 912acc8b2e852aa7ccdd7fc09193f46fa64730f74972e9a955b8ba2bf3e40f1f
-  data.tar.gz: c6b91b991495bb45ce6580596c9919a4a376437f3c441706c63f84a62941c77e
+  metadata.gz: d25d9fc46fcd88c468cb2441bf096e15773103f9ca2ad0d1930bdcc3f4e71b33
+  data.tar.gz: aab5b2f4c851c924dba5789282b7b575810ff1cf70bed84e5be0b167d8b1e2e5
 SHA512:
-  metadata.gz: 86f7e988a2b97f36bb951045fca9214fd81b53239ae6a2fe5c0330a01f6f81c51bfcdb73052e2ac07bf434ec47dd362005274fa54243f8b3be9e4ec74fe53a96
-  data.tar.gz: 274687d5e6b292d4f6bbf85515c95f9d4eb84bef5b8c9b5a51f6fd363ed99000ee7e36ff30672d6b714009077a637b3ecc43746a726631164b12d44d7ac1b563
+  metadata.gz: 54aed3b7e306361c981dfeb275ca0721ac3e02c9570fe34fdf02affab88c8fbbc1df6f771870bfe64eb9964731ef6842e09c11351236b37680bbb7c34fe119e2
+  data.tar.gz: ff384dc8ef4a33a885bdd05aaf33e065cbe5093964a05f549db37ddd8d16178dafd22f80f3edd9c41240eb7b634e74ff7cab2c1f46378430cba61d0bfb681214

data/lib/asynchronize.rb

@@ -4,15 +4,15 @@
 #   Defines only one method on the including class: `asynchronize`
 #
 module Asynchronize
+  # Defines the asynchronize method
   def self.included(base)
     base.class_eval do
       ##
       # Call to asynchronize a method.
       #
       #   This does two things
-      #   1. Creates and prepends a module named Asynchronized.
-      #   2. Scopes that module to the calling class.
-      #   3. Defines each of the passed methods on that module.
+      #   1. Creates and prepends a module <BaseName>::Asynchronized.
+      #   2. Defines each of the passed methods on that module.
       #
       #   Additional notes:
       #   - The new methods wrap the old method within Thread.new.
@@ -53,7 +53,7 @@ module Asynchronize
   ##
   # Build Method
   #
-  #  This always returns the same Proc object. In it's own method for clarity.
+  #   This always returns the same Proc object. In it's own method for clarity.
   #
   # @return [Proc] The actual asynchronous method defined.
   #
@@ -61,7 +61,8 @@ module Asynchronize
     return Proc.new do |*args, &block|
       return Thread.new(args, block) do |thread_args, thread_block|
         Thread.current[:return_value] = super(*thread_args)
-        thread_block.call(Thread.current[:return_value]) if thread_block
+        next thread_block.call(Thread.current[:return_value]) if thread_block
+        Thread.current[:return_value]
       end
     end
   end
@@ -74,7 +75,7 @@ module Asynchronize
   #   - If the container module is defined, return it.
   #   - If the container module is not defined, create, prepend, and return it.
   #
-  # @param obj [Class] The Class to prepend our module to
+  # @param obj [Class] The class the module should belong to.
   # @return [Module] The already prepended module to define our methods on.
   #
   def self._get_container_for(obj)

data/readme.md

@@ -2,7 +2,7 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/30d40e270a3d7a0775a9/maintainability)](https://codeclimate.com/github/kennycoc/asynchronize/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/30d40e270a3d7a0775a9/test_coverage)](https://codeclimate.com/github/kennycoc/asynchronize/test_coverage)
 # Asynchronize
-### A declarative syntax for creating multithreaded methods.
+### A declarative syntax for creating asynchronous methods.
 
 Find yourself writing the same boilerplate for all your asynchronous methods?
 Get dry with asynchronize.
@@ -16,10 +16,10 @@ Create a class with asynchronized methods
 require 'asynchronize'
 class Test
   include Asynchronize
-  # Can be called before or after the definitions. I prefer it at the top of classes.
+  # Can be called before or after method definitions. I prefer it at the top of classes.
   asynchronize :my_test, :my_other_test
   def my_test
-    return 'test'
+    return 'testing'
   end
   def my_other_test
     #do stuff here too
@@ -28,26 +28,29 @@ end
 ```
 
 Now, to call those methods.
-You can manage the thread yourself; the returned value will be in the thread
-variable `:return_value` once it returns.
+You can pass a block, and access the return value as the block parameter. The
+return value from your block will be accessible at `Thread#value` and the return
+value from the original function will be accessible via the thread variable
+`:return_value`.
 ```Ruby
-thread = Test.new.my_test
-puts thread.join[:return_value] # > test
+thread = Test.new.my_test do |return_value|
+  return return_value.length
+end
+thread.value          # > 7
+thread[:return_value] # > testing
 ```
 
-Or to stay asynchronous when processing the result, you can pass it a block.
-It will still return the thread, and the return value will still be in the
-thread variable `:return_value`
+Or, without a block `Thread#value` and `thread[:return_value]` both reference
+the return value of the original function.
 ```Ruby
-thread = Test.new.my_test do |return_value|
-  puts return_value # > test
-end
-thread.join[:return_value] # > also test
+thread = Test.new.my_test
+puts thread.value          # > testing
+puts thread[:return_value] # > testing
 ```
 
-As you can see, it's just a regular thread. Make sure you call `Thread#join` to
-ensure it completes before your process exits, and to catch any exceptions that
-may have been thrown!
+As you can see, it's just a regular thread. Make sure you call either
+`Thread#value` or`Thread#join` to ensure it completes before your process exits,
+and to catch any exceptions that may have been thrown!
 
 ## Inspiration
 While working on another project, I found myself writing this way too often:
@@ -59,23 +62,23 @@ def method_name(args)
 end
 ```
 It's extra typing, and adds an unneeded extra layer of nesting. I couldn't find
-an existing library that wasn't trying add new layers of abstraction to
-memorize; sometimes you just want a normal thread. Now, just call asynchronize
-to make any method asynchronous.
+an existing library that wasn't trying add new layers of abstraction I didn't
+need; sometimes you just want a normal thread. Now, just call asynchronize to
+make any method asynchronous.
 
 ## Versioning Policy
-
-Beginning with version 1.0.0, this project will follow [Semantic Versioning]
-(https://semver.org) until then, the patch number (0.0.x) will be
+Beginning with version 1.0.0, this project will follow [Semantic
+Versioning](https://semver.org). Until then, the patch number (0.0.x) will be
 updated for any changes that do not affect the public interface. Versions that
-increment the minor number will have at least one of the following. A new
+increment the minor number (0.x.0) will have at least one of the following. A new
 feature will be added, some feature will be deprecated, or some previously
 deprecated feature will be removed. Deprecated features will be removed on the
 very next version that increments the minor version number.
 
 ## FAQ
 ### Doesn't metaprogramming hurt performance?
-Not at all! It actually works just like inheritance, so it won't be a problem.
+Not at all! What we're doing in this project actually works exactly like
+inheritance, so it won't be a problem.
 
 ### So, how does it work?
 When you `include Asynchronize` it creates an `asynchronize` method on your
@@ -90,10 +93,9 @@ method's return values, I thought it was important to allow this.
 
 ### Why do I need another gem? My code's bloated enough as it is?
 It's super tiny. Just a light wrapper around the existing language features.
-Seriously, it's just around forty lines of code as of version 0.3.0. Actually,
-according to [cloc](https://www.npmjs.com/package/cloc) there's almost four
-times as many lines in the tests as the source. You should read it, I'd love
-feedback!
+Seriously, it's just around forty lines of code. Actually, according to
+[cloc](https://www.npmjs.com/package/cloc) there's almost four times as many
+lines in the tests as the source. You should read it, I'd love feedback!
 
 ### Do you accept contributions?
 Absolutely!
@@ -118,7 +120,7 @@ preventing usage of `super` with `define_method`. I'm unable to find a suitable
 workaround for this issue. (`method(__method__).super_method.call` causes
 problems when a method inherits from the asynchronized class.)
 
-Luckily, all major Ruby implementations support Ruby language version 2.3. So I
+Luckily, all major Ruby implementations support Ruby language version 2.3, so I
 don't see this as a huge problem. If anyone wants support for older versions,
 and knows how to workaround this issue, feel free to submit a pull request.
 

data/spec/spec.rb

@@ -9,6 +9,9 @@ class BasicSpec < Minitest::Test
         def test(val=5)
           return val
         end
+        def another_test(val=5)
+          return val
+        end
       end
     end
     after do
@@ -111,25 +114,31 @@ class BasicSpec < Minitest::Test
       end
       it "should be able to call super when super has been asynchronized" do
         class Test
-          asynchronize :test
+          asynchronize :another_test
         end
         class ChildClassTest
-          undef_method :test
-          def test
+          def another_test
             return super.join[:return_value] + 1
           end
         end
-        ChildClassTest.new.test.must_equal 6
+        ChildClassTest.new.another_test.must_equal 6
       end
     end
 
-    describe "when asynchronize is called with no arguments" do
-      it "should not define an Asynchronized container" do
+    describe "when asynchronize is called" do
+      it "should not define an Asynchronized container if there are no arguments" do
         Test.asynchronize
         Test.ancestors.find do |a|
           a.name.split('::').include? 'Asynchronized'
         end.must_be_nil
       end
+      it "should not define two modules if we call it twice" do
+        Test.asynchronize :test
+        Test.asynchronize :another_test
+        Test.ancestors.select do |a|
+          a.name.split('::').include? 'Asynchronized'
+        end.length.must_equal 1
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asynchronize
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kenneth Cochran
@@ -66,7 +66,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.11'
-description: Sometimes you just want a regular thread without the overhead of a whole
+description: Asynchronize provides a declarative syntax for creating asynchronous
+  methods. Sometimes you just want a regular thread without the overhead of a whole
   new layer of abstraction. Asynchronize provides a declarative syntax to wrap any
   method in a Thread.
 email: kenneth.cochran101@gmail.com
@@ -102,7 +103,7 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: A declarative syntax for creating multithreaded methods.
+summary: A declarative syntax for creating asynchronous methods.
 test_files:
 - spec/spec.rb
 - spec/minitest_helper.rb