facets 2.8.4 → 2.9.0.pre.1

data/lib/core/facets/applique/file_helpers.rb

@@ -0,0 +1,33 @@
+#
+def temporary_directory
+  @temporary_directory ||= 'tmp'
+end
+
+When /Given a directory '(.*?)' containing/ do |dir, text|
+  @temporary_directory = File.join(@temporary_directory, dir)
+  text.lines.each do |file|
+    next if file =~ /^\s*$/
+    file = File.join(@temporary_directory, file.strip)
+    dir  = File.dirname(file)
+    FileUtils.mkdir_p(dir)
+    File.open(file, 'w'){ |f| f << "SPINICH" }
+  end
+end
+
+Before :all do
+  if File.exist?(temporary_directory)
+    FileUtils.rm_r(temporary_directory)
+  end
+  FileUtils.mkdir_p(temporary_directory)
+end
+
+# Used for File extensions
+When "had a file '(((.*?)))'" do |name|
+  name = name.sub(/^tmp\//, '')
+  File.open("tmp/#{name}", 'w'){|f| f << "Hello World"}
+end
+
+When "had a binary file '(((.*?)))'" do |name|
+  name = name.sub(/^tmp\//, '')
+  File.open("tmp/#{name}", 'wb'){|f| f << "Hello\nWorld\n"}
+end

data/lib/core/facets/array/after.rb

@@ -0,0 +1 @@
+require 'facets/array/before'

data/lib/core/facets/array/before.rb

@@ -0,0 +1,39 @@
+class Array
+
+  # Returns the value previous to the given value. The value previous
+  # to the first is the last. Returns nil if the given value is not
+  # in the array.
+  #
+  # Examples
+  #
+  #   sequence = ['a', 'b', 'c']
+  #   sequence.before('a')           #=> 'c'
+  #   sequence.before('b')           #=> 'a'
+  #   sequence.before('c')           #=> 'b'
+  #   sequence.before('d')           #=> nil
+  #
+  # CREDIT: Tyler Rick
+  def before(value)
+    return nil unless include? value
+    self[(index(value).to_i - 1) % length]
+  end
+
+  # Returns the value after the given value. The value before the last
+  # is the first. Returns nil if the given value is not in the array.
+  #
+  # Examples
+  #
+  #   sequence = ['a', 'b', 'c']
+  #   sequence.after('a')           #=> 'b'
+  #   sequence.after('b')           #=> 'c'
+  #   sequence.after('c')           #=> 'a'
+  #   sequence.after('d')           #=> nil
+  #
+  # CREDIT: Tyler Rick
+  def after(value)
+    return nil unless include? value
+    self[(index(value).to_i + 1) % length]
+  end
+
+end
+

data/lib/core/facets/array/collisions.rb

@@ -0,0 +1 @@
+require 'facets/array/commonality'

data/lib/core/facets/array/combination.rb

@@ -37,22 +37,6 @@ class Array
       end
     end
 
-    # OLD WAY
-    #a = []
-    #s = self
-    #n = s.size
-    #return unless (1..n) === k
-    #dx = (0...k).to_a
-    #loop do
-    #  a << s.values_at(*idx)
-    #  i = k - 1
-    #  i -= 1 while idx[i] == n - k + i
-    #  break if i < 0
-    #  idx[i] += 1
-    #  (i + 1 ... k).each {|j| idx[j] = idx[i] + j - i}
-    #end
-    #a
-
   end
 
 end

data/lib/core/facets/{enumerable → array}/commonality.rb

@@ -1,15 +1,17 @@
-module Enumerable
+class Array
 
   # Returns all items that are equal in terms of the supplied block.
   # If no block is given objects are considered to be equal if they
   # return the same value for Object#hash and if obj1 == obj2.
   #
-  #   [1, 2, 2, 3, 4, 4].commonality # => { 2 => [2, 2], 4 => [4, 4] }
+  #   [1, 2, 2, 3, 4, 4].commonality  #=> { 2 => [2, 2], 4 => [4, 4] }
   #
   #   ["foo", "bar", "a"].commonality { |str| str.length }
-  #   # => { 3 => ["foo, "bar"] }
+  #   #=> { 3 => ["foo", "bar"] }
+  #
+  # This can be useful, for instance, in determining all persons that share
+  # their last name with another person ...
   #
-  #   # Returns all persons that share their last name with another person.
   #   persons.collisions { |person| person.last_name }
   #
   # CREDIT: Florian Gross
@@ -18,14 +20,14 @@ module Enumerable
     had_no_block = !block
     block ||= lambda { |item| item }
     result = Hash.new { |hash, key| hash[key] = Array.new }
-    self.each do |item|
+    each do |item|
       key = block.call(item)
       result[key] << item
     end
     result.reject! do |key, values|
       values.size <= 1
     end
-    #return had_no_block ? result.values.flatten : result
+    # -- return had_no_block ? result.values.flatten : result
     return result
   end
 

data/lib/core/facets/array/conjoin.rb

@@ -7,49 +7,80 @@ class Array
   # default the terminating separator to " and ". This is no longer
   # the case. You must specifically provide these parameters.
   #
+  # If no paramters are given, it acts like #join but will a space
+  # separator.
+  #
   #   [1,2,3].conjoin
-  #   => "123"
+  #   #=> "1 2 3"
+  #
+  # Use comma+space and 'and' on tail.
   #
   #   [1,2,3].conjoin(', ', ' and ')
-  #   => "1, 2 and 3
+  #   #=> "1, 2 and 3"
+  #
+  # Use comma+space and 'or' on tail using :last option.
   #
   #   [1,2,3].conjoin(', ', :last => ' or ')
-  #   => "1, 2 or 3
+  #   #=> "1, 2 or 3"
+  #
+  # Use semicolon+space and ampersand on tail using index.
   #
   #   [1,2,3].conjoin('; ', -1 => ' & ')
-  #   => "1; 2 & 3
+  #   #=> "1; 2 & 3"
+  #
+  # Can take a block to determine separator.
   #
   #   [1,2,3,4].conjoin{ |i, a, b| i % 2 == 0 ? '.' : '-' }
-  #   => "1.2-3.4"
+  #   #=> "1.2-3.4"
+  #
+  # This makes very esoteric transformation possible.
+  #
+  #   [1,1,2,2].conjoin{ |i, a, b| a == b ? '=' : ' != ' }
+  #   #=> "1=1 != 2=2"
+  #
+  #   [1,2,3,4].conjoin{ |i, x, y| "<#{i} #{x} #{y}>" }
+  #   #=> "1<0 1 2>2<1 2 3>3<2 3 4>4"
   #
-  #   [1,1,2,2].conjoin{ |i, a, b| a == b ? '=' : '!=' }
-  #   => "1=1!=2=2"
+  # There are also spacing options. Providing the :space option
+  # pads the separators.
+  #
+  #   [1,2,3].conjoin(',', '&', :space=>2)
+  #   #=> "1  ,  2  &  3"
+  #
+  # And the :spacer option can set an alternate spacing string.
+  #
+  #   [1,2,3].conjoin('|', '>', :space=>2, :spacer=>'-')
+  #   #=> "1--|--2-->--3"
   #
   # CREDIT: Trans
 
   def conjoin(*args, &block)
     return first.to_s if size < 2
 
+    options = (Hash===args.last) ? args.pop : {}
+
+    spacing = options.delete(:space)  || 0
+    spacer  = options.delete(:spacer) || " "
+    space   = spacer * spacing.to_i
+
     sep = []
 
     if block_given?
       (size - 1).times do |i|
-        sep << yield(i, *slice(i,2))
+        sep << space + yield(i, *slice(i,2)) + space
       end
     else
-      options   = (Hash===args.last) ? args.pop : {}
-      separator = args.shift || ""
-      options[-1] = args.shift unless args.empty?
+      separator   = args.shift || " "
+      options[-1] = args.shift if args.first
 
-      sep = [separator] * (size - 1)
+      options[0]  = options.delete(:first) if options.key?(:first)
+      options[-1] = options.delete(:last)  if options.key?(:last)
 
-      if options.key?(:last)
-        options[-1] = options.delete(:last)
-      end
+      separator = space + separator + space
 
-      options[-1] ||= " and "
+      sep = [separator] * (size - 1)
 
-      options.each{|i, s| sep[i] = s}
+      options.each{|i, s| sep[i] = space + s + space}
     end
     zip(sep).join
   end

data/lib/core/facets/array/delete_unless.rb

@@ -3,7 +3,7 @@ class Array
   # Inverse of #delete_if.
   #
   #   [1,2,3].delete_unless{ |x| x < 2 }
-  #   => [1,2]
+  #   #=> [1]
   #
   # CREDIT: Daniel Schierbeck
 

data/lib/core/facets/array/divide.rb

@@ -0,0 +1,20 @@
+class Array
+
+  # Divide on matching pattern.
+  #
+  #   ['a1','b1','a2','b2'].divide(/^a/)
+  #   #=> [['a1','b1'],['a2','b2']]
+  #
+  # CREDIT: Trans
+
+  def divide(pattern)
+    memo = []
+    each do |obj|
+      memo.push [] if pattern === obj
+      memo.last << obj
+    end
+    memo
+  end
+
+end
+

data/lib/core/facets/array/duplicates.rb

@@ -0,0 +1 @@
+require 'facets/array/nonuniq'

data/lib/core/facets/{enumerable → array}/entropy.rb

@@ -1,20 +1,22 @@
-require 'facets/enumerable/probability'
+require 'facets/array/probability'
 
-module Enumerable
+class Array
 
   # 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  #=>
+  #   e = %w{ a b c d e e e }.entropy
+  #
+  #   ("%.3f" % e)  #=> "2.128"
   #
   # CREDIT: Derek
 
   def entropy
-    arr = to_a
+    arr = self
     probHash = arr.probability
-    # h is the Shannon entropy of the array
+    # -- 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
@@ -28,7 +30,7 @@ module Enumerable
   # CREDIT: Derek
 
   def ideal_entropy
-    arr = to_a
+    arr = self
     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

data/lib/core/facets/array/extract_options.rb

@@ -0,0 +1,31 @@
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  #
+  def extract_options!
+    if Hash === last && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end
+

data/lib/core/facets/array/from.rb

@@ -0,0 +1,33 @@
+class Array
+
+  # Returns last _n_ elements.
+  #
+  #   %w{W o r l d}.from(3)  #=> %w{l d}
+  #
+  def from(i)
+    return self if i >= size
+    self[i, size - i]
+  end unless method_defined?(:from)
+
+  # Fetch values from a start index thru an end index.
+  #
+  #   [1,2,3,4,5].thru(0,2)  #=> [1,2,3]
+  #   [1,2,3,4,5].thru(2,4)  #=> [3,4,5]
+  #
+  #   [1,2,3,4,5].thru(2)  #=> [1,2,3]
+  #   [1,2,3,4,5].thru(4)  #=> [1,2,3,4,5]
+  #
+  def thru(from, to=nil)
+    from, to = 0, from unless to
+    to = size - 1 if to >= size
+    a = []
+    i = from
+    while i <= to
+      a << self[i]
+      i += 1
+    end
+    a
+  end unless method_defined?(:thru)
+
+end
+

data/lib/core/facets/array/index.rb

@@ -1,16 +1,14 @@
 class Array
 
-  # CORE OVERRIDE
-
   if RUBY_VERSION < '1.8.7'
 
     alias_method :_facets_index, :index
 
     # Allows #index to accept a block.
     #
-    # OVERRIDE! This is one of the bery few core
-    # overrides in Facets.
+    #   ['a', 'b', 'c'].index{ |x| x.upcase == 'C' } #=> 2
     #
+    # IMPORTANT: This is one of the few core overrides in Facets.
     def index(obj=nil, &block)
       if block_given?
         _facets_index(find(&block))

data/lib/core/facets/array/indexable.rb

@@ -10,7 +10,7 @@ class Array
   #
   #   a = ["a","y","z"]
   #   a.first!      #=> "a"
-  #   p a           #=> ["y","z"]
+  #   a             #=> ["y","z"]
   #
   # CREDIT: Trans
 
@@ -19,55 +19,13 @@ class Array
   # Alias for pop, which removes and returns
   # the last element in an array.
   #
-  #   a = [1,2]
-  #   a.last! 3
-  #   p a           #=> [1,2,3]
+  #   a = [1,2,3]
+  #   a.last!       #=> 3
+  #   a             #=> [1,2]
   #
   # CREDIT: Trans
 
   alias_method :last!, :pop
 
-  #
-  #
-
-  #alias_method :/, :[]
-
-=begin
-  # TODO Probably not best to overide store and fetch operators. Rename?
-
-  # Modifies #[] to also accept an array of indexes.
-  #
-  #   a = ['a','b','c','d','e','f']
-  #
-  #   a[[1]]      #=> ['b']
-  #   a[[1,1]]    #=> ['b','b']
-  #   a[[1,-1]]   #=> ['b','f']
-  #   a[[0,2,4]]  #=> ['a','c','e']
-  #
-  def [](*args)
-    return values_at(*args.at(0)) if Array === args.at(0)
-    return slice(*args)
-  end
-
-  # Modifies #[]= to accept an array of indexes for assignment.
-  #
-  #   a = ['a','b','c','d']
-  #
-  #   a[[1,-1]] = ['m','n']    #=> ['m','n']
-  #   a                        #=> ['a','m','c','n']
-  #
-  def []=(*args)
-    if Array === args.at(0)
-      idx,vals = args.at(0),args.at(1)
-      idx.each_with_index{ |a,i| store(a,vals.at(i)) }
-      return values_at( *idx )
-    else
-      return store(*args)
-    end
-  end
-
-end
-=end
-
 end