mr_darcy 0.1.0

data/lib/mr_darcy/promise/base.rb

@@ -0,0 +1,117 @@
+module MrDarcy
+  module Promise
+    class Base
+
+      def initialize block
+        state
+        schedule_promise do
+          evaluate_promise &block
+        end
+      end
+
+      def then &block
+        @child_promise ||= generate_child_promise
+        child_promise.resolve_block = block
+        resolve_child_promise if resolved?
+        reject_child_promise  if rejected?
+        child_promise.promise
+      end
+
+      def fail &block
+        @child_promise ||= generate_child_promise
+        child_promise.reject_block = block
+        resolve_child_promise if resolved?
+        reject_child_promise  if rejected?
+        child_promise.promise
+      end
+
+      def result
+        Kernel::raise "Subclasses must implement me"
+      end
+
+      def final
+        Kernel::raise "Subclasses must implement me"
+      end
+
+      def raise
+        r = result
+        Kernel::raise r if rejected?
+      end
+
+      %w| resolved? unresolved? rejected? |.map(&:to_sym).each do |method|
+        define_method method do |*args|
+          state_machine.public_send(method, *args)
+        end
+      end
+
+      def resolve value
+        set_value_to value
+        state_machine_resolve
+        resolve_child_promise
+      end
+
+      def reject exception
+        set_value_to exception
+        state_machine_reject
+        reject_child_promise
+      end
+
+      private
+
+      attr_accessor :value, :child_promise, :state
+
+      def state
+        @state ||= :unresolved
+      end
+
+      def set_value_to value
+        @value = value
+      end
+
+      def state_machine_resolve
+        state_machine.resolve
+      end
+
+      def state_machine_reject
+        state_machine.reject
+      end
+
+      def state_machine
+        State.state(self)
+      end
+
+      def has_child_promise?
+        !!child_promise
+      end
+
+      def resolve_child_promise
+        schedule_promise do
+          child_promise.parent_resolved(value) if has_child_promise?
+        end
+      end
+
+      def reject_child_promise
+        schedule_promise do
+          child_promise.parent_rejected(value) if has_child_promise?
+        end
+      end
+
+      def schedule_promise
+        Kernel::raise "Subclasses must implement me"
+      end
+
+      def evaluate_promise &block
+        begin
+          block.call DSL.new(self)
+        rescue Exception => e
+          reject e
+        end
+      end
+
+      def generate_child_promise
+        Kernel::raise "Subclasses must implement me"
+      end
+
+    end
+  end
+end

data/lib/mr_darcy/promise/celluloid.rb

@@ -0,0 +1,52 @@
+require 'celluloid/autostart'
+
+module MrDarcy
+  module Promise
+    class Celluloid < Base
+
+      def initialize *args
+        @waiting = false
+        super
+      end
+
+      def resolve value
+        super
+        condition.signal if @waiting
+      end
+
+      def reject exception
+        super
+        condition.signal if @waiting
+      end
+
+      def result
+        wait_until_not_unresolved
+        value
+      end
+
+      def final
+        wait_until_not_unresolved
+        self
+      end
+
+      private
+
+      def schedule_promise &block
+        ::Celluloid::Future.new &block
+      end
+
+      def condition
+        @condition ||= ::Celluloid::Condition.new
+      end
+
+      def wait_until_not_unresolved
+        @waiting = true
+        condition.wait if unresolved?
+      end
+
+      def generate_child_promise
+        ChildPromise.new driver: :thread
+      end
+    end
+  end
+end

data/lib/mr_darcy/promise/child_promise.rb

@@ -0,0 +1,83 @@
+module MrDarcy
+  module Promise
+    class ChildPromise < MrDarcy::Deferred
+
+      attr_accessor :resolve_block, :reject_block
+
+      def initialize opts={}
+        @driver = opts[:driver] if opts.has_key? :driver
+        super
+      end
+
+      def parent_resolved value
+        begin
+          return resolve_with value unless handles_resolve?
+          new_value = result_for :resolve, value
+          if thenable? new_value
+            defer_resolution_via new_value
+          else
+            resolve_with new_value
+          end
+        rescue Exception => e
+          reject_with e
+        end
+      end
+
+      def parent_rejected value
+        begin
+          return reject_with value unless handles_reject?
+          new_value = result_for :reject, value
+          if thenable? new_value
+            defer_resolution_via new_value
+          else
+            resolve_with new_value
+          end
+        rescue Exception => e
+          reject_with e
+        end
+      end
+
+      private
+
+      def result_for which, value
+        block = public_send("#{which}_block")
+        if block
+          block.call value
+        else
+          value
+        end
+      end
+
+      def handles_reject?
+        !!reject_block
+      end
+
+      def handles_resolve?
+        !!resolve_block
+      end
+
+      def thenable? object
+        object.respond_to?(:then) && object.respond_to?(:fail)
+      end
+
+      def defer_resolution_via child_promise
+        child_promise.then do |value|
+          resolve_with value
+          value
+        end
+        child_promise.fail do |exception|
+          reject_with exception
+          exception
+        end
+      end
+
+      def resolve_with value
+        promise.resolve value
+      end
+
+      def reject_with exception
+        promise.reject exception
+      end
+    end
+  end
+end

