functional-ruby 0.6.0 → 0.7.0

data/spec/spec_helper.rb

@@ -1,6 +1,4 @@
-require 'eventmachine'
-
-require 'functional/all'
+require 'functional'
 
 # import all the support files
 Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: functional-ruby
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-22 00:00:00.000000000 Z
+date: 2013-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: |2
-      A gem for adding Erlang, Clojure, and Go inspired concurrency and functional programming tools to Ruby.
+      A gem for adding Erlang, Clojure, and Go inspired functional programming tools to Ruby.
 email: jerry.dantonio@gmail.com
 executables: []
 extensions: []
@@ -35,46 +35,19 @@ extra_rdoc_files:
 files:
 - README.md
 - LICENSE
-- lib/functional/agent.rb
-- lib/functional/all.rb
 - lib/functional/behavior.rb
 - lib/functional/behaviour.rb
-- lib/functional/cached_thread_pool.rb
-- lib/functional/concurrency.rb
-- lib/functional/core.rb
-- lib/functional/event.rb
-- lib/functional/event_machine_defer_proxy.rb
-- lib/functional/fixed_thread_pool.rb
-- lib/functional/future.rb
-- lib/functional/global_thread_pool.rb
-- lib/functional/obligation.rb
 - lib/functional/pattern_matching.rb
-- lib/functional/promise.rb
-- lib/functional/thread_pool.rb
 - lib/functional/utilities.rb
 - lib/functional/version.rb
 - lib/functional.rb
 - lib/functional_ruby.rb
 - md/behavior.md
-- md/concurrency.md
-- md/future.md
-- md/obligation.md
 - md/pattern_matching.md
-- md/promise.md
 - md/utilities.md
-- spec/functional/agent_spec.rb
 - spec/functional/behavior_spec.rb
-- spec/functional/cached_thread_pool_spec.rb
-- spec/functional/concurrency_spec.rb
-- spec/functional/event_machine_defer_proxy_spec.rb
-- spec/functional/event_spec.rb
-- spec/functional/fixed_thread_pool_spec.rb
-- spec/functional/future_spec.rb
 - spec/functional/integration_spec.rb
-- spec/functional/obligation_shared.rb
 - spec/functional/pattern_matching_spec.rb
-- spec/functional/promise_spec.rb
-- spec/functional/thread_pool_shared.rb
 - spec/functional/utilities_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jdantonio/functional-ruby/
@@ -111,18 +84,8 @@ signing_key:
 specification_version: 4
 summary: Erlang and Clojure inspired functional programming tools for Ruby.
 test_files:
-- spec/functional/agent_spec.rb
 - spec/functional/behavior_spec.rb
-- spec/functional/cached_thread_pool_spec.rb
-- spec/functional/concurrency_spec.rb
-- spec/functional/event_machine_defer_proxy_spec.rb
-- spec/functional/event_spec.rb
-- spec/functional/fixed_thread_pool_spec.rb
-- spec/functional/future_spec.rb
 - spec/functional/integration_spec.rb
-- spec/functional/obligation_shared.rb
 - spec/functional/pattern_matching_spec.rb
-- spec/functional/promise_spec.rb
-- spec/functional/thread_pool_shared.rb
 - spec/functional/utilities_spec.rb
 - spec/spec_helper.rb

data/lib/functional/agent.rb

