facets 1.0.2 → 1.0.3

data/packages/more/lib/facet/functor.rb

@@ -0,0 +1,98 @@
+#--
+# Functor
+# Copyright (c) 2004,2005 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.
+#
+# ==========================================================================
+#  Revision History
+# ==========================================================================
+#  05-09-22  trans
+#    Made a subclass of BasicObject.
+#
+#  05-01-10  trans
+#    Ported to Mega Modules.
+# ==========================================================================
+#++
+
+require 'facet/basicobject'
+
+#:title: Functor
+#
+# By definition a Functor is simply a first class method, but these are common
+# in the form of Method and Proc. So here a Functor is a bit more specialized
+# as a 1st class _metafunction_. Essentally, a Functor can vary its behavior
+# accorrding to the operation applied to it.
+#
+# == Synopsis
+#
+#   require 'mega/functor'
+#
+#   f = Functor.new { |op, x| x.send(op, x) }
+#   f + 1  #=> 2
+#   f + 2  #=> 4
+#   f + 3  #=> 6
+#   f * 1  #=> 1
+#   f * 2  #=> 2
+#   f * 3  #=> 9
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+#
+
+class Functor < BasicObject
+  def initialize(*obj, &func)
+    @obj = obj
+    @func = func
+  end
+  def method_missing(op, *args)
+    if @obj.empty?
+      @func.call(op, *args)
+    else
+      @func.call(op, *(@obj + args))
+    end
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC_Functor < Test::Unit::TestCase
+
+    def test_function
+      f = Functor.new { |op, x| x.send(op, x) }
+      assert_equal( 2, f + 1 ) #=> 2
+      assert_equal( 4, f + 2 ) #=> 4
+      assert_equal( 6, f + 3 ) #=> 6
+      assert_equal( 1, f * 1 ) #=> 1
+      assert_equal( 4, f * 2 ) #=> 4
+      assert_equal( 9, f * 3 ) #=> 9
+    end
+
+    def test_decoration
+      f = Functor.new("A") { |op, a, x| x.send(op, a + x) }
+      assert_equal( 'BAB', f + 'B' )
+      assert_equal( 'CAC', f + 'C' )
+      assert_equal( 'DAD', f + 'D' )
+    end
+
+  end
+
+=end

data/packages/more/lib/facet/heap.rb

