epitools 0.5.116 → 0.5.118

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f59b5b62bfba503dc018fd54d0862d83c39a28c42c111cb65f7c715ec148dac6
-  data.tar.gz: 9a39b0bbd31c21f7434e8230521f3ad69a7013915dc52eb8a917840a56e208d5
+  metadata.gz: c905d2edd9ff4e5738a2a14992e64168ab876049a481a57f03bfec551aa65bbc
+  data.tar.gz: 81a3dabab5584a115d2a2826e34d681c7a910201b1a13ee58b5b3a9f2129b728
 SHA512:
-  metadata.gz: 9032e99a44dcc83f6277722d79384cdb5fefbebd4324d34c049b51e62dbc09fca49a16450863c1b607c6dc6075445dc744fab9bf717fe43599223b358e6dd191
-  data.tar.gz: 8abee532a4ecc30fe0ea6c9c365fe8c137e7190425b398f54cdc3dadeee4ec00431b3b55d25b91b4cc3f36918626c0d7404a370388f0622792d4f859919cbf09
+  metadata.gz: 6daaa56aeba42a400b2a6e0387fc329e7b95b88a16bae5b704efc2ec956f59d0e0c1580816ea4378441bee7755fc3d1bacb2f7e48f3ac5553b45dcc97330c112
+  data.tar.gz: 05b6d0bd082e135f2274d3e896c2baab6da7d4ec02bebdb05c3f4a8a05b5cfe342f020985c29efabd4b421968c803afb02ba5349ad23d28ee6ea7acce22a5c0e

data/VERSION

@@ -1 +1 @@
-0.5.116
+0.5.118

data/lib/epitools.rb

