asynchronize 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3469c3b1731ec0b85a8014439e676153947b17adf250567a15779fc039cb39a4
+  data.tar.gz: 7145e39f5206053ab44c1f896b3b26c242891919b48e1c4afae26ce61e2b8199
+SHA512:
+  metadata.gz: f970416bd025a1e3ad544fcda9d4babb6fbf7eb75c9e764c88ed987c720f2c3122893d83aacd142ecfbbc80f1a169e6554144efef33a37d5fd96140659366dd8
+  data.tar.gz: 3b4829c2ecccdad396c960966febf28d6176621cede70d1243aae3abd6a968c3df4a0e5fa25ff6dcd7ee0831d479c6e95bc6fec2e21a3416d48a5afa84a78ca1

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "spec/*spec.rb"
+end
+
+desc "Run tests"
+task :default => :test

data/asynchronize.gemspec

@@ -0,0 +1,24 @@
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name = 'asynchronize'
+  s.version = '0.1.0'
+  s.date = Date.today.to_s
+  s.summary = 'Easily make multiple methods asynchronous at once.'
+  s.description = 'Take any synchronous method, and run it asynchronously, ' +
+    'without cluttering your code with repetetive boilerplate.'
+  s.author = 'Kenneth Cochran'
+  s.email = 'kenneth.cochran101@gmail.com'
+  s.files = [
+    'lib/asynchronize.rb',
+    'spec/spec.rb',
+    'asynchronize.gemspec',
+    'Rakefile',
+    'readme.md'
+  ]
+  s.test_files = [
+    'spec/spec.rb'
+  ]
+  s.homepage = 'https://github.com/kennycoc/asynchronize'
+  s.license = 'MIT'
+end

data/lib/asynchronize.rb

