facets-glimmer 3.2.0

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

@@ -0,0 +1,53 @@
+require 'facets/functor'
+require 'facets/enumerable/recursively'
+
+class Array
+
+  # Apply a method to array, and recursively apply that method
+  # to each sub-array or given +types+.
+  #
+  # By default the sub-types are passed through unaffected. Passing
+  # a block to #recursively can be used to change this.
+  #
+  # types - List of class types to recurse. [Array<Class>]
+  # block - Optional filter procedure to apply on each recursion.
+  #
+  # Examples
+  #
+  #   arr = ["a", ["b", "c"]]
+  #   arr.recursively.map{ |v| v.to_sym }
+  #   #=> [:a, [:b, :c]]
+  #
+  #   arr = ["a", ["b", "c"]]
+  #   arr.recursively{ |a| a.reverse }.map{ |v| v.to_sym }
+  #   #=> [:a, [:c, :b]]
+  #
+  # Returns [Recursor].
+
+  def recursively(*types, &block)
+    Recursor.new(self, *types, &block)
+  end
+
+  ## TODO: When no longer needing to support 1.8.6 we could get rid of
+  ## the Recursor class and use:
+  ##
+  ## def recursively(*types, &block)
+  ##   types = types.empty? ? [self.class] : types
+  ##   Functor.new do |op, &yld|
+  ##     rec = block || lambda{ |a| a }
+  ##     yld = yld   || lambda{ |v| v }  # ? to_enum
+  ##     __send__(op) do |v|
+  ##       case v
+  ##       when String # b/c of 1.8
+  ##         yld.call(v)
+  ##       when *types
+  ##         res = v.recursively(*types, &block).__send__(op,&yld)
+  ##         rec.call(res)
+  ##       else
+  ##         yld.call(v)
+  ##       end
+  ##     end
+  ##   end
+  ## end
+
+end

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

@@ -0,0 +1,21 @@
+class Array
+
+  # Non-destructive form of `Array#delete_values`. Unlike `delete_values`
+  # this method returns a new array.
+  #
+  # values - List of array elements to reject.
+  #
+  # Examples
+  #
+  #     [1,2,3,4,5].reject_values(2,4)  # => [1,3,5]
+  #
+  # Returns [Array]
+  #
+  # CREDIT: Sean Mackesey
+
+  def reject_values(*values)
+    reject { |x| values.include?(x) }
+  end
+
+end
+

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

@@ -0,0 +1,24 @@
+class Array
+  # Public: Split an array in two using a predicate
+  #
+  # Yields each element of the array.
+  #
+  # Examples
+  #
+  #   %w(The quick brown fox).span { |word| word.length < 4 }
+  #   #=> [['The'], ['quick', 'brown', 'fox']]
+  #
+  #   [1, 1, 2, 3, 5, 8, 13, 21, 34].span(&:odd?)
+  #   #=> [[1, 1], [2, 3, 5, 8, 13, 21, 34]]
+  #
+  # Returns a 2-tuple of arrays, the first element being the longest prefix for
+  # which the block evaluates to true, the second element being the rest of the
+  # array.
+  def span
+    # This implementation is another way of saying
+    # `[take_while(&:block), drop_while(&:block)]`
+    index = find_index { |e| !yield e }
+    return [dup, []] if index.nil?
+    [take(index), drop(index)]
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'facets/array/store'
+
+class Array
+
+  # Splice acts as a combination of #slice! and #store.
+  # If two arguments are given it calls #store.
+  # If a single argument is given it calls slice!.
+  #
+  # Examples
+  #
+  #   a = [1,2,3]
+  #   a.splice(1)    #=> 2
+  #   a              #=> [1,3]
+  #
+  #   a = [1,2,3]
+  #   a.splice(1,4)  #=> 4
+  #   a              #=> [1,4,3]
+  #
+  # Returns [Array].
+  #
+  # CREDIT: Trans
+
+  def splice(*args)
+    if args.size == 1
+      slice!(*args)
+    else
+      store(*args)
+    end
+  end
+
+end

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

