facets 1.4.1 → 1.4.2

data/ProjectInfo

@@ -2,7 +2,7 @@
 
 title    : Facets
 name     : facets
-version  : '1.4.1'
+version  : '1.4.2'
 created  : '2004-12-16'
 status   : Beta/Stable
 
@@ -38,7 +38,20 @@ revision:
 
 package: !!package
   distribute: [ gem, tar.bz2, deb ]
-  dir: release
+  dir: ../REL
+  exclude:
+    - web/doc/api
+
+roll: !!package
+  distribute: [ tar.bz2 ]
+  dir: ../REL/roll
+  exclude:
+    - 'web/doc/api'
+    - 'lib/facet/'
+  rules: |
+    lib/facets        **/*       lib/facets/$version
+    data/roll/facets  **/*       data/roll/facets/$version
+    lib               facets.rb  lib/facets/$version
 
 release: !!release
   host       : rubyforge.org

data/Reapfile

@@ -21,7 +21,7 @@ desc %{Second stage (rdoc-core,rdoc-more,package)}
 task '2stage' => [ :'rdoc-core', :'rdoc-more', :package ]
 
 desc %{Final stage (publish,release)}
-task '3stage' => [ :publish, :release ]
+task '3stage' => [ :puplish, :release ]
 
 #
 # Generate facet/ redirection folder.

data/data/roll/facets/Libspec

@@ -0,0 +1,17 @@
+---
+domain  : facets.rubyforge.org/demo
+name    : facets
+version : '1.4.1'
+date    : '2006-06-10'
+
+title   : Ruby Facets
+summary : Vast Core Extensions and Additions Library
+
+author  : Trans
+email   : transfire at gmail.com
+
+main:
+  - '.'
+  - core
+  - more
+

data/forge/core/class/to_module.rb

@@ -0,0 +1,3 @@
+# stub
+require 'facets/core/module/to_module.rb'
+

data/forge/core/module/inherit.rb

@@ -1,59 +1,99 @@
 
-class ClassModule < Module
-  undef_method :singleton_method_added
-end
+
+require 'facets/core/class/to_module'
 
 class Module
 
-  # Be nice if this could be a constant instead.
-  def ClassModule
-    @_ClassModule_ ||= ::ClassModule.new
-  end
-    
-  def singleton_method_added( m )
-    mod = self
-    mod::ClassModule().module_eval {
-      define_method( m, &mod.method(m) )
-    }
+  def inherit( *mods )
+    mods.each do |mod|
+      cmod = (class << mod; self; end).to_module
+      extend cmod
+      include mod
+    end
+    nil
   end
 
-  def inherit( mod )
-    include mod
-    extend mod::ClassModule()
-  end
-  
 end
 
 
 
-#=begin test
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
 
-module M
-  def self.hello ; "Hello" ; end
-  def hello ; "hello" ; end
-end
+=begin test
 
-class X
-  inherit M
-end
+  require 'test/unit'
 
-p X.hello
-p X.new.hello
+  class TCInherit1 < Test::Unit::TestCase
 
-module N
-  inherit M
-end
+    module Foo
+      def self.x ; 10 ; end
+      def y ; 20 ; end
+    end
 
-p X.hello
-p X.new.hello
+    module Bar ; inherit Foo ; end
 
-class Y
-  inherit N
-end
+    class X ; inherit Bar ; end
+
+    # test
+
+    def test_001
+      assert_equal( 10, Foo.x )
+    end
+
+    def test_002
+      assert_equal( 10, Bar.x )
+    end
 
-p Y.hello
-p Y.new.hello
+    def test_003
+      assert_equal( 10, X.x )
+    end
 
+    def test_004
+      x = X.new
+      assert_equal( 20, x.y )
+    end
 
-#=end
+    # These won't work; this solution in non-dynamic.
+
+    #def test_004
+    #  def Foo.g ; 30 ; end
+    #  assert_equal( 30, Bar.g )
+    #end
+
+    #def test_005
+    #  #def Foo.g ; 30 ; end
+    #  assert_equal( 30, X.g )
+    #end
+
+  end
+
+  class TCInherit2 < Test::Unit::TestCase
+
+    module X
+      def self.x ; self ; end
+      def x ; self ; end
+    end
+    class  Y ; inherit X ; end
+    module Z ; inherit X ; end
+    class  Q ; inherit Z ; end
+
+    def test_001
+      y = Y.new
+      assert_equal( Y, Y.x )
+      assert_equal( y, y.x )
+    end
+
+    def test_002
+      q = Q.new
+      assert_equal( Q, Q.x )
+      assert_equal( q, q.x )
+    end
+
+  end
 
+=end

data/forge/core/module/inherit0.rb

@@ -0,0 +1,59 @@
+
+class ClassModule < Module
+  undef_method :singleton_method_added
+end
+
+class Module
+
+  # Be nice if this could be a constant instead.
+  def ClassModule
+    @_ClassModule_ ||= ::ClassModule.new
+  end
+    
+  def singleton_method_added( m )
+    mod = self
+    mod::ClassModule().module_eval {
+      define_method( m, &mod.method(m) )
+    }
+  end
+
+  def inherit( mod )
+    include mod
+    extend mod::ClassModule()
+  end
+  
+end
+
+
+
+#=begin test
+
+module M
+  def self.hello ; "Hello" ; end
+  def hello ; "hello" ; end
+end
+
+class X
+  inherit M
+end
+
+p X.hello
+p X.new.hello
+
+module N
+  inherit M
+end
+
+p X.hello
+p X.new.hello
+
+class Y
+  inherit N
+end
+
+p Y.hello
+p Y.new.hello
+
+
+#=end
+