@@ -0,0 +1,59 @@
+module Asynchronize
+  require 'set'
+  def self.included base
+    base.class_eval do
+      # The methods we have already asynchronized
+      @@asynced_methods = Set.new
+      # The methods that should be asynchronized.
+      @@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
+
+      def self.asynchronize(*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
+          Asynchronize.create_new_method(method, self)
+        end
+      end
+
+      # Save the old method_added so we don't overwrite it.
+      if method_defined? :method_added
+        alias_method :old_method_added, :method_added
+        undef_method(:method_added)
+      end
+
+      def self.method_added(method)
+        old_method_added(method) if method_defined? :old_method_added
+        return unless @@methods_to_async.include? method
+        return if @@methods_asyncing.include? method
+        Asynchronize.create_new_method(method, self)
+      end
+    end
+  end
+
+  def self.create_new_method(method, klass)
+    klass.instance_eval do
+      old_method = instance_method(method)
+      return if @@asynced_methods.include?(old_method)
+      undef_method method
+      @@methods_asyncing.add(method)
+
+      define_method(method) do |*args, &block|
+        return Thread.new(args, block) do |targs, tblock|
+          result = old_method.bind(self).(*targs)
+          unless tblock.nil?
+            tblock.call(result);
+          else
+            Thread.current[:return_value] = result
+          end
+        end
+      end # define_method
+      @@methods_asyncing.delete(method)
+      @@asynced_methods.add(instance_method method)
+    end
+  end
+end

data/readme.md

@@ -0,0 +1,90 @@
+# Asynchronize
+### The easiest way to make a method asynchronous.
+
+Find yourself writing the same boilerplate for all your asynchronous methods?
+Get dryyy with asynchronize.
+
+There are no dependencies other than Ruby.
+Just install with `gem install asynchronize` or add to your Gemfile and `bundle`
+
+## Usage
+Create a class with asynchronized methods
+```Ruby
+require 'asynchronize'
+class Test
+  include Asynchronize
+  # This can be called anywhere.
+  asynchronize :my_test, :my_other_test
+  def my_test
+    return 'test'
+  end
+  def my_other_test
+    #do stuff here too
+  end
+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
+variable `:return_value` once it returns.
+```Ruby
+thread = Test.new.my_test
+thread.join
+puts thread[:return_value]
+# > test
+```
+
+## Inspiration
+I got tired of writing this over and over.
+```Ruby
+def method_name(args)
+  Thread.new(args) do |targs|
+    # Actual code.
+  end
+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.
+
+## FAQ
+### Metaprogramming?? won't this 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.
+
+### So, how does it work?
+When you `include Asynchronize` it does two things.
+1. It defines the asynchronize method for your class
+2. It defines method_added on your class.
+
+When you call asynchronize, it creates a set containing all of the methods you
+want asynchronized. If they already exist, they are modified; otherwise,
+method_added checks for them with every new method you add to the class. This
+way, you can call asynchronize any time, and know that the methods will be
+asynchronized when you use them.
+
+### So, does that mean I can't use asynchronize if I already use method_added?
+We check for and alias your old method_added. It will be called before
+anything else. Of course, if you define method_added after including
+Asynchronize, you have to do the same and be careful to not overwrite ours!
+
+### Why do I need another framework? 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 fifty lines of code. Actually, according to
+[cloc](https://www.npmjs.com/package/cloc) there's twice as many lines in the
+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.
+
+## License
+MIT

data/spec/spec.rb

@@ -0,0 +1,108 @@
+require 'minitest/autorun'
+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)
+          return val
+        end
+      end
+    end
+
+    describe "when we asynchronize a method" do
+      it "should not be the same method" do
+        original_method = Test.instance_method :test
+        Test.asynchronize :test
+        new_method = Test.instance_method(:test)
+        original_method.wont_equal(new_method, "The method was not overwritten")
+      end
+      it "should not return a thread unless we asynchronize it" do
+        Test.new.test.class.wont_equal(Thread, "The method was not overwritten")
+      end
+      it "should be the same method if we call a second time" do
+        Test.asynchronize :test
+        original_method = Test.instance_method :test
+        Test.asynchronize :test
+        new_method = Test.instance_method :test
+        original_method.must_equal(new_method,
+          "Asynchronized Inception has occurred")
+      end
+      it "should not throw an error if the specified method does not exist" do
+        Test.asynchronize :notamethod
+      end
+      it "should not create a method if the specified method does not exist" do
+        Test.asynchronize :notamethod
+        Test.method_defined?(:notamethod).must_equal false
+      end
+      it "should not affect methods on other classes when called before" do
+        Test.asynchronize :test
+        class MyTest
+          def test
+          end
+        end
+        Test.new.test.class.must_equal(Thread)
+        MyTest.new.test.class.wont_equal(Thread)
+      end
+      it "should not affect methods on other classes when called after" do
+        class AnotherTest
+          def test
+          end
+        end
+        Test.asynchronize :test
+        Test.new.test.class.must_equal(Thread)
+        AnotherTest.new.test.class.wont_equal(Thread)
+      end
+    end
+
+    describe "when we call asynchronized after defining the method" do
+      before do
+        Test.asynchronize :test
+      end
+      it "should return a thread" do
+        Test.new.test.class.must_equal(Thread,
+          "The asynchronized method without a block did not return a thread.")
+      end
+      it "should provide the result in return_value" do
+        Test.new.test.join[:return_value].must_equal 5
+      end
+      it "should provide the result as a block parameter" do
+        temp = 0
+        Test.new.test do |res|
+          temp = res
+        end.join
+        temp.must_equal 5, "temp is equal to #{temp}."
+      end
+    end
+
+    describe "when we call asynchronized before defining the method" do
+      before do
+        Test.asynchronize :othertest
+        class Test
+          def othertest
+            return 5
+          end
+        end
+      end
+      it "should return a thread" do
+        Test.new.othertest.class.must_equal(Thread,
+          "The asynchronized method without a block did not return a thread.")
+      end
+      it "should provide the result in return_value" do
+        Test.new.othertest.join[:return_value].must_equal 5
+      end
+      it "should provide the result as a block parameter" do
+        temp = 0
+        Test.new.othertest do |res|
+          temp = res
+        end.join
+        temp.must_equal 5, "temp is equal to #{temp}."
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: asynchronize
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kenneth Cochran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-31 00:00:00.000000000 Z
+dependencies: []
+description: Take any synchronous method, and run it asynchronously, without cluttering
+  your code with repetetive boilerplate.
+email: kenneth.cochran101@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- asynchronize.gemspec
+- lib/asynchronize.rb
+- readme.md
+- spec/spec.rb
+homepage: https://github.com/kennycoc/asynchronize
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Easily make multiple methods asynchronous at once.
+test_files:
+- spec/spec.rb