@@ -0,0 +1,30 @@
+class Array
+
+  # Split on matching pattern. Unlike #divide this does not include matching
+  # elements.
+  #
+  # Examples
+  #
+  #   ['a1','a2','b1','a3','b2','a4'].split(/^b/)
+  #   #=> [['a1','a2'],['a3'],['a4']]
+  #
+  # Returns list of split-up arrays. [Array<Array>]
+
+  def split(pattern)
+    memo = []
+    sect = []
+    each do |obj|
+      if pattern === obj
+        memo << sect
+        sect = []
+      else
+        sect << obj
+      end
+    end
+    memo << sect
+    memo.pop while memo.last == []
+    memo
+  end
+
+end
+

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

@@ -0,0 +1,25 @@
+class Array
+
+  # Split on matching pattern. Breaks the array into [before, middle, after]
+  # segments. Uses Array#index to find the middle element.
+  #
+  # Examples
+  #
+  #   ['a1','a2','b1','a3','b2','a4'].split('b1')
+  #   #=> [['a1','a2'],b1,['a3','b2','a4']]
+  #
+  #   ['a1','a2','b1','a3','b2','a4'].split('foo')
+  #   #=> [[],nil,[]]
+  #
+  # Returns list of split-up arrays. [Tuple<Array,Object,Array>]
+
+  def split_at(*args, &block)
+    if middle = index(*args, &block)
+      [self[0...middle], self[middle], self[middle+1..-1]]
+    else
+      [[], nil, []]
+    end
+  end
+
+end
+

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

@@ -0,0 +1,23 @@
+require 'facets/enumerable/squeeze'
+
+class Array
+
+  # Destructive version of Enumerable#squeeze.
+  #
+  #   a = [1,2,2,3,3,2,1]
+  #   a.squeeze!
+  #   a #=> [1,2,3,2,1]
+  #
+  #   a = [1,2,2,3,3,2,1]
+  #   a.squeeze!(*[3])
+  #   a #=> [1,2,2,3,2,1]
+  #
+  # Returns the receiver. [Array]
+  #
+  # CREDIT: T. Yamada
+
+  def squeeze!(*limited_to)
+    replace(squeeze(*limited_to))
+  end
+
+end

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

@@ -0,0 +1,23 @@
+require 'facets/array/variance'
+
+class Array
+
+  # Calculate the standard_deviation of an array of numbers
+  #
+  # Examples
+  #
+  #   [].standard_deviation #=> nil
+  #   [1, 2, 3].standard_deviation #=> 0.816496580927726
+  #   [96, 35, 72, 30, 75, 33, 68, 13, 49, 71].standard_deviation #=> 24.69331893448104
+  #   [36, -67, -17, 85, -46, -64, -23, -13, 89, -47].standard_deviation #=> 54.67183918618432
+  #   [60.7829, 31.2622, 20.626, 78.8907, 61.5328].standard_deviation #=> 21.428815505053002
+  #
+  def standard_deviation
+    return nil if empty?
+    Math.sqrt(variance)
+  end
+
+  alias sd standard_deviation
+end
+
+

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

@@ -0,0 +1,31 @@
+class Array
+
+  # Iterate over every nth element of an array.
+  #
+  #   r = []
+  #   [:a, :b, :c, :d].step(2) { |x| r << x }
+  #   r   #=> [:b, :d]
+  #   
+  # Without a block it returns an Enumerator.
+  #
+  #   [:a, :b, :c, :d].step(1).to_a   #=> [:a, :b, :c, :d]
+  #   [:a, :b, :c, :d].step(2).to_a   #=> [:b, :d]
+  #   [:a, :b, :c, :d].step(3).to_a   #=> [:c]
+  #   [:a, :b, :c, :d].step(5).to_a   #=> []
+  #
+  # CREDIT: Ryan Duryea
+
+  def step(n) #:yield:
+    if block_given?
+      ((n - 1)...size).step(n).each do |i|
+        yield(fetch(i))
+      end
+    else
+      Enumerator.new(size / n) do |y|
+        ((n - 1)...self.size).step(n).each { |i| y << fetch(i) }  
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,16 @@
+class Array
+
+  # Store a value at a given index. Store is an alias for #[]=.
+  #
+  # Example:
+  #
+  #   a = []
+  #   a.store(1, "A")
+  #   a[1] #=> "A"
+  #
+  # Returns the stored object.
+
+  alias_method :store, :[]=
+
+end
+

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

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

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

