asynchronize 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af0aada41350e739802a92c04ef32bc64fbb897dd4d3ff7b0450c1485f9a243a
-  data.tar.gz: 457e2ccdf4b87955b8dc68011f8e7d84be3458fa6a83333f56b755457729121f
+  metadata.gz: eac19fda33067270bc4464149d1f02a9561cd6a994e004f9e73c0b288ae38f5c
+  data.tar.gz: 55301cee6db401579e3d8836c6485b4ae33e76f6319f98e6853f151076c77a83
 SHA512:
-  metadata.gz: d0f2214354035c147289553f31326709f7707a1a6a5a6101778f87198f18abd99c511763297f87662cec869426c20bae9ee5522d19232ce33878c4e238a573ae
-  data.tar.gz: 7abf0867f9c2e238f475b0925db4610194de9ef954baa48648d79492ae4fc89eaddba1e2801394cafc4034f675aaf5e5f4b0b80677c348404ef3b97cc81567af
+  metadata.gz: 1c06a933de8ec8aab5f2f97bf0943b5405a02ff3ff74f3612506cab6eb74117ac090f1810b5e3aa1a52b98babae51499fe8319c773e74cf41f6dbfa106d62c6b
+  data.tar.gz: 19661f53978d370e1cf80b34c1ee5a19bb7575a7f5600752ddd67960a4da6dc9148f3ac6c52e1cb06f249f99281cc6bc247e14642728fa4e6080552b8235ab9d

data/asynchronize.gemspec

@@ -2,7 +2,7 @@ require 'date'
 
 Gem::Specification.new do |s|
   s.name = 'asynchronize'
-  s.version = '0.1.2'
+  s.version = '0.2.0'
   s.date = Date.today.to_s
   s.summary = 'Easily make multiple methods asynchronous with one line of code.'
   s.description = 'Take any synchronous method, and run it asynchronously, ' +

data/lib/asynchronize.rb

@@ -3,13 +3,13 @@ module Asynchronize
   def self.included(base)
     base.class_eval do
       # The methods we have already asynchronized
-      @@asynced_methods = Set.new
+      @asynced_methods = Set.new
       # The methods that should be asynchronized.
-      @@methods_to_async = Set.new
+      @methods_to_async = Set.new
       # Originally used a single value here, but that's not thread safe.
       # ...Though you probably have other problems if you have multiple
       # threads adding methods to your class.
-      @@methods_asyncing = Set.new
+      @methods_asyncing = Set.new
 
       ##
       # Call to asynchronize a method.
@@ -23,19 +23,18 @@ module Asynchronize
       # @example To add any number of methods to be asynchronized.
       #   asynchronize :method1, :method2, :methodn
       def self.asynchronize(*methods)
-        @@methods_to_async.merge(methods)
+        @methods_to_async.merge(methods)
         methods.each do |method|
           # If it's not defined yet, we'll get it with method_added
-          next unless method_defined? method
+          next unless method_defined?(method)
           Asynchronize.create_new_method(method, self)
         end
       end
 
-      # require 'pry'; binding.pry
       # Save the old method_added so we don't overwrite it.
-      if self.methods.include? :method_added
+      if self.methods.include?(:method_added)
         singleton_class.send(:alias_method, :old_method_added, :method_added)
-        singleton_class.undef_method(:method_added)
+        singleton_class.send(:undef_method, :method_added)
       end
 
       ##
@@ -45,12 +44,14 @@ module Asynchronize
       #   anything else Ruby calls this automatically when defining a method; it
       #   should not be called directly.
       def self.method_added(method)
-        # Don't do anything else if we're not actually adding a new method
-        return if @@methods_asyncing.include? method
-        @@methods_asyncing.add(method)
-        self.old_method_added(method) if self.methods.include? :old_method_added
-        return unless @@methods_to_async.include? method
-        # This will delete from @@methods_asyncing
+        # Return if this is an inherited class that hasn't included asynchronize
+        return if @methods_asyncing.nil?
+        # Return if we're already processing this method
+        return if @methods_asyncing.include?(method)
+        @methods_asyncing.add(method)
+        self.old_method_added(method) if self.methods.include?(:old_method_added)
+        return unless @methods_to_async.include?(method)
+        # This will delete from @methods_asyncing
         Asynchronize.create_new_method(method, self)
       end
     end
@@ -63,13 +64,13 @@ module Asynchronize
       old_method = instance_method(method)
       # Can't just store the method name, since it would break if the method
       # was redefined.
-      return if @@asynced_methods.include?(old_method)
-      undef_method method
+      return if @asynced_methods.include?(old_method)
+      undef_method(method)
 
-      @@methods_asyncing.add(method)
+      @methods_asyncing.add(method)
       define_method(method, Asynchronize._build_new_method(old_method))
-      @@methods_asyncing.delete(method)
-      @@asynced_methods.add(instance_method(method))
+      @methods_asyncing.delete(method)
+      @asynced_methods.add(instance_method(method))
     end
   end
 
@@ -77,12 +78,8 @@ module Asynchronize
   def self._build_new_method(old_method)
     return Proc.new do |*args, &block|
       return Thread.new(old_method, args, block) do |told_method, targs, tblock|
-        result = told_method.bind(self).call(*targs)
-        if tblock.nil?
-          Thread.current[:return_value] = result
-        else
-          tblock.call(result)
-        end
+        Thread.current[:return_value] = told_method.bind(self).call(*targs)
+        tblock.call(Thread.current[:return_value]) unless tblock.nil?
       end
     end
   end

data/readme.md

