thread_queues 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6ca817b3ff688ca8b86e3999a607c3df3b1303e
-  data.tar.gz: df412baf2c93ed8012664f669948277e01b45169
+  metadata.gz: ccec23b5ab55ae4400aee2fe167c800f77f8a92c
+  data.tar.gz: 4949876041f7070682817bb1429cc83264b96630
 SHA512:
-  metadata.gz: c5b7b8fdfda30821ab583c5eaf9a518876aa85b80795cd85430c355a93c7a914d545e0639697ed9a972d8f1cfcde4f33d420cff2256bdfa639288a5a729745fd
-  data.tar.gz: 3828274cd1da77a1d9f2209c75eaf44a0a16aefc697b90f3603149ba2b9cb586716677a3b8743c08b22b22d85ab819853b284f85ce3fc71cc4fa94bf54d4dae1
+  metadata.gz: c9a5c77bba20b9eb89f9fa96976d4e2483a4146641dbbbed241bbd213b30f7709661cf1fdebfcfa9dc25c1eaf1fc66fb0dadf618efeed6f4ef86dc5b78ac289f
+  data.tar.gz: c2fd0bfa948a3f8c9e32b685ff1f78da6f3a840ae3108d4c9c0bd9af4c99bf0f9f4519504b3b6eef303a4bf60f206582ca145004d868b31d1133920954b223ec

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/thread_queues/string_buffer.rb

@@ -1,18 +1,34 @@
 require "monitor"
 
 class ThreadQueues::StringBuffer
+  attr_reader :lineno, :pos
+
   def initialize(queue)
     @queue = queue
     @buffer = ""
     @mutex = Monitor.new
+    @lineno = 0
+    @pos = 0
   end
 
-  def gets
+  def gets(sep = "\n", limit = nil)
+    if limit == nil && !sep.is_a?(String)
+      limit = sep
+      sep = "\n"
+    end
+
     @mutex.synchronize do
       loop do
