facets 1.7.46 → 1.8.0

data/work/core/module/permissions.rb

@@ -0,0 +1,32 @@
+
+class Module
+
+  def publish(*args)
+    a = args.fattern
+    public *a
+    return *a
+  end
+
+  def readonly(*args)
+    a = args.fattern
+    w,r = a.partition { |m| m.to_s[-1,1] == '=' }
+    private *w
+    public *r
+    return *a
+  end
+
+  def writeonly(*args)
+    a = args.fattern
+    w,r = a.partition { |m| m.to_s[-1,1] == '=' }
+    private *r
+    public *w
+    return *a
+  end
+
+  def hidden(*args)
+    a = args.fattern
+    private *a
+    return *a
+  end
+  
+end

data/work/core/module/preserved.rb

@@ -0,0 +1,108 @@
+=begin
+= preserved.rb
+== SYNOPSIS
+
+  require "preserved"
+
+  class XXX
+    def foo
+      # ... should not be redefined ...
+    end
+
+    preserved :foo
+  end
+
+  class YYY < XXX
+    def foo #########!! NameError raised here
+
+== CLASS Module
+=== METHODS
+: preserved(name...)
+  Prohibits redefining the methods specified by name. 
+  We call these methods "preserved methods". 
+
+: preserved_methods
+  Returns an array which consists of preserved methods. 
+=end
+
+class Module
+  PRESERVED_VERSION = "2001-07-20"
+
+  def preserved(*meth)
+    instance_eval %q{
+      Preserved_methods = [] unless defined?(Preserved_methods)
+      meth.each do |m|
+	m = m.id2name if m.is_a? Symbol
+	if ! m.is_a? String
+	  raise ArgumentError, "#{m} is not a symbol"
+	elsif ! instance_methods.include? m
+	  raise NameError, "undefined method `#{m}' for class #{self}"
+	end
+	Preserved_methods.replace(Preserved_methods | [m])
+      end
+    }
+  end
+
+  def preserved_methods
+    instance_eval %q{
+      Preserved_methods = [] unless defined?(Preserved_methods)
+      Preserved_methods.dup
+    }
+  end
+
+  private
+
+  def method_added(id)
+    catch(:preserved!) do
+      instance_eval %q{
+	return if id == :method_added
+	Preserved_methods = [] unless defined?(Preserved_methods)
+
+	if Preserved_methods.include? id.id2name
+	  throw :preserved!
+	end
+      }
+      return
+    end
+    raise NameError, "preserved method `#{id}' redefined for class #{self}"
+  end
+end
+
+if __FILE__ == $0
+  _,demo,_=<<'=== EXAMPLE',<<"== AUTHORS",<<"=end";eval demo # Forget this ;-)
+=begin
+=== EXAMPLE
+
+  class C
+    def a; end
+    p [1, C, preserved_methods] #=> [1, C, []]
+    preserved :a
+    p [2, C, preserved_methods] #=> [2, C, ["a"]]
+  end
+
+  class S < C
+    p [3, S, preserved_methods] #=> [3, S, ["a"]]
+    def a0; end
+    preserved :a0
+    p [4, S, preserved_methods] #=> [4, S, ["a", "a0"]]
+  end
+
+  class C
+    p [5, C, preserved_methods] #=> [5, C, ["a"]]
+  end
+
+  class S
+    def a; end                  #!! preserved method `a' redefinded for class S
+  end
+
+== AUTHORS
+
+Gotoken
+
+== HISTORY
+
+  2001-07-20: Preserved_method would be modified by replace (kg)
+  2000-10-17: First release (gotoken@notwork.org)
+
+=end
+end

data/work/core/module/sattr_accessor.rb

@@ -0,0 +1 @@
+require 'nano/module/sattr'

data/work/core/module/sattr_reader.rb

@@ -0,0 +1 @@
+require 'nano/module/sattr'

data/work/core/module/sattr_setter.rb

@@ -0,0 +1 @@
+require 'nano/module/sattr'

data/work/core/module/sattr_tester.rb

@@ -0,0 +1 @@
+require 'nano/module/sattr'

data/work/core/module/sattr_writer.rb

@@ -0,0 +1 @@
+require 'nano/module/sattr'

data/work/core/module/tc_attr.rb

