mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/elementor.rb

@@ -0,0 +1,133 @@
+# = Elementor
+#
+# Provides elementwise functionality.
+#
+# == Authors
+#
+# * Thomas Sawyer
+# * George Moschovitis
+# * Martin DeMello
+#
+# == Notes
+#
+# * This could have been impemented with a generic Functor, rather than
+#   the specialized Elementor, but for the fact Procs can not yet
+#   handle blocks.
+# * There used to be a "Cascading Elementor", but that proved idiotic
+#   in the face of adding an instance_eval block to #every.
+# * Any ideas for a better name for #accumulate? --gmosx
+# * The use of every! and it's relation to Enumerator still seems a bit
+#   off beat. Should #every always use #map? And another method #each?
+#
+# == Copying
+#
+# Copyright (c) 2006 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'enumerator'
+require 'facets/functor'
+
+module Enumerable
+
+  # Create Elementor.
+
+  def to_elem(meth=nil)
+    Elementor.new(self, meth || :map)
+  end
+
+  def per
+    @__per__ ||= Functor.new do |op|
+      Elementor.new(self, op)
+    end
+  end
+
+  # Returns an elemental object. This allows
+  # you to map a method on to every element.
+  #
+  #   r = [1,2,3].every + 3  #=> [4,5,6]
+
+  def every
+    @_every ||= to_elem
+  end
+
+  # In place version of #every.
+
+  def every!
+    raise NoMethodError unless respond_to?(:map!)
+    @_every_inplace ||= to_elem(:map!)
+  end
+
+  #def every
+  #  @_every ||= Functor.new do |op,*args|
+  #    map{ |a| a.send(op,*args) }
+  #  end
+  #end
+
+  #def every!
+  #  raise NoMethodError unless respond_to?(:map!)
+  #  @_every_inplace ||= Functor.new do |op,*args|
+  #    map!{ |a| a.send(op,*args) }
+  #  end
+  #end
+
+  # Possible name change for every.
+  #
+  #   r = [1,2,3].elements + 3  #=> [4,5,6]
+  #
+  # Certainly reads better.
+
+  alias_method :elements, :every
+  alias_method :elements!, :every!
+
+end
+
+
+# = Elementor
+#
+# Elementor is a type of Functor. Operations
+# applied to it are routed to each element.
+
+class Enumerable::Elementor
+  private(*instance_methods.select{|x| x !~ /^__/ })
+
+  def initialize(elem_object, elem_method=nil)
+    @elem_object = elem_object
+    @elem_method = elem_method || :map
+  end
+
+  def instance_delegate
+    @elem_object
+  end
+
+  def instance_operator
+    @elem_method
+  end
+
+  def method_missing(sym,*args,&blk)
+    @elem_object.__send__(@elem_method){ |x| x.__send__(sym,*args,&blk) }
+  end
+end
+
+
+class Enumerable::Enumerator
+
+  # Create Elementor.
+
+  def to_elem(meth=nil)
+    Elementor.new(self, meth || :each)
+  end
+
+  # Enumerator doesn't support inplace element operations, per se.
+
+  undef_method :every!
+  undef_method :elements!
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/elementwise.rb

@@ -0,0 +1,61 @@
+require 'facets/functor'
+
+module Enumerable
+
+  # Returns an elementwise Functor designed to make R-like
+  # elementwise operations possible.
+  #
+  #   [1,2].elementwise + 3          #=> [4,5]
+  #   [1,2].elementwise + [4,5]      #=> [5,7]
+  #   [1,2].elementwise + [[4,5],3]  #=> [[5,7],[4,5]
+  #
+  #--
+  # Special thanks to Martin DeMello for helping to develop this.
+  #++
+
+  def elementwise(count=1)
+    @_elementwise_functor ||= []
+    @_elementwise_functor[count] ||= Functor.new do |op,*args|
+      if args.empty?
+        r = self
+        count.times do
+          r = r.collect{ |a| a.send(op) }
+        end
+        r
+      else
+        r = args.collect do |arg|
+          if Array === arg #arg.kind_of?(Enumerable)
+            x = self
+            count.times do
+              ln = (arg.length > length ? length : arg.length )
+              x = x.slice(0...ln).zip(arg[0...ln]).collect{ |a,b| a.send(op,b) }
+              #slice(0...ln).zip(arg[0...1n]).collect{ |a,b| b ? a.send(op,b) : nil }
+            end
+            x
+          else
+            x = self
+            count.times do
+              x = x.collect{ |a| a.send(op,arg) }
+            end
+            x
+          end
+        end
+        r.flatten! if args.length == 1
+        r
+      end
+    end
+  end
+
+  # Concise alias for #elementwise.
+  #
+  #   a = [1,2]
+  #   a.ewise + 3          #=> [4,5]
+  #   a.ewise + [4,5]      #=> [5,7]
+  #   a.ewise + [[4,5],3]  #=> [[5,7],[4,5]
+  #
+  # Note this used to be #ew as weel as the '%' operator.
+  # Both of whihc are deprecated.
+
+  alias_method :ewise, :elementwise
+
+end

