asynchronous 0.1.0

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 1.8.7"
+end

data/Gemfile.lock

@@ -0,0 +1,72 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    addressable (2.3.5)
+    atomic (1.1.14)
+    builder (3.2.2)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    git (1.2.6)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.20)
+    httpauth (0.2.0)
+    i18n (0.6.5)
+    jeweler (1.8.8)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (0.9.2)
+      faraday (~> 0.8)
+      httpauth (~> 0.2)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.1.5)
+    shoulda-matchers (2.4.0)
+      activesupport (>= 3.0.0)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  jeweler (~> 1.8.7)
+  rdoc (~> 3.12)
+  shoulda

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Adam Luzsi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Adam Luzsi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+asynchronous
+============
+
+Asynchronous Patterns for Ruby Based on Pure MRI CRuby code
+
+# Examples
+
+the "simple async processing" will let you use os threads (1.9.n+)
+for multiprocessing so you can give multiple task to do and
+until you ask for the value, the process will be in the background
+You can also use OS threads instead of VM Threads for real Parallelism
+
+the "require_files" shows you how can you get files from directory
+in a recursive way and stuffs like that so you can be lay
+
+## LICENSE
+
+(The MIT License)
+
+Copyright (c) 2009-2013 Adam Luzsi <adamluzsi@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+require File.join "bundler","gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/asynchronous.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require File.expand_path(File.join(File.dirname(__FILE__),"files.rb"))
+
+### Specification for the new Gem
+Gem::Specification.new do |spec|
+
+  spec.name          = "asynchronous"
+  spec.version       = File.open(File.join(File.dirname(__FILE__),"VERSION")).read.split("\n")[0].chomp.gsub(' ','')
+  spec.authors       = ["Adam Luzsi"]
+  spec.email         = ["adamluzsi@gmail.com"]
+  spec.description   = %q{Async dsl for easy concurrency patterns in both VM managed and OS managed way (Concurrency and Parallelism) }
+  spec.summary       = %q{Simple Async Based on standard CRuby}
+  spec.homepage      = "https://github.com/adamluzsi/asynchronous"
+  spec.license       = "MIT"
+
+  spec.files         = SpecFiles
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  ##=======Runtime-ENV================##
+  #spec.add_runtime_dependency "asdf", ['~>4.1.3']
+
+  ##=======Development-ENV============##
+  #spec.add_development_dependency "asdf",['~>4.1.3']
+
+end

data/examples/async_patterns.rb

@@ -0,0 +1,56 @@
+# Require Gemfile gems
+require_relative "../lib/asynchronous"
+
+# you can use simple :c also instead of :concurrency
+# remember :concurrency is all about GIL case, so
+# you can modify the objects in memory
+# This is ideal for little operations in simultaneously or
+# when you need to update objects in the memory
+calculation = async :concurrency do
+
+  sleep 2
+  4 * 2
+
+end
+puts "hello concurrency"
+
+calculation.value += 1
+
+puts calculation.value
+
+#>--------------------------------------------------
+# or you can use simple {} without sym and this will be by default a
+# :concurrency pattern
+
+calculation = async { sleep 3; 4 * 3 }
+
+puts "hello simple concurrency"
+
+calculation.value += 1
+
+# remember you have to use .value to cal the return value from the code block!
+puts calculation.value
+
+
+#>--------------------------------------------------
+# now let's see the Parallelism
+# you can use simple :p also instead of :parallelism
+# remember :parallelism is all about real OS thread case, so
+# you CANT modify the objects in memory only copy on write modify
+# This is ideal for big operations where you need do a big process
+# and only get the return value so you can do big works without the fear of the
+# Garbage collector slowness or the GIL lock
+# when you need to update objects in the memory use :concurrency
+calculation = async :parallelism do
+
+  sleep 4
+  4 * 5
+
+end
+puts "hello parallelism"
+
+calculation.value += 1
+
+puts calculation.value
+
+#>--------------------------------------------------

data/files.rb

@@ -0,0 +1,24 @@
+### Get Files from dir
+begin
+
+  files_to_be_loaded = %w[version.rb]
+
+  SpecFiles= Array.new
+
+  Dir[File.expand_path(File.join(File.dirname(__FILE__),"**","*"))].sort.uniq.each do |one_file_name|
+    one_file_name = File.expand_path one_file_name
+    file_name = one_file_name[(File.expand_path(File.dirname(__FILE__)).to_s.length+1)..(one_file_name.length-1)]
+
+    if !one_file_name.include?("pkg")
+      if !File.directory? file_name
+        SpecFiles.push file_name
+        STDOUT.puts file_name if $DEBUG
+        if files_to_be_loaded.include? one_file_name.split(File::SEPARATOR).last
+          load one_file_name
+        end
+      end
+    end
+
+  end
+
+end

data/lib/asynchronous.rb

@@ -0,0 +1,9 @@
+#encoding: UTF-8
+module Asynchronous
+
+  require File.join(File.dirname(__FILE__),"asynchronous","clean_class")
+  require File.join(File.dirname(__FILE__),"asynchronous","concurrency")
+  require File.join(File.dirname(__FILE__),"asynchronous","parallelism")
+  require File.join(File.dirname(__FILE__),"asynchronous","kernel")
+
+end