@@ -0,0 +1,107 @@
+
+require 'test/unit'
+
+require 'nano/module/attr'
+require 'nano/module/attr_reader'
+require 'nano/module/attr_writer'
+require 'nano/module/attr_accessor'
+require 'nano/module/attr_setter'
+require 'nano/module/attr_checker'
+require 'nano/module/attr_key'
+require 'nano/module/attr_sort'
+# TODO
+require 'nano/module/iattr'
+require 'nano/module/iattr_reader'
+require 'nano/module/iattr_writer'
+require 'nano/module/iattr_accessor'
+require 'nano/module/iattr_setter'
+require 'nano/module/iattr_checker'
+
+# fixture
+
+class C
+  attr :a, :a=
+  attr :b?, :b=
+  attr :c, true
+  attr :d, :e, true
+
+  @@ar = attr_reader( :ar )
+  @@aw = attr_writer( :aw )
+  @@aa = attr_accessor( :aa )
+
+  def self.ar ; @@ar ; end
+  def self.aw ; @@aw ; end
+  def self.aa ; @@aa ; end
+
+  attr_checker :t
+  attr_setter :s
+end
+
+# test
+
+class TC_Attr < Test::Unit::TestCase
+
+  def setup
+    @c = C.new
+  end
+
+  # attr
+
+  def test_attr_1
+    assert_nothing_raised{ @c.a = 10 }
+    assert_equal( 10, @c.a )
+  end
+
+  def test_attr_2
+    assert_nothing_raised{ @c.b = "1" }
+    assert( @c.b? )
+  end
+
+  def test_attr_3
+    assert_nothing_raised{ @c.c = 20 }
+    assert_equal( 20, @c.c )
+  end
+
+  def test_attr_4
+    assert_nothing_raised{ @c.d = 30 }
+    assert_equal( 30, @c.d )
+    assert_nothing_raised{ @c.e = 40 }
+    assert_equal( 40, @c.e )
+  end
+
+  # attr_checker
+
+  def test_attr_checker
+    assert_equal( nil, @c.t? )
+    @c.instance_eval { @t = false }
+    assert_equal( false, @c.t? )
+    @c.instance_eval { @t = true }
+    assert_equal( true, @c.t? )
+  end
+
+  # attr_setter
+
+  def test_attr_setter
+    assert_equal( @c, @c.s(10) )
+    assert_equal( 10, @c.s )
+  end
+
+  # attr_reader
+
+  def test_attr_reader
+    assert_equal( [ :ar ], C.ar )
+  end
+
+  # attr_writer
+
+  def test_attr_writer
+    assert_equal( [ :aw= ], C.aw )
+  end
+
+  # attr_accessor
+
+  def test_attr_accessor
+    assert_equal( [ :aa, :aa= ], C.aa )
+  end
+
+end

data/work/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/work/core/module/version.rb

@@ -0,0 +1,23 @@
+require 'mega/version'
+
+class Module
+  # If a module or class has a FILE constant set to __FILE__ and
+  # a (optional) SERIES, this method will return a Version.
+  # If a load error occurs this will not throw an error,
+  # but will simply set the version to UNDEFINED.
+  #
+  #   Class.version  #=> "UNDEFINED"
+  #
+  def version
+    t = "UNDEFINED"
+    if self::FILE
+      begin
+        t = File.open(self::FILE) { |f| f.ctime.strftime("%y.%m.%d") }
+      rescue LoadError
+        t = "UNDEFINED"
+      end
+    end
+    s = self::SERIES || 0
+    Version.new( "#{s}.#{t}" )
+  end
+end

data/work/core/string/frequency.rb

@@ -0,0 +1,40 @@
+# DEPRECATED!!!
+
+require 'facet/string/to_arr'
+require 'facet/enumerable/frequency'
+
+class String
+
+  def frequency(*args)
+    to_arr(*args).frequency
+  end
+
+end
+
+#--
+# NOTE: add String#occur and String#occur_within in future ?
+#++
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCString < Test::Unit::TestCase
+
+    def test_frequency
+      assert_equal( {'a'=>1,'b'=>1}, "ab".frequency )
+      assert_equal( {'tom'=>1,'boy'=>1}, "tom boy".frequency(:word) )
+      assert_equal( {'tom'=>1,'boy'=>1}, "tom\nboy".frequency(:line) )
+    end
+
+  end
+
+=end