@@ -0,0 +1,226 @@
+#--
+# Heap
+#
+# Copyright (c) 2002,2004 Renald Buter (Ruby Version)
+# [See Cormen1990 for original]
+#
+# 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.
+#
+#
+# ==========================================================================
+# Revision History
+# --------------------------------------------------------------------------
+# 2005.04.28 trans
+#   Ported to Calibre and Documentatation.
+# ==========================================================================
+#
+# NOTE:
+#   Ruby Quiz has a simple Heap class and had a contest for writting 
+#   ascii-ast visual trees of the heap. If someone would like
+#   a small poject it would be cool to improve on this class, in general,
+#   and also see about integrating the best of those Ruby Quiz solutions.
+#
+# THANKS:
+#   Special thanks to Nenad Ocelic for many suggestions.
+#
+#++
+
+#:title: Heap
+#
+# A simple Heap structure and sort.
+#
+# == Extending Heap
+#
+# To extend the heap, implement a cmp(i,j) method which compares array
+# elements i and j and returns true iff i is larger than j, where larger or
+# is the required heap sorting. See Heap::Min and Heap::Max for examples.
+#
+# == Notes
+#
+# The +parent+, +left+ and +right+ methods do not check the supplied parameter,
+# but their result is _only_ valid if the supplied with an integer >=0 
+# for +left+ and +right+ and >0 for +parent+.
+#
+# == Reference
+#
+#   <quote>
+#   Cormen1990: Chapter 7 (Heapsort) of 'An introduction to algorithms', by
+#   Cormen, T.H; Leiserson, C.E.; Rivest, R.L; MIT Press, Cambridge, 1990
+#   ISBN 0-262-53091-0
+#   </quote>
+#
+# == Author(s)
+#
+# * Renald Buter (buter at cwts nl)
+#
+
+class Heap
+
+  class EmptyHeapException < Exception; end
+
+  # We are an abstract class
+  private_class_method :new
+  def self.inherited(sub) sub.class_eval("public_class_method :new") end
+
+  # Keeps an heap sorted with the largest element on top
+  class Max < Heap
+
+    def initialize(array=[]) super(array) end
+
+    def cmp(a,b) a > b end
+
+  end
+
+  # Keeps an heap sorted with the smallest element on top
+  class Min < Heap
+
+    def initialize(array=[]) super(array) end
+
+    def cmp(a,b) a < b end
+
+  end
+
+  # Initialise the heap. If supplied an array, build the heap with the values
+  # of the array. The array can be unsorted. Note: this method can only be
+  # called by superclasses
+  def initialize(array)
+    @array, @heap_size = array, array.length
+    ((@heap_size * 0.5) - 1).downto(0) { |i| heapify(i) }
+  end
+
+  # Get the heap size
+  def size
+    @heap_size
+  end
+
+  # Pretty print
+  def to_s
+    "<#{self.class}: size=#@heap_size, top=#{self.top}>"
+  end
+
+  # Heap-sort a clone of the internal array. This will not touch the
+  # internal array. Returns the array sorted *reversely* on the heap
+  # condition!
+  def sort
+    old_ary = @array.dup
+    old_heap = @heap_size
+    new_ary = sort_internal
+    @array = old_ary
+    @heap_size = old_heap
+    new_ary
+  end
+
+  # Heap-sort the internal array. This reduces heap size to 1, since
+  # sorting the internal array destroys the heap property. Use this only if
+  # the heap is not used after this call and you want save speed and
+  # memory; otherwise use Heap#sort. See +Heap#sort+.
+  def sort_internal
+    (@array.length-1).downto(1) do |i|
+      swap(0,i)
+      @heap_size -= 1
+      heapify(0)
+    end
+    @array
+  end
+
+  # Get the first (maximum) element on the heap
+  def top
+    raise EmptyHeapException if @heap_size < 1
+    @array[0]
+  end
+
+  # Extract the first element from the heap. Will raise EmptyHeapException
+  # if there are no (more) elements on the heap.
+  def pop
+    raise EmptyHeapException if @heap_size < 1
+    @heap_size -= 1
+    top, @array[0] = @array[0], @array[@heap_size]
+    heapify(0)
+    top
+  end
+
+  # Push an element on the heap.
+  def push(elm)
+    i = @heap_size
+    @heap_size += 1
+    while i > 0 and cmp(elm, @array[(j = parent(i))])
+      @array[i] = @array[(i = j)]
+    end
+    @array[i] = elm
+  end
+
+  # Push a list of  elements on the heap.
+  def push_all(elms)
+    elms.each {|e| push(e)}
+  end
+
+protected
+
+  # Compare elements at the supplied indices
+  def cmp_idx(i,j) 
+    cmp(@array[i], @array[j]) 
+  end
+
+  # Get the parent of the node i > 0.
+  def parent(i)
+    ( i - 1 ) >> 1  # (i-1)/2, only valid iff i > 0 !!
+  end
+
+  # Get the node left of node i >= 0
+  def left(i)
+    ( i << 1 ) + 1  # 2i+1
+  end
+
+  # Get the node right of node i >= 0
+  def right(i)
+    ( i << 1 ) + 2  # 2i+2
+  end
+
+  # Keeps an heap sorted with the smallest (largest) element on top
+  def heapify(i)
+    l = left i
+    top = if l < @heap_size && cmp_idx(l,i) then l else i end
+    r = right i
+    top = if r < @heap_size && cmp_idx(r,top) then r else top end
+    if top != i
+      swap(i, top)
+      heapify(top)
+    end
+  end
+
+  # Get the size of the internal array. This may be different from the heap
+  # size, e.g. after +sort+ has been called.
+  def internal_size
+    @array.size
+  end
+
+  # Swap elements in the array
+  def swap(i,j)
+    @array[i], @array[j] = @array[j], @array[i]
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO
+
+=begin #test
+
+  require 'test/unit'
+
+=end

data/packages/more/lib/facet/inheritor.rb

