devnull 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.3.0"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.5.2"
+  gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 H.Hiro (Maraigue)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,47 @@
+= devnull
+
+DevNull behaves a null file, and works like an IO object. For example:
+
+ dn = DevNull.new
+ dn.puts "foo" # => nil (do nothing)
+ dn.gets # => nil
+ dn.read # => ""
+
+The library may be a good solution if you would like to switch whether an input/output file is needed. For example:
+
+ def some_process(arg, logfile = nil)
+   # You may set an IO object as 'logfile', and logs are written to the file.
+   
+   result = process1(arg)
+   logfile.puts result if logfile
+   
+   result = process2(arg)
+   logfile.puts result if logfile
+   
+   result = process3(arg)
+   logfile.puts result if logfile
+ end
+
+can be rewritten as follows:
+
+ def some_process(arg, logfile = DevNull.new)
+   logfile.puts process1(arg)
+   logfile.puts process2(arg)
+   logfile.puts process3(arg)
+ end
+
+== Contributing to devnull
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 maraigue. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,80 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "devnull"
+  gem.homepage = "http://github.com/maraigue/devnull"
+  gem.license = "MIT"
+  gem.summary = %Q{Ruby implementation of null file (like /dev/null on Un*x, NUL on Windows)}
+  gem.description = <<DESC
+DevNull behaves a null file, and works like an IO object. For example:
+
+dn = DevNull.new
+dn.puts "foo" # => nil (do nothing)
+dn.gets # => nil
+dn.read # => ""
+
+The library may be a good solution if you would like to switch whether an input/output file is needed. For example:
+
+def some_process(arg, logfile = nil)
+  # You may set an IO object as 'logfile', and logs are written to the file.
+  
+  result = process1(arg)
+  logfile.puts result if logfile
+  
+  result = process2(arg)
+  logfile.puts result if logfile
+  
+  result = process3(arg)
+  logfile.puts result if logfile
+end
+
+can be rewritten as follows:
+
+def some_process(arg, logfile = DevNull.new)
+  logfile.puts process1(arg)
+  logfile.puts process2(arg)
+  logfile.puts process3(arg)
+end
+DESC
+  gem.email = "main@hhiro.net"
+  gem.authors = ["H.Hiro (Maraigue)"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "devnull #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/devnull.gemspec

@@ -0,0 +1,92 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{devnull}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["H.Hiro (Maraigue)"]
+  s.date = %q{2011-03-28}
+  s.description = %q{DevNull behaves a null file, and works like an IO object. For example:
+
+dn = DevNull.new
+dn.puts "foo" # => nil (do nothing)
+dn.gets # => nil
+dn.read # => ""
+
+The library may be a good solution if you would like to switch whether an input/output file is needed. For example:
+
+def some_process(arg, logfile = nil)
+  # You may set an IO object as 'logfile', and logs are written to the file.
+  
+  result = process1(arg)
+  logfile.puts result if logfile
+  
+  result = process2(arg)
+  logfile.puts result if logfile
+  
+  result = process3(arg)
+  logfile.puts result if logfile
+end
+
+can be rewritten as follows:
+
+def some_process(arg, logfile = DevNull.new)
+  logfile.puts process1(arg)
+  logfile.puts process2(arg)
+  logfile.puts process3(arg)
+end
+}
+  s.email = %q{main@hhiro.net}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "devnull.gemspec",
+    "lib/devnull.rb",
+    "spec/devnull_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/maraigue/devnull}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Ruby implementation of null file (like /dev/null on Un*x, NUL on Windows)}
+  s.test_files = [
+    "spec/devnull_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 2.3.0"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.3.0"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, [">= 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.3.0"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, [">= 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/devnull.rb

@@ -0,0 +1,141 @@
+# Ruby implementation of null file (like /dev/null on Un*x, NUL on Windows)
+# (C) 2010- H.Hiro(Maraigue) main@hhiro.net
+# 
+# DevNull behaves a null file, and works like an IO object. For example:
+# 
+# <pre>dn = DevNull.new
+# dn.puts "foo" # => nil (do nothing)
+# dn.gets # => nil
+# dn.read # => ""</pre>
+# 
+# The library may be a good solution if you would like to switch whether an input/output file is needed. For example:
+# 
+# <pre>def some_process(arg, logfile = nil)
+#   # You may set an IO object as 'logfile', and logs are written to the file.
+#   
+#   result = process1(arg)
+#   logfile.puts result if logfile
+#   
+#   result = process2(arg)
+#   logfile.puts result if logfile
+#   
+#   result = process3(arg)
+#   logfile.puts result if logfile
+# end</pre>
+# 
+# can be rewritten as follows:
+# 
+# <pre>def some_process(arg, logfile = DevNull.new)
+#   logfile.puts process1(arg)
+#   logfile.puts process2(arg)
+#   logfile.puts process3(arg)
+# end</pre>
+
+require "enumerator"
+
+class DevNull
+  def initialize
+    # do nothing
+  end
+  
+  # --
+  # methods treated as being not implemented
+  # ++
+  def fileno; raise NotImplementedError; end
+  alias :to_i :fileno
+  def fsync; raise NotImplementedError; end
+  def fdatasync; raise NotImplementedError; end
+  def stat; raise NotImplementedError; end
+  def fcntl(arg1, arg2); raise NotImplementedError; end
+  def ioctl(arg1, arg2); raise NotImplementedError; end
+  
+  # --
+  # methods that do nothing
+  # ++
+  def close; end
+  def close_read; end
+  def close_write; end
+  def print(*args); end
+  def printf(arg1, *other_args); end
+  def puts(*args); end
+  def syswrite(*args); end
+  def ungetbyte(arg); end
+  def ungetc(arg); end
+  
+  # --
+  # methods that do nothing and returns something
+  # ++
+  def getc; nil; end
+  def getbyte; nil; end
+  def gets(arg1=nil, arg2=nil); nil; end
+  def path; nil; end
+  def pid; nil; end
+  def external_encoding; nil; end
+  def internal_encoding; nil; end
+  
+  def to_io; self; end
+  def <<(obj); self; end
+  def binmode; self; end
+  def flush; self; end
+  def reopen(arg1, arg2=nil); self; end
+  def set_encoding(arg1, arg2=nil, arg3=nil); self; end
+  
+  def autoclose?; true; end
+  def binmode?; true; end
+  def closed?; true; end
+  def eof; true; end
+  def eof?; true; end
+  def sync; true; end
+  
+  def close_on_exec?; false; end
+  def closed_read?; false; end
+  def closed_write?; false; end
+  def isatty; false; end
+  def tty?; false; end
+  
+  def lineno; 0; end
+  def pos; 0; end
+  def tell; 0; end
+  def rewind; 0; end
+  def seek(arg1, arg2=nil); 0; end
+  def sysseek(arg1, arg2=nil); 0; end
+  
+  def readlines(arg1=nil, arg2=nil); []; end
+  
+  def putc(arg); arg; end
+  def autoclose=(arg); arg; end
+  def close_on_exec=(arg); arg; end
+  def lineno=(arg); arg; end
+  def pos=(arg); arg; end
+  def sync=(arg); arg; end
+  def truncate(arg); arg; end
+  def write(arg); arg.to_s.length; end
+  def syswrite(arg); arg.to_s.length; end
+  def write_nonblock(arg); arg.to_s.length; end
+  
+  def each(*args); (block_given? ? self : [].to_enum); end
+  alias :each_line :each
+  alias :lines :each
+  alias :each_byte :each
+  alias :bytes :each
+  alias :each_char :each
+  alias :chars :each
+  alias :each_codepoint :each
+  alias :codepoints :each
+  
+  def sysread(arg1, arg2=nil); raise EOFError; end
+  def readpartial(arg1, arg2=nil); raise EOFError; end
+  def read_nonblock(arg1, arg2=nil); raise EOFError; end
+  def readchar; raise EOFError; end
+  def readbyte; raise EOFError; end
+  def readline(arg1=nil, arg2=nil); raise EOFError; end
+  
+  def read(len = 0, outbuf = nil)
+    if outbuf != nil
+      outbuf.replace("")
+      outbuf
+    else
+      (len.to_i == 0 ? "" : nil)
+    end
+  end
+end

data/spec/devnull_spec.rb

@@ -0,0 +1,287 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require "devnull"
+
+describe DevNull do
+  # GENERAL NOTE:
+  # 
+  # These test codes are based on the document:
+  # http://www.ruby-doc.org/core/classes/IO.html .
+  # However, the contents in the URL may be changed.
+  # If needed, add and/or rewrite the test code.
+  
+  # NOTE 1:
+  # 
+  # This devnull library is not to support any internal statuses
+  # stored in IO instances (e.g. instance variables).
+  # For example,
+  #
+  # f = open("/dev/null")
+  # f.lineno      # => 0
+  # f.lineno = 10 
+  # f.lineno      # => 10
+  # 
+  # but
+  # 
+  # g = DevNull.new
+  # g.lineno      # => 0
+  # g.lineno = 10 
+  # g.lineno      # => 0
+  # 
+  # Such internal-status-related methods is defined,
+  # but should always return statuses according to
+  # its *initial* statuses.
+  
+  # NOTE 2:
+  # 
+  # Some of the instance methods for IO related to low-level I/O is
+  # not implemented. In such case, the method returns NotImplementedError.
+  # (e.g. DevNull#fileno)
+  
+  before(:each) do
+    @null = DevNull.new
+  end
+  
+  # ---------- specs for Enumerators:
+  # Those methods should return an Enumerator that contains nothing.
+  %w[
+    each
+    bytes each_byte
+    chars each_char
+    codepoints each_codepoint
+  ].each do |method_name|
+    it "should return an Enumerator for Devnull##{method_name}" do
+      # First, check whether the method returns an Enumerator.
+      enum = eval("@null.#{method_name}")
+      enum.should be_instance_of(Enumerable::Enumerator)
+      # Then, check whether the Enumerator is empty.
+      lambda{ enum.each{ raise RuntimeError } }.should_not raise_error
+      lambda{ eval("@null.#{method_name} { raise RuntimeError }") }.should_not raise_error
+    end
+  end
+  
+  # ---------- specs for called without any argument and returning self
+  %w[
+    flush to_io
+  ].each do |method_name|
+    it "should return self for Devnull##{method_name}" do
+      eval("@null.#{method_name}").should == @null
+    end
+  end
+  
+  # ---------- specs for called without any argument and returning nil
+  %w[
+    close close_read close_write external_encoding internal_encoding
+    getbyte getc pid
+  ].each do |method_name|
+    it "should return nil for Devnull##{method_name}" do
+      eval("@null.#{method_name}").should == nil
+    end
+  end
+  
+  # ---------- specs for called with 1 argument and returning nil
+  %w[
+    ungetbyte ungetc
+  ].each do |method_name|
+    it "should return nil for Devnull##{method_name} with 1 arguments" do
+      lambda{ eval("@null.#{method_name}") }.should raise_error(ArgumentError)
+      eval("@null.#{method_name}(1)").should == nil
+      lambda{ eval("@null.#{method_name}(1, 2)") }.should raise_error(ArgumentError)
+    end
+  end
+  
+  # ---------- specs for called with any number of arguments and returning nil
+  %w[
+    print puts
+  ].each do |method_name|
+    it "should return nil for Devnull##{method_name} with any number of arguments" do
+      eval("@null.#{method_name}").should == nil
+      eval("@null.#{method_name}(1)").should == nil
+      eval("@null.#{method_name}(1, 2, 3)").should == nil
+    end
+  end
+  
+  # ---------- specs for called without any argument and returning true
+  %w[
+    autoclose? binmode? closed? eof eof? sync
+  ].each do |method_name|
+    it "should return true for Devnull##{method_name}" do
+      eval("@null.#{method_name}").should be_true
+    end
+  end
+  
+  # ---------- specs for called without any argument and returning false
+  %w[
+    close_on_exec? isatty tty?
+  ].each do |method_name|
+    it "should return false for Devnull##{method_name}" do
+      eval("@null.#{method_name}").should be_false
+    end
+  end
+  
+  # ---------- specs for called without any argument and returning 0
+  %w[
+    lineno pos tell rewind
+  ].each do |method_name|
+    it "should return 0 for Devnull##{method_name}" do
+      eval("@null.#{method_name}").should == 0
+    end
+  end
+  
+  # ---------- specs for called with 1 or 2 arguments and returning 0
+  %w[
+    seek sysseek
+  ].each do |method_name|
+    it "should return 0 for Devnull##{method_name}" do
+      lambda{ eval("@null.#{method_name}") }.should raise_error(ArgumentError)
+      eval("@null.#{method_name}(1)").should == 0
+      eval("@null.#{method_name}(1, 2)").should == 0
+      lambda{ eval("@null.#{method_name}(1, 2, 3)") }.should raise_error(ArgumentError)
+    end
+  end
+  
+  # ---------- specs for called with a string argument and returning its string length
+  %w[
+    syswrite write write_nonblock
+  ].each do |method_name|
+    it "should return the argument string's length for Devnull##{method_name}(string)" do
+      eval("@null.#{method_name}('hoge')").should == 4
+      eval("@null.#{method_name}('abcdefg')").should == 7
+    end
+  end
+  
+  # ---------- specs for assignment-type methods that do nothing
+  %w[
+    autoclose= close_on_exec= lineno= pos= sync=
+  ].each do |method_name|
+    it "should do nothing when called Devnull##{method_name}" do
+      lambda{ eval("@null.#{method_name}(1)") }.should_not raise_error
+    end
+  end
+  
+  # ---------- specs for methods called with no argument and always failing with EOFError
+  %w[
+    readbyte readchar
+  ].each do |method_name|
+    it "should raise EOFError when called Devnull##{method_name}" do
+      lambda{ eval("@null.#{method_name}") }.should raise_error(EOFError)
+      lambda{ eval("@null.#{method_name}(1)") }.should raise_error(ArgumentError)
+    end
+  end
+  
+  # ---------- specs for methods called with 1 or 2 arguments and always failing with EOFError
+  %w[
+    read_nonblock readpartial sysread
+  ].each do |method_name|
+    it "should raise EOFError when called Devnull##{method_name}" do
+      lambda{ eval("@null.#{method_name}") }.should raise_error(ArgumentError)
+      lambda{ eval("@null.#{method_name}(1)") }.should raise_error(EOFError)
+      lambda{ eval("@null.#{method_name}(1, 2)") }.should raise_error(EOFError)
+      lambda{ eval("@null.#{method_name}(1, 2, 3)") }.should raise_error(ArgumentError)
+    end
+  end
+  
+  # ---------- specs for not implemented methods
+  it "should raise NotImplementedError for Devnull#fcntl when called with 2 arguments" do
+    lambda{ @null.fcntl(0) }.should raise_error(ArgumentError)
+    lambda{ @null.fcntl(0, 0) }.should raise_error(NotImplementedError)
+    lambda{ @null.fcntl(0, 0, 0) }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise NotImplementedError for Devnull\#\{fsync,fdatasync\}" do
+    lambda{ @null.fsync }.should raise_error(NotImplementedError)
+    lambda{ @null.fdatasync }.should raise_error(NotImplementedError)
+  end
+  
+  it "should raise NotImplementedError for Devnull\#\{fileno,to_i\}" do
+    lambda{ @null.fileno }.should raise_error(NotImplementedError)
+    lambda{ @null.to_i }.should raise_error(NotImplementedError)
+  end
+  
+  it "should raise NotImplementedError for Devnull#ioctl when called with 2 arguments" do
+    lambda{ @null.ioctl(0) }.should raise_error(ArgumentError)
+    lambda{ @null.ioctl(0, 0) }.should raise_error(NotImplementedError)
+    lambda{ @null.ioctl(0, 0, 0) }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise NotImplementedError for Devnull#stat" do
+    lambda{ @null.stat }.should raise_error(NotImplementedError)
+  end
+  
+  # ---------- others
+  it "should return self for Devnull#<<" do
+    (@null << "test").should == @null
+  end
+  
+  it "should do nothing for Devnull#binmode" do
+    lambda{ @null.binmode }.should_not raise_error
+  end
+  
+  it "should return nil for Devnull#printf when called with 1 or more arguments" do
+    lambda{ @null.printf }.should raise_error(ArgumentError)
+    @null.printf(0).should be_nil
+    @null.printf(0, 0).should be_nil
+    @null.printf(0, 0, 0, 0).should be_nil
+  end
+  
+  it "should return the argument for Devnull#putc when called with 1 arguments" do
+    lambda{ @null.putc }.should raise_error(ArgumentError)
+    @null.putc(0).should == 0
+    @null.putc("hoge").should == "hoge"
+    lambda{ @null.putc(0, 0)  }.should raise_error(ArgumentError)
+  end
+  
+  it "should return an empty string for Devnull#read() or Devnull#read(0)" do
+    @null.read.should == ""
+    @null.read(0).should == ""
+    
+    buffer = "hoge"
+    @null.read(0, buffer).should be_equal(buffer)
+    buffer.should == ""
+  end
+  
+  it "should return nil for Devnull#read(positive_integer)" do
+    @null.read(1).should be_nil
+    @null.read(10).should be_nil
+    
+    buffer = "hoge"
+    @null.read(10, buffer).should be_equal(buffer)
+    buffer.should == ""
+  end
+  
+  it "should return nil for Devnull#gets(0 to 2 arguments)" do
+    @null.gets().should == nil
+    @null.gets(0).should == nil
+    @null.gets(0, 0).should == nil
+    lambda{ @null.gets(0, 0, 0) }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise EOFError when called Devnull#readline" do
+    lambda{ @null.readline }.should raise_error(EOFError)
+    lambda{ @null.readline(0) }.should raise_error(EOFError)
+    lambda{ @null.readline(0, 0) }.should raise_error(EOFError)
+    lambda{ @null.readline(0, 0, 0) }.should raise_error(ArgumentError)
+  end
+  
+  it "should return empty array for Devnull#readlines(0 to 2 arguments)" do
+    @null.readlines().should == []
+    @null.readlines(0).should == []
+    @null.readlines(0, 0).should == []
+    lambda{ @null.readlines(0, 0, 0) }.should raise_error(ArgumentError)
+  end
+  
+  it "should return self for Devnull#reopen(1 or 2 arguments)" do
+    lambda{ @null.reopen() }.should raise_error(ArgumentError)
+    @null.reopen(0).should == @null
+    @null.reopen(0, 0).should == @null
+    lambda{ @null.reopen(0, 0, 0) }.should raise_error(ArgumentError)
+  end
+  
+  it "should return self for Devnull#set_encoding(1 to 3 arguments)" do
+    lambda{ @null.set_encoding() }.should raise_error(ArgumentError)
+    @null.set_encoding(0).should == @null
+    @null.set_encoding(0, 0).should == @null
+    @null.set_encoding(0, 0, 0).should == @null
+    lambda{ @null.set_encoding(0, 0, 0, 0) }.should raise_error(ArgumentError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'devnull'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification 
+name: devnull
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- H.Hiro (Maraigue)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-28 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  prerelease: false
+  type: :development
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  prerelease: false
+  type: :development
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  prerelease: false
+  type: :development
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id004
+description: |
+  DevNull behaves a null file, and works like an IO object. For example:
+  
+  dn = DevNull.new
+  dn.puts "foo" # => nil (do nothing)
+  dn.gets # => nil
+  dn.read # => ""
+  
+  The library may be a good solution if you would like to switch whether an input/output file is needed. For example:
+  
+  def some_process(arg, logfile = nil)
+    # You may set an IO object as 'logfile', and logs are written to the file.
+    
+    result = process1(arg)
+    logfile.puts result if logfile
+    
+    result = process2(arg)
+    logfile.puts result if logfile
+    
+    result = process3(arg)
+    logfile.puts result if logfile
+  end
+  
+  can be rewritten as follows:
+  
+  def some_process(arg, logfile = DevNull.new)
+    logfile.puts process1(arg)
+    logfile.puts process2(arg)
+    logfile.puts process3(arg)
+  end
+
+email: main@hhiro.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- devnull.gemspec
+- lib/devnull.rb
+- spec/devnull_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/maraigue/devnull
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Ruby implementation of null file (like /dev/null on Un*x, NUL on Windows)
+test_files: 
+- spec/devnull_spec.rb
+- spec/spec_helper.rb