zopen 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b97ac6a008c95a2bf01bc09976919d43ca557922
-  data.tar.gz: d883f2917c04e223ad8ba5b45264cede4f004d4d
+  metadata.gz: ad1a11d193d3b241eb3736978a001ffb27419f02
+  data.tar.gz: 4ca599acb3c0f0c2dde0adeada8c18a08fff2bc7
 SHA512:
-  metadata.gz: 353cb39f04c2980897093b1ac8fb4fa81ccc899474893cb0373d1f10252d4885bc263c78dc19f259f845331b0cfde2ffe6342599b1e31f9215cb79de161c20aa
-  data.tar.gz: ac690a82001bfedfdd17d7c3444c1019fd0a93a27e3bb4fa6eeb155d416a40d635d874303e23cc215a0978a7b0d28d43ff64017c73730036f8eaf59b6a3b4645
+  metadata.gz: a26b37e0874abeafadbafb86fa25b639160e3fc4001bb2fbaa5692fd2665132f5ed7cd1f2f3aee75846c9edf4d98305c337f0a3adbcd42ccf5bb17067afcb60d
+  data.tar.gz: a2ff651afd0f673d06eb4b189f222feed60d96dd947bf06ec60673ac3fab13ad725d22c0e6ec8fcbefff7e69167c24246069caa4452b03ad6067bb52e54c2d88

data/lib/zopen.rb

@@ -18,228 +18,239 @@ require 'delegate'
 # extensions and use different packers.
 module ZOpen
 
