simple-fifo 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: af466537c7b9bfa49ef532d011a082d3584ba7800a205ad1e591cc44dd10768d
+  data.tar.gz: f3241744fc946f73b932e5c068501fadfcfa5b845832e6a63af89e962de0bc37
+SHA512:
+  metadata.gz: ab15739f205f44920f54efbfad23dea5739c37e260e3af47c0657aac754abaa696dec3deae0d45ec6da902ed2c90fd58a6310348e84065a7e050871018957405
+  data.tar.gz: 9b5244a9b08903a61a8948bf1fc4db114cf686769e4d37107597ab1ab6c94d885ce779c6a142a66bc9961936250e00ab05ece26655a32f687f5e5abf3365339f

data/.gitignore

@@ -0,0 +1,3 @@
+spec/data
+.rvmrc
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,9 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - 2.2.1
+
+before_install:
+  - sudo apt-get update
+  - sudo apt-get install ruby-dev

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+group :test do
+  gem 'rspec'
+  gem 'rake'
+end
+
+group :development do
+  gem 'pry'
+end

data/README.md

@@ -0,0 +1,124 @@
+Forked from ruby-fifo: https://github.com/shurizzle/ruby-fifo
+
+A small, simple library for using Fifos in Ruby. A Fifo is traditionally a Unix
+idea that lets processes communicate by writing to and reading from a special
+kind of file in the filesystem. More information on fifos can be found here:
+[http://en.wikipedia.org/wiki/Named_pipe](http://en.wikipedia.org/wiki/Named_pipe).
+
+# Installation
+
+To install simple-fifo, execute the following command at your terminal:
+
+    $ gem install simple-fifo
+
+Being sure not to include the dollar sign. The dollar sign is simply convention
+for denoting a terminal command.
+
+# Usage
+
+To use a fifo, you need both a reader and a writer (the POSIX standard does not
+define the behaviour from using the same file handle as both a reader and a
+writer so this library does not allow it).
+
+Here's some example code that will simply write to a fifo and read from it, all
+in the same process:
+
+``` ruby
+reader = Fifo.new('path/to/fifo', :r, :nowait)
+writer = Fifo.new('path/to/fifo', :w, :nowait)
+
+writer.puts "Hello, world!"
+reader.gets
+#=> "Hello, world!\n"
+```
+
+Notice that we pass in `:r` and `:w` for the reader and writer respectively.
+Also, we have this `:nowait` symbol in there. This tells the library that we
+don't want to use "blocking" fifos.
+
+## Blocking vs Non-blocking
+
+A blocking fifo will block the current thread of execution until the other end
+is opened. For example, the following code will never finish executing:
+
+``` ruby
+reader = Fifo.new('path/to/fifo', :r, :wait)
+writer = Fifo.new('path/to/fifo', :w, :wait)
+```
+
+The thread will be blocked after the first line and it will wait until the
+writing end of the fifo is opened before allowing execution to continue. This
+also works exactly the same way in reverse (if you opened the writer before the
+reader).
+
+The following code should work fine:
+
+``` ruby
+fork do
+  reader = Fifo.new('path/to/fifo', :r, :wait)
+  reader.gets
+  #=> Eventually, this will return "Hello, fork!\n"
+end
+
+fork do
+  writer = Fifo.new('path/to/fifo', :w, :wait)
+  writer.puts "Hello, fork!"
+end
+```
+
+### Non-blocking
+
+Alternately, you can use non-blocking pipes. These pipes don't wait for the
+other end to be open before doing there work. The following code will work just
+fine all in the same process:
+
+``` ruby
+writer = Fifo.new('path/to/fifo', :w, :nowait)
+writer.puts "Testing"
+
+reader = Fifo.new('path/to/fifo', :r, :nowait)
+reader.gets
+#=> "Testing\n"
+```
+
+### Defaults
+
+Because of this, non-blocking is the default type of fifo that this library will
+create.
+
+``` ruby
+fifo = Fifo.new('path/to/fifo')
+# This is a non-blocking reader by default
+```
+
+## Other methods for reading and writing
+
+There are other forms of reading and writing that will be familiar to you if you
+have used the Ruby File object:
+
+``` ruby
+reader = Fifo.new('path/to/fifo', :r, :nowait)
+writer = Fifo.new('path/to/fifo', :w, :nowait)
+
+writer.puts "Two", "Lines"
+reader.gets
+#=> "Two\n"
+reader.gets
+#=> "Lines\n"
+
+writer.print "12345"
+# reader.gets would block forever here, no new line
+reader.getc
+#=> "1"
+reader.read(1)
+#=> "2"
+reader.read(3)
+#=> "345"
+
+# reader.read(1)
+#=> Blocks until something is written
+
+writer.print "Same as puts\n"
+reader.readline
+#=> "Same as puts\n"
+```

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rspec/core/rake_task'
+
+task :default => [:spec]
+
+desc "Run all tests."
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Opens up an irb session with the load path and library required."
+task :console do
+  exec "irb -I lib/ -r ./lib/simple-fifo.rb"
+end
+
+desc "Alias for rake console."
+task :c => [:console]

data/lib/simple-fifo.rb

@@ -0,0 +1,13 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require 'forwardable'
+
+if RUBY_PLATFORM =~ /mswin/
+  require 'web32/pipe'
+  $POSIX = false
+else
+  $POSIX = true
+end
+
+require 'simple-fifo/fifo'

data/lib/simple-fifo/fifo.rb

@@ -0,0 +1,139 @@
+class Fifo
+  # Module to allow delegation
+  include Forwardable
+
+  # Constructs a new Fifo. Can open either a read or write fifo in either
+  # blocking or non-blocking mode.
+  #
+  # Examples:
+  #
+  #   # Non-blocking read Fifo (default)
+  #   r = Fifo.new('path/to/fifo')
+  #
+  #   # Blocking read Fifo
+  #   r = Fifo.new('path/to/fifo', :r, :wait)
+  #
+  #   # Non blocking write Fifo
+  #   w = Fifo.new('path/to/fifo', :w, :nowait)
+  def initialize(file, perms = :r, mode = :nowait)
+    raise 'Unknown file permission. Must be either :r or :w.' unless [:r, :w].include?(perms)
+
+    unless [:wait, :nowait].include?(mode)
+      raise 'Unknown file mode. Must be either :wait or :nowait for blocking' \
+            ' or non-blocking respectively.'
+    end
+
+    if $POSIX
+      unless File.exist?(file)
+        File.mkfifo(file)
+        File.chmod(0o0666, file)
+      end
+
+      perms = perms.to_s + (mode == :wait ? '' : '+')
+      @pipe = open_pipe(file, perms)
+    else
+      include Win32
+
+      mode  = mode  == :wait ? Pipe::WAIT : Pipe::NOWAIT
+      @pipe = perms == :r ? Pipe.new_server(file, mode) : Pipe.new_client(file)
+      @pipe.connect if perms == :r
+    end
+
+    def_delegators :@pipe, :read, :write, :close, :to_io, :flush
+  end
+
+  # Prints the arguments passed in to the fifo. to_s is called on either
+  # argument passed in.
+  #
+  # Example:
+  #
+  #   f = Fifo.new('path/to/fifo', :w)
+  #   f.print "Hello!"
+  #   f.print "Multiple", "Arguments"
+  #   f.puts "!" # Need a puts because fifos are line buffered
+  #
+  #   r = Fifo.new('path/to/fifo', :r)
+  #   r.gets
+  #   #=> "Hello!MultipleArugments!\n"
+  def print(*args)
+    args.each do |obj|
+      self.write obj.to_s
+    end
+
+    write $OUTPUT_RECORD_SEPARATOR
+    flush
+  end
+
+  # Works the same as Kernel::puts, writes a string or multiple strings to the
+  # Fifo and then appends a new line. In the case of multiple arguments, a new
+  # line is printed after each one.
+  #
+  # Examples:
+  #
+  #   w = Fifo.new('path/to/fifo', :w)
+  #   r = Fifo.new('path/to/fifo', :r)
+  #
+  #   w.puts "1", "2", "3", "4"
+  #
+  #   r.gets
+  #   #=> "1\n"
+  #
+  #   r.gets
+  #   #=> "2\n"
+  #
+  #   r.gets
+  #   #=> "3\n"
+  #
+  #   r.gets
+  #   #=> "4\n"
+  def puts(*args)
+    args.each do |obj|
+      self.write "#{obj.to_s.sub(/\n$/, '')}\n"
+      flush
+    end
+  end
+
+  # Reads a single character
+  #
+  # Alias for read(1).
+  def getc
+    self.read(1)
+  end
+
+  # Works in the same way as gets does but uses the $_ global variable for
+  # reading in each character. There is no functional difference between this
+  # and gets.
+  def readline
+    str = ''
+    while ($_ = self.read(1)) != "\n"
+      str << $_
+    end
+    str << "\n"
+  end
+
+  # Reads from the Fifo until it encounters a new line. Will block the current
+  # thread of execution until it hits a new line. This includes when the fifo is
+  # empty and nothing is writing to it.
+  #
+  # Example:
+  #
+  #   w = Fifo.new('path/to/fifo', :w)
+  #   r = Fifo.new('path/to/fifo', :r)
+  #
+  #   w.puts "Hello, world!"
+  #   r.gets
+  #   #=> "Hello, world!\n"
+  def gets
+    self.readline
+  end
+
+  private
+
+  def open_pipe(file, perms)
+    File.open(file, perms)
+  rescue Errno::EINTR
+    # We just want to open a file, so keep retrying.
+    # Inspired by golang's solution: https://github.com/golang/go/commit/50d0ee0c98ea21f818d2daa9bc21ef51861a2ef9
+    retry
+  end
+end

data/simple-fifo.gemspec

@@ -0,0 +1,18 @@
+require 'rubygems'
+
+Gem::Specification.new { |s|
+  s.name                  = 'simple-fifo'
+  s.version               = '1.0.0'
+  s.author                = ['shura', 'jackorp']
+  s.email                 = 'jar.prokop@volny.cz'
+  s.homepage              = 'http://github.com/jackorp/simple-fifo'
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.9.2'
+  s.summary               = 'A cross-platform library to use named pipe'
+  s.description           = 'A FIFO library making I/O operations on FIFO files simple.'
+  s.files                 = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  s.require_path          = 'lib'
+  s.has_rdoc              = true
+}

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: simple-fifo
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- shura
+- jackorp
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-13 00:00:00.000000000 Z
+dependencies: []
+description: A FIFO library making I/O operations on FIFO files simple.
+email: jar.prokop@volny.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/simple-fifo.rb
+- lib/simple-fifo/fifo.rb
+- simple-fifo.gemspec
+homepage: http://github.com/jackorp/simple-fifo
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: A cross-platform library to use named pipe
+test_files: []