ruby_ex 0.1.2 → 0.2.0

data/lib/shuffle.rb

@@ -1,9 +1,9 @@
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
 # License::   GNU General Public License (GPL).
-# Revision::  $Id: shuffle.rb 279 2005-06-05 17:46:53Z ertai $
+# Revision::  $Id: shuffle.rb 339 2005-09-06 23:27:27Z ertai $
 
-class Array
+module Shuffle
 
   def shuffle! ( generator=nil )
     n = size
@@ -25,6 +25,10 @@ class Array
     dup.swap!(i, j)
   end
 
+end # module Shuffle
+
+class Array
+  include Shuffle
 end # class Array
 
 

data/lib/spring.rb

@@ -3,10 +3,9 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: ertai $
-# $Id: spring.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: spring.rb 339 2005-09-06 23:27:27Z ertai $
 
 
-require 'ruby_ex'
 require 'thread'
 require 'observer'
 

data/lib/spring_set.rb

@@ -3,10 +3,9 @@
 # License: Gnu General Public License.
 
 # $LastChangedBy: ertai $
-# $Id: spring_set.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: spring_set.rb 339 2005-09-06 23:27:27Z ertai $
 
 
-require 'spring'
 
 
 class SpringSet

data/lib/{symtbl.rb → sym_tbl.rb}

@@ -3,9 +3,8 @@
 # License: Ruby license.
 
 # $LastChangedBy: ertai $
-# $Id: symtbl.rb 279 2005-06-05 17:46:53Z ertai $
+# $Id: sym_tbl.rb 339 2005-09-06 23:27:27Z ertai $
 
-require 'ruby_ex'
 require 'set'
 
 class SymTbl
@@ -15,12 +14,23 @@ class SymTbl
   attr_reader :sid, :local, :father
 
   def initialize ( father_env=nil, default=nil )
-    @father = father_env
     @sid = (@@sid += 1)
     @local = Hash.new(default)
+    if father_env.is_a? Hash
+      @father = nil
+      merge!(father_env)
+    else
+      @father = father_env
+    end
+  end
+
+  def key_convert ( aKey )
+    (aKey.is_a? Symbol)? aKey : aKey.to_s.to_sym
   end
 
   def [] ( aKey )
+    return nil if aKey == ''
+    aKey = key_convert(aKey)
     if @local.has_key? aKey
       @local[aKey]
     elsif @father.nil?
@@ -31,6 +41,7 @@ class SymTbl
   end
 
   def []= ( aKey, aValue )
+    aKey = key_convert(aKey)
     @local[aKey] = aValue
   end
 
@@ -62,15 +73,60 @@ class SymTbl
     ancestors.map{ |s| s.desc_one }.to_yaml
   end
 
+  def merge(other)
+    symtbl = self.class.new(self)
+    symtbl.merge!(other)
+  end
+
+  def merge!(other)
+    other.each { |k, v| @local[key_convert(k)] = v }
+    self
+  end
+
+  alias update merge!
+
+  def has_key?(key)
+    key = key_convert(key)
+    if @local.has_key?(key)
+      true
+    else
+      if @father.nil?
+        false
+      else
+        @father.has_key?(key)
+      end
+    end
+  end
+
+  alias key? has_key?
+  alias include? has_key?
+  alias member? has_key?
+
+  def has_local_key?(key)
+    @local.has_key?(key_convert(key))
+  end
+
+  def new_child
+    self.class.new(self)
+  end
+
 end # class SymTbl
 
 
 
 test_section __FILE__ do
 
-  require 'ruby_ex'
   class SymTblTest < Test::Unit::TestCase
 
+    def setup
+      @father = SymTbl.new
+      @father[:a] = 0
+      @father[:b] = 1
+      @son = SymTbl.new(@father)
+      @son[:a] = 10
+      @son[:c] = 2
+    end
+
     def test1
       root = SymTbl.new
 
@@ -99,10 +155,39 @@ test_section __FILE__ do
 
       assert_equal(42, sub2[:a], 't8')
 