-	# Handler for a plain file.
-	#
-	# This just opens a File
-	Plain = lambda do |filename, mode|
-		File.new(filename, mode)
-	end
-
-	# Handler for gzip compressed files.
-	#
-	# This handler uses either *zlib* module or the external *gzip*
-	# program.
-	Gzip = lambda do |filename, mode|
-		begin
-			require 'zlib'
-			case mode
-			when /r/, nil then Zlib::GzipReader.open(filename)
-			when /w/ then Zlib::GzipWriter.open(filename)
-			else fail "Unsupported open mode: #{mode}"
-			end
-		rescue LoadError
-			case mode
-			when /r/, nil then IO.popen("gzip -d -c '#{filename}'", mode)
-			when /w/ then IO.popen("gzip -c - > '#{filename}'", mode)
-			else fail "Unsupported open mode: #{mode}"
-			end
-		end
-	end
-
-	# Handler for bzip2 compressed files.
-	#
-	# This handler uses either *bzip2* module provided by the
-	# *bzip2-ruby* gem or the external *bzip2* program.
-	Bzip2 = lambda do |filename, mode|
-		begin
-			require 'bzip2'
-			case mode
-			when /r/, nil then Bzip2::Reader.open(filename)
-			when /w/ then Bzip2::Writer.open(filename)
-			else fail "Unsupported open mode: #{mode}"
-			end
-		rescue LoadError
-			case mode
-			when /r/, nil then IO.popen("bzip2 -d -c '#{filename}'", mode)
-			when /w/ then IO.popen("bzip2 -c - > '#{filename}'", mode)
-			else fail "Unsupported open mode: #{mode}"
-			end
-		end
-	end
-
-	# Handler for xz compressed files.
-	#
-	# This handler uses either *XZ* module provided by the
-	# *ruby-xz* gem or the external *xz* program.
-	XZ = lambda do |filename, mode|
-		begin
-			require 'xz'
-			case mode
-			when /r/, nil then ::XZ::StreamReader.open(filename)
-			when /w/ then ::XZ::StreamWriter.open(filename)
-			else fail "Unsupported open mode: #{mode}"
-			end
-		rescue LoadError
-			case mode
-			when /r/, nil then IO.popen("xz -d -c '#{filename}'", mode)
-			when /w/ then IO.popen("xz -c - > '#{filename}'", mode)
-			else fail "Unsupported open mode: #{mode}"
-			end
-		end
-	end
-
-	# A possible compressed file.
-	#
-	# This class delegates all functions to its underlying IO-like
-	# object, which should provide the typical read/write
-	# methods. However, many compressed files to not allow random
-	# access, so methods like *seek* might not be available.
-	class File < SimpleDelegator
-		class << self
-			alias_method :open, :new
-		end
-
-		# Open file.
-		#
-		# The only two open modes that are guaranteed to be supported
-		# are 'r' and 'w' for reading and writing, respectively.
-		#
-		# If a code block is given the block is called with the new
-		# file as parameter and the file is closed when the block
-		# returns.
-		#
-		# @param filename [String] the name of the file to be opened
-		# @param mode [String,nil] the mode to open the file
-		# @return [File] the opened file
-		# @yield [File] this file
-		def initialize(filename, mode=nil)
-			super(openfile(filename, mode))
-			if block_given?
-				yield self
-				close
-			end
-		end
-
-		# Return the content of a file.
-		#
-		# @param filename [String] the name of the file
-		# @return [String] the content of the file
-		def self.read(filename)
-			new(filename, 'r') { |f| return f.read }
-		end
-
-		# Write a string to a file.
-		#
-		# @param filename [String] the name of the file
-		# @param text [String] the string to be written to the file
-		def self.write(filename, text)
-			new(filename, 'w') { |f| f.write text }
-		end
-
-		private
-		# Open a file with a certain mode.
-		#
-		# This method tests all registered handlers until it finds
-		# some whose pattern matches the filename. Then the
-		# corresponding handler is called.
-		#
-		# If no matching handler is found the file is opened as plain
-		# file.
-		#
-		# @param filename [String] the name of the file
-		# @param mode [String] the mode to open the file in
-		def openfile(filename, mode)
-			h = handlers
-			h.find do |pat, open|
-				return open.call(filename, mode) if pat =~ filename
-			end if h
-			::File.new(filename, mode)
-		end
-
-		protected
-		# Returns a hash of handlers.
-		#
-		# This function returns a hash of handlers. Each key should be
-		# a regexp to test the file name. The key should be a callable
-		# object (i.e. an object that has a *call* method, e.g. a
-		# *Proc*). The callable object resembles the *open* function
-		# *of a File object, i.e., it is called with two parameters
-		# **filename* and *mode* and should return a corresponding
-		# *opened *IO* object.
-		#
-		# This function may be overwritten in subclasses in order to
-		# provide custom handlers.
-		def handlers
-			@@handlers
-		end
-
-		@@handlers = {
-		              /\.gz$/ => Gzip,
-		              /\.bz2$/ => Bzip2,
-		              /\.xz$/ => XZ
-		             }
-	end
-
-	# Create a new File-like class with handlers.
-	#
-	# This *handlers* parameter should be a hash whose keys are a
-	# regular expression and the values are open-like callable
-	# objects. If a name of a file to be opened matches a regular
-	# expression, the corresponding callable object is called with the
-	# file name and the open mode, and it should return an appropriate
-	# IO object.
-	#
-	# @param handlers [Hash<Regexp,Proc>,nil] a hash of file handlers
-	# @return [Class] a new file class
-	def self.newfile(handlers = nil)
-		if handlers then
-			zFile = Class.new(File)
-			zFile.send :define_method, :handlers do
-				handlers
-			end
-			zFile
-		else
-			File
-		end
-	end
-
-	# Opens a file with standard handlers.
-	#
-	# This opens a file that recognized gzip, bzip2 and xz compressed
-	# files.
-	#
-	# Like File.open this method may be passed a code block which is
-	# called with the new File as parameter.
-	#
-	# @param filename [String] the name of the file
-	# @param mode [String,nil] the open mode
-	# @return [File] the opened file
-	# @yield [File] this file
-	def self.open(filename, mode=nil)
-		if block_given? then
-			File.open(filename, mode) { |f| yield f }
-		else
-			File.open(filename, mode)
-		end
-	end
-
-	# Writes text to a file with standard handlers.
-	#
-	# This method recognizes gzip, bzip2 and xz compressed files.
-	#
-	# @param [String] filename the name of the file
-	# @param [String] text the text to be written to the file
-	def self.write(filename, text)
-		File.write(filename, text)
-	end
-
-	# Reads text from a file with standard handlers.
-	#
-	# This method recognizes gzip, bzip2 and xz compressed files.
-	#
-	# @param [String] filename the name of the file
-	# @return [String] the content of the file
-	def self.read(filename)
-		File.read(filename)
-	end
+  # Handler for a plain file.
+  #
+  # This just opens a File
+  Plain = lambda do |filename, mode|
+    File.new(filename, mode)
+  end
+
+  # Handler for gzip compressed files.
+  #
+  # This handler uses either *zlib* module or the external *gzip*
+  # program.
+  Gzip = lambda do |filename, mode|
+    begin
+      require 'zlib'
+      case mode
+      when /r/, nil then Zlib::GzipReader.open(filename)
+      when /w/ then Zlib::GzipWriter.open(filename)
+      else fail "Unsupported open mode: #{mode}"
+      end
+    rescue LoadError
+      case mode
+      when /r/, nil then IO.popen("gzip -d -c '#{filename}'", mode)
+      when /w/ then IO.popen("gzip -c - > '#{filename}'", mode)
+      else fail "Unsupported open mode: #{mode}"
+      end
+    end
+  end
+
+  # Handler for bzip2 compressed files.
+  #
+  # This handler uses either *bzip2* module provided by the
+  # *bzip2-ruby* gem or the external *bzip2* program.
+  Bzip2 = lambda do |filename, mode|
+    begin
+      require 'bzip2'
+      case mode
+      when /r/, nil then Bzip2::Reader.open(filename)
+      when /w/ then Bzip2::Writer.open(filename)
+      else fail "Unsupported open mode: #{mode}"
+      end
+    rescue LoadError
+      case mode
+      when /r/, nil then IO.popen("bzip2 -d -c '#{filename}'", mode)
+      when /w/ then IO.popen("bzip2 -c - > '#{filename}'", mode)
+      else fail "Unsupported open mode: #{mode}"
+      end
+    end
+  end
+
+  # Handler for xz compressed files.
+  #
+  # This handler uses either *XZ* module provided by the
+  # *ruby-xz* gem or the external *xz* program.
+  XZ = lambda do |filename, mode|
+    begin
+      require 'xz'
+      case mode
+      when /r/, nil then ::XZ::StreamReader.open(filename)
+      when /w/ then ::XZ::StreamWriter.open(filename)
+      else fail "Unsupported open mode: #{mode}"
+      end
+    rescue LoadError
+      case mode
+      when /r/, nil then IO.popen("xz -d -c '#{filename}'", mode)
+      when /w/ then IO.popen("xz -c - > '#{filename}'", mode)
+      else fail "Unsupported open mode: #{mode}"
+      end
+    end
+  end
+
+  # A possible compressed file.
+  #
+  # This class delegates all functions to its underlying IO-like
+  # object, which should provide the typical read/write
+  # methods. However, many compressed files to not allow random
+  # access, so methods like *seek* might not be available.
+  class File < SimpleDelegator
+    class << self
+      # Open file.
+      #
+      # The only two open modes that are guaranteed to be supported
+      # are 'r' and 'w' for reading and writing, respectively.
+      #
+      # If a code block is given the block is called with the new
+      # file as parameter and the file is closed when the block
+      # returns.
+      #
+      # @param filename [String] the name of the file to be opened
+      # @param mode [String,nil] the mode to open the file
+      # @return [File] the opened file
+      # @yield [File] this file
+      def new(filename, mode = nil)
+        file = allocate
+        file.send(:initialize, filename, mode)
+        if block_given?
+          begin
+            yield file
+          ensure
+            file.close
+          end
+        else
+          file
+        end
+      end
+
+      alias_method :open, :new
+    end
+
+    # Constructor
+    def initialize(filename, mode=nil)
+      super(openfile(filename, mode))
+    end
+
+    # Return the content of a file.
+    #
+    # @param filename [String] the name of the file
+    # @return [String] the content of the file
+    def self.read(filename)
+      new(filename, 'r') { |f| return f.read }
+    end
+
+    # Write a string to a file.
+    #
+    # @param filename [String] the name of the file
+    # @param text [String] the string to be written to the file
+    def self.write(filename, text)
+      new(filename, 'w') { |f| f.write text }
+    end
+
+    private
+    # Open a file with a certain mode.
+    #
+    # This method tests all registered handlers until it finds
+    # some whose pattern matches the filename. Then the
+    # corresponding handler is called.
+    #
+    # If no matching handler is found the file is opened as plain
+    # file.
+    #
+    # @param filename [String] the name of the file
+    # @param mode [String] the mode to open the file in
+    def openfile(filename, mode)
+      h = handlers
+      h.find do |pat, open|
+        return open.call(filename, mode) if pat =~ filename
+      end if h
+      ::File.new(filename, mode)
+    end
+
+    protected
+    # Returns a hash of handlers.
+    #
+    # This function returns a hash of handlers. Each key should be
+    # a regexp to test the file name. The key should be a callable
+    # object (i.e. an object that has a *call* method, e.g. a
+    # *Proc*). The callable object resembles the *open* function
+    # *of a File object, i.e., it is called with two parameters
+    # **filename* and *mode* and should return a corresponding
+    # *opened *IO* object.
+    #
+    # This function may be overwritten in subclasses in order to
+    # provide custom handlers.
+    def handlers
+      @@handlers
+    end
+
+    @@handlers = {
+                  /\.gz$/ => Gzip,
+                  /\.bz2$/ => Bzip2,
+                  /\.xz$/ => XZ
+                 }
+  end
+
+  # Create a new File-like class with handlers.
+  #
+  # This *handlers* parameter should be a hash whose keys are a
+  # regular expression and the values are open-like callable
+  # objects. If a name of a file to be opened matches a regular
+  # expression, the corresponding callable object is called with the
+  # file name and the open mode, and it should return an appropriate
+  # IO object.
+  #
+  # @param handlers [Hash<Regexp,Proc>,nil] a hash of file handlers
+  # @return [Class] a new file class
+  def self.newfile(handlers = nil)
+    if handlers then
+      zFile = Class.new(File)
+      zFile.send :define_method, :handlers do
+        handlers
+      end
+      zFile
+    else
+      File
+    end
+  end
+
+  # Opens a file with standard handlers.
+  #
+  # This opens a file that recognized gzip, bzip2 and xz compressed
+  # files.
+  #
+  # Like File.open this method may be passed a code block which is
+  # called with the new File as parameter.
+  #
+  # @param filename [String] the name of the file
+  # @param mode [String,nil] the open mode
+  # @return [File] the opened file
+  # @yield [File] this file
+  def self.open(filename, mode=nil)
+    if block_given? then
+      File.open(filename, mode) { |f| yield f }
+    else
+      File.open(filename, mode)
+    end
+  end
+
+  # Writes text to a file with standard handlers.
+  #
+  # This method recognizes gzip, bzip2 and xz compressed files.
+  #
+  # @param [String] filename the name of the file
+  # @param [String] text the text to be written to the file
+  def self.write(filename, text)
+    File.write(filename, text)
+  end
+
+  # Reads text from a file with standard handlers.
+  #
+  # This method recognizes gzip, bzip2 and xz compressed files.
+  #
+  # @param [String] filename the name of the file
+  # @return [String] the content of the file
+  def self.read(filename)
+    File.read(filename)
+  end
 end