data/lib/mr_darcy/promise/dsl.rb

@@ -0,0 +1,29 @@
+module MrDarcy
+  module Promise
+    class DSL
+
+      def initialize promise
+        @promise = promise
+      end
+
+      def resolve(value)
+        promise.resolve value
+      end
+
+      def reject(exception)
+        promise.reject exception
+      end
+
+      %w| unresolved? resolved? rejected? then fail result final |.map(&:to_sym).each do |method|
+        define_method method do |*args|
+          promise.public_send method, *args
+        end
+      end
+
+      private
+
+      attr_accessor :promise
+
+    end
+  end
+end

data/lib/mr_darcy/promise/em.rb

@@ -0,0 +1,29 @@
+require 'eventmachine'
+
+module MrDarcy
+  module Promise
+    class EM < Thread
+
+      def initialize *args
+        unless EventMachine.reactor_running?
+          ::Thread.new { EventMachine.run }
+          ::Thread.pass until EventMachine.reactor_running?
+        end
+        super
+      end
+
+      private
+
+      def schedule_promise
+        EventMachine.schedule proc do
+          yield
+        end
+      end
+
+      def generate_child_promise
+        ChildPromise.new driver: :em
+      end
+
+    end
+  end
+end

data/lib/mr_darcy/promise/state/base.rb

@@ -0,0 +1,43 @@
+module MrDarcy
+  module Promise
+    module State
+      class Base
+        attr_accessor :stateful
+
+        def initialize stateful
+          self.stateful = stateful
+        end
+
+        def unresolved?
+          false
+        end
+
+        def resolved?
+          false
+        end
+
+        def rejected?
+          false
+        end
+
+        def resolve
+          raise "Can't resolve from #{get_state} state"
+        end
+
+        def reject
+          raise "Cant reject from #{get_state} state"
+        end
+
+        private
+
+        def get_state
+          stateful.send :state
+        end
+
+        def set_state state
+          stateful.send :state=, state
+        end
+      end
+    end
+  end
+end

data/lib/mr_darcy/promise/state/rejected.rb

@@ -0,0 +1,11 @@
+module MrDarcy
+  module Promise
+    module State
+      class Rejected < Base
+        def rejected?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/mr_darcy/promise/state/resolved.rb

@@ -0,0 +1,11 @@
+module MrDarcy
+  module Promise
+    module State
+      class Resolved < Base
+        def resolved?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/mr_darcy/promise/state/unresolved.rb

@@ -0,0 +1,19 @@
+module MrDarcy
+  module Promise
+    module State
+      class Unresolved < Base
+        def unresolved?
+          true
+        end
+
+        def resolve
+          set_state :resolved
+        end
+
+        def reject
+          set_state :rejected
+        end
+      end
+    end
+  end
+end

data/lib/mr_darcy/promise/state.rb

@@ -0,0 +1,25 @@
+module MrDarcy
+  module Promise
+    module State
+      autoload :Base,       File.expand_path('../state/base', __FILE__)
+      autoload :Unresolved, File.expand_path('../state/unresolved', __FILE__)
+      autoload :Resolved,   File.expand_path('../state/resolved', __FILE__)
+      autoload :Rejected,   File.expand_path('../state/rejected', __FILE__)
+
+      module_function
+
+      def state stateful
+        case stateful.send :state
+        when :unresolved
+          Unresolved.new stateful
+        when :resolved
+          Resolved.new stateful
+        when :rejected
+          Rejected.new stateful
+        else
+          raise "Unknown state #{stateful.state}"
+        end
+      end
+    end
+  end
+end

data/lib/mr_darcy/promise/synchronous.rb

@@ -0,0 +1,27 @@
+# This class implements a synchronous interface to promise execution.
+# It's not much use, except for unit testing.
+
+module MrDarcy
+  module Promise
+    class Synchronous < Base
+
+      def result
+        value
+      end
+
+      def final
+        self
+      end
+
+      private
+
+      def schedule_promise
+        yield
+      end
+
+      def generate_child_promise
+        ChildPromise.new driver: :synchronous
+      end
+    end
+  end
+end

data/lib/mr_darcy/promise/thread.rb

@@ -0,0 +1,64 @@
+module MrDarcy
+  module Promise
+    class Thread < Base
+
+      def initialize *args
+        @wait_lock = Mutex.new
+        @wait_cond = ConditionVariable.new
+        @wait_lock.lock
+        super
+      end
+
+      def result
+        wait_if_unresolved
+        value
+      end
+
+      def final
+        wait_if_unresolved
+        self
+      end
+
+      def resolve value
+        super
+        @wait_cond.signal
+      end
+
+      def reject value
+        super
+        @wait_cond.signal
+      end
+
+      private
+
+      def schedule_promise &block
+        ::Thread.new &block
+      end
+
+      def wait_if_unresolved
+        @wait_cond.wait @wait_lock if unresolved?
+      end
+
+      def semaphore
+        @semaphore ||= Mutex.new
+      end
+
+      def generate_child_promise
+        ChildPromise.new driver: :thread
+      end
+
+      def set_value_to value
+        semaphore.synchronize { super }
+      end
+
+      def state_machine_resolve
+        semaphore.synchronize { super }
+      end
+
+      def state_machine_reject
+        semaphore.synchronize { super }
+      end
+
+    end
+  end
+end

data/lib/mr_darcy/promise.rb

@@ -0,0 +1,31 @@
+module MrDarcy
+  module Promise
+    autoload :State,        File.expand_path('../promise/state', __FILE__)
+    autoload :Base,         File.expand_path('../promise/base', __FILE__)
+    autoload :DSL,          File.expand_path('../promise/dsl', __FILE__)
+    autoload :ChildPromise, File.expand_path('../promise/child_promise', __FILE__)
+
+    autoload :Synchronous,  File.expand_path('../promise/synchronous', __FILE__)
+    autoload :Thread,       File.expand_path('../promise/thread', __FILE__)
+    autoload :Celluloid,    File.expand_path('../promise/celluloid', __FILE__)
+    autoload :EM,           File.expand_path('../promise/em', __FILE__)
+
+    module_function
+
+    def new driver: ::MrDarcy.driver, &block
+      case driver
+      when :thread, :Thread
+        ::MrDarcy::Promise::Thread.new block
+      when :synchronous, :Synchronous
+        ::MrDarcy::Promise::Synchronous.new block
+      when :celluloid, :Celluloid
+        ::MrDarcy::Promise::Celluloid.new block
+      when :em, :EM, :event_machine, :eventmachine, :EventMachine
+        ::MrDarcy::Promise::EM.new block
+      else
+        raise "Unknown driver #{driver}"
+      end
+    end
+
+  end
+end

data/lib/mr_darcy/role.rb

@@ -0,0 +1,45 @@
+module MrDarcy
+  class Role
+    attr_accessor :name, :options
+
+    def initialize name, opts={}, &block
+      self.name    = name
+      self.options = opts
+      @module = Module.new(&block)
+    end
+
+    def pollute player
+      guard_against_false_players player
+
+      @module.instance_methods.each do |method_name|
+        implementation = @module.instance_method method_name
+        player.define_singleton_method method_name, implementation
+      end
+    end
+
+    def clean player
+      @module.instance_methods.each do |method_name|
+        player.singleton_class.send :remove_method, method_name if player.respond_to? method_name
+      end
+    end
+
+    private
+
+    def guard_against_false_players player
+      options.each do |test_type, values|
+        case test_type
+        when :must_respond_to
+          Array(values).each do |method_name|
+            raise ArgumentError, "player must implement #{method_name}" unless player.respond_to? method_name
+          end
+        when :must_not_respond_to
+          Array(values).each do |method_name|
+            raise ArgumentError, "player must not implement #{method_name}" if player.respond_to? method_name
+          end
+        else
+          raise ArgumentError, "unknown restriction #{test_type}"
+        end
+      end
+    end
+  end
+end

data/lib/mr_darcy/version.rb

@@ -0,0 +1,3 @@
+module MrDarcy
+  VERSION = "0.1.0"
+end

data/lib/mr_darcy.rb

@@ -0,0 +1,26 @@
+require "mr_darcy/version"
+require "mr_darcy/role"
+require "mr_darcy/context"
+require "mr_darcy/deferred"
+require "mr_darcy/promise"
+
+module MrDarcy
+
+  module_function
+
+  def driver=(driver)
+    @driver=driver
+  end
+
+  def driver
+    @driver ||= :Thread
+  end
+
+  def all_drivers
+    %w| synchronous thread celluloid em |.map(&:to_sym)
+  end
+
+  def promise driver: driver, &block
+    MrDarcy::Promise.new driver: driver, &block
+  end
+end

data/mr_darcy.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mr_darcy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mr_darcy"
+  spec.version       = MrDarcy::VERSION
+  spec.authors       = ["James Harton"]
+  spec.email         = ["james@resistor.io"]
+  spec.summary       = %q{A mashup of async Promises and DCI in Ruby.}
+  spec.description   = <<-EOF
+  MrDarcy takes async promises from the javascript word, DCI from Jim
+  Gay's brain and sprinkles some ruby on top for great justice!
+  EOF
+  spec.homepage      = "https://github.com/jamesotron/MrDarcy"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  %w| rake rspec guard guard-rspec guard-bundler terminal-notifier-guard
+      pry eventmachine em-http-request celluloid |.each do |gem|
+    spec.add_development_dependency gem
+  end
+end