@@ -1,130 +0,0 @@
-require 'observer'
-require 'thread'
-
-require 'functional/global_thread_pool'
-
-module Functional
-
-  # An agent is a single atomic value that represents an identity. The current value
-  # of the agent can be requested at any time (#deref). Each agent has a work queue and operates on
-  # the global thread pool. Consumers can #post code blocks to the agent. The code block (function)
-  # will receive the current value of the agent as its sole parameter. The return value of the block
-  # will become the new value of the agent. Agents support two error handling modes: fail and continue.
-  # A good example of an agent is a shared incrementing counter, such as the score in a video game.
-  class Agent
-    include Observable
-
-    TIMEOUT = 5
-
-    attr_reader :initial
-    attr_reader :timeout
-
-    def initialize(initial, timeout = TIMEOUT)
-      @value = initial
-      @timeout = timeout
-      @rescuers = []
-      @validator = nil
-      @queue = Queue.new
-
-      $GLOBAL_THREAD_POOL << proc{ work }
-    end
-
-    def value(timeout = 0) return @value; end
-    alias_method :deref, :value
-
-    def rescue(clazz = Exception, &block)
-      @rescuers << Rescuer.new(clazz, block) if block_given?
-      return self
-    end
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
-
-    def validate(&block)
-      @validator = block if block_given?
-      return self
-    end
-    alias_method :validates, :validate
-    alias_method :validate_with, :validate
-    alias_method :validates_with, :validate
-
-    def post(&block)
-      return @queue.length unless block_given?
-      @queue << block
-      return @queue.length
-    end
-
-    def <<(block)
-      self.post(&block)
-      return self
-    end
-
-    def length
-      @queue.length
-    end
-    alias_method :size, :length
-    alias_method :count, :length
-
-    alias_method :add_watch, :add_observer
-
-    private
-
-    # @private
-    Rescuer = Struct.new(:clazz, :block)
-
-    # @private
-    def try_rescue(ex) # :nodoc:
-      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
-      rescuer.block.call(ex) if rescuer
-    rescue Exception => e
-      # supress
-    end
-
-    # @private
-    def work # :nodoc:
-      loop do
-        Thread.pass
-        handler = @queue.pop
-        begin
-          result = Timeout.timeout(@timeout){
-            handler.call(@value)
-          }
-          if @validator.nil? || @validator.call(result)
-            @value = result
-            changed
-            notify_observers(Time.now, @value)
-          end
-        rescue Exception => ex
-          try_rescue(ex)
-        end
-      end
-    end
-  end
-end
-
-module Kernel
-
-  def agent(initial, timeout = Functional::Agent::TIMEOUT)
-    return Functional::Agent.new(initial, timeout)
-  end
-  module_function :agent
-
-  def deref(agent, timeout = nil)
-    if agent.respond_to?(:deref)
-      return agent.deref(timeout)
-    elsif agent.respond_to?(:value)
-      return agent.deref(timeout)
-    else
-      return nil
-    end
-  end
-  module_function :deref
-
-  def post(agent, &block)
-    if agent.respond_to?(:post)
-      return agent.post(&block)
-    else
-      return nil
-    end
-  end
-  module_function :deref
-end

data/lib/functional/all.rb

@@ -1,13 +0,0 @@
-require 'functional/agent'
-require 'functional/behavior'
-require 'functional/cached_thread_pool'
-require 'functional/concurrency'
-require 'functional/event'
-require 'functional/fixed_thread_pool'
-require 'functional/future'
-require 'functional/obligation'
-require 'functional/pattern_matching'
-require 'functional/promise'
-require 'functional/thread_pool'
-require 'functional/utilities'
-require 'functional/version'

data/lib/functional/cached_thread_pool.rb