data/tests/zopen_spec.rb

@@ -4,63 +4,63 @@ require 'tempfile'
 require 'zopen'
 
 describe ZOpen do
-	before do
-		@fhandler = ZOpen.newfile
-	end
+  before do
+    @fhandler = ZOpen.newfile
+  end
 
-	it 'should read plain files' do
-		t = Tempfile.new('foo')
-		t.write "Hallo Welt\n"
-		t.close
+  it 'should read plain files' do
+    t = Tempfile.new('foo')
+    t.write "Hallo Welt\n"
+    t.close
 
-		f = @fhandler.open(t.path)
-		f.read.must_equal "Hallo Welt\n"
-		f.close
+    f = @fhandler.open(t.path)
+    f.read.must_equal "Hallo Welt\n"
+    f.close
 
-		@fhandler.open(t.path) do |f2|
-			f2.read.must_equal "Hallo Welt\n"
-		end
+    @fhandler.open(t.path) do |f2|
+      f2.read.must_equal "Hallo Welt\n"
+    end
 
-		@fhandler.read(t.path).must_equal "Hallo Welt\n"
-	end
+    @fhandler.read(t.path).must_equal "Hallo Welt\n"
+  end
 
-	it 'should fail on non existing files' do
-		assert_raises Errno::ENOENT do
-			@fhandler.open('nonexistingfile')
-		end
-	end
+  it 'should fail on non existing files' do
+    assert_raises Errno::ENOENT do
+      @fhandler.open('nonexistingfile')
+    end
+  end
 