-      assert_equal([{2=>{:a=>42}}, {1=>{:a=>2, :c=>3}}, {0=>{:b=>1, :a=>0}}],
+      assert_equal([{4=>{:a=>42}}, {3=>{:a=>2, :c=>3}}, {2=>{:b=>1, :a=>0}}],
                    YAML::load(sub2.desc))
     end
 
+    def test_has_key?
+      assert(@son.has_key?(:a))
+      assert(@son.has_key?(:b))
+      assert(@son.has_key?(:c))
+      assert(! @son.has_key?(:not_a_key))
+    end
+
+    def test_merge!
+      s = SymTbl.new
+      s[:a] = 40
+      s[:c] = 42
+      @son.merge!(s)
+      assert_equal(40, @son[:a])
+      assert_equal(42, @son[:c])
+    end
+
+    def test_merge
+      s = SymTbl.new
+      s[:a] = 40
+      s[:c] = 42
+      r = @son.merge(s)
+      assert_equal(10, @son[:a])
+      assert_equal(2, @son[:c])
+      assert_equal(40, r[:a])
+      assert_equal(1, r[:b])
+      assert_equal(42, r[:c])
+      assert_equal(@son, r.father)
+    end
+
   end # class SymTblTest
 
 end

data/lib/sym_tbl_gsub.rb

@@ -0,0 +1,227 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Nicolas Pouillard. All rights reserved.
+# License::   Ruby License
+# Revision::  $Id: sym_tbl_gsub.rb 339 2005-09-06 23:27:27Z ertai $
+
+require 'sym_tbl'
+
+class Object
+
+  def symtbl_gsub ( symtbl )
+    nil
+  end
+
+  def do_symtbl_gsub ( symtbl )
+    result = symtbl_gsub(symtbl)
+    return (result.nil?)? self : result
+  end
+
+  def symtbl_to_s
+    to_s
+  end
+
+end # class Object
+
+
+
+module PrettyInspect
+  def symtbl_to_s
+    inspect
+  end
+end # module PrettyInspect
+
+
+
+class Hash
+  have PrettyInspect
+
+  def symtbl_gsub ( symtbl )
+    changed = false
+    res = self.class.new
+    each do |k,v|
+      new_k = k.symtbl_gsub(symtbl)
+      new_v = v.symtbl_gsub(symtbl)
+      changed = true if new_k or new_v
+      res[new_k || k] = (new_v || v)
+    end
+    changed ? res : nil
+  end
+
+end # class Hash
+
+
+
+class Array
+  have PrettyInspect
+
+  def symtbl_gsub ( symtbl )
+    changed = false
+    res = self.class.new
+    each do |e|
+      changed = true if new_e = e.symtbl_gsub(symtbl)
+      res << (new_e || e)
+    end
+    changed ? res : nil
+  end
+
+end # class Array
+
+
+
+class SymTbl
+
+  def symtbl_gsub! ( symtbl )
+    new_local = @local.symtbl_gsub(symtbl)
+    return nil if new_local.nil?
+    @local = new_local
+    self
+  end
+
+  def symtbl_gsub ( symtbl )
+    dup.symtbl_gsub!(symtbl)
+  end
+
+end # class SymTbl
+
+
+
+class Pathname
+
+  def symtbl_gsub ( symtbl )
+    res = to_s.symtbl_gsub(symtbl)
+    return self.class.new(res) unless res.nil?
+  end
+
+end # class Pathname
+
+
+
+class Regexp
+  have PrettyInspect
+
+  def symtbl_gsub ( symtbl )
+    res = source.symtbl_gsub(symtbl)
+    return self.class.new(res) unless res.nil?
+  end
+
+end # class Regexp
+
+
+
+class Symbol
+
+  def symtbl_gsub ( symtbl )
+    res = to_s.symtbl_gsub(symtbl)
+    return res.to_sym unless res.nil?
+  end
+
+end # class Symbol
+
+
+
+class String
+
+  def symtbl_gsub ( symtbl )
+    return nil unless self =~ /<<(.*)>>/
+    cur, last = self, nil
+    while cur != last
+      last = cur
+      cur = cur.gsub(/<<([^<>]*)>>/) do
+        s = symtbl[$1]
+        (s.nil?)? $& : s.symtbl_to_s
+      end
+    end
+    (cur == self)? nil : cur
+  end
+
+end # class String
+
+
+PathList.import!
+class PathList
+
+  alias add_matching_without_expand add_matching
+  def add_matching(pattern)
+    pattern = @expand[pattern] if defined? @expand and @expand
+    add_matching_without_expand pattern
+  end
+  protected :add_matching
+
+  def symtbl_gsub! ( symtbl )
+    @expand = lambda { |pattern| pattern.do_symtbl_gsub(symtbl) }
+    map! { |path| path.do_symtbl_gsub(symtbl) }
+    @expand = nil
+    self
+  end
+
+  def symtbl_gsub ( symtbl )
+    dup.symtbl_gsub!(symtbl)
+  end
+
+end # class PathList
+
+
+
+module SymTblGsub
+
+  test_section __FILE__ do
+    class SymTblGsubTest < Test::Unit::TestCase
+      def setup
+        @s = SymTbl.new(
+          :foo => :bar,
+          :bar => [1, 2],
+            3   => 'foo',
+          :i   => '<<j>>',
+          :j   => '<<3>>',
+          :pwd => __FILE__.to_path.dirname.to_s
+        )
+      end
+      def assert_symtbl ( my, ref=nil )
+        assert_equal ref, my.symtbl_gsub(@s)
+      end
+      def test_string
+        assert_symtbl '<<foo>>', 'bar'
+        assert_symtbl '<<foo>><<3>> >> <<', 'barfoo >> <<'
+        assert_symtbl '<<<<>>>>%%><<>>^#^#'
+        assert_symtbl '<<<<bar>>>>', '<<[1, 2]>>'
+        assert_symtbl '%<<<<foo>>>>#', '%[1, 2]#'
+        assert_symtbl "_\n\t\000_<<i>>__", "_\n\t\000_foo__"
+        assert_symtbl '<<<<i>>>>', 'bar'
+        assert_symtbl '<<dne>> <<foo>>', '<<dne>> bar'
+      end
+      class Foo
+      end
+      def test_object
+        assert_symtbl Foo.new
+      end
+      def test_hash
+        assert_symtbl({'<<foo>>' => '<<i>>', 'barbar' => '<<3>>' },
+                      {'barbar'=>'foo', 'bar'=>'foo'})
+      end
+      def test_array
+        assert_symtbl(['<<foo>>', '<<i>>', 'barbar <<3>>' ],
+                      ['bar', 'foo', 'barbar foo'])
+      end
+      def test_pathname
+        assert_symtbl('foo/<<foo>>/<<i>>'.to_path, 'foo/bar/foo'.to_path)
+      end
+      def test_regexp
+        assert_symtbl(/<<foo>>(<<i>>)*/, /bar(foo)*/)
+      end
+      def test_symbol
+        assert_symtbl(:'<<foo>> <<i>>', :'bar foo')
+      end
+      def test_pathlist
+        pathlist = ['<<foo>>', '<<i>>'.to_path]
+        ls1 = '<<bing>>/../test'.to_path + 'resources/autoload_tree/*.rb'
+        ls2 = '<<pwd>>/../test'.to_path + 'resources/autoload_tree/*.rb'
+        pathlist << ls2 << ls1
+        my = PathList[pathlist].symtbl_gsub(@s).map! { |x| x.basename }
+        my.all? { |x| assert_kind_of(Pathname, x) }
+        ref = %w[ bar foo A.rb B.rb ]
+        assert_equal ref.to_set, my.map!{ |x| x.to_s }.to_set
+      end
+    end # class SymTblGsubTest
+  end
+
+end # module SymTblGsub

data/lib/{synflow.rb → syn_flow.rb}

@@ -10,7 +10,6 @@
 # parallel systems.
 #
 
-require 'ruby_ex'
 require 'thread'
 require 'set'
 
@@ -146,7 +145,7 @@ class SynFlowFactory
     @transitions.include?(*transition)
   end
 
-  
+
   def delta ( src, label )
     @transitions.delta(src, label)
   end

data/lib/text.rb

@@ -0,0 +1,218 @@
+# Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   Gnu General Public License.
+# Revision::  $Id: text.rb 359 2005-09-16 10:05:22Z ertai $
+
+class Text
+
+  attr_accessor :text, :width, :cut_if_needed
+
+  @@default_options = { :width => 78, :cut_if_needed => false }.freeze
+
+  # options:
+  #   width:         the maximal line width (default 78)
+  #   cut_if_needed: see cropping
+  def initialize ( text, options={} )
+    options = @@default_options.merge options
+    @text = text
+    @width = options[:width]
+    @cut_if_needed = options[:cut_if_needed]
+  end
+
+
+
+  def justify! ( &block )
+    input = @text.to_a
+    @text, block = '', method(:adder) if block.nil?
+    last_line = input.size - 1
+    input.each_with_index do |line, i|
+      line =~ /^(\s*)(.*)\s*?(\n?)$/
+      indent, base, eol = $1, $2, $3
+      words = base.split(/\s+/)
+      base = words.join(' ')
+      width = indent.width + base.width
+      unless width > @width or base.empty? or i == last_line
+        spaces = words.size - 1
+        padding_size = @width - width
+        if spaces > 0
+          nb = ' ' * (padding_size / spaces + 1)
+          nb2 = nb + ' '
+          rest = padding_size % spaces + 1
+          base.gsub!(/ /) do
+            rest -= 1
+            (rest >= 0) ? nb2 : nb
+          end
+        end
+      end
+      block[indent, base, eol]
+    end
+    self
+  end
+
+
+
+  def split! ( &block )
+    last_new_line = (@text[-1] == ?\n)? "\n" : ''
+    indent = @text[/\A([ \t]*)/, 1]
+    words = @text.split(/\s+/)
+    @text, block = '', method(:adder) if block.nil?
+
+    line = ''
+    while not words.empty?
+      words.shift if words.first.empty?
+      word = words.first
+      if indent.width + line.width + word.width + 1 <= @width
+        line += ' ' unless line.empty?
+        line += word
+        words.shift
+      elsif line.empty?
+        if @cut_if_needed
+          line = word[0..width-1]
+          words[0] = word[width..-1]
+          block[indent, line, "\n"]
+          line = ''
+        else
+          block[indent, word, "\n"]
+          words.shift
+        end
+      else
+        block[indent, line, "\n"]
+        line = ''
+      end
+    end
+
+    block[indent, line, last_new_line] unless line.empty?
+    self
+  end
+
+
+
+  def split_and_justify! ( &block )
+    split!.justify!(&block)
+  end
+
+
+  def crop! ( width=@width, message=" ...\n", &block )
+    input = @text
+    @text, block = '', method(:adder) if block.nil?
+    message = message.to_s
+    width2 = width - 1 - message.chomp.width
+    raise ArgumentError, "Bad width: too low" if width2 < 0
+    input.each do |line|
+      if line.width > width
+        block[line[0..width2], message]
+      else
+        block[line]
+      end
+    end
+    self
+  end
+
+
+  def clip! ( head_size=100, tail_size=30, message="\n[...clipped...]\n\n", &block )
+    input = @text.to_a
+    size = input.size
+    return identity!(&block) if head_size + tail_size >= size
+    head = (head_size - 1 < 0)? [] : input[0 .. head_size - 1]
+    tail = input[[0, size - tail_size, head_size].max .. -1]
+    @text, block = '', method(:adder) if block.nil?
+    head.each(&block)
+    message.each(&block)
+    tail.each(&block)
+    self
+  end
+
+
+  def adder ( *args )
+    @text += args.join
+  end
+
+
+  def identity! ( &block )
+    @text.each(&block) unless block.nil?
+    self
+  end
+
+
+  def clear
+    @text.clear
+  end
+
+
+  def mask!
+    @text = '*****'.to_text
+  end
+
+
+  def to_s
+    @text.dup
+  end
+
+
+  # Redirect calls like `justify' to `dup.justify!'
+  def method_missing ( meth, *args, &block )
+    in_place_meth = :"#{meth}!"
+    return super unless respond_to? in_place_meth
+    dup.send(in_place_meth, *args, &block)
+  end
+
+end # class Text
+
+
+class String
+  def to_text ( *args, &block )
+    Text.new(self, *args, &block)
+  end
+end # class String
+
+
+test_section __FILE__ do
+
+  class TestText < ::Test::Unit::TestCase
+
+    def setup
+      @o = { :width => 10 }
+      @text = " foofoof barbarfoo foo f bar for na goo baz buz g"
+      @cropped = " foofo ...\n"
+      @splitted = " foofoof\n barbarfoo\n foo f bar\n for na\n goo baz\n buz g"
+      @splitted_justified = " foofoof\n barbarfoo\n foo  f bar\n for     na\n goo    baz\n buz g"
+      @splitted_justified_cropped = " foofoof\n barba ...\n foo   ...\n for   ...\n goo   ...\n buz g"
+      @clipped = " foofoof\n barbarfoo\n\n[...clipped...]\n\n buz g"
+    end
+
+    def teardown
+    end
+
+    def test_justify
+      assert_equal @splitted_justified, @splitted.to_text(@o).justify.text
+    end
+
+    def test_split
+      assert_equal @splitted, @text.to_text(@o).split.text
+    end
+
+    def test_split_and_justify
+      assert_equal @splitted_justified, @text.to_text(@o).split_and_justify.text
+    end
+
+    def test_crop
+      assert_equal @cropped, @text.to_text(@o).crop.text
+      assert_equal @splitted_justified_cropped, @splitted_justified.to_text(@o).crop.text
+    end
+
+    def test_clip
+      assert_equal @clipped, @splitted_justified.to_text(@o).clip(2, 1).text
+      assert_equal 'yo', @splitted_justified.to_text(@o).clip(0, 0, 'yo').text
+      assert_equal " foofoof\nyo", @splitted_justified.to_text(@o).clip(1, 0, 'yo').text
+      assert_equal 'yo buz g', @splitted_justified.to_text(@o).clip(0, 1, 'yo').text
+      assert_equal @splitted_justified, @splitted_justified.to_text(@o).clip(100, 0, 'yo').text
+      assert_equal @splitted_justified, @splitted_justified.to_text(@o).clip(6, 0, 'yo').text
+      assert_equal @splitted_justified, @splitted_justified.to_text(@o).clip(0, 6, 'yo').text
+      assert_equal @splitted_justified, @splitted_justified.to_text(@o).clip(3, 3, 'yo').text
+      assert_equal " foofoof\n barbarfoo\nyo for     na\n goo    baz\n buz g",
+                   @splitted_justified.to_text(@o).clip(2, 3, 'yo').text
+    end
+
+  end # class TestText
+
+end