magritte 0.5.0 → 0.5.5

data/README.md

@@ -7,6 +7,8 @@ to an IO or to a block. A simple line buffer class is also provided,
 to turn block writes to the output block into line-by-line output
 to make interacting with the sub-process easier.
 
+![Ceci n'est pas une pipe](https://raw.github.com/relistan/magritte/master/assets/ceci-nest-pas-une-pipe.jpg)
+
 What it Does
 ------------
 You have a sub-command that you want to put data into and from which
@@ -50,6 +52,9 @@ Magritte::Pipe.from_input_string(data)
   .filtering_with('grep "relistan"')
 ```
 
+This works as above, however the input has been taken from the `data`
+string rather than a file.
+
 ####IO Stream as Input
 
 ```ruby
@@ -79,6 +84,10 @@ Magritte::Pipe.from_input_file('some.txt')
   .filtering_with('grep "relistan"')
 ```
 
+Each block of data that was read from the `stdout` of the sub-process
+`grep` is passed to the `out_to` block. Note that this is a block of
+data of uncertain size, and will not end on nice line boundaries.
+
 ####Line Buffering
 
 When passing data into your block, it's often much easier to work on
@@ -96,6 +105,23 @@ Magritte::Pipe.from_input_file('some.txt')
   .filtering_with('grep "relistan"')
 ```
 
+Note that line buffering does not apply to stream outputs, only to 
+output blocks as there is generally no reason to do this with a stream.
+
+####Line Buffer with Arbitrary Record Separators
+
+The default line ending character for the `LineBuffer` is the Unix 
+linefeed '\n' character.  You can, however, use any record separator
+you like.  It is done like this (e.g. for Windows line endings):
+
+```ruby
+Magritte::Pipe.from_input_file('some.txt')
+  .separated_by("\r\n")
+  .line_by_line
+  .out_to { |data| puts data }
+  .filtering_with('grep "relistan"')
+```
+
 Exit Status
 -----------
 Magritte will raise an `Errno::EPIPE` in the event of a non-zero

data/lib/magritte/iostreams.rb

@@ -0,0 +1,63 @@
+require 'forwardable'
+
+module Magritte  
+  class BlockStream
+    extend Forwardable
+
+    READ_BLOCK_SIZE = 512
+
+    attr_reader :io
+    def_delegators :@io, :flush, :closed?, :close
+
+    def initialize(io)
+      @io = io
+    end
+
+    def write(data)
+      return 0 if data.empty?
+      return 0 if @io.closed?
+
+      begin
+        @io.write_nonblock(data)
+      rescue Errno::EAGAIN
+        return 0
+      end
+    end
+
+    def read
+      begin
+        data = @io.read_nonblock(READ_BLOCK_SIZE) unless @io.closed?
+      rescue EOFError
+        @io.close
+      rescue Errno::EAGAIN
+      end
+
+      data || ""
+    end
+  end
+
+  class ProcOutputStream
+    def initialize(output_proc)
+      @output = output_proc
+    end
+
+    def write(data)
+      bytes_written = @output.call(data)
+      raise 'output block must return number of bytes written!' unless bytes_written.is_a?(Fixnum)
+      bytes_written
+    end
+  end
+
+  class LineBufferOutputStream
+    def initialize(output_proc, record_separator="\n") 
+      @output_proc = output_proc;
+      @buffer = LineBuffer.new(record_separator)
+    end
+
+    def write(data)
+      bytes_written = @buffer.write(data)
+      @buffer.each_line { |line| @output_proc.call(line) }
+      bytes_written
+    end
+  end
+end

data/lib/magritte/pipe.rb

@@ -1,14 +1,13 @@
 require 'open3'
 require 'stringio'
 require_relative 'line_buffer'
+require_relative 'iostreams'
 
 # Acts as a two way pipe like the shell command line. We put
 # data into a sub-process and capture the output.
 
 module Magritte
   class Pipe
-    READ_BLOCK_SIZE = 512
-
     def initialize(input, output=nil)
       @input  = input
       @output = output
@@ -20,26 +19,35 @@ module Magritte
     end
 
     def self.from_input_stream(io)
-      new(io)
+      new(BlockStream.new(io))
     end
 
     def self.from_input_string(str)
-      new(StringIO.new(str || ""))
+      self.from_input_stream((StringIO.new(str)))
     end
 
     def out_to(io=nil, &block)
-      if block_given?
-        @output = Proc.new(&block)
+      unless block_given?
+        @output = BlockStream.new(io)
+        return self
+      end
+
+      proc = Proc.new(&block)
+      if @line_by_line
+        @output = LineBufferOutputStream.new(proc, @record_separator || "\n")
       else
-        @output = io if io
+        @output = ProcOutputStream.new(proc)
       end
 
       self
     end
 
+    def separated_by(record_separator)
+      @record_separator = record_separator
+    end
+
     def line_by_line
       @line_by_line = true
-      @buffer = LineBuffer.new
       self
     end
 
@@ -47,8 +55,8 @@ module Magritte
       raise "No output IO is set! Invoke out_to first!" unless @output
 
       Open3.popen2e(command) do |subproc_input, subproc_output, wait_thr|
-        @subproc_output = subproc_output
-        @subproc_input  = subproc_input
+        @subproc_output = BlockStream.new(subproc_output)
+        @subproc_input  = BlockStream.new(subproc_input)
 
         clear_buffers
 
@@ -63,7 +71,7 @@ module Magritte
 
           if read_ready
             read_from_subproc
-            send_output
+            write_output
           end
 
           # We close the input to signal to the sub-process that we are
@@ -95,71 +103,27 @@ module Magritte
     end
 
     def descriptor_array_for(stream)
-      stream.closed? ? nil : [stream]
-    end
-
-    def write_to(io, data)
-      return 0 if data.empty?
-      return 0 if io.closed?
-
-      begin
-        io.write_nonblock(data)
-      rescue Errno::EAGAIN
-        return 0
-      end
+      stream.closed? ? nil : [stream.io]
     end
 
     def write_to_subproc
-      bytes_written = write_to(@subproc_input, @write_data)
+      bytes_written = @subproc_input.write(@write_data)
       @write_data = @write_data[bytes_written..-1]
     end
 
     def read_from_subproc
-      @read_data += read_from(@subproc_output)
+      @read_data += @subproc_output.read
     end
 
     def read_from_input
-      @write_data += read_from(@input)
+      @write_data += @input.read
     end
 
-    def send_output
-      bytes_written = if @line_by_line && @output.is_a?(Proc)
-        send_output_line_by_line
-      else
-        send_output_block
-      end
-
+    def write_output
+      bytes_written = @output.write(@read_data)
       @read_data = @read_data[bytes_written..-1]
     end
 
-    def send_output_line_by_line
-      bytes_written = @buffer.write(@read_data)
-      @buffer.each_line { |line| @output.call(line) }
-      bytes_written
-    end
-
-    def send_output_block
-      if @output.is_a?(Proc)
-        bytes_written = @output.call(@read_data)
-        raise 'output block must return number of bytes written!' unless bytes_written.is_a?(Fixnum)
-        bytes_written
-      else
-        write_to(@output, @read_data)
-      end
-
-    end
-
-    def read_from(io)
-      begin
-        data = io.read_nonblock(READ_BLOCK_SIZE) unless io.closed?
-      rescue EOFError
-        io.close
-      rescue Errno::EAGAIN
-      end
-
-      data || ""
-    end
-
     def ready_to_close?
       @input.closed? && @write_data.empty? && @read_data.empty? && !@subproc_input.closed?
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: magritte
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-11 00:00:00.000000000 Z
+date: 2013-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70302135231300 !ruby/object:Gem::Requirement
+  requirement: &70322250772220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70302135231300
+  version_requirements: *70322250772220
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70302135230200 !ruby/object:Gem::Requirement
+  requirement: &70322250771120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *70302135230200
+  version_requirements: *70322250771120
 description: ! '  Magritte is a simple but powerful wrapper to Open3 pipes that makes
   it easy to handle two-way piping of data into and out of a sub-process. Various
   input IO wrappers are supported and output can either be to an IO or to a block.
@@ -45,6 +45,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/magritte/iostreams.rb
 - lib/magritte/line_buffer.rb
 - lib/magritte/pipe.rb
 - lib/magritte.rb