@@ -0,0 +1,19 @@
+class Array
+
+  # Convert an associative array to a Hash.
+  #
+  # Examples
+  #
+  #   [[:a, 1], [:b, 2]].to_h
+  #   #=> {:a=>1, :b=>2}
+  #
+  # Returns [Hash].
+  #
+  def to_h
+    h = {}
+    each{ |(k,v)| h[k] = v }
+    h
+  end unless method_defined?(:to_h)
+
+end
+

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

@@ -0,0 +1,50 @@
+class Array
+
+  # Construct a new array created by traversing the array and its
+  # sub-arrays, executing the given block on the elements.
+  #
+  # Examples
+  #
+  #   h = ["A", "B", ["X", "Y"]]
+  #   g = h.traverse{ |e| e.downcase }
+  #   g  #=> ["a", "b", ["x", "y"]]
+  #
+  # This is the same as <code>recursive.map</code> and will
+  # likely be deprecated in the future because of it.
+  #
+  # Returns new array. [Array]
+  #
+  # CREDIT: Trans
+
+  def traverse(&block)
+    if block_given?
+      map do |e|
+        if e.respond_to?(:to_ary)
+          e.to_ary.traverse(&block)
+        else
+          block.call(e)
+        end
+      end
+    else
+      to_enum(:traverse)
+    end
+  end
+
+  # Like #recursive_map, but will change the array in place.
+  #
+  # Examples:
+  #
+  #   h = ["A", "B", ["X", "Y"]]
+  #   h.traverse!{ |e| e.downcase }
+  #   h  #=> ["a", "b", ["x", "y"]]
+  #
+  # Returns self. [Array]
+  #
+  # CREDIT: Trans
+
+  def traverse!(&block)
+    replace(traverse(&block))
+  end
+
+end
+

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

@@ -0,0 +1,24 @@
+class Array
+
+  # Like #uniq, but determines uniqueness based on a given block.
+  # As can be seen in the following examples, order is significant.
+  #
+  # Examples
+  #
+  #   a = (-5..5).to_a
+  #   a.uniq_by!{ |i| i*i }
+  #   a #=> [-5, -4, -3, -2, -1, 0]
+  #
+  #   a = (-5..5).to_a.reverse
+  #   a.uniq_by!{ |i| i*i }
+  #   a #=> [5, 4, 3, 2, 1, 0]
+  #
+  # Returns [Array] of unique elements.
+  #
+  def uniq_by! #:yield:
+    h = {}
+    replace( inject([]){|a,x| h[yield(x)] ||= a << x} )
+  end
+
+end
+

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

@@ -0,0 +1,29 @@
+class Array
+
+  # Enumerates permutation of Array.
+  # Unlike Array#permutation, there are no duplicates in generated permutations.
+  # Instead, elements must be comparable.
+  #
+  #   [1,1,2,2,3].unique_permutation(2).to_a
+  #   #=> [[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2]]
+  #   # Note: [1,1,2,2,3].permutation(2).to_a
+  #   #=> [[1, 1], [1, 2], [1, 2], [1, 3], [1, 1], [1, 2], [1, 2], [1, 3], [2, 1], [2, 1], [2, 2], [2, 3], [2, 1], [2, 1], [2, 2], [2, 3], [3, 1], [3, 1], [3, 2], [3, 2]]
+  #
+  # CREDIT: T. Yamada
+  def unique_permutation(n=self.size)
+    return to_enum(:unique_permutation,n) unless block_given?
+    return if n<0||self.size<n
+    a=self.sort # sort is O(nlogn), so I believe this is not so costly. (Also sort is not destructive)
+    yield a[0,n]
+    loop{
+      a=a[0,n]+a[n..-1].reverse
+      k=(a.size-2).downto(0).find{|i|a[i]<a[i+1]}
+      break if !k
+      l=(a.size-1).downto(k+1).find{|i|a[k]<a[i]}
+      a[k],a[l]=a[l],a[k]
+      a=a[0,k+1]+a[k+1..-1].reverse
+      yield a[0,n]
+    }
+  end
+ 
+end

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

