Class: Async::HTTP::Body::Writable

Inherits:
Readable
  • Object
show all
Defined in:
lib/async/http/body/writable.rb

Overview

A dynamic body which you can write to and read from.

Defined Under Namespace

Classes: Closed

Instance Method Summary collapse

Methods inherited from Readable

#each, #finish, #join

Constructor Details

#initialize(length = nil) ⇒ Writable

Returns a new instance of Writable.



33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/async/http/body/writable.rb', line 33

def initialize(length = nil)
  @queue = Async::Queue.new
  
  @length = length
  
  @count = 0
  
  @finished = false
  
  @closed = false
  @error = nil
end

Instance Method Details

#close(error = nil) ⇒ Object

Stop generating output; cause the next call to write to fail with the given error.



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/async/http/body/writable.rb', line 51

def close(error = nil)
  unless @closed
    @queue.enqueue(nil)
    
    @closed = true
    @error = error
  end
  
  super
end

#empty? ⇒ Boolean

Has the producer called #finish and has the reader consumed the nil token?

Returns:

  • (Boolean) 


63
64
65
 
# File 'lib/async/http/body/writable.rb', line 63

def empty?
  @finished
end

#inspect ⇒ Object 



94
95
96
 
# File 'lib/async/http/body/writable.rb', line 94

def inspect
  "\#<#{self.class} #{@count} chunks written#{@finished ? ', finished' : ', waiting'}>"
end

#length ⇒ Object 



46
47
48
 
# File 'lib/async/http/body/writable.rb', line 46

def length
  @length
end

#read ⇒ Object

Read the next available chunk.



68
69
70
71
72
73
74
75
76
 
# File 'lib/async/http/body/writable.rb', line 68

def read
  return if @finished
  
  unless chunk = @queue.dequeue
    @finished = true
  end
  
  return chunk
end

#write(chunk) ⇒ Object Also known as: <<

Write a single chunk to the body. Signal completion by calling ‘#finish`.



79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/async/http/body/writable.rb', line 79

def write(chunk)
  # If the reader breaks, the writer will break.
  # The inverse of this is less obvious (*)
  if @closed
    raise(@error || Closed)
  end
  
  # TODO should this yield if the queue is full?
  
  @count += 1
  @queue.enqueue(chunk)
end