-        if match = @buffer.match(/\A(.+)\n/)
-          @buffer.gsub!(/\A(.+)\n/, "")
-          return match[0]
+        if match = @buffer.match(/\A([\s\S]+?)#{Regexp.escape(sep)}/)
+          take = match[0]
+          if limit && take.length > limit
+            take = take.slice(0, limit)
+          end
+
+          @buffer.gsub!(/\A#{Regexp.escape(take)}/, "")
+          @lineno += 1
+          @pos += match[0].bytesize
+          return take
         end
 
         begin
@@ -25,31 +41,121 @@ class ThreadQueues::StringBuffer
     end
   end
 
-  def read(length)
+  def each_line(&blk)
+    with_enumerator(blk) do |y|
+      begin
+        loop do
+          y << gets
+        end
+      rescue EOFError
+      end
+    end
+  end
+
+  def each_char(&blk)
+    with_enumerator(blk) do |y|
+      each_chunk do |chunk|
+        chunk.each_char do |char|
+          y << char
+        end
+      end
+    end
+  end
+
+  def each_byte(&blk)
+    with_enumerator(blk) do |y|
+      each_chunk do |chunk|
+        chunk.each_byte do |byte|
+          y << byte
+        end
+      end
+    end
+  end
+
+  def read(length = nil, outbuf = nil)
+    return read_all if length == nil
+
+    content = nil
+
     @mutex.synchronize do
       loop do
         if @buffer.length >= length
-          return @buffer.slice!(0, length)
+          content = @buffer.slice!(0, length)
+          @pos += content.bytesize
+          break
         end
 
         begin
           store_more_in_buffer
         rescue EOFError => e
-          return rest_of_buffer if @buffer.length > 0
-          raise e
+          if @buffer.length > 0
+            content = rest_of_buffer
+            break
+          end
+
+          # Return nil if length is set like a normal IO - otherwise an empty string.
+          if length
+            return nil
+          else
+            content = ""
+          end
         end
       end
     end
+
+    if outbuf
+      outbuf.clear
+      outbuf << content
+    end
+
+    return content
+  end
+
+  def empty?
+    if @pos == 0 && !@closed
+      begin
+        store_more_in_buffer
+      rescue EOFError
+      end
+    end
+
+    @pos == 0 && @buffer.empty?
   end
 
 private
 
+  def read_all
+    str = ""
+    each_line do |line|
+      str << line
+    end
+
+    return str
+  end
+
   def rest_of_buffer
     buffer = @buffer
     @buffer = ""
+    @pos += buffer.bytesize
     return buffer
   end
 
+  def each_chunk
+    begin
+      loop do
+        begin
+          content = @queue.pop.to_s
+          @pos += content.bytesize
+          yield content
+        rescue Exception => e
+          raise EOFError, "No live threads left. Deadlock?" if e.message == "No live threads left. Deadlock?"
+          raise e
+        end
+      end
+    rescue EOFError
+    end
+  end
+
   def store_more_in_buffer
     @mutex.synchronize do
       begin
@@ -60,4 +166,16 @@ private
       end
     end
   end
+
+  def with_enumerator(blk)
+    enum = Enumerator.new do |y|
+      yield(y)
+    end
+
+    if blk
+      enum.each(&blk)
+    else
+      enum
+    end
+  end
 end

data/spec/thread_queues/string_buffer_spec.rb

@@ -1,8 +1,10 @@
 require "spec_helper"
 
 describe ThreadQueues::StringBuffer do
-  it "works with gets" do
-    queue = ThreadQueues::BlockingQueue.new
+  let(:queue) { ThreadQueues::BlockingQueue.new }
+  let(:lines) { lines = ["hello\n", "my\r\n", "name\n", "is kasper\n"] }
+  let(:whole_string) { lines.join("") }
+  let(:string_buffer) {
     string_buffer = ThreadQueues::StringBuffer.new(queue)
 
     Thread.new do
@@ -17,35 +19,132 @@ describe ThreadQueues::StringBuffer do
       queue.close
     end
 
-    string_buffer.gets.should eq "hello\n"
-    string_buffer.gets.should eq "my\r\n"
-    string_buffer.gets.should eq "name\n"
-    string_buffer.gets.should eq "is kasper\n"
+    string_buffer
+  }
 
-    expect { string_buffer.gets }.to raise_error(EOFError)
+  describe "#gets" do
+    it "returns lines as default" do
+      string_buffer.gets.should eq "hello\n"
+      string_buffer.gets.should eq "my\r\n"
+      string_buffer.gets.should eq "name\n"
+      string_buffer.gets.should eq "is kasper\n"
+
+      expect { string_buffer.gets }.to raise_error(EOFError)
+    end
+
+    it "accepts custom seperators" do
+      string_buffer.gets("\r").should eq "hello\nmy\r"
+      string_buffer.gets("\r").should eq "\nname\nis kasper\n"
+      expect { string_buffer.gets }.to raise_error(EOFError)
+    end
+
+    it "accepts a limit" do
+      string_buffer.gets(3).should eq "hel"
+      string_buffer.gets(10).should eq "lo\n"
+      string_buffer.gets(10).should eq "my\r\n"
+    end
+
+    it "accepts both a limit and a custom seperator" do
+      string_buffer.gets("\r", 3).should eq "hel"
+      string_buffer.gets("\r", 999).should eq "lo\nmy\r"
+      string_buffer.gets("\r", 999).should eq "\nname\nis kasper\n"
+    end
   end
 
-  it "should read the right lengths" do
-    queue = ThreadQueues::BufferedQueue.new(5)
-    string_buffer = ThreadQueues::StringBuffer.new(queue)
+  describe "#read" do
+    it "with a given length" do
+      string_buffer.read(6).should eq "hello\n"
+      string_buffer.read(4).should eq "my\r\n"
+      string_buffer.read(5).should eq "name\n"
+      string_buffer.read(10).should eq "is kasper\n"
 
-    Thread.new do
-      Thread.current.abort_on_exception = true
+      expect { string_buffer.gets }.to raise_error(EOFError)
+    end
 
-      queue.push("hel")
-      queue.push("lo\n")
-      queue.push("my\r\n")
-      queue.push("nam")
-      queue.push("e\n")
-      queue.push("is kasper\n")
-      queue.close
+    it "reads the whole thing when length is nil" do
+      string_buffer.read.should eq whole_string
+    end
+
+    it "supports outbuf argument" do
+      outbuf = "kasper"
+      string_buffer.read(6, outbuf).should eq "hello\n"
+      outbuf.should eq "hello\n"
+    end
+
+    it "should return the correct values when it has reaches eof" do
+      string_buffer.read.should eq whole_string
+      string_buffer.read.should eq ""
+      string_buffer.read(5).should eq nil
     end
+  end
+
+  it "#each_line" do
+    count = 0
+    string_buffer.each_line do |line|
+      line.should eq lines[count]
+      count += 1
+    end
+  end
+
+  it "#each_char" do
+    count = 0
+    string_buffer.each_char do |char|
+      char.should eq whole_string.slice(count, 1)
+      count += 1
+    end
+
+    string_buffer.pos.should eq 25
+  end
+
+  it "#each_byte" do
+    count = 0
+    string_buffer.each_byte do |byte|
+      byte.should eq whole_string.bytes[count]
+      count += 1
+    end
+
+    string_buffer.pos.should eq 25
+  end
 
-    string_buffer.read(6).should eq "hello\n"
-    string_buffer.read(4).should eq "my\r\n"
-    string_buffer.read(5).should eq "name\n"
-    string_buffer.read(10).should eq "is kasper\n"
+  it "#lineno" do
+    string_buffer.lineno.should eq 0
+
+    string_buffer.gets
+    string_buffer.lineno.should eq 1
+
+    string_buffer.gets
+    string_buffer.lineno.should eq 2
+
+    string_buffer.gets
+    string_buffer.lineno.should eq 3
+
+    string_buffer.gets
+    string_buffer.lineno.should eq 4
 
     expect { string_buffer.gets }.to raise_error(EOFError)
+    string_buffer.lineno.should eq 4
+  end
+
+  it "#pos" do
+    string_buffer.pos.should eq 0
+    string_buffer.gets
+    string_buffer.pos.should eq 6
+    string_buffer.read(4)
+    string_buffer.pos.should eq 10
+    string_buffer.read(999)
+    string_buffer.pos.should eq 25
+  end
+
+  describe "#empty?" do
+    it "returns false when empty" do
+      string_buffer.empty?.should eq false
+    end
+
+    it "returns true when not empty" do
+      queue = ThreadQueues::BlockingQueue.new
+      sbuffer = ThreadQueues::StringBuffer.new(queue)
+      queue.close
+      sbuffer.empty?.should eq true
+    end
   end
 end

data/thread_queues.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: thread_queues 0.0.2 ruby lib
+# stub: thread_queues 0.0.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "thread_queues"
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["kaspernj"]
-  s.date = "2014-12-07"
+  s.date = "2014-12-09"
   s.description = "Do thread-related work with BlockingQueue and BufferedQueue in Ruby."
   s.email = "k@spernj.org"
   s.extra_rdoc_files = [

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thread_queues
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - kaspernj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-07 00:00:00.000000000 Z
+date: 2014-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: string-cases