@@ -0,0 +1,20 @@
+require 'facets/array/average'
+
+class Array
+
+  # Calculate the variance of an array of numbers
+  #
+  # Examples
+  #
+  #   [].variance #=> nil
+  #   [1, 2, 3].variance #=> 0.6666666666666666
+  #   [96, 35, 72, 30, 75, 33, 68, 13, 49, 71].variance #=> 609.76
+  #   [36, -67, -17, 85, -46, -64, -23, -13, 89, -47].variance #=> 2989.0099999999993
+  #   [60.7829, 31.2622, 20.626, 78.8907, 61.5328].variance #=> 459.1941339495999
+  #
+  def variance
+    avg = average
+    map {|n| (n - avg) ** 2 }.average
+  end
+end
+

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

@@ -0,0 +1,21 @@
+class Array
+
+  # Class level rendition of Array#zip.
+  #
+  # arrays - List of arrays to zip. [Array<Array>]
+  #
+  # Example:
+  #
+  #   Array.zip([1,2],[3,4]]
+  #   #=> [[1,3],[2,4]]
+  #
+  # Returns arranged array of arrays. [Array<Array>]
+  #
+  # Returns an empty array if no arguments are given. [Array]
+
+  def self.zip(*arrays)
+    return [] if arrays.empty?
+    return arrays[0].zip(*arrays[1..-1])
+  end
+
+end

data/lib/core/facets/array.rb

@@ -0,0 +1,49 @@
+require_relative 'array/after.rb'
+#require_relative 'array/arrange.rb'            # too new
+require_relative 'array/average.rb'
+require_relative 'array/before.rb'
+require_relative 'array/collapse.rb'
+require_relative 'array/collisions.rb'
+require_relative 'array/commonality.rb'
+require_relative 'array/conjoin.rb'
+require_relative 'array/contains.rb'
+require_relative 'array/delete.rb'
+require_relative 'array/delete_unless.rb'
+require_relative 'array/delete_values.rb'
+require_relative 'array/divide.rb'
+require_relative 'array/duplicates.rb'
+require_relative 'array/each_pair.rb'
+require_relative 'array/each_value.rb'
+require_relative 'array/entropy.rb'
+require_relative 'array/extract_options.rb'
+require_relative 'array/from.rb'
+require_relative 'array/indexable.rb'
+#require_relative 'array/intersection.rb'       # too new
+#require_relative 'array/median.rb'             # uncommon
+require_relative 'array/merge.rb'
+#require_relative 'array/missing.rb'            # too new
+require_relative 'array/mode.rb'
+require_relative 'array/nonuniq.rb'
+require_relative 'array/not_empty.rb'
+require_relative 'array/only.rb'
+require_relative 'array/pad.rb'
+require_relative 'array/peek.rb'
+#require_relative 'array/percentile.rb'         # uncommon
+require_relative 'array/unique_permutation.rb'
+require_relative 'array/poke.rb'
+require_relative 'array/probability.rb'
+require_relative 'array/pull.rb'
+require_relative 'array/occurrence.rb'
+#require_relative 'array/op_pow.rb'             # uncommon
+require_relative 'array/recurse.rb'
+require_relative 'array/recursively.rb'
+require_relative 'array/reject_values.rb'
+require_relative 'array/splice.rb'
+require_relative 'array/split.rb'
+require_relative 'array/squeeze.rb'
+require_relative 'array/store.rb'
+require_relative 'array/thru.rb'
+require_relative 'array/to_h.rb'
+require_relative 'array/traverse.rb'
+require_relative 'array/uniq_by.rb'
+

data/lib/core/facets/binding/__callee__.rb