@@ -16,7 +16,6 @@ end
 #
 %w[
   core_ext
-  zopen
   colored
   clitools
   numwords

data/lib/epitools/autoloads.rb

@@ -79,6 +79,7 @@ autoload :Matrix,       'epitools/core_ext/matrix'
 autoload :SemanticVersion, 'epitools/semantic_version'
 
 
+
 ## Gems (common)
 
 autoreq  :Nokogiri,     'nokogiri'
@@ -91,6 +92,10 @@ autoreq  :RBTree,       'rbtree'
 autoreq  :MultiRBTree,  'rbtree'
 autoreq  :ID3Tag,       'id3tag'
 
+autoreq :Numo do
+  require 'numo/narray'
+end
+
 autoreq :AwesomePrint do
   require 'awesome_print'
 

data/lib/epitools/core_ext/array.rb

@@ -190,6 +190,27 @@ class Array
   end
   alias_method :col, :column
 
+  #
+  # Create a 2D matrix out of arrays
+  #
+  def self.matrix(height, width, initial_value=nil)
+    if block_given?
+      height.times.map do |row|
+        width.times.map do |col|
+          yield(row, col)
+        end
+      end
+    else
+      height.times.map do
+        [initial_value] * width
+      end
+    end
+  end
+
+  alias_class_method :rect, :matrix
+  alias_class_method :of_arrays, :matrix
+
+
   ####################################################################
 
   #

data/lib/epitools/core_ext/enumerable.rb

@@ -207,16 +207,19 @@ module Enumerable
   end
 
 
-  #
-  # Sum the elements
-  #
-  def sum(&block)
-    if block_given?
-      map(&block).reduce(:+)
-    else
-      reduce(:+)
+  unless defined? sum
+    #
+    # Sum the elements
+    #
+    def sum(&block)
+      if block_given?
+        map(&block).reduce(:+)
+      else
+        reduce(:+)
+      end
     end
   end
+
   alias_method :sum_by, :sum
 
   #

data/lib/epitools/core_ext/matrix.rb

@@ -19,6 +19,13 @@ class Matrix
   alias_class_method :zeros, :zero
   alias_class_method :zeroes, :zero
 
+  #
+  # Build an array of 1's
+  #
+  def self.ones(*dims)
+    build(*dims) { 1 }
+  end
+
   #
   # Create a matrix of the specified size full of random numbers.
   #
@@ -26,7 +33,6 @@ class Matrix
     build(*dims) { rand }
   end
 
-
   #
   # The size of the matrix, returned as `[rows, columns]`.
   #
@@ -34,6 +40,17 @@ class Matrix
     [row_size, column_size]
   end
 
+  #
+  # Iterate over rows (takes a block or returns an Enumerator)
+  #
+  def each_row
+    return to_enum(:each_row) unless block_given?
+
+    (0...row_count).each do |num|
+      yield row(num)
+    end
+  end
+
   #
   # Print the matrix to the STDOUT.
   #
@@ -58,9 +75,20 @@ class Matrix
 
     puts
   end
-
   alias_method :draw, :print
 
+  #
+  # Overlay one matrix onto another
+  #
+  def blit!(submatrix, top, left)
+    submatrix.each_row.with_index do |row, y|
+      row.each.with_index do |elem, x|
+        self[top+y,left+x] = elem
+      end
+    end
+  end
+  alias_method :overlay!, :blit!
+
   #
   # Allow mathematical operations (*, /, +, -) with a scalar (integer or float) on the right side.
   #

data/lib/epitools/core_ext/numbers.rb

@@ -266,34 +266,51 @@ class Integer
   alias_method :bits, :to_bits
 
   #
-  # Cached constants for base62 encoding
+  # Cached constants for encoding numbers into bases up to 64
   #
-  BASE62_DIGITS   = ['0'..'9', 'A'..'Z', 'a'..'z'].map(&:to_a).flatten
-  BASE62_BASE     = BASE62_DIGITS.size
+  BASE_DIGITS       = [*'0'..'9', *'A'..'Z', *'a'..'z', '_', '-']
+  SMALL_POWERS_OF_2 = {2=>1, 4=>2, 8=>3, 16=>4, 32=>5, 64=>6}
 
   #
-  # Convert a number to a string representation (in "base62" encoding).
+  # Convert a number into a string representation (encoded in a base <= 64).
   #
-  # Base62 encoding represents the number using the characters: 0..9, A..Z, a..z
+  # The number is represented usiing the characters: 0..9, A..Z, a..z, _, -
   #
-  # It's the same scheme that url shorteners and YouTube uses for their
-  # ID strings. (eg: http://www.youtube.com/watch?v=dQw4w9WgXcQ)
+  # (Setting base to 64 results in the encoding scheme that YouTube and url shorteners
+  # use for their ID strings, eg: http://www.youtube.com/watch?v=dQw4w9WgXcQ)
   #
-  def to_base62
-    result = []
-    remainder = self
-    max_power = ( Math.log(self) / Math.log(BASE62_BASE) ).floor
-
-    max_power.downto(0) do |power|
-      divisor = BASE62_BASE**power
-      #p [:div, divisor, :rem, remainder]
-      digit, remainder = remainder.divmod(divisor)
-      result << digit
+  def to_base(base=10)
+    raise "Error: Can't handle bases greater than 64" if base > 64
+
+    n        = self
+    digits   = []
+    alphabet = BASE_DIGITS[0...base]
+
+    if bits = SMALL_POWERS_OF_2[base]
+      # a slightly accelerated version for powers of 2
+      mask   = (2**bits)-1
+
+      loop do
+        digits << (n & mask)
+        n = n >> bits
+
+        break if n == 0
+      end
+    else
+      # generic base conversion
+      loop do
+        n, digit = n.divmod(base)
+        digits << digit
+
+        break if n == 0
+      end
     end
 
-    result << remainder if remainder > 0
+    digits.reverse.map { |d| alphabet[d] }.join
+  end
 
-    result.map{|digit| BASE62_DIGITS[digit]}.join ''
+  def to_base62
+    to_base(62)
   end
 
   #

data/lib/epitools/core_ext/string.rb

@@ -311,30 +311,33 @@ class String
   end
 
   #
-  # Cached constants for base62 decoding.
+  # Cached constants for base conversion.
   #
-  BASE62_DIGITS  = Hash[ Integer::BASE62_DIGITS.zip((0...Integer::BASE62_DIGITS.size).to_a) ]
-  BASE62_BASE    = Integer::BASE62_BASE
+  BASE_DIGITS = Integer::BASE_DIGITS.map.with_index.to_h
 
   #
-  # Convert a string (encoded in base16 "hex" -- for example, an MD5 or SHA1 hash)
-  # into "base62" format. (See Integer#to_base62 for more info.)
+  # Convert a string encoded in some base <= 64 into an integer.
+  # (See Integer#to_base for more info.)
   #
-  def to_base62
-    to_i(16).to_base62
+  def from_base(base=10)
+    n = 0
+    chars.reverse_each.with_index do |c, power|
+      value = BASE_DIGITS[c]
+      n += (base**power) * value
+    end
+    n
+  end
+
+  def from_base62
+    from_base(62)
   end
 
   #
-  # Convert a string encoded in base62 into an integer.
-  # (See Integer#to_base62 for more info.)
+  # Convert a string (encoded in base16 "hex" -- for example, an MD5 or SHA1 hash)
+  # into "base62" format. (See Integer#to_base62 for more info.)
   #
-  def from_base62
-    accumulator = 0
-    digits = chars.map { |c| BASE62_DIGITS[c] }.reverse
-    digits.each_with_index do |digit, power|
-      accumulator += (BASE62_BASE**power) * digit if digit > 0
-    end
-    accumulator
+  def to_base62
+    to_i(16).to_base62
   end
 
   #

data/lib/epitools/minimal.rb

@@ -241,8 +241,8 @@ module Kernel
   #
   # Print "self" with a linefeed at the end
   #
-  def displayln
-    puts self
+  def displayln(out=$stdout)
+    out.puts self
   end
 
 end

data/lib/epitools/path.rb

@@ -596,7 +596,11 @@ class Path
       when String, Numeric, true, false, nil
         self[key] = new
       else
-        raise "Error: Can't use a #{new.class} as an xattr value. Try passing a String."
+        if new.respond_to? :to_str
+          self[key] = new.to_str
+        else
+          raise "Error: Can't use a #{new.class} as an xattr value. Try passing a String."
+        end
       end
     end
   end
@@ -670,7 +674,7 @@ class Path
     return to_enum(:grep, pat).to_a unless block_given?
 
     each_line do |line|
-      yield line if line =~ pat
+      yield line if line[pat]
     end
   end
 
@@ -779,6 +783,62 @@ class Path
     end
   end
 
+  ###############################################################################
+  # zopening files
+  ###############################################################################
+
+  COMPRESSORS = {
+    "gz"  => "gzip",
+    "xz"  => "xz",
+    "bz2" => "bzip2"
+  }
+
+  #
+  # A mutation of "open" that lets you read/write gzip files, as well as
+  # regular files.
+  #
+  # (NOTE: gzip detection is based on the filename, not the contents.)
+  #
+  # It accepts a block just like open()!
+  #
+  # Example:
+  #    zopen("test.txt")          #=> #<File:test.txt>
+  #    zopen("test.txt.gz")       #=> #<Zlib::GzipReader:0xb6c79424>
+  #    zopen("otherfile.gz", "w") #=> #<Zlib::GzipWriter:0x7fe30448>>
+  #    zopen("test.txt.gz") { |f| f.read } # read the contents of the .gz file, then close the file handle automatically.
+  #
+  def zopen(mode="rb")
+    # if ext == "gz"
+    #   io = open(mode)
+    #   case mode
+    #   when "r", "rb"
+    #     io = Zlib::GzipReader.new(io)
+    #     def io.to_str; read; end
+    #   when "w", "wb"
+    #     io = Zlib::GzipWriter.new(io)
+    #   else
+    #     raise "Unknown mode: #{mode.inspect}. zopen only supports 'r' and 'w'."
+    #   end
+    # elsif bin = COMPRESSORS[ext]
+    if bin = COMPRESSORS[ext]
+      if which(bin)
+        io = IO.popen([bin, "-d" ,"-c", path])
+      else
+        raise "Error: couln't find #{bin.inspect} in the path"
+      end
+    else
+      io = open(path)
+    end
+
+    if block_given?
+      result = yield(io)
+      io.close
+      result
+    else
+      io
+    end
+
+  end
 
   ###############################################################################
   # Parsing files
@@ -788,22 +848,24 @@ class Path
   # Parse the file based on the file extension.
   # (Handles json, html, yaml, xml, csv, marshal, and bson.)
   #
-  def parse
-    case ext.downcase
+  def parse(io=self.io, forced_ext=nil)
+    case (forced_ext or ext.downcase)
+    when 'gz', 'bz2', 'xz'
+      parse(zopen, exts[-2])
     when 'json'
-      read_json
+      read_json(io)
     when 'html', 'htm'
-      read_html
+      read_html(io)
     when 'yaml', 'yml'
-      read_yaml
+      read_yaml(io)
     when 'xml', 'rdf', 'rss'
-      read_xml
+      read_xml(io)
     when 'csv'
-      read_csv
+      read_csv(io)
     when 'marshal'
-      read_marshal
+      read_marshal(io)
     when 'bson'
-      read_bson
+      read_bson(io)
     else
       raise "Unrecognized format: #{ext}"
     end
@@ -816,8 +878,9 @@ class Path
     each_line.map { |line| JSON.parse line }
   end
 
+
   # Parse the file as JSON
-  def read_json
+  def read_json(io=self.io)
     JSON.load(io)
   end
   alias_method :from_json, :read_json
@@ -828,7 +891,7 @@ class Path
   end
 
 
-  def read_html
+  def read_html(io=self.io)
     Nokogiri::HTML(io)
   end
   alias_method :from_html, :read_html
@@ -840,11 +903,12 @@ class Path
   end
 
   # Parse the file as YAML
-  def read_yaml
+  def read_yaml(io=self.io)
     YAML.load(io)
   end
   alias_method :from_yaml, :read_yaml
 
+
   # Parse the file as CSV
   def read_csv(opts={})
     CSV.open(io, opts).each
@@ -852,12 +916,12 @@ class Path
   alias_method :from_csv, :read_csv
 
   # Parse the file as XML
-  def read_xml
+  def read_xml(io=self.io)
     Nokogiri::XML(io)
   end
 
   # Parse the file as a Ruby Marshal dump
-  def read_marshal
+  def read_marshal(io=self.io)
     Marshal.load(io)
   end
 
@@ -867,7 +931,7 @@ class Path
   end
 
   # Parse the file as BSON
-  def read_bson
+  def read_bson(io=self.io)
     BSON.deserialize(read)
   end
 
@@ -880,7 +944,7 @@ class Path
   # Read ID3 tags (requires 'id3tag' gem)
   #
   # Available fields:
-  #    tag.artist, tag.title, tag.album, tag.year, tag.track_nr, tag.genre, tag.get_frame(:TIT2)&.content, 
+  #    tag.artist, tag.title, tag.album, tag.year, tag.track_nr, tag.genre, tag.get_frame(:TIT2)&.content,
   #    tag.get_frames(:COMM).first&.content, tag.get_frames(:COMM).last&.language
   #
   def id3
@@ -1124,7 +1188,7 @@ class Path
   # Remove a file or directory
   #
   def rm
-    raise "Error: #{self} does not exist" unless symlink? or exists? 
+    raise "Error: #{self} does not exist" unless symlink? or exists?
 
     if directory? and not symlink?
       Dir.rmdir(self) == 0
@@ -1391,7 +1455,7 @@ class Path
   # TODO: Remove the tempfile when the Path object is garbage collected or freed.
   #
   def self.tmpfile(prefix="tmp")
-    path = Path.new Tempfile.new(prefix).path, unlink_when_garbage_collected: true
+    path = Path.new(Tempfile.new(prefix).path, unlink_when_garbage_collected: true)
     yield path if block_given?
     path
   end
@@ -1536,20 +1600,29 @@ class Path::URI < Path
   #
   # When this is: http://host.com:port/path/filename.ext?param1=value1&param2=value2&...
   #
-  def to_s; uri.to_s; end
+  def to_s
+    uri.to_s
+  end
 
+  def inspect
+    "#<Path::URI:#{to_s}>"
+  end
 
-  #
-  # ...this is: 'http'
-  #
-  def scheme; uri.scheme; end
+  def scheme
+    uri.scheme
+  end
   alias_method :protocol, :scheme
 
   %w[http https ftp magnet].each do |s|
-    define_method("#{s}?") { scheme[/^#{s}$/i] }
+    define_method("#{s}?") { scheme.downcase == s }
   end
 
-  def http?; super or https?; end
+  #
+  # `http?` checks for 'http' OR 'https' schemes
+  #
+  def http?
+    super or https?
+  end
 
   #
   # ...and this is: 'host.com'
@@ -1582,22 +1655,27 @@ class Path::URI < Path
   def open(mode="r", &block)
     require 'open-uri'
     if block_given?
-      open(to_s, mode, &block)
+      Kernel.open(to_s, mode, &block)
     else
-      open(to_s, mode)
+      Kernel.open(to_s, mode)
     end
   end
 
-  # Note: open is already aliased to io in parent class.
+  alias_method :io, :open
+
   def read(*args)
-    require 'open-uri'
-    case scheme
-    when /https?/i
-      io.read(*args)
-    else
-      raise "No connector for #{scheme} yet. Please fix!"
-    end
-  end
+    open { |io| io.read(*args) }
+  end
+
+  # def read(*args)
+  #   require 'open-uri'
+  #   case scheme
+  #   when /https?/i
+  #     io.read(*args)
+  #   else
+  #     raise "No connector for #{scheme} yet. Please fix!"
+  #   end
+  # end
 
 end
 

data/spec/btree_spec.rb

@@ -0,0 +1,25 @@
+require 'rbtree'
+
+describe RBTree do
+
+  before :each do
+    @t = RBTree.new
+    @alphabet = [*'a'..'z'] 
+    @alphabet.shuffle.each { |c| @t[c] = c.ord }
+  end
+
+  it "sizes" do
+    @t.size.should == 26
+  end
+
+  it "eaches" do
+    visited_keys = []
+
+    @t.each do |k,v|
+      k.ord.should == v
+      visited_keys << k
+    end
+
+    visited_keys.should == @alphabet
+  end
+end

data/spec/core_ext_spec.rb

@@ -423,13 +423,15 @@ describe Integer do
     i[0..-1].should == [1,1,0,1,1,1]
   end
 
-  it "converts to/from base62" do
-    Integer::BASE62_BASE.should == 62
-
+  it "converts to/from bases" do
     [1,20,500,501,34191923].each do |n|
       n.to_base62.from_base62.should == n
     end
 
+    "777".from_base(16).should == 1911
+    500.to_base(10).should == "500"
+    500.to_base(10).from_base(10).should == 500
+
     sum = "asdf".md5
     sum.to_base62.from_base62.to_s(16).should == sum
   end
@@ -584,6 +586,18 @@ describe Array do
     a.cols.map(&:size).should == [3,3,2,2,2]
   end
 
+  it "matrixes" do
+    m = Array.matrix(2,2,0)
+    m.should == [[0,0],[0,0]]
+
+    m = Array.rect(2,2)
+    m.should == [[nil,nil],[nil,nil]]
+
+    m = Array.rect(2,2) {|x,y| rand }
+    pp m
+    m.should_not == [[0,0],[0,0]]
+  end
+
 end
 
 
@@ -1011,6 +1025,35 @@ describe Matrix do
     m.to_a.should == [[0,0,5]]
   end
 
+  it "'each_row's" do
+    m = Matrix.zeros(2,2)
+    m.each_row do |row|
+      row.size.should == 2
+      row.to_a.should == [0,0]
+    end
+
+    Enumerator.should === m.each_row
+  end
+
+  it "'ones'es" do
+    Matrix.ones(2).to_a == [1,1]
+    Matrix.ones(2,2).to_a.should == [[1,1],[1,1]]
+    proc { Matrix.ones(1,1,1) }.should raise_error(ArgumentError)
+  end
+
+  it "blits" do
+    m = Matrix.zeros(5,5)
+    s = Matrix.ones(2,2)
+    m.blit!(s, 2, 1)
+    m.to_a.should == [
+      [0,0,0,0,0],
+      [0,0,0,0,0],
+      [0,1,1,0,0],
+      [0,1,1,0,0],
+      [0,0,0,0,0],
+    ]
+  end
+
 end
 
 

data/spec/path_spec.rb

@@ -135,8 +135,9 @@ describe Path do
   it "reads/writes various formats (json, yaml, etc.)" do
     data = { "hello" => "there", "amazing" => [1,2,3,4] }
 
-    yaml = Path.tmpfile
+    yaml = Path["/tmp/test.yaml"]
     yaml.write_yaml(data)
+    yaml.exists?.should == true
     yaml.read_yaml.should == data
 
     json = Path.tmpfile
@@ -147,6 +148,9 @@ describe Path do
     html = Path.tmpfile
     html.write data
     html.read_html.at("h1").to_s.should == data
+
+  ensure
+    yaml.rm
   end
 
   it "parses files" do
@@ -367,6 +371,34 @@ describe Path do
     tmp.size.should == before
   end
 
+  it "zopens" do
+    tmpjson = Path["/tmp/test.json"]
+
+    hash = {
+      "json" => true,
+      "jsonity" => 500
+    }
+
+    tmpjson.write(JSON.dump(hash))
+    tmpjson.read.from_json["json"].should == true
+
+    parsed = tmpjson.parse
+    parsed.should == hash
+
+    system("gzip -c < #{tmpjson} > #{tmpjson}.gz")
+
+    tmpgzip = Path["#{tmpjson}.gz"]
+    tmpgzip.exists?.should == true
+    tmpgzip.size.should be > 0
+
+    parsed = tmpgzip.parse
+    parsed.should_not be_nil
+    parsed.should == hash
+
+    tmpjson&.rm
+    tmpgzip&.rm
+  end
+
   it "exts" do
     path = Path["file.tar.gz"]
     path.ext.should == "gz"

data/spec/typed_struct_spec.rb

@@ -33,18 +33,18 @@ describe TypedStruct do
   it "drops unknowns" do
 
     ts = TypedStruct["a:int"]
-    lambda { ts.new a: 1, b: 2 }.should raise_error
+    lambda { ts.new a: 1, b: 2 }.should raise_error(NoMethodError)
 
     ts = TypedStruct["a:int -"]
     lambda {
       t = ts.new a: 1, b: 2
       t.a.should == 1
-      lambda { t.b }.should raise_error
+      lambda { t.b }.should raise_error(NoMethodError)
     }.should_not raise_error
   end
 
   it "can't use wildcard and drop unknown at once" do
-    lambda { TypedStruct["a:int - *"].new }.should raise_error
+    lambda { TypedStruct["a:int - *"].new }.should raise_error(RuntimeError)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epitools
 version: !ruby/object:Gem::Version
-  version: 0.5.116
+  version: 0.5.118
 platform: ruby
 authors:
 - epitron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-04 00:00:00.000000000 Z
+date: 2018-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -93,10 +93,10 @@ files:
 - lib/epitools/trie.rb
 - lib/epitools/typed_struct.rb
 - lib/epitools/wm.rb
-- lib/epitools/zopen.rb
 - spec/.rspec
 - spec/autoreq_spec.rb
 - spec/browser_spec.rb
+- spec/btree_spec.rb
 - spec/clitools_spec.rb
 - spec/colored_spec.rb
 - spec/core_ext_spec.rb

data/lib/epitools/zopen.rb

@@ -1,50 +0,0 @@
-require 'zlib'
-
-COMPRESSORS = {
-  ".gz"  => "gzip",
-  ".xz"  => "xz",
-  ".bz2" => "bzip2"
-}
-
-#
-# A mutation of "open" that lets you read/write gzip files, as well as
-# regular files.
-#
-# (NOTE: gzip detection is based on the filename, not the contents.)
-#
-# It accepts a block just like open()!
-#
-# Example:
-#    zopen("test.txt")          #=> #<File:test.txt>
-#    zopen("test.txt.gz")       #=> #<Zlib::GzipReader:0xb6c79424>
-#    zopen("otherfile.gz", "w") #=> #<Zlib::GzipWriter:0x7fe30448>>
-#    zopen("test.txt.gz") { |f| f.read } # read the contents of the .gz file, then close the file handle automatically.
-#
-def zopen(path, mode="rb")
-  ext = File.extname(path).downcase
-
-  if ext == ".gz"
-    io = open(path, mode)
-    case mode
-    when "r", "rb"
-      io = Zlib::GzipReader.new(io)
-    when "w", "wb"
-      io = Zlib::GzipWriter.new(io)
-    else
-      raise "Unknown mode: #{mode.inspect}. zopen only supports 'r' and 'w'."
-    end
-  elsif bin = COMPRESSORS[ext]
-    io = IO.popen([bin, "-d" ,"-c", path])
-  else
-    io = open(path)
-  end
-
-  if block_given?
-    result = yield(io)
-    io.close
-    result
-  else
-    io
-  end
-
-end