@@ -5,7 +5,7 @@
 ### The easiest way to make multiple methods asynchronous.
 
 Find yourself writing the same boilerplate for all your asynchronous methods?
-Get dryyy with asynchronize.
+Get dry with asynchronize.
 
 Just install with `gem install asynchronize` or add to your Gemfile and `bundle`
 
@@ -27,21 +27,20 @@ end
 ```
 
 Now, to call those methods.
-You can just pass it a block.
-```Ruby
-Test.new.my_test do |return_value|
-  puts return_value
-end
-# > test
-```
-
-Or, you can manage the thread yourself; the returned value will be in the thread
+You can manage the thread yourself; the returned value will be in the thread
 variable `:return_value` once it returns.
 ```Ruby
 thread = Test.new.my_test
 thread.join
-puts thread[:return_value]
-# > test
+puts thread[:return_value] # > test
+```
+
+Or for convenience, you can just pass it a block.
+The return value, will still be in the thread variable `:return_value`
+```Ruby
+Test.new.my_test do |return_value|
+  puts return_value # > test
+end
 ```
 
 ## Inspiration
@@ -54,10 +53,21 @@ def method_name(args)
 end
 ```
 It's extra typing, adds an unneeded extra layer of nesting, and just feels
-dirty. Now, I can just call asynchronize to make any method asynchronous.
+dirty. I couldn't find an existing library that wasn't trying to solve other
+problems I didn't have. Now, just call asynchronize to make any method
+asynchronous.
+
+## Versioning Policy
+Once I feel like this is ready for production code - 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 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
-### Metaprogramming?? won't this hurt performance?
+### Doesn't metaprogramming hurt performance?
 Not at all! We're actually totally redefining the methods, so the method itself
 is exactly as efficient as it would have been had you wrote it that way
 originally.
@@ -87,6 +97,12 @@ tests as the source. You should read it, I'd love feedback!
 ### Do you accept contributions?
 Absolutely! If your use case isn't compatible with the project, you find a
 bug, or just want to donate some tests; make an issue or send a PR please.
+To run the test suite, just run `bundle` then `rake` from the project directory.
+
+### What's the difference between this and promises?
+This attempts to be a very lightweight wrapper around threads. There's no new
+interface to use, just define a regular method, and interact with it like a
+regular thread.
 
 ## License
 MIT

data/spec/spec.rb

@@ -4,9 +4,6 @@ require './lib/asynchronize.rb'
 class BasicSpec < Minitest::Test
   describe Asynchronize do
     before do
-      if defined? Test
-        BasicSpec.send(:remove_const, :Test)
-      end
       class Test
         include Asynchronize
         def test(val=5)
@@ -14,6 +11,9 @@ class BasicSpec < Minitest::Test
         end
       end
     end
+    after do
+      BasicSpec.send(:remove_const, :Test)
+    end
 
     describe "when we asynchronize a method" do
       it "should not be the same method" do
@@ -42,21 +42,21 @@ class BasicSpec < Minitest::Test
       end
       it "should not affect methods on other classes when called before" do
         Test.asynchronize :test
-        class MyTest
+        class OtherBeforeTest
           def test
           end
         end
         Test.new.test.class.must_equal(Thread)
-        MyTest.new.test.class.wont_equal(Thread)
+        OtherBeforeTest.new.test.class.wont_equal(Thread)
       end
       it "should not affect methods on other classes when called after" do
-        class AnotherTest
+        class OtherAfterTest
           def test
           end
         end
         Test.asynchronize :test
         Test.new.test.class.must_equal(Thread)
-        AnotherTest.new.test.class.wont_equal(Thread)
+        OtherAfterTest.new.test.class.wont_equal(Thread)
       end
     end
 
@@ -107,10 +107,7 @@ class BasicSpec < Minitest::Test
 
     describe "when there is an existing method_added" do
       before do
-        if defined? AnotherTest
-          BasicSpec.send(:remove_const, :AnotherTest)
-        end
-        class AnotherTest
+        class MethodAddedTest
           @running = false
           def self.method_added(method)
             return if @running
@@ -129,9 +126,51 @@ class BasicSpec < Minitest::Test
           end
         end
       end
+      after do
+        BasicSpec.send(:remove_const, :MethodAddedTest)
+      end
       it "should call that method_added before, and only once." do
-        AnotherTest.new.test.join[:return_value].must_equal 5
+        MethodAddedTest.new.test.join[:return_value].must_equal 5
+      end
+    end
+
+    describe "when inheriting from another class" do
+      before do
+        class ChildClassTest < Test
+          include Asynchronize
+          def test
+            return super + 1
+          end
+        end
+      end
+      after do
+        BasicSpec.send(:remove_const, :ChildClassTest)
+      end
+      it "should be able to call super when it's been asynchronized" do
+        class ChildClassTest
+          asynchronize :test
+        end
+        ChildClassTest.new.test.join[:return_value].must_equal 6
+      end
+      it "should be able to call super when super has been asynchronized" do
+        class Test
+          asynchronize :test
+        end
+        class ChildClassTest
+          undef_method :test
+          def test
+            return super.join[:return_value] + 1
+          end
+        end
+        ChildClassTest.new.test.must_equal 6
       end
     end
   end
+
+  # describe "when being inherited from another class" do
+  #   before do
+  #
+  #   end
+  #   after do
+  # end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: asynchronize
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Kenneth Cochran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-31 00:00:00.000000000 Z
+date: 2018-06-02 00:00:00.000000000 Z
 dependencies: []
 description: Take any synchronous method, and run it asynchronously, without cluttering
   your code with repetetive boilerplate.