data/work/core/string/op_add.rb

@@ -0,0 +1,24 @@
+require 'facet/string/succ'
+require 'facet/string/pred'
+
+class String
+
+  alias_method( :add, :+ )
+
+  def +(s)
+    if s.kind_of?(Numeric)
+      succ(s)
+    else
+      add(s)
+    end
+  end
+
+  def -(s)
+    if s.kind_of?(Numeric)
+      pred(s)
+    else
+      gsub(s, '')
+    end
+  end
+
+end

data/work/core/string/op_div.rb

@@ -0,0 +1,15 @@
+#--
+# Credit goes to Paul Brannan <paul_at_atdesk.com>
+#++
+class String
+  # Allow easy manipulation of path strings.
+  #
+  #   require 'facet/string/slash'
+  #
+  #   prefix = '/usr' / 'local'  #=> "/usr/local"
+  #   prefix / 'bin'             #=> "/usr/local/bin"
+  #
+  def /(other)  #:infix:
+    File.join(self, other)
+  end
+end

data/work/core/string/pred.rb

@@ -0,0 +1,217 @@
+
+class String
+
+  # --- str.prev      => string
+  # Minimal difference previous.
+  # #prev is the essentially the opposite of #next. 
+  # #next and #prev are not exact opposites however,
+  # as some cases of #prev are indeterminate. In these
+  # cases #prev returns the minimal possible solution.
+  #
+  #   "123ABC".prev  #=> "123ABB"
+  #
+  # Credit goes to Pit Capitian.
+  # (The code could use some improving.)
+  def prev
+    case self
+    when ''
+      ''
+    when /[1-9B-Zb-z]/
+      alnum_pred
+    when /[0Aa].*[0Aa]/
+      alnum_pred
+    when /[0Aa]\000*$/
+      binary_pred
+    when /[0Aa]/
+      new_pred
+    else
+      binary_pred
+    end
+  end
+
+  # ---- str.pred      => string
+  # Minimal difference predecessor. It is the essentially the opposite
+  # of #succ, althouth it is not the exact opposite. This version adds
+  # an optional paramter to specify the _n_th predecessor be returned
+  def pred(n=1)
+    s = self
+    n.times { s = s.prev }
+    s
+  end
+
+  private
+
+    def alnum_pred
+      result = dup
+      zero_idx = last_idx = borrowed = borrowed_chars = nil
+      idx = size
+      while idx > 0
+        idx -= 1
+        last_idx = idx unless last_idx
+        case result[ idx ]
+        when ?1 .. ?9, ?B .. ?Z, ?b .. ?z
+          result[ idx ] -= 1
+          zero_idx = idx if result[ idx ] == ?0
+          borrowed = nil
+          break
+        when ?0
+          borrowed = result[ idx ] = ?9
+          borrowed_chars = 1
+        when ?A, ?a
+          result[ idx ] += ( ?Z - ?A )
+          zero_idx = idx
+          if borrowed == result[ idx ]
+            borrowed_chars -= 1
+          else
+            borrowed = result[ idx ]
+            borrowed_chars = 1
+          end
+        else
+          last_idx = nil if last_idx == idx
+        end
+      end
+      if borrowed && borrowed_chars > 0
+        result = new_pred
+      elsif zero_idx && zero_idx < last_idx
+        idx = 0
+        loop do
+          case result[ idx ]
+          when ?1 .. ?9, ?A .. ?Y, ?a .. ?y
+            break
+          when ?0, ?Z, ?z
+            result[ idx, 1 ] = '' if idx == zero_idx
+            break
+          else
+            idx += 1
+          end
+        end
+      end
+      result
+    end
+
+    def binary_pred
+      result = dup
+      idx = size
+      while idx > 0
+        idx -= 1
+        if result[ idx ] > 0
+          result[ idx ] -= 1
+          break
+        else
+          result[ idx ] = 255
+        end
+      end
+      if idx == 0
+        case result[ idx ]
+        when 0
+          result[ 0, 1 ] = '' if size > 1
+        when 255
+          result = new_pred
+        end
+      end
+      result
+    end
+
+    def new_pred
+      "new_pred " + self
+    end
+
+end
+
+
+
+=begin test
+
+  require 'test/unit'
+
+  class Pred_TC < Test::Unit::TestCase
+
+    def assert_pred( pred, str, msg = str )
+      assert_equal( pred, str.pred, "pred #{msg}" )
+    end
+
+    def assert_inverse( str, msg = str )
+      assert_equal( str, str.pred.succ, "inverse #{msg}" )
+    end
+
+    def assert_pred_with_inverse( pred, str, msg = str )
+      assert_pred( pred, str, msg )
+      assert_inverse( str, msg )
+    end
+
+    def test_01_empty
+      assert_pred_with_inverse( '', '', 'empty' )
+    end
+
+    def test_02_simple_alnum
+      assert_pred_with_inverse( '1', '2' )
+      assert_pred_with_inverse( '42', '43' )
+      assert_pred_with_inverse( '3999', '4000' )
+      assert_pred_with_inverse( '00399', '00400' )
+      assert_pred_with_inverse( 'A', 'B' )
+      assert_pred_with_inverse( 'HH', 'HI' )
+      assert_pred_with_inverse( 'AZZ', 'BAA' )
+      assert_pred_with_inverse( 'AAAZZ', 'AABAA' )
+      assert_pred_with_inverse( 'd', 'e' )
+      assert_pred_with_inverse( 'xx', 'xy' )
+      assert_pred_with_inverse( 'yzz', 'zaa' )
+      assert_pred_with_inverse( 'zzyzz', 'zzzaa' )
+      assert_pred_with_inverse( '8Z9z', '9A0a' )
+      assert_pred_with_inverse( ' /4-Z++9 $z #9#', ' /5-A++0 $a #0#' )
+    end
+
+    def test_03_leading_1Aa
+      assert_pred_with_inverse( '0', '1' )
+      assert_pred_with_inverse( '99', '100' )
+      assert_pred_with_inverse( '00099', '00100' )
+      assert_pred_with_inverse( 'Z', 'AA' )
+      assert_pred_with_inverse( 'zZz', 'aaAa' )
+      assert_pred_with_inverse( '9zZ', '10aA' )
+      assert_pred_with_inverse( 'Z9z9', 'AA0a0' )
+      assert_pred_with_inverse( ' /9-Z++9 $z #9#', ' /10-A++0 $a #0#' )
+    end
+
+    def test_04_illegal_alnum
+      assert_pred( 'new_pred 00', '00' )
+      assert_pred( 'new_pred 0000', '0000' )
+      assert_pred( 'new_pred A0', 'A0' )
+      assert_pred( 'new_pred 0a0', '0a0' )
+      assert_pred( 'new_pred 00Aa', '00Aa' )
+      assert_pred( 'new_pred aA', 'aA' )
+      assert_pred( 'new_pred Aa00', 'Aa00' )
+    end
+
+    def test_05_simple_binary
+      assert_pred_with_inverse( ' ', '!' )
+      assert_pred_with_inverse( '!$', '!%' )
+      assert_pred_with_inverse( "$\377\377\377", "%\000\000\000" )
+      assert_pred_with_inverse( "<==\377", "<=>\000" )
+      assert_pred_with_inverse( "\377 ", "\377!" )
+    end
+
+    def test_06_leading_001
+      assert_pred_with_inverse( "\000", "\001" )
+      assert_pred_with_inverse( "\377", "\001\000" )
+      assert_pred_with_inverse( "\377\377\377", "\001\000\000\000" )
+      assert_pred_with_inverse( "\000\000\377", "\000\001\000" )
+    end
+
+    def test_07_binary_with_0Aa
+      assert_pred_with_inverse( '/', '0' )
+      assert_pred_with_inverse( '@', 'A' )
+      assert_pred_with_inverse( '`', 'a' )
+      assert_pred_with_inverse( "$ @\377", "$ A\000" )
+      assert_pred_with_inverse( "+/\377\377", "+0\000\000" )
+    end
+
+    def test_08_illegal_binary
+      assert_pred( "new_pred \000", "\000" )
+      assert_pred( "new_pred \000\000", "\000\000" )
+      assert_pred( "new_pred 0\001", "0\001" )
+      assert_pred( "new_pred A+", "A+" )
+      assert_pred( "new_pred <a>", "<a>" )
+    end
+
+  end
+
+=end