@@ -1,122 +0,0 @@
-require 'thread'
-
-require 'functional/thread_pool'
-require 'functional/utilities'
-
-module Functional
-
-  def self.new_cached_thread_pool
-    return CachedThreadPool.new
-  end
-
-  class CachedThreadPool < ThreadPool
-    behavior(:thread_pool)
-
-    DEFAULT_GC_INTERVAL = 60
-    DEFAULT_THREAD_IDLETIME = 60
-
-    attr_reader :working
-
-    def initialize(opts = {})
-      @gc_interval = opts[:gc_interval] || DEFAULT_GC_INTERVAL
-      @thread_idletime = opts[:thread_idletime] || DEFAULT_THREAD_IDLETIME
-      super()
-      @working = 0
-      @mutex = Mutex.new
-    end
-
-    def kill
-      @status = :killed
-      @mutex.synchronize do
-        @pool.each{|t| Thread.kill(t.thread) }
-      end
-    end
-
-    def size
-      return @pool.length
-    end
-
-    def post(*args, &block)
-      raise ArgumentError.new('no block given') unless block_given?
-      if running?
-        collect_garbage if @pool.empty?
-        @mutex.synchronize do
-          if @working >= @pool.length
-            create_worker_thread
-          end
-          @queue << [args, block]
-        end
-        return true
-      else
-        return false
-      end
-    end
-
-    # @private
-    def status # :nodoc:
-      @mutex.synchronize do
-        @pool.collect do |worker|
-          [
-            worker.status,
-            worker.status == :idle ? delta(worker.idletime, timestamp) : nil,
-            worker.thread.status
-          ]
-        end
-      end
-    end
-
-    private
-
-    Worker = Struct.new(:status, :idletime, :thread)
-
-    # @private
-    def create_worker_thread # :nodoc:
-      worker = Worker.new(:idle, timestamp, nil)
-
-      worker.thread = Thread.new(worker) do |me|
-
-        loop do
-          task = @queue.pop
-
-          @working += 1
-          me.status = :working
-
-          if task == :stop
-            me.status = :stopping
-            break
-          else
-            task.last.call(*task.first)
-            @working -= 1
-            me.status = :idle
-            me.idletime = timestamp
-          end
-        end
-
-        @pool.delete(me)
-        if @pool.empty?
-          @termination.set
-          @status = :shutdown unless killed?
-        end
-      end
-
-      @pool << worker
-    end
-
-    # @private
-    def collect_garbage # :nodoc:
-      @collector = Thread.new do
-        loop do
-          sleep(@gc_interval)
-          @mutex.synchronize do
-            @pool.reject! do |worker|
-              worker.thread.status.nil? ||
-                (worker.status == :idle && @thread_idletime >= delta(worker.idletime, timestamp))
-            end
-          end
-          @working = @pool.count{|worker| worker.status == :working}
-          break if @pool.empty?
-        end
-      end
-    end
-  end
-end

data/lib/functional/concurrency.rb

@@ -1,35 +0,0 @@
-require 'thread'
-
-require 'functional/agent'
-require 'functional/future'
-require 'functional/promise'
-
-require 'functional/thread_pool'
-require 'functional/cached_thread_pool'
-require 'functional/fixed_thread_pool'
-
-require 'functional/global_thread_pool'
-
-require 'functional/event_machine_defer_proxy' if defined?(EventMachine)
-
-module Kernel
-
-  # Post the given agruments and block to the Global Thread Pool.
-  #
-  # @param args [Array] zero or more arguments for the block
-  # @param block [Proc] operation to be performed concurrently
-  #
-  # @return [true,false] success/failre of thread creation
-  #
-  # @note Althought based on Go's goroutines and Erlang's spawn/1,
-  # Ruby has a vastly different runtime. Threads aren't nearly as
-  # efficient in Ruby. Use this function appropriately.
-  #
-  # @see http://golang.org/doc/effective_go.html#goroutines
-  # @see https://gobyexample.com/goroutines
-  def go(*args, &block)
-    return false unless block_given?
-    $GLOBAL_THREAD_POOL.post(*args, &block)
-  end
-  module_function :go
-end

data/lib/functional/core.rb

@@ -1,2 +0,0 @@
-require 'functional/behavior'
-require 'functional/pattern_matching'

data/lib/functional/event.rb

@@ -1,53 +0,0 @@
-require 'thread'
-require 'timeout'
-
-module Functional
-
-  class Event
-
-    def initialize
-      @set = false
-      @notifier = Queue.new
-      @mutex = Mutex.new
-      @waiting = 0
-    end
-
-    def set?
-      return @set == true
-    end
-
-    def set
-      return true if set?
-      @mutex.synchronize {
-        @set = true
-        while @waiting > 0
-          @notifier << :set
-          @waiting -= 1
-        end
-      }
-    end
-
-    def reset
-      @mutex.synchronize {
-        @set = false
-      }
-    end
-
-    def wait(timeout = nil)
-      return true if set?
-
-      if timeout.nil?
-        @waiting += 1
-        @notifier.pop
-      else
-        Timeout::timeout(timeout) do
-          @waiting += 1
-          @notifier.pop
-        end
-      end
-      return true
-    rescue Timeout::Error
-      return false
-    end
-  end
-end