nano 0.8.1

data/lib/nano/enumerable/each_unique_pair.rb

@@ -0,0 +1,41 @@
+require 'nano/enumerable/each_combination'
+
+class Array
+
+  # Processes each unique pair (of indices, not value) 
+  # in the array by yielding them to the supplied block.
+  #
+  #   a = [1,2,3,4]
+  #   a.each_unique_pair{ |a,b| puts a+','+b }
+  #
+  # produces
+  #
+  #   1,2
+  #   1,3
+  #   1,4
+  #   2,3
+  #   2,4
+  #   3,4
+  #
+  # This does not guarantee the uniqueness of values. 
+  # For example:
+  #
+  #   a = [1,2,1]
+  #   a.each_unique_pair{ |a,b| puts a+','+b }
+  #
+  # prduces
+  #
+  #   1,2
+  #   1,1
+  #   2,1
+  #
+  # This is equivalent to <tt>each_combination(2){ ... }</tt>.
+  def each_unique_pair(&yld)
+    self.each_combination(2,&yld)
+    #s = self.to_a
+    #self.each_with_index{ |a,i|
+    #  self[(i+1)..-1].each{ |b| yield a,b }
+    #}
+  end
+
+end

data/lib/nano/enumerable/entropy.rb

@@ -0,0 +1,30 @@
+#--
+# Credit goes to Derek.
+#++
+require 'nano/enumerable/ideal_entropy'
+require 'nano/enumerable/probability'
+
+module Enumerable
+  # Shannon's entropy for an array - returns the average
+  # bits per symbol required to encode the array.
+  # Lower values mean less "entropy" - i.e. less unique
+  # information in the array.
+  #
+  #   %w{ a b c d e e e }.entropy  #=>
+  #
+  def entropy
+    arr = self.to_a
+    probHash = arr.probability
+    # h is the Shannon entropy of the array
+    h = -1.to_f * probHash.keys.inject(0.to_f) do |sum, i|
+      sum + (probHash[i] * (Math.log(probHash[i])/Math.log(2.to_f)))
+    end
+    h
+  end
+end
+
+class String
+  def entropy
+    self.split(//).entropy
+  end
+end

data/lib/nano/enumerable/filter_collect.rb

@@ -0,0 +1,29 @@
+#--
+# Credit goes to Florian Gross.
+#++
+module Enumerable
+
+  # Collects/Maps and filters items out in one single step.
+  # You can use throw(:skip) in the supplied block to indicate that the
+  # current item should not end up in the resulting array.
+  #
+  #   # Return names of all person with an age of at least 18.
+  #   persons.filter_collect do |person|
+  #     throw(:skip) if person.age < 18
+  #     person.name
+  #   end
+  #
+  # Also see Enumerable#collect, Enumerable#find_all.
+  #
+  def filter_collect #:yield:
+    result = []
+    self.each do |item|
+      catch(:skip) do
+        new_item = yield(item)
+        result << new_item
+      end
+    end
+    return result
+  end
+
+end #Enumerable

data/lib/nano/enumerable/filter_map.rb

@@ -0,0 +1,7 @@
+#--
+# Credit goes to Florian Gross.
+#++
+require 'nano/enumerable/filter_collect'
+module Enumerable
+  alias_method :filter_map, :filter_collect
+end

data/lib/nano/enumerable/find_collisions.rb

@@ -0,0 +1,15 @@
+require 'nano/enumerable/commonality'
+
+module Enumerable
+
+  # Like commonality but returns an array if no block is given.
+  #
+  def find_collisions( &blk ) #:yield:
+    if block_given?
+      commonality( &blk )
+    else
+      commonality.values.flatten.uniq
+    end
+  end
+
+end

data/lib/nano/enumerable/frequency.rb

@@ -0,0 +1,16 @@
+#--
+# Credit goes to Brian Schröder and Derek for inspiration.
+#++
+module Enumerable
+
+  # Generates a hash mapping each unique symbol in the array
+  # to the absolute frequency it appears.
+  def frequency
+    probs = Hash.new(0)
+    each do | e |
+      probs[e] += 1
+    end
+    probs
+  end
+
+end

data/lib/nano/enumerable/graph.rb

@@ -0,0 +1,28 @@
+module Enumerable
+
+  # Like <tt>#map</tt>/<tt>#collect</tt>, but it generates a Hash.  The block
+  # is expected to return two values: the key and the value for the new hash.
+  #
+  #   numbers  = (1..3)
+  #   squares  = numbers.graph { |n| [n, n*n] }   # { 1=>1, 2=>4, 3=>9 }
+  #   sq_roots = numbers.graph { |n| [n*n, n] }   # { 1=>1, 4=>2, 9=>3 }
+  #
+  #--
+  # Credits for original work goes to Zallus Kanite and Gavin Sinclair.
+  #++
+  def graph(&yld)
+    if yld
+      inject({}) do |h,kv|
+        nk, nv = yld[*kv]
+        h[nk] = nv
+        h
+      end
+    else
+      Hash[*self.to_a.flatten]
+    end
+  end
+
+  # no longer used
+  #alias_method( :build_hash, :graph )
+  #alias_method( :build_hash!, :graph! )
+end

data/lib/nano/enumerable/ideal_entropy.rb

@@ -0,0 +1,24 @@
+
+module Enumerable
+  # Returns the maximum possible Shannon entropy of the array
+  # with given size assuming that it is an "order-0" source
+  # (each element is selected independently of the next).
+  #
+  #
+  #
+  #--
+  # Credit goes to Derek.
+  #++
+  def ideal_entropy
+    arr = self.to_a
+    unitProb = 1.0.to_f / arr.size.to_f
+    (-1.to_f * arr.size.to_f * unitProb * Math.log(unitProb)/Math.log(2.to_f))
+  end
+end
+
+# Not needed b/c ideal_entropy is only dependent on size.
+# class String
+#   def ideal_entropy
+#     self.split(//).ideal_entropy
+#   end
+# end

data/lib/nano/enumerable/map_with_counter.rb

@@ -0,0 +1,4 @@
+require 'nano/enumerable/collect_with_counter'
+module Enumerable
+  alias_method( :map_with_counter, :collect_with_counter )
+end

data/lib/nano/enumerable/map_with_index.rb

@@ -0,0 +1,4 @@
+require 'nano/enumerable/collect_with_counter'
+module Enumerable
+  alias_method( :map_with_index, :collect_with_counter )
+end

data/lib/nano/enumerable/none%3F.rb

@@ -0,0 +1,28 @@
+#--
+# Credit goes to Gavin Sinclair.
+#++
+module Enumerable
+
+  # Enumerable#none? is the logical opposite of the builtin method
+  # Enumerable#any?.  It returns +true+ if and only if _none_ of
+  # the elements in the collection satisfy the predicate.
+  #
+  # If no predicate is provided, Enumerable#none? returns +true+
+  # if and only if _none_ of the elements have a true value
+  # (i.e. not +nil+ or +false+).
+  #
+  #   [].none?                      # true
+  #   [nil].none?                   # true
+  #   [5,8,9].none?                 # false
+  #   (1...10).none? { |n| n < 0 }  # true
+  #   (1...10).none? { |n| n > 0 }  # false
+  #
+  def none?  # :yield: e
+    if block_given?
+      not self.any? { |e| yield e }
+    else
+      not self.any?
+    end
+  end
+
+end

data/lib/nano/enumerable/occur.rb

@@ -0,0 +1,36 @@
+
+module Enumerable
+
+  # Returns an array of elements for the elements that occur n times.
+  # Or according to the results of a given block.
+  #
+  #   [1,1,2,3,3,4,5,5].occur(1)             #=> [2,4]
+  #   [1,1,2,3,3,4,5,5].occur(2)             #=> [1,3,5]
+  #   [1,1,2,3,3,4,5,5].occur(3)             #=> []
+  #
+  #   [1,2,2,3,3,3].occur(1..1)              #=> [1]
+  #   [1,2,2,3,3,3].occur(2..3)              #=> [2,3]
+  #
+  #   [1,1,2,3,3,4,5,5].occur { |n| n == 1 } #=> [2,4]
+  #   [1,1,2,3,3,4,5,5].occur { |n| n > 1 }  #=> [1,3,5]
+  #
+  def occur(n=nil) #:yield:
+    result = Hash.new { |hash, key| hash[key] = Array.new }
+    self.each do |item|
+      key = item
+      result[key] << item
+    end
+    if block_given?
+      result.reject! { |key, values| ! yield(values.size) }
+    else
+      raise ArgumentError unless n
+      if Range === n
+        result.reject! { |key, values| ! n.include?(values.size) }
+      else
+        result.reject! { |key, values| values.size != n }
+      end
+    end
+    return result.values.flatten.uniq
+  end
+
+end

data/lib/nano/enumerable/one%3F.rb

@@ -0,0 +1,35 @@
+#--
+# Credit goes to Gavin Sinclair.
+#++
+module Enumerable
+
+  # Enumerable#one? returns +true+ if and only if <em>exactly one</em>
+  # element in the collection satisfies the given predicate.
+  #
+  # If no predicate is provided, Enumerable#one? returns +true+ if
+  # and only if <em>exactly one</em> element has a true value
+  # (i.e. not +nil+ or +false+).
+  #
+  #   [].one?                      # false
+  #   [nil].one?                   # false
+  #   [5].one?                     # true
+  #   [5,8,9].one?                 # false
+  #   (1...10).one? { |n| n == 5 } # true
+  #   (1...10).one? { |n| n < 5 }  # false
+  #
+  def one?  # :yield: e
+    matches = 0
+    if block_given?
+      self.each do |e|
+        if yield(e)
+          matches += 1
+          return false if matches > 1
+        end
+      end
+      return (matches == 1)
+    else
+      one? { |e| e }
+    end
+  end
+
+end

data/lib/nano/enumerable/partition_by.rb

@@ -0,0 +1,28 @@
+
+module Enumerable
+
+  # See Enumerable#partition for the background. #partition_by is best
+  # explained by example.
+  #
+  #   (1..5).partition_by { |n| n % 3 }
+  #        #=> { 0 => [3], 1 => [1, 4], 2 => [2,5] } 
+  #
+  #   ["I had", 1, "dollar and", 50, "cents"].partition_by { |e| e.class }
+  #        #=> { String => ["I had","dollar and","cents"], Fixnum => [1,50] } 
+  #
+  # #partition_by is used to group items in a collection by something they
+  # have in common.  The common factor is the key in the resulting hash, the
+  # array of like elements is the value.
+  #--
+  # Credit goes to Gavin Sinclair.
+  #++
+  def partition_by #:yield:
+    result = {}
+    self.each do |e|
+      value = yield e
+      (result[value] ||= []) << e
+    end
+    result
+  end
+
+end

data/lib/nano/enumerable/probability.rb

@@ -0,0 +1,36 @@
+#--
+# Credit goes to Brian Schröder for current code
+# and Derek for original.
+#++
+module Enumerable
+
+  # Generates a hash mapping each unique symbol in the array
+  # to the relative frequency, i.e. the probablity, of
+  # it appearence.
+  def probability
+    probs = Hash.new(0.0)
+    size = 0.0
+    each do | e |
+      probs[e] += 1.0
+      size += 1.0
+    end
+    probs.keys.each do |e| probs[e] /= size end
+    probs
+  end
+
+# old def
+#
+#   def probability
+#     arr = self.to_a
+#     probHash = Hash.new
+#     size = arr.size.to_f
+#     arr.uniq.each do |i|
+#       ct = arr.inject(0) do |mem,obj|
+#         obj.eql?(i) ? (mem+1) : mem
+#       end
+#       probHash[i] = ct.to_f/size
+#     end
+#     probHash
+#   end
+
+end

data/lib/nano/enumerable/to_h.rb

@@ -0,0 +1,14 @@
+module Enumerable
+
+  # Produces a hash from an Enumerable with index for keys.
+  #
+  #   a1 = [ :a, :b ]
+  #   a1.to_h  #=> { 0=>:a, 1=>:b }
+  #
+  def to_h
+    h = {}
+    each_with_index{ |e,i| h[i] = e }
+    h
+  end
+
+end

data/lib/nano/enumerable/unique_by.rb

@@ -0,0 +1,16 @@
+
+module Enumerable
+
+  # Like #uniq, but determines uniqueness based on a given block.
+  #
+  #   (-5..5).to_a.uniq_by {|i| i*i }
+  #
+  # produces
+  #
+  #   [-5, -4, -3, -2, -1, 0]
+  #
+  def uniq_by #:yield:
+    h = {}; inject([]) {|a,x| h[yield(x)] ||= a << x}
+  end
+
+end

data/lib/nano/file.rb

@@ -0,0 +1,3 @@
+require 'nano/file/%3A%3Acreate'
+require 'nano/file/%3A%3Aopen_as_string'
+require 'nano/file/%3A%3Asplit_all'

data/lib/nano/file/%3A%3Acreate.rb

@@ -0,0 +1,18 @@
+#--
+# Copyright (c) 2005 George Moschovitis <gm@navel.gr>
+#++
+
+# Creates a new file, or overwrites an existing file,
+# and writes a string into it. Can also take a block
+# just like File#open, which is yielded _after_ the
+# string is writ.
+#
+#   str = 'The content for the file'
+#   File.create('myfile.txt', str)
+#
+def File.create(path, str='', &blk)
+  File.open(path, 'w') { |f|
+    f << str
+    blk.call(f) if blk
+  }
+end

data/lib/nano/file/%3A%3Aopen_as_string.rb

@@ -0,0 +1,45 @@
+
+# Opens a file as a string and writes back the string to the file at
+# the end of the block.
+#
+# Returns the number of written bytes or +nil+ if the file wasn't
+# modified.
+#
+# Note that the file will even be written back in case the block
+# raises an exception.
+#
+# Mode can either be "b" or "+" and specifies to open the file in
+# binary mode (no mapping of the plattform's newlines to "\n" is
+# done) or to append to it.
+#
+# Usage:
+#   # Reverse contents of "message"
+#   File.open_as_string("message") { |str| str.reverse! }
+#
+#   # Replace "foo" by "bar" in "binary"
+#   File.open_as_string("binary", "b") { |str| str.gsub!("foo", "bar") }
+#
+def File.open_as_string(name, mode = "")
+  unless block_given?
+    raise(ArgumentError, "Need to supply block to File.open_as_string")
+  end
+
+  if mode.is_a?(Numeric) then
+    flag, mode = mode, ""
+    mode += "b" if flag & File::Constants::BINARY != 0
+    mode += "+" if flag & File::Constants::APPEND != 0
+  else
+    mode.delete!("^b+")
+  end
+
+  str = File.open(name, "r#{mode}") { |file| file.read } rescue ""
+  old_str = str.clone
+
+  begin
+    yield str
+  ensure
+    if str != old_str then
+      File.open(name, "w#{mode}") { |file| file.write(str) }
+    end
+  end
+end