@@ -0,0 +1 @@
+require 'facets/binding/caller'

data/lib/core/facets/binding/__method__.rb

@@ -0,0 +1 @@
+require 'facets/binding/caller'

data/lib/core/facets/binding/call_stack.rb

@@ -0,0 +1 @@
+require 'facets/kernel/callstack'

data/lib/core/facets/binding/caller.rb

@@ -0,0 +1,42 @@
+require 'facets/binding/callstack'
+
+class Binding
+
+  # Returns the call stack, same format as Kernel#caller()
+  #
+  def caller( skip=0 )
+    eval("caller(#{skip})")
+  end
+
+  # Return the line number on which the binding was created.
+  #
+  def __LINE__
+    Kernel.eval("__LINE__", self)
+  end
+
+  # Returns file name in which the binding was created.
+  #
+  def __FILE__
+    Kernel.eval("__FILE__", self)
+  end
+
+  # Return the directory of the file in which the binding was created.
+  #
+  def __DIR__  
+    File.dirname(self.__FILE__)
+  end
+
+  # Retreive the current running method.
+  #
+  def __method__
+    Kernel.eval("__method__", self)
+  end
+
+  # Retreive the current running method.
+  #
+  def __callee__
+    Kernel.eval("__callee__", self)
+  end
+
+end
+

data/lib/core/facets/binding/callstack.rb

@@ -0,0 +1 @@
+require 'facets/kernel/callstack'

data/lib/core/facets/binding/defined.rb

@@ -0,0 +1,10 @@
+class Binding
+
+  # Returns the nature of something within the context of the binding.
+  # Returns nil if that thing is not defined.
+  def defined?(x)
+    eval("defined? #{x}")
+  end
+
+end
+

data/lib/core/facets/binding/op.rb

@@ -0,0 +1,4 @@
+# This file is here for backward compatibility only.
+# It can be deprecated eventually.
+
+require 'facets/binding/op_get'

data/lib/core/facets/binding/op_get.rb

@@ -0,0 +1,25 @@
+class Binding
+
+  # Returns the value of some variable.
+  #
+  #   a = 2
+  #   binding["a"]  #=> 2
+  #
+  def []( x )
+    eval( x.to_s )
+  end
+
+  # Set the value of a local variable.
+  #
+  #   binding["a"] = 4
+  #   a  #=> 4
+  #
+  # @deprecated No longer wortks in Ruby 1.9+.
+  #
+  # @see Binding#with for an alternative.
+  def []=( l, v )
+    eval( "lambda {|v| #{l} = v}").call( v )
+  end
+
+end
+

data/lib/core/facets/binding/op_set.rb

@@ -0,0 +1 @@
+require 'facets/binding/op_get'

data/lib/core/facets/binding/self.rb

@@ -0,0 +1,15 @@
+class Binding
+
+  # This is already defined by Rubinius:
+  #   Kernel.eval('Rubinius::VariableScope.current.self', self)
+  unless method_defined?(:self)
+
+    # Returns self of the binding's context.
+    def self
+      eval('self')
+    end
+
+  end
+
+end
+

data/lib/core/facets/binding/with.rb

@@ -0,0 +1,12 @@
+class Binding
+
+  # Returns a new binding with local varaibles set.
+  #
+  # CREDIT: Trans
+
+  def with(_local_variables, &_yields)
+    eval("lambda{ |#{_local_variables.keys.join(',')},&yields| binding }").call(*_local_variables.values, &_yields)
+  end
+
+end
+

data/lib/core/facets/binding.rb

@@ -0,0 +1,12 @@
+require_relative 'binding/caller.rb'
+require_relative 'binding/callstack.rb'
+require_relative 'binding/call_stack.rb'
+require_relative 'binding/defined.rb'
+require_relative 'binding/op.rb'
+require_relative 'binding/op_get.rb'
+require_relative 'binding/op_set.rb'
+require_relative 'binding/self.rb'
+require_relative 'binding/with.rb'
+require_relative 'binding/__callee__.rb'
+require_relative 'binding/__method__.rb'
+