opal-async 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a38a4215b9b7cdde96a1e4d00c08c5940bd829c052281b93ba7286c31bab856a
+  data.tar.gz: d329ce4369abd51128b468dc61fe26266fd96590688f55a6e2d934b631da831c
+SHA512:
+  metadata.gz: 7d2373f2972e5402a14523f2975d544a2ba0faa4a2e68e527e4d27c3b327d279b687cccdda0b80ec34389149c0fa6d418e8faa04d9fc4b68f8f0ae96b679e1d4
+  data.tar.gz: 13b4c95d7c39c6f5d7a0497156e40f72fc01ae96f5e32707a09b230bc3c2e81d803aae4bfd94315f956b005b892855aacdf59670824b5de99e3aa15c530f36ff

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015-2020 Ben Titcomb & Andy Maleh
+
+MIT License
+
+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,167 @@
+# Opal: Async
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'opal-async', github: "ravenstine/opal-async
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install opal-async
+
+Then require 'opal-async' in both your Opal code and your Opal compilation environment.
+
+
+## Usage
+
+#### Enumerator
+
+The enumerator provides iteration methods for any enumerable object.  These methods are 'non-blocking', so other operations in the event loop can continue to be executed in between iterations.  Beware, this is not faster than a normal blocking iteration; it is trading off performance for not blocking other operations you may want to have continue such as UI updates & camera frame capture.  Very large arrays will take a long time to finish while the overhead may not be noticeable for smaller arrays.  It is best to do some tests and assess whether the trade-off is balanced enough for your needs.
+
+Methods can be chained and when the enumerator is finished, a promise is executed using #done.
+
+For example:
+
+```ruby
+require 'opal-async'
+enumerator = Async::Enumerator.new([1,2,3,4,5,6,7,8,9])
+enumerator.map{|x| x + 2}.done{|x| puts x}
+#=> [3,4,5,6,7,8,9,10,11]
+```
+
+Here's an example of method-chaining:
+```ruby
+enumerator = Async::Enumerator.new([1,2,3,4,5,6,7,8,9])
+enumerator.map{|x| x + 2}.each_slice(3).each{|x| puts x}
+#=> [3,4,5]
+#=> [6,7,8]
+#=> [9,10,11]
+```
+
+##### Available enumerator methods:
+- each
+- map
+- each_slice
+- select
+- reject
+
+#### Task
+A task contains code that will be added to the call stack of the event loop.  The Enumerator uses tasks to run small chunks of code without blocking the event loop.  A task can do the same things that a Timeout or an Interval can do but with some added features and optimizations.
+
+With no options provided, a task will be run immediately once the event loop comes back to it(if the environment supports this).  If the environment does not support immediates, it will attempt to polyfill an immediate before falling back on a 0ms timeout.
+
+Example: 
+
+```
+Async::Task.new do
+  puts "hello world"
+end
+
+#=> hello world
+```
+
+By default, a task will only run once.  To make a task repeat, set the option times to however many times you want the task to repeat.  You can also have access to countup and countdown variables.
+
+```
+Async::Task.new do times: 5 do |countup, countdown|
+  puts countdown
+end
+
+#=> 5
+#=> 4
+#=> 3
+#=> 2
+#=> 1
+``` 
+
+To make a task repeat infinitely, set times to ```:infinite```, or repeat to ```true```.  A countup will be provided but no countdown.  You can also use ```:i``` for short.
+
+```
+Async::Task.new times: :infinite do
+  puts "forever"
+end
+
+#=> forever
+#=> forever
+#=> forever
+...
+
+```
+
+The step option will determine how much you want your task to "step".
+
+```
+Async::Task.new times: 10, step: 2 do |countup, countdown|
+  puts countup
+end
+
+#=> 0
+#=> 2
+#=> 4
+#=> 6
+#=> 8
+```
+
+To set a delay time on your task, specify the delay option with the number of milliseconds you want the duration of the delay to be.  This can also be done when you have set your task to repeat.
+
+```
+Async::Task.new delay: 1000 do
+  puts "this took 1 second"
+end 
+```
+
+The delay and steps of a task can be modified within the execution of the task.  The following example will start out slow and increase in speed:
+
+```
+task = Async::Task.new times: 5, delay: 5000 do |countup, countdown|
+  puts countdown
+  task.delay = task.delay - 1000
+end
+```
+
+Tasks also have callbacks that can be performed on certain events.
+
+Here is an example of how to execute code after a repeating task has finished:
+
+```
+task = Async::Task.new times: 3, delay: 1000 do |countup, countdown|
+  puts countdown
+end
+
+task.on_finish {puts "BOOM"}
+
+#=> 3
+#=> 2
+#=> 1
+#=> BOOM
+```
+
+Other callbacks include ```on_start``` and ```on_stop```.
+
+
+#### Other Timers
+
+You can also timeouts and intervals specifically:
+
+
+```
+Timeout.new 3000 do
+  puts "I just waited 3 seconds."
+end
+```
+
+```
+Interval.new 3000 do
+  puts "I'm going to do this every 3 seconds."
+end
+```
+
+## Contributors
+
+- [Benjamin Titcomb](https://github.com/Ravenstine) (Creator and Main Contributor)
+- [Andy Maleh](https://github.com/AndyObtiva) (Gemifier)

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/lib/opal-async.rb

@@ -0,0 +1 @@
+require 'opal/async'

data/lib/opal/async.rb

@@ -0,0 +1,4 @@
+require 'opal'
+
+# Just register our opal code path with opal build tools
+Opal.append_path File.expand_path('../../../opal', __FILE__)

data/opal/async.rb

@@ -0,0 +1,7 @@
+module Async
+end
+require 'async/timeout'
+require 'async/interval'
+require 'async/countdown'
+require 'async/task'
+require 'async/enumerator'

data/opal/async/countdown.rb

@@ -0,0 +1,31 @@
+module Async
+  class Countdown
+    def initialize time=0, intervals=1, step=1, &block
+      @countdown = intervals
+      @countup = 0
+      @step = step
+      @block = block
+      @time = time
+      start
+    end
+  
+    def start
+      @interval = `setInterval(function(){#{@block.call(@countdown,@countup)};#{@countdown -= @step};#{@countup += @step};#{stop if @countdown.zero?};}, #{@time})`
+      @stopped = false
+    end
+   
+    def stop
+      `clearInterval(#@interval)`
+      @stopped = true
+    end
+  
+    def restart
+      stop
+      start
+    end
+  
+    def stopped?
+      @stopped = true
+    end
+  end
+end

data/opal/async/enumerator.rb

@@ -0,0 +1,164 @@
+require 'native'
+
+module Async
+  class Enumerator
+    def initialize(enumerable, options={})
+      puts 'initialize enumerator'
+      @options = options
+      @enumerable = enumerable
+      @jobs = []
+      @jobs_finished = 0
+      @jobs_queued = 0
+      @lock = false
+      set_defaults
+    end
+  
+    def locked?
+      !@lock
+    end
+  
+    def unlocked?
+      !@lock
+    end
+  
+    def lock
+      @lock = true
+    end
+  
+    def unlock
+      @lock = false
+    end
+  
+    def queue(proc)
+      @jobs << proc
+      @jobs_queued += 1
+      watcher = Task.new times: :infinite do
+        if unlocked?
+          lock
+          @jobs.first.call
+          watcher.stop
+        elsif @jobs.count.zero?
+          watcher.stop
+        end
+      end
+    end
+  
+    def set_defaults
+      @output = []
+      @finished = false
+      @length = @enumerable.length
+    end
+    def each step=1, &block
+      proc = Proc.new do
+        set_defaults
+        @step = step
+        Task.new times: @length, step: @step do |ind, cdown|
+          Task.new do
+            yield(@enumerable[ind], ind)
+            finish_job if cdown <= 1
+          end
+        end
+        @output = @enumerable
+      end
+      queue proc
+      self
+    end
+    def each_slice step=1, &block
+      proc = Proc.new do
+        set_defaults
+        @step = step
+        chunk = []
+        block_was_given = block_given?
+        Task.new times: @length do |ind, cdown|
+          Task.new do
+            chunk << @enumerable[ind]
+            if (ind + 1) % @step == 0
+              if block_was_given
+                @output << yield(@enumerable[ind], ind)
+              else
+                @output << chunk
+              end
+              chunk = []
+            end
+            if cdown <= 1
+              finish_job 
+            end
+          end
+        end
+      end
+      queue proc
+      self
+    end
+    def map step=1, &block
+      proc = Proc.new do
+        set_defaults
+        @step = step
+        Task.new step: @step, times: @length do |ind, cdown|
+          Task.new do
+            @output[ind] = yield(@enumerable[ind], ind)
+            if cdown <= 1
+              finish_job 
+            end
+          end
+        end
+      end
+      queue proc
+      self
+    end
+    def select step=1, &block
+      proc = Proc.new do
+        set_defaults
+        @step = step
+        Task.new step: @step, times: @length do |ind, cdown|
+          Task.new do
+            operation = yield(@enumerable[ind], ind)
+            @output << @enumerable[ind] if operation == true 
+            if cdown <= 1
+              finish_job 
+            end
+          end
+        end
+      end
+      queue proc
+      self
+    end
+    def reject step=1, &block
+      proc = Proc.new do
+        set_defaults
+        @step = step
+        Task.new step: @step, times: @length do |ind, cdown|
+          Task.new do
+            operation = yield(@enumerable[ind], ind)
+            @output << @enumerable[ind] unless operation == true 
+            if cdown <= 1
+              finish_job 
+            end
+          end
+        end
+      end
+      queue proc
+      self
+    end
+    def done &block
+      complete Proc.new {yield(@output, self)}
+    end
+    def then &block
+      complete Proc.new {yield(self.class.new(@output))}
+    end
+    def finish_job
+      @enumerable = @output
+      @jobs.shift
+      @jobs_finished += 1
+      unlock
+    end
+    def complete proc
+      checker = Task.new times: :infinite do
+        if (@jobs_finished >= @jobs_queued)
+          checker.stop
+          proc.call
+        end
+      end
+      self
+    end
+  end
+end

data/opal/async/interval.rb

@@ -0,0 +1,28 @@
+module Async
+  class Interval
+    def initialize time=0, &block
+      @block = block
+      @time = time
+      start
+    end
+   
+    def stop
+      `clearInterval(#{@interval})`
+      @stopped = true
+    end
+  
+    def start
+      @interval = `setInterval(function(){#{@block.call}}, #{@time})`
+      @stopped = false
+    end
+  
+    def stopped?
+      @stopped
+    end
+  
+    def restart
+      stop
+      start
+    end
+  end
+end

data/opal/async/task.rb

@@ -0,0 +1,155 @@
+module Async
+  class Task
+    attr_accessor :delay, :times
+    def initialize options={}, &block
+      @options = options
+      @block = block
+      generate_settings
+      start
+    end
+  
+    def generate_settings
+      @countdown = @options[:times] || 1
+      @countup = 0
+      @step = @options[:step] || 1
+      @delay = @options[:delay] || 0
+      @times = @options[:times]
+      @proc = Proc.new do
+        if @times
+          if @times.is_a?(Fixnum)
+            @block.call(@countup, @countdown)
+            @countdown -= @step
+            unless @countdown <= 0
+              start unless @stopped
+            else
+              stop
+              @after_finish.call(@enumerable) if @after_finish
+            end
+          elsif [:infinite, :unlimited, :indefinite, :i].include?(@times) || @options[:repeat]
+            @block.call(@countup, nil)
+            start unless @stopped
+          end
+          @countup += @step
+        else
+          @block.call
+          @stopped = true
+        end
+      end
+    end
+  
+    def on_stop &block
+      @after_stop = block
+    end
+  
+    def on_start &block
+      @before_start = block
+    end
+  
+    def on_finish &block
+      @after_finish = block
+    end
+  
+    def stopped?
+      @stopped
+    end
+  
+    def stop
+      @stopper.call if @stopper
+      @after_stop.call(@enumerable) if @after_stop
+      @stopped = true
+    end
+  
+    def restart
+      stop
+      generate_settings
+      start
+    end
+  
+    def start
+      @before_start.call(@enumerable) if @before_start
+      if @delay && @delay > 0
+        set_timeout
+      else
+        set_immediate
+      end
+      @stopped = false
+    end
+  
+    def set_timeout
+      @task = `setTimeout(function() {
+        #{@proc.call};
+      }, #{@delay || 0})`
+      
+      @stopper = Proc.new{`window.clearTimeout(#@task)`}
+    end
+  
+    def set_immediate
+      if `window.setImmediate != undefined`
+        @task = `window.setImmediate(function() {
+          #{@proc.call};
+        })`
+  
+  
+        @stopper = Proc.new{`window.clearImmediate(#@task)`}
+  
+      elsif `window.msSetImmediate != undefined`
+        @task = `window.msSetImmediate(function() {
+          #{@proc.call};
+        })`
+  
+  
+        @stopper = Proc.new{`window.msClearImmediate(#@task)`}
+  
+      elsif `window.MessageChannel != undefined`
+        ### Higher precedence than postMessage because it is supported in WebWorkers.
+        `
+          var task = function(){
+            if(#{!stopped?}){
+              #{@proc.call};
+            };
+          };
+          var mc = new MessageChannel();
+  
+          mc.port1.onmessage = function(){ 
+            if (!#{stopped?}){
+              task.apply(task) 
+            }
+          };
+          mc.port2.postMessage(null);
+        `
+  
+        @stopper = Proc.new{}
+      elsif  `window.postMessage != undefined`
+        @message_id = "opal.async.task.#{rand(1_000_000)}."
+        @task = `window.addEventListener("message", function(event){
+          if((event.data === '#{@message_id}') && #{!stopped?}){
+            #{@proc.call};
+          }
+        }, true)`
+  
+        `window.postMessage("#{@message_id}", "*")`
+  
+        @stopper = Proc.new{@message_id = nil}
+      elsif `document != undefined` && `document.onreadystatechange === null`
+        `
+          var script = document.createElement("script");
+          script.onreadystatechange = function() {
+            if (!#{stopped?}) {
+              #{@proc.call};
+            }
+            script.onreadystatechange = null;
+            script.parentNode.removeChild(script);
+          };
+          document.documentElement.appendChild(script);
+        `
+        @stopper = Proc.new{}
+      else
+        @task = `setTimeout(function() {
+          #{@proc.call};
+        }, 0)`
+      end
+  
+    end
+  
+  end
+end

data/opal/async/timeout.rb

@@ -0,0 +1,30 @@
+module Async
+  class Timeout
+  
+    def initialize time=0, &block
+      @time = time
+      @block = block
+      start
+    end
+   
+    def stopped?
+      @stopped
+    end
+  
+    def stop
+      `clearTimeout(#@timeout)`
+      @stopped = true
+    end
+  
+    def restart
+      stop
+      start
+    end
+  
+    def start
+      @timeout = `setTimeout(function(){#{@block.call};#{@stopped = true}}, #{@time})`
+      @stopped = false
+    end
+    
+  end
+end

data/opal/opal-async.rb

@@ -0,0 +1 @@
+require 'async'

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: opal-async
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Ravenstine
+- Andy Maleh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: opal-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: juwelier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides non-blocking tasks and enumerators for Opal.
+email:
+- benjamin@pixelstreetinc.com
+- andy.am@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- VERSION
+- lib/opal-async.rb
+- lib/opal/async.rb
+- opal/async.rb
+- opal/async/countdown.rb
+- opal/async/enumerator.rb
+- opal/async/interval.rb
+- opal/async/task.rb
+- opal/async/timeout.rb
+- opal/opal-async.rb
+homepage: http://github.com/AndyObtiva/opal-async
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README
+- "--line-numbers"
+- "--include"
+- opal
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Provides non-blocking tasks and enumerators for Opal.
+test_files: []