devnull 0.1.1 → 0.1.2

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YjNkMmFiODI0YmMzNmQ5YWM3OTQ3YzY0NWQ4NTU3Mjk2MzdhYmI2Nw==
-  data.tar.gz: !binary |-
-    ZTdkNzAwMzAzZmY3ZjRlNmEyZjlhNTczYzEzMTBjMGM0ZDk0NGMyNQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    Y2ExMDFhNDZiZTk5NTZhMTNjZDViNWI1YTQ4NTRhYmY1OWQxODQ1ZjUxNDgw
-    NWU3ODMxMzJhYmE1ZDE1YjMyNDNiMGM1OGE2OGJhY2U5NTVmYzk2MTVlYTI4
-    NWFmMjM0YjA1Y2JmNGVkZmQ2YjJiZTJkZDM5NmFkNzRjM2Y1NDg=
-  data.tar.gz: !binary |-
-    ZGQ3N2QxYzg3Y2JlMThiOGU5N2RlNGFlZDJlZTQxYTc1MDk2MTk2ZTc4YzI0
-    MTc5ZjUxNzI4YmIzNjE2MWZhNWIzODM4OGMxZjVkMGVkNGM0Nzg2OTQ0ZDhj
-    MWQ3MDY5OGYwMTg0NzZhNDFiOWFhNWQyNTEzYTUyMGI0YWM5NGQ=
+SHA1:
+  metadata.gz: ab9b2bd9353de1577f8f63817a253c45737ed89a
+  data.tar.gz: af8ebecb37ab062fdbfb1486b87fa3e07d626b2a
+SHA512:
+  metadata.gz: a03f5dbdedf57b83c2754612b19bdc9f492369c87875b4572c29ea6449a6f58facd248161659606cb2c207807356c236ee15fb701413d0dc572896f77b0a27fa
+  data.tar.gz: abb6eb752a74ba70377f592f77600a67979ed17cd906a973bb7cfc74be307a5a1039854583e8be57873b8bbda28fa387259d4381c436d3a9152abdca561dec10

data/History.txt

@@ -6,3 +6,10 @@
 
 * Fixed duplicated definition of DevNull#syswrite (Thanks Andrew Grimm!)
 
+https://github.com/maraigue/devnull/pull/1
+
+=== 0.1.2 / 2015-02-20
+
+* Moved the location of code 'VERSION = "A.B.C"' (Thanks Patrik Wenger!)
+
+https://github.com/maraigue/devnull/commit/5c8d40b7e03c07a96ae647bc302eec74abfc224d#commitcomment-8379713

data/README.txt

@@ -1,55 +1,64 @@
 = devnull
 
-http://github.com/maraigue/devnull
+home  :: https://rubygems.org/gems/devnull
+code  :: https://github.com/maraigue/devnull
+
+== DESCRIPTION:
 
 Ruby implementation of null file (like /dev/null on Un*x, NUL on Windows)
 
-== DESCRIPTION:
+== SYNOPSIS:
 
-DevNull behaves a null file, and works like an IO object. For example:
+DevNull instance works like an IO object. For example:
 
- dn = DevNull.new
- dn.puts "foo" # => nil (do nothing)
- dn.gets # => nil
- dn.read # => ""
+  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
+  def some_process(arg, logfile = nil)
+    # You may set an IO object as 'logfile'.
+    # If so, 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
+  def some_process(arg, logfile = DevNull.new)
+    logfile.puts process1(arg)
+    logfile.puts process2(arg)
+    logfile.puts process3(arg)
+  end
 
-== INSTALL:
+== INSTALLATION:
 
-gem install devnull
+Installed by RubyGems with the command (recommended):
+
+  $ gem install devnull
+
+Or you can use it with downloading devnull.rb file and load it by `require "./devnull"`.
 
 == DEVELOPERS:
 
+(auto-generation by Hoe https://rubygems.org/gems/hoe)
+
 After checking out the source, run:
 
   $ rake newb
 
-This task will install any missing dependencies, run the tests/specs,
-and generate the RDoc.
+This task will install any missing dependencies, run the tests/specs, and generate the RDoc.
 
-== LICENSE:
+== LICENSE
 
 (The MIT License)
 

data/lib/devnull.rb

@@ -1,141 +1,142 @@
-# 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"
-VERSION = "0.1.1"
-
-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 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
+# 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
+  VERSION = "0.1.2"
+  
+  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 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

metadata

@@ -1,53 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: devnull
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - H.Hiro (maraigue)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-27 00:00:00.000000000 Z
+date: 2015-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
+        version: '3.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.6'
-description: ! "DevNull behaves a null file, and works like an IO object. For example:\n\n
-  dn = DevNull.new\n dn.puts \"foo\" # => nil (do nothing)\n dn.gets # => nil\n dn.read
-  # => \"\"\n\nThe library may be a good solution if you would like to switch whether
-  an input/output file is needed. For example:\n\n def some_process(arg, logfile =
-  nil)\n   # You may set an IO object as 'logfile', and logs are written to the file.\n
-  \  \n   result = process1(arg)\n   logfile.puts result if logfile\n   \n   result
-  = process2(arg)\n   logfile.puts result if logfile\n   \n   result = process3(arg)\n
-  \  logfile.puts result if logfile\n end\n\ncan be rewritten as follows:\n\n def
-  some_process(arg, logfile = DevNull.new)\n   logfile.puts process1(arg)\n   logfile.puts
-  process2(arg)\n   logfile.puts process3(arg)\n end"
+        version: '3.13'
+description: Ruby implementation of null file (like /dev/null on Un*x, NUL on Windows)
 email:
 - main@hhiro.net
 executables: []
@@ -61,30 +52,30 @@ files:
 - lib/devnull.rb
 - spec/devnull_spec.rb
 - spec/spec_helper.rb
-- .gemtest
-homepage: http://github.com/maraigue/devnull
-licenses: []
+homepage: https://rubygems.org/gems/devnull
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README.txt
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: devnull
-rubygems_version: 2.0.3
+rubyforge_project: 
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: DevNull behaves a null file, and works like an IO object
+summary: Ruby implementation of null file (like /dev/null on Un*x, NUL on Windows)
 test_files: []