@@ -0,0 +1,239 @@
+#--
+# Inheritor
+#
+# Copyright (c) 2005 Thomas Sawyer
+#
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#
+# ==========================================================================
+#  Revision History
+# ==========================================================================
+#  2005.10.01  trans
+#  * created
+# ==========================================================================
+#++
+
+# :title: Inheritor
+#
+# Inheritor providse a means to store and inherit data via
+# the class heirarchy. An inheritor creates two methods
+# one named after the key that provides a reader. And one
+# named after key! which provides the writer. (Because of
+# the unique nature of inheritor the reader and writer
+# can't be the same method.)
+#
+#   class X
+#     inheritor :foo, [], :+
+#   end
+#
+#   class Y < X
+#   end
+#
+#   X.x! << :a
+#   X.x => [:a]
+#   Y.x => [:a]
+#
+#   Y.x! << :b
+#   X.x => [:a]
+#   Y.x => [:a, :b]
+#
+
+require 'facet/classinherit'
+
+class Object
+
+  # Create an inheritor "class attribute".
+  def inheritor( key, obj, op=nil )
+    op = op ? op.to_sym : :add
+
+    instance_variable_set("@#{key}", obj)
+
+    base = self
+    deflambda = lambda do
+
+      define_method( key ) do
+        defined?(super) ? super.__send__(op,obj) : obj.dup
+      end
+
+      define_method( "#{key}!" ) do
+        instance_variable_get("@#{key}") || inheritor( key, obj.class.new, op )
+        #if instance_variables.include?("@#{key}")
+        #  instance_variable_get("@#{key}")
+        #else
+        #  if self != base
+        #    inheritor( key, obj.class.new, op )
+        #  end
+        #end
+      end
+    end
+
+    # if the object is a module (not a class or other object)
+    if self == Class or self == Module
+      class_eval &deflambda
+    elsif is_a?(Class)
+      (class << self; self; end).class_eval &deflambda
+    elsif is_a?(Module)
+      class_inherit &deflambda      
+      #class_inherit &deflambda
+    else
+      (class << self; self; end).class_eval &deflambda
+    end
+
+    obj
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  #class TC01 < Test::Unit::TestCase
+  #  def setup
+  #    @a = [1]
+  #    @i = Inheritor.new( @a, [2], :+ )
+  #  end
+  #  def test_01_001
+  #    assert_equal([2],@i)
+  #  end
+  #  def test_01_002
+  #    assert_equal([1,2],@i.inheritance)
+  #  end
+  #end
+
+  class TC02 < Test::Unit::TestCase
+    class C
+      inheritor :koko, [1], :+
+    end
+    class D < C
+      inheritor :koko, [2], :+
+    end
+
+    def test_02_001
+      assert_equal( [1], C.koko! )
+    end
+    def test_02_002
+      assert_equal( [1], C.koko )
+    end
+    def test_02_003
+      assert_equal( [2], D.koko! )
+    end
+    def test_02_004
+      assert_equal( [1,2], D.koko )
+    end
+  end
+
+  class TC03 < Test::Unit::TestCase
+    class C
+      inheritor :koko, [1], :+
+    end
+    class D < C
+    end
+
+    def test_03_001
+      assert_equal( [1], C.koko! )
+    end
+    def test_03_002
+      assert_equal( [1], C.koko )
+    end
+    def test_03_003
+      assert_equal( [], D.koko! )
+    end
+    def test_03_004
+      assert_equal( [1], D.koko )
+    end
+  end
+
+  class TC04 < Test::Unit::TestCase
+    class X
+      inheritor :x, {:a=>1}, :merge
+    end
+    module M
+      inheritor :x, {:b=>2}, :merge
+    end
+    class Y < X
+      include M
+      inheritor :x, {:c=>3}, :merge
+    end
+
+    def test_04_001
+      assert_equal( {:a=>1}, X.x )
+    end
+    def test_04_002
+      assert_equal( 2, M.x[:b] )
+    end
+    def test_04_003
+      assert_equal( {:a=>1,:b=>2,:c=>3}, Y.x )
+    end
+    def test_04_004
+      assert_equal( 1, X.x[:a] )
+      assert_equal( nil, X.x[:b] )
+      assert_equal( nil, X.x[:c] )
+    end
+    def test_04_005 ; assert_equal( 1, Y.x[:a] ) ; end
+    def test_04_006 ; assert_equal( 2, Y.x[:b] ) ; end
+    def test_04_007 ; assert_equal( 3, Y.x[:c] ) ; end
+    def test_04_008
+      Y.x![:d] = 4
+      assert_equal( 4, Y.x[:d] )
+    end
+  end
+
+  class TC05 < Test::Unit::TestCase
+    class C
+      inheritor :relations, [], :concat
+    end
+    class D < C
+      #inheritor :relations, [], :concat
+    end
+
+    C.relations! << 1
+    C.relations! << 2
+    D.relations! << 3
+
+    def test_05_001
+      assert_equal( [1,2], C.relations )
+      assert_equal( [1,2,3], D.relations )
+    end
+  end
+
+  class TC06 < Test::Unit::TestCase
+    module MM
+      inheritor :koko, [], :+
+      koko! << 1
+    end
+    class CC1
+      include MM
+      #inheritor :koko, [], :+
+      koko! << 2
+      koko! << 3
+    end
+    class CC2
+      include MM
+      #inheritor :koko, [], :+
+      koko! << 4
+    end
+
+    def test_06_001
+      assert_equal( [1], MM.koko )
+    end
+    def test_06_002
+      assert_equal( [1,2,3], CC1.koko )
+    end
+    def test_06_003
+      assert_equal( [1,4], CC2.koko )
+    end
+  end
+
+=end