data/lib/gems/facets-2.4.5/lib/more/facets/enumerablepass.rb

@@ -0,0 +1,217 @@
+# = EnumerablePass
+#
+# This is a simple reimplementation of the core Enumerable module
+# to allow the methods to take and pass-on arbitrary arguments to the
+# underlying #each call. This library uses Enumerator and scans
+# Enumerable so it can alwasy stay in sync.
+#
+# NOTE Any Enumerable method with a negative arity cannot do pass arguments
+# due to ambiguity in the argument count. So the methods #inject and #zip
+# do NOT work this way, but simply work as they do in Enumerable.
+# The method #find (and #detect) though has been made to work by removing
+# its rarely used optional parameter and providing instead an optional
+# keyword parameter (:ifnone => ...). Please keep these difference in mind.
+#
+#   class T
+#     include EnumerablePass
+#     def initialize(arr)
+#       @arr = arr
+#     end
+#     def each(n)
+#       arr.each{ |e| yield(e+n) }
+#     end
+#   end
+#
+#   t = T.new([1,2,3])
+#   t.collect(4)
+#   #=> [5,6,7]
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2004 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'enumerator'
+
+# = EnumerablePass
+#
+# This is a simple reimplementation of the core Enumerable module
+# to allow the methods to take and pass-on arbitrary arguments to the
+# underlying #each call. This library uses Enumerator and scans
+# Enumerable so it can alwasy stay in sync.
+#
+# NOTE Any Enumerable method with a negative arity cannot do pass arguments
+# due to ambiguity in the argument count. So the methods #inject and #zip
+# do NOT work this way, but simply work as they do in Enumerable.
+# The method #find (and #detect) though has been made to work by removing
+# its rarely used optional parameter and providing instead an optional
+# keyword parameter (:ifnone => ...). Please keep these difference in mind.
+#
+#   class T
+#     include EnumerablePass
+#     def initialize(arr)
+#       @arr = arr
+#     end
+#     def each(n)
+#       arr.each{ |e| yield(e+n) }
+#     end
+#   end
+#
+#   t = T.new([1,2,3])
+#   t.collect(4)
+#   #=> [5,6,7]
+#
+module EnumerablePass
+
+  def self.wrap_enumerable_method( methodname )
+
+    m = methodname
+    meth = Enumerable.instance_method(m)
+    arity = meth.arity
+
+    case arity <=> 0
+    when 0
+      class_eval %{
+        def #{m}( *args, &yld )
+          enum_for(:each, *args).#{m}( &yld )
+        end
+      }
+    when 1
+      class_eval %{
+        def #{m}( *args, &yld )
+          args, each_args = args[0...#{arity}], args[#{arity}..-1]
+          enum_for(:each, *each_args).#{m}( *args, &yld )
+        end
+      }
+    else
+      class_eval %{
+        def #{m}( *args, &yld )
+          enum_for(:each).#{m}( *args, &yld )
+        end
+      }
+    end
+  end
+
+  Enumerable.instance_methods(false).each do |m|
+    wrap_enumerable_method( m )
+  end
+
+  # Make exception for #find (a negative arity method) to accept
+  # keyword argument.
+  #
+  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+  #
+  def find(*args, &yld)  # future use **keys ?
+    if Hash === args.last and args.last.key?(:ifnone)
+      ifnone = args.last.delete(:ifnone)
+      args.pop if args.last.empty?
+      enum_for(:each, *args).find( ifnone, &yld )
+    else
+      enum_for(:each, *args).find( &yld )
+    end
+  end
+  alias_method :detect, :find
+
+end
+
+
+=begin  OLD CODE
+module EnumerableArgs
+
+  def collect(*args)  # :yield:
+    a = []
+    each(*args){ |n| a << yield(n) }
+    a
+  end
+  alias_method( :map, :collect )
+
+  def detect(*args)  # :yield:
+    each(*args){ |n| return n if yield(n) }
+    nil
+  end
+  alias_method( :find, :detect )
+
+  def each_with_index(*args)
+    i=0
+    each(*args){ |*n| n << i; yield(*n); i+=1 }
+    self
+  end
+
+  def to_a(*args)
+    a = []
+    each(*args){ |n| a << n }
+    a
+  end
+  alias_method( :entries, :to_a )
+
+  # An additional method not part of standard Enumerable.
+  # The regular version of this method can be found in Facets,
+  # but it is a bit more advanced then this one.
+  # At some point they need to be put into sync.
+  def each_slice(*args, &yld)
+    a = []; s = []
+    ar = yld.arity.abs
+    each(*args){ |n|
+      s << n
+      if s.length >= ar
+        yld.call(*s)
+        s = []
+      end
+    }
+    a
+  end
+  alias_method( :each_by, :each_slice )
+
+  def select(*args)  # :yield:
+    a = []
+    each(*args){ |n| a << n if yield(n) }
+    a
+  end
+  alias_method( :find_all, :select )
+
+  def grep(pattern, *args)
+    a = []
+    each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
+    a
+  end
+
+  def include?(anObj, *args)
+    each(*args){ |n| return true if anObj == n }
+    false
+  end
+  alias_method( :member?, :include? )
+
+  def max(*args)
+    to_a(*args).max
+  end
+
+  def min(*args)
+    to_a(*args).min
+  end
+
+  def reject(*args)
+    a = []
+    each(*args){ |n| a << n if ! yield(n) }
+    a
+  end
+
+  def sort(*args)
+    # TODO
+  end
+
+end
+=end
+

data/lib/gems/facets-2.4.5/lib/more/facets/equatable.rb

@@ -0,0 +1,120 @@
+# = Equatable
+#
+# This mixin provides methods of equality based
+# on a single #identity method which must return
+# a list of accessors used as the identity keys.
+#
+# It also provides a "shortcut" for creating the
+# #identity method based on given accessors and returns
+# the Equatable module for inclusion.
+#
+#   include Equatable(:a, :b)
+#
+# is equivalent to including a module containing:
+#
+#   def ==(other)
+#     self.a == other.a && self.b == other.b
+#   end
+#
+#   def eql?(other)
+#     self.a.eql?(other.a) && self.b.eql?(other.b)
+#   end
+#
+#   def hash()
+#     self.a.hash ^ self.b.hash
+#   end
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2004 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+
+# = Equatable
+#
+# This mixin provides methods of equality based
+# on a single #identity method which must return
+# a list of accessors used as the identity keys.
+#
+# It also provides a "shortcut" for creating the
+# #identity method based on given accessors and returns
+# the Equatable module for inclusion.
+#
+#   include Equatable(:a, :b)
+#
+# is equivalent to including a module containing:
+#
+#   def ==(other)
+#     self.a == other.a && self.b == other.b
+#   end
+#
+#   def eql?(other)
+#     self.a.eql?(other.a) && self.b.eql?(other.b)
+#   end
+#
+#   def hash()
+#     self.a.hash ^ self.b.hash
+#   end
+#
+module Equatable
+
+  def self.identify(base, *accessors)
+    base.send(:define_method, :identity){ accessors }
+    self
+  end
+
+  def ==(o)
+    identity.all?{ |a| send(a) == o.send(a) }
+  end
+
+  def eql?(o)
+    identity.all?{ |a| send(a).eql?(o.send(a)) }
+  end
+
+  def hash
+    identity.inject(0){ |memo, a| memo ^ send(a).hash }
+  end
+
+end
+
+class Module
+
+  # This function provided a "shortcut" for creating the
+  # #identity method based on given accessors and returns
+  # the Equatable module for inclusion.
+  #
+  #  include Equatable(:a, :b)
+  #
+  # is equivalent to including a module containing:
+  #
+  #   def ==(other)
+  #     self.a == other.a && self.b == other.b
+  #   end
+  #
+  #   def eql?(other)
+  #     self.a.eql?(other.a) && self.b.eql?(other.b)
+  #   end
+  #
+  #   def hash()
+  #     self.a.hash ^ self.b.hash
+  #   end
+  #
+
+  def Equatable(*accessors)
+    Equatable.identify(self, *accessors)
+  end
+
+end
+