-	it 'should write plain files' do
-		t = Tempfile.new('foo')
-		t.close
+  it 'should write plain files' do
+    t = Tempfile.new('foo')
+    t.close
 
-		f = @fhandler.open(t.path, 'w')
-		f.write "Hallo Welt\n"
-		f.close
-		File.read(t.path).must_equal "Hallo Welt\n"
+    f = @fhandler.open(t.path, 'w')
+    f.write "Hallo Welt\n"
+    f.close
+    File.read(t.path).must_equal "Hallo Welt\n"
 
-		@fhandler.open(t.path, 'w') do |fout|
-			fout.write "Hello world\n"
-		end
-		File.read(t.path).must_equal "Hello world\n"
+    @fhandler.open(t.path, 'w') do |fout|
+      fout.write "Hello world\n"
+    end
+    File.read(t.path).must_equal "Hello world\n"
 
-		@fhandler.write t.path, "Hello world\n"
-		File.read(t.path).must_equal "Hello world\n"
-	end
+    @fhandler.write t.path, "Hello world\n"
+    File.read(t.path).must_equal "Hello world\n"
+  end
 
-	describe 'File with patterns' do
-		it 'should call the correct handler' do
-			file = Minitest::Mock.new
-			file.expect :write, nil, ["Hallo Welt\n"]
-			file.expect :close, nil, []
+  describe 'File with patterns' do
+    it 'should call the correct handler' do
+      file = Minitest::Mock.new
+      file.expect :write, nil, ["Hallo Welt\n"]
+      file.expect :close, nil, []
 
-			open = Minitest::Mock.new
-			open.expect :call, file, ['foo.txt', nil]
+      open = Minitest::Mock.new
+      open.expect :call, file, ['foo.txt', nil]
 
-			@fhandler = ZOpen.newfile({%r/\.txt$/ => open})
-			f = @fhandler.open('foo.txt')
-			f.write "Hallo Welt\n"
-			f.close
-		end
-	end
+      @fhandler = ZOpen.newfile({%r/\.txt$/ => open})
+      f = @fhandler.open('foo.txt')
+      f.write "Hallo Welt\n"
+      f.close
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zopen
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Frank Fischer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2016-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -38,7 +38,7 @@ files:
 - tests/zopen_spec.rb
 homepage: http://bitbucket.org/lyro/zopen
 licenses:
-- GPL-3
+- GPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -56,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Automatically open compressed files