data/lib/asynchronous/clean_class.rb

@@ -0,0 +1,18 @@
+class CleanClass < BasicObject
+
+  # remove methods from the class!
+  #def self.purge_methods
+
+    (self.instance_methods-[
+        :undef_method,
+        :object_id,
+        :__send__,
+        :methods,
+        :new
+    ]).each do |method|
+      undef_method method
+    end
+
+  #end
+
+end

data/lib/asynchronous/concurrency.rb

@@ -0,0 +1,58 @@
+module Asynchronous
+
+  # you can use simple :c also instead of :concurrency
+  # remember :concurrency is all about GIL case, so
+  # you can modify the objects in memory
+  # This is ideal for little operations in simultaneously or
+  # when you need to update objects in the memory
+  class Concurrency < CleanClass
+
+    def initialize(callable)
+      begin
+        @value= nil
+        @rescue_state= nil
+        @thread ||= ::Thread.new { callable.call }
+        @rescue_state= nil
+      rescue ThreadError
+        @rescue_state ||= true
+        sleep 5
+        retry
+      end
+    end
+
+    def value
+
+      if @value.nil?
+        until @rescue_state.nil?
+          sleep 1
+        end
+        @value= @thread.value
+      end
+
+      return @value
+
+    end
+
+    def value=(obj)
+      @value= obj
+    end
+
+    def inspect
+      if @thread.alive?
+        "#<Async running>"
+      else
+        value.inspect
+      end
+    end
+
+    def method_missing(method, *args)
+      value.__send__(method, *args)
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      value.respond_to?(method, include_private)
+    end
+
+  end
+
+end

data/lib/asynchronous/kernel.rb

@@ -0,0 +1,30 @@
+# kernel method for asyncron calls
+# basic version is :
+#
+# var= async { "ruby Code here" }
+# var.value #> "ruby Code here"
+#
+# or
+#
+# var = async :parallelism do
+#  "some awsome ruby code here!"
+# end
+#
+module Kernel
+  def async(type= :Concurrency ,&block)
+    type= type.to_s
+    case type.downcase[0]
+      when "c"
+        begin
+          Asynchronous::Concurrency.new(block)
+        end
+      when "p"
+        begin
+          Asynchronous::Parallelism.new(block)
+        end
+      else
+        nil
+
+    end
+  end
+end

data/lib/asynchronous/parallelism.rb

@@ -0,0 +1,88 @@
+module Asynchronous
+  # now let's see the Parallelism
+  # you can use simple :p also instead of :parallelism
+  # remember :parallelism is all about real OS thread case, so
+  # you CANT modify the objects in memory only copy on write modify
+  # This is ideal for big operations where you need do a big process
+  # and only get the return value so you can do big works without the fear of the
+  # Garbage collector slowness or the GIL lock
+  # when you need to update objects in the memory use :concurrency
+  class Parallelism < CleanClass
+
+    # Basic
+    begin
+
+      #require 'yaml'
+      @@pids=[]
+      def initialize callable
+
+        @value= nil
+        @rd, @wr = ::IO.pipe
+        @pid= ::Kernel.fork do
+
+          ::Kernel.trap("TERM") do
+            exit
+          end
+
+          @rd.close
+          @wr.write ::Marshal.dump(callable.call)#.to_yaml
+          @wr.close
+
+        end
+
+        @@pids.push(@pid)
+
+      end
+
+    end
+
+    # return value
+    begin
+
+      def value
+
+        if @value.nil?
+
+          @wr.close
+          return_value= @rd.read
+          return_value= ::Marshal.load(return_value)
+          @rd.close
+          @@pids.delete(@pid)
+          @value= return_value
+
+        end
+
+        return @value
+
+      end
+
+
+      def value=(obj)
+        @value= obj
+      end
+
+      #def method_missing(method,*args)
+      #  value.__send__(method,*args)
+      #end
+      #
+      #def respond_to_missing?(method, include_private = false)
+      #  value.respond_to?(method, include_private)
+      #end
+
+    end
+
+    # kill Zombies at Kernel Exit
+    begin
+      ::Kernel.at_exit {
+        @@pids.each { |pid|
+          begin
+            ::Process.kill(:TERM, pid)
+          rescue ::Errno::ESRCH, ::Errno::ECHILD
+            ::STDOUT.puts "`kill': No such process (Errno::ESRCH)"
+          end
+        }
+      }
+    end
+
+  end
+end

data/test/test.rb

@@ -0,0 +1,3 @@
+# Require Gemfile gems
+require_relative "../lib/asynchronous"
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: asynchronous
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Adam Luzsi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-10 00:00:00.000000000 Z
+dependencies: []
+description: ! 'Async dsl for easy concurrency patterns in both VM managed and OS
+  managed way (Concurrency and Parallelism) '
+email:
+- adamluzsi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- asynchronous.gemspec
+- examples/async_patterns.rb
+- files.rb
+- lib/asynchronous.rb
+- lib/asynchronous/clean_class.rb
+- lib/asynchronous/concurrency.rb
+- lib/asynchronous/kernel.rb
+- lib/asynchronous/parallelism.rb
+- test/test.rb
+homepage: https://github.com/adamluzsi/asynchronous
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Simple Async Based on standard CRuby
+test_files:
+- test/test.rb
+has_rdoc: