Class: Rpromise

Inherits:
Object
  • Object
show all
Defined in:
lib/rpromise.rb,
lib/rpromise/version.rb

Defined Under Namespace

Modules: State Classes: Handler

Constant Summary collapse

VERSION = 
"0.2.0"

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Rpromise

Returns a new instance of Rpromise.



15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/rpromise.rb', line 15

def initialize()
  @state = State::PENDING
  @defered = nil
  @thread = Thread.new do
    begin
      yield(method(:resolve!), method(:reject!))
    rescue => e
      reject!(e)
    end
  end
  @thread.abort_on_exception = true
end

Instance Attribute Details

#state ⇒ Object (readonly)

Returns the value of attribute state.



13
14
15
 
# File 'lib/rpromise.rb', line 13

def state
  @state
end

#thread ⇒ Object (readonly)

Returns the value of attribute thread.



13
14
15
 
# File 'lib/rpromise.rb', line 13

def thread
  @thread
end

Class Method Details

.from_method(obj, method_name, *args, &block) ⇒ Object 



73
74
75
76
77
 
# File 'lib/rpromise.rb', line 73

def self.from_method(obj, method_name, *args, &block)
  Rpromise.new do |resolve, reject|
    resolve.call(obj.method(method_name).call(*args,&block))
  end
end

Instance Method Details

#pending? ⇒ Boolean

Returns:

  • (Boolean) 


38
39
40
 
# File 'lib/rpromise.rb', line 38

def pending?
  return @state == State::PENDING
end

#reject!(value = nil) ⇒ Object 



64
65
66
67
68
69
70
71
 
# File 'lib/rpromise.rb', line 64

def reject!(value = nil)
  @state = State::REJECTED
  @value = value

  unless @defered.nil?
    handle(@defered)
  end
end

#rejected? ⇒ Boolean

Returns:

  • (Boolean) 


46
47
48
 
# File 'lib/rpromise.rb', line 46

def rejected?
  return @state == State::REJECTED
end

#resolve!(value = nil) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/rpromise.rb', line 50

def resolve!(value = nil)
  if value.is_a?(::Rpromise)
    value.then(method(:resolve!), method(:reject!))
    return
  end

  @state = State::RESOLVED
  @value = value

  unless @defered.nil?
    handle(@defered)
  end
end

#resolved? ⇒ Boolean

Returns:

  • (Boolean) 


42
43
44
 
# File 'lib/rpromise.rb', line 42

def resolved?
  return @state == State::RESOLVED
end

#then(on_resolved = nil, on_rejected = nil) ⇒ Object

Raises:

  • (ArgumentError) 


28
29
30
31
32
33
34
35
36
 
# File 'lib/rpromise.rb', line 28

def then(on_resolved = nil, on_rejected = nil)
  raise ArgumentError unless is_valid_block?(on_resolved)
  raise ArgumentError unless is_valid_block?(on_rejected)
  return self if on_resolved.nil? && on_rejected.nil?
  return ::Rpromise.new do |resolve, reject|
    handler = Handler.new(on_resolved, on_rejected, resolve, reject)
    handle(handler)
  end
end