data/forge/core/module/to_module.rb

@@ -0,0 +1,37 @@
+
+class Module
+
+  # Module returns itself.
+
+  def to_module
+    self #.dup
+  end
+
+end
+
+
+class Class
+
+  # Creates a new module by copying the methods of the class.
+
+  #--
+  # Unfortunately this is not dynamic. So once created changes to 
+  # the original class will not propagate. I.e. It's not inheritance
+  # proper --and that'snot possible excecpt by change Ruby source.
+  #++
+
+  def to_module
+    new_module = Module.new
+    mod = self
+    ancestors.each do |a|
+      a.methods(false).each do |m|
+        m1st = mod.method(m)
+        new_module.module_eval do
+          define_method( m, &m1st )
+        end
+      end
+    end
+    new_module
+  end
+
+end

data/{lib/facets → forge}/core/string/frequency.rb

@@ -1,3 +1,4 @@
+# DEPRECATED!!!
 
 require 'facet/string/to_arr'
 require 'facet/enumerable/frequency'

data/{lib/facets → forge}/core/string/probability.rb

@@ -1,3 +1,4 @@
+# DEPRECATED!!!!
 
 require 'facet/string/to_arr'
 require 'facet/enumerable/probability'

data/forge/core/string/to_arr.rb

@@ -0,0 +1,57 @@
+# DEPRECATED!!!!
+
+
+class String
+
+  # Split a string into an array according to ath egiven mode.
+  # The mode is a recognized symbol or a regexp. If no mode is
+  # given the default mode :char (same as regular expression //)
+  # is used.
+  #
+  # Symbolized modes include :byte, :char, :word, :line and :enum.
+  #
+  # The :enum mode passes the call up to the Enumerable#to_a, thus
+  # providing a means to Ruby's current built-in behavior.
+  #
+  #   'abc 123'.to_arr        #=> ['a','b','c',' ','1','2','3']
+  #   'abc 123'.to_arr(:word) #=> ['abc','123']
+  #
+  def to_arr(mode=nil)
+    case mode
+    when nil, :char, :chars
+      split(//)
+    when :enum
+      super
+    when :byte, :bytes
+      unpack('C*')
+    when :word, :words
+      split(/[ ]+/)
+    when :line, :lines
+      split(/\n/)
+    else
+      split(mode)
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_to_arr
+      assert_equal( ['a','b','c'], 'abc'.to_arr )
+    end
+
+  end
+
+=end

data/forge/more/capsule2.rb

@@ -0,0 +1,152 @@
+# = capsule.rb
+#
+# == 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.
+#
+# == Authors & Contributors
+#
+# * Thomas Sawyer
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# License::   Ruby License
+
+# = Extensible
+#
+# A Capsule encapsulates reusable code and is an analog to the Module class,
+# but rather than storing it's own methods it simply stores modules. These
+# modules are divided into two groups: extensions and inclusions. A capsule
+# is reused via the Kernel#inherit method.
+#
+
+class Capsule < Module
+
+  attr_reader :extensions, :inclusions
+
+  def initialize( &template )
+    @extensions = []
+    @inclusions = []
+    instance_eval &template if template
+  end
+
+  # Shortcut for creating an inclusion-extension pair capsule.
+
+  def self.[]( e, i )
+    new << e < i
+  end
+
+  # Add modules to the inclusions group.
+
+  def include( *inclusions )
+    #inclusions.each { |i| self < i }
+    @inclusions.concat inclusions
+  end
+
+  # Add modules to the extensions group.
+
+  def extend( *extensions )
+    @extensions.concat extensions
+  end
+
+  # Add a module to the inclusions group.
+
+  def <( inclusion )
+    @inclusions << inclusion
+    self
+  end
+
+  # Add a module to the extensions group.
+
+  def <<( extension )
+    @extensions << extension
+    self
+  end
+
+  # Append this capsules features to a given base module or class.
+
+  def append_features( base )
+    #return if base == self
+    # use #instance_exec in Ruby 1.9+
+    base.send( :extend,  *@extensions )
+    #base.send( :include, *@inclusions )
+    super
+  end
+
+end
+
+class Module
+
+  # Inherit behavior from other modules or capsules.
+
+  def inherit( *capsules )
+    capsules.each do |c|
+      c.append_features( self )
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TC_Capsule < Test::Unit::TestCase
+
+    module Mc
+      def c ; "c" ; end
+    end
+
+    module Mi
+      def i; "i"; end
+    end
+
+    # quick notation for a pair
+    #M = Capsule[ Mc, Mi ]
+    module M
+      extend Mc
+      include Mi
+    end
+
+    # or long notaion for more complex components
+    #N = Capsule.new do
+    module N
+      extend Mc
+      include Mi
+    end
+
+    class X
+      include M
+    end
+p X.ancestors
+    class Y
+      include N
+    end
+
+    def test_001
+      assert_equal("c", X.c)
+      assert_equal( "i", X.new.i)
+    end
+
+    def test_002
+      assert_equal("c", Y.c)
+      assert_equal( "i", Y.new.i)
+    end
+
+  end
+
+=end