facets 2.4.5 → 2.5.0

data/lib/more/facets/eventhook.rb

@@ -1,132 +0,0 @@
-# = Event Hook
-#
-# Exception-based Event Hooks provides an Event Hooks system designed
-# on top of Ruby's built-in Exception system.
-#
-#   def dothis2
-#     puts 'pre'
-#     hook :quitit
-#     puts 'post'
-#   end
-#
-#   def tryit2
-#     begin
-#       puts "BEFORE"
-#       dothis2
-#       puts "AFTER"
-#     rescue EventHook
-#       event :quitit do
-#         puts "HERE"
-#       end
-#     end
-#   end
-#
-#   tryit2
-#
-# == 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.
-
-
-# = Event Hook
-#
-# Exception-based Event Hooks provides an Event Hooks system designed
-# on top of Ruby's built-in Exception system.
-#
-#   def dothis2
-#     puts 'pre'
-#     hook :quitit
-#     puts 'post'
-#   end
-#
-#   def tryit2
-#     begin
-#       puts "BEFORE"
-#       dothis2
-#       puts "AFTER"
-#     rescue EventHook
-#       event :quitit do
-#         puts "HERE"
-#       end
-#     end
-#   end
-#
-#   tryit2
-#
-class EventHook < Exception
-  attr_reader :name, :cc
-  def initialize(name, cc)
-    @name = name
-    @cc = cc
-  end
-  def call
-    @cc.call
-  end
-end
-
-module Kernel
-  def hook(sym)
-    callcc{ |c| raise EventHook.new(sym, c) }
-  end
-  def event(sym)
-    if $!.name == sym
-      yield
-      $!.call
-    end
-  end
-end
-
-
-#
-# Test
-#
-
-=begin
-
-  require 'test/unit'
-
-  class TestEventHook < Test::Unit::TestCase
-
-    class T
-      attr_reader :a
-      def dothis
-        @a << '{'
-        hook :here
-        @a << '}'
-      end
-      def tryit
-        @a = ''
-        begin
-          @a << "["
-          dothis
-          @a << "]"
-        rescue EventHook
-          event :here do
-            @a << "HERE"
-          end
-        end
-      end
-    end
-
-    def test_run
-      t = T.new
-      t.tryit
-      assert_equal('[{HERE}]', t.a)
-    end
-
-  end
-
-=end

data/lib/more/facets/fileshell.rb

@@ -1,202 +0,0 @@
-warn 'please use folio (gem install folio) for future versions'
-
-# = File Shell
-#
-# Comprehensive file system access tool. FileShell acts as a "virtual"
-# shell prompt.
-#
-#   c = VirtualShell.new
-#   c.ls  #=> ['ipso.txt']
-#
-# == NOTES
-#
-# * This is still expiremental library and is still undergoing rivision.
-#
-# Authors:: Trans
-# Copying:: (c) 2007 Thomas Sawyer
-# License:: Ruby License
-
-require 'fileutils'
-
-# = File Shell
-#
-# Comprehensive file system access tool. FileShell acts as a "virtual"
-# shell prompt.
-#
-#   c = VirtualShell.new
-#   c.ls  #=> ['ipso.txt']
-#
-class FileShell
-
-  attr_reader :root
-
-  def initialize(*root_and_options)
-    @options = Hash === root_and_options ? root_and_options.pop : {}
-    @root    = root_and_options.first || "/"
-
-    @dryrun = options[:dryrun]
-    @quiet  = options[:quiet]
-    #@force  = options[:force]
-  end
-
-  def dryrun? ; @dryrun ; end
-  def quiet?  ; @quiet  ; end
-  def verbose?  ; !@quiet  ; end
-  #def force?  ; @force  ; end
-
-  # Direct access to a directory or a file.
-  def [](name)
-    if File.directory?(name)
-      Dir.new(name)
-    elsif File.file?(name)
-      File.new(name)
-    else
-      nil
-    end
-  end
-
-  # Is a directory root?
-  def root?(dir=nil)
-    pth = File.expand_path(dir||work)
-    return true if pth == '/'
-    return true if pth =~ /^(\w:)?\/$/
-    false
-  end
-
-  # Present working directory.
-  def pwd; super; end
-
-  # Directory listing
-  def ls(dir, options=nil)
-    Dir.entries.collect do |f|
-      File.directory?(f) ? Dir.new(f) : File.new(f)
-    end
-  end
-
-  # Change directory.
-  #
-  # cd(dir, options)
-  # cd(dir, options) {|dir| .... }
-  def cd(dir, options=nil, &yld)
-    fu(options).cd(dir, &yld)
-  end
-  alias chdir cd
-
-  # mkdir(dir, options)
-  # mkdir(list, options)
-  def mkdir(dir, options=nil)
-    fu(options).mkdir(dir)
-  end
-
-  # mkdir_p(dir, options)
-  # mkdir_p(list, options)
-  def mkdir_p(dir, options=nil)
-    fu(options).mkdir_p(dir)
-  end
-
-  # rmdir(dir, options)
-  # rmdir(list, options)
-  def rmdir(dir, options=nil)
-    fu(options).rmdir(dir)
-  end
-
-  # ln(old, new, options)
-  # ln(list, destdir, options)
-  def ln(old, new, options=nil)
-    fu(options).ln(old, new)
-  end
-
-  # ln_s(old, new, options)
-  # ln_s(list, destdir, options)
-  def ln_s(old, new, options=nil)
-    fu(options).ln_s(old, new)
-  end
-
-  # ln_sf(src, dest, options)
-  def ln_sf(src, dest, options=nil)
-    fu(options).ln_sf(src, dest)
-  end
-
-  # cp(src, dest, options)
-  # cp(list, dir, options)
-  def cp(src, dest, options=nil)
-    fu(options).cp(src, dest)
-  end
-
-  # cp_r(src, dest, options)
-  # cp_r(list, dir, options)
-  def cp_r(src, dest, options=nil)
-    fu(options).cp_r(src, dest)
-  end
-
-  # mv(src, dest, options)
-  # mv(list, dir, options)
-  def mv(src, dest, options=nil)
-    fu(options).mv(src, dest)
-  end
-  alias move mv
-
-  # rm(list, options)
-  def rm(list, options=nil)
-    fu(options).rm(list)
-  end
-
-  # rm_r(list, options)
-  def rm_r(list, options=nil)
-    fu(options).rm_r(list)
-  end
-
-  # rm_rf(list, options)
-  def rm_rf(list, options=nil)
-    fu(options).rm_rf(list)
-  end
-
-  # install(src, dest, mode = <src's>, options)
-  def install(src, dest, mode=src, options=nil)
-    fu(options).install(src, dest, mode)
-  end
-
-  # chmod(mode, list, options)
-  def chmod(mode, list, options=nil)
-    fu(options).chmod(mode, list)
-  end
-
-  # chmod_R(mode, list, options)
-  def chmod_R(mode, list, options=nil)
-    fu(options).chmod_R(mode, list)
-  end
-
-  # chown(user, group, list, options)
-  def chown(user, group, list, options=nil)
-    fu(options).chown(user, group, list)
-  end
-
-  # chown_R(user, group, list, options)
-  def chown_R(user, group, list, options=nil)
-    fu(options).chown_R(user, group, list)
-  end
-
-  # touch(list, options)
-  def touch(list, options=nil)
-    fu(options).touch(list)
-  end
-
- private
-
-  #
-  def fu(opts)
-    nowrite = opts[:nowrite] || opts[:dryrun] || opts[:noop]   || dryrun?
-    verbose = opts[:verbose] || opts[:dryrun] || !opts[:quiet] || verbose?
-
-    if nowrite and verbose
-      FileUtils::Dryrun
-    elsif nowrite
-      FileUtils::NoWrite
-    elsif verbose
-      FileUtils::Verbose
-    else
-      FileUtils
-    end
-  end
-
-end

data/lib/more/facets/hash/symbolize_keys.rb

@@ -1,94 +0,0 @@
-require 'facets/hash/rekey'
-
-class Hash
-
-  # Converts all keys in the Hash to Symbols, returning a new Hash.
-  # With a +filter+, limits conversion to only a certain selection of keys.
-  #
-  #   foo = { :name=>'Gavin', 'wife'=>:Lisa }
-  #   foo.symbolize_keys    #=>  { :name=>"Gavin", :wife=>:Lisa }
-  #   foo.inspect           #=>  { "name" =>"Gavin", "wife"=>:Lisa }
-  #
-  # This method is considered archaic. Use #rekey instead.
-
-  def symbolize_keys(&filter)
-    if filter
-      rekey{ |k| filter[k] ? k.to_sym : nil }
-    else
-      rekey{ |k| k.to_sym }
-    end
-  end
-
-  #alias_method( :keys_to_sym, :symbolize_keys )
-
-  #--
-  # # Rails has these aliases too, but they are not very good for
-  # # gerenal use, IMHO. But perhaps someone can convince me otherwise.
-  # alias_method( :to_options,  :symbolize_keys )
-  #++
-
-  # Synonym for Hash#symbolize_keys, but modifies the receiver in place and returns it.
-  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
-  #
-  #   foo = { 'name'=>'Gavin', 'wife'=>:Lisa }
-  #   foo.symbolize_keys!    #=>  { :name=>"Gavin", :wife=>:Lisa }
-  #   foo.inspect            #=>  { :name=>"Gavin", :wife=>:Lisa }
-  #
-  # This method is considered archaic. Use #rekey instead.
-
-  def symbolize_keys!(&filter)
-    if filter
-      rekey!{ |k| filter[k] ? k.to_sym : nil }
-    else
-      rekey!{ |k| k.to_sym }
-    end
-
-  end
-
-  #alias_method( :keys_to_sym!, :symbolize_keys! )
-
-  # Converts all keys in the Hash to Strings, returning a new Hash.
-  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }
-  #   foo.stringify_keys    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #   foo.inspect           #=>  { :name =>"Gavin", :wife=>:Lisa }
-  #
-  # This method is considered archaic. Use #rekey instead.
-
-  def stringify_keys(&filter)
-    if filter
-      rekey{ |k| filter[k] ? k.to_s : nil }
-    else
-      rekey{ |k| k.to_s }
-    end
-  end
-
-  #alias_method(:keys_to_s, :stringify_keys)
-
-  # Synonym for Hash#stringify_keys, but modifies the receiver in place and returns it.
-  # With a +filter+ parameter, limits conversion to only a certain selection of keys.
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }
-  #   foo.stringify_keys!    #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #   foo.inspect            #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #
-  # This method is considered archaic. Use #rekey instead.
-
-  def stringify_keys!(&filter)
-    if filter
-      rekey!{ |k| filter[k] ? k.to_s : nil }
-    else
-      rekey!{ |k| k.to_s }
-    end
-  end
-
-  #alias_method( :keys_to_s!, :stringify_keys!)
-
-  #--
-  # # Rails has these aliases too.
-  # alias_method( :to_options!, :symbolize_keys! )
-  #++
-
-end
-

data/lib/more/facets/tagiter.rb

@@ -1,366 +0,0 @@
-# = tagiterator.rb
-#
-# == Copyright (c) 2000 Ⴗnyasu <nyasu@osk.3web.ne.jp>
-#
-#   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.
-#
-# == Author(s)
-#
-# * Ⴗnyasu
-
-# Author::    Ⴗnyasu <nyasu@osk.3web.ne.jp>
-# Copyright:: Copyright (c) 2000 Ⴗnyasu
-# License::   Ruby License
-
-# = TagIterator (aka Tagiter)
-#
-# Simple but very useful HTML/XHTML cascading parser.
-#
-# Quickly iterate through tagged markup documents like HTML and XML.
-# TagIterator is great for quick and dirty web scrapping.
-#
-# == Usage
-#
-#   # sample html
-#   stext = <<-EOF
-#   <body> This is a test...
-#     <sub> S1 </sub> <sub> S2 </sub>
-#     <DL>
-#       <DT> A1
-#       <DT> A2
-#       <DT> A3
-#     </DL>
-#     <DL>
-#       <DT> B1
-#       <DT> B2
-#       <DT> B3
-#     </DL>
-#     <NEST>
-#       <P ALIGN="R">TOP</P>
-#       <NEST>
-#         <P>SECOND</P>
-#         <OL>
-#           <LI>C1
-#           <LI>C2
-#           <LI>C3
-#           <LI>C4
-#         </OL>
-#       </NEST>
-#       <OL>
-#         <LI>D1
-#         <LI>D2
-#         <LI>D3
-#         <LI>D4
-#       </OL>
-#     </NEST>
-#   </body>
-#   EOF
-#
-#   a = TagIterator.new(stext)
-#   a.first("body") do |y|
-#     y.nth("dl",2) do |dl|
-#       dl.enumtag("dt") do |t|
-#         puts t.text.strip
-#       end
-#     end
-#     y.first("nest") do |n|
-#       n.first("p") do |c|
-#         print c.text, ' '
-#         puts c.attributes.collect{ |k,v| "#{k}=#{v}" }
-#       end.next("nest") do |m|
-#         m.first("p") do |c|
-#           puts c.text
-#         end.next("ol") do |o|
-#           o.enumtag("li") do |i| puts i.text.strip end
-#         end
-#       end.next("ol") do |o|
-#         o.enumtag("li") do |i| puts i.text.strip end
-#       end
-#     end
-#   end
-#   a.each_block("sub") do |y|
-#     puts y.text.strip
-#   end
-#
-# _produces_
-#
-#   B1
-#   B2
-#   B3
-#   TOP align=R
-#   SECOND
-#   C1
-#   C2
-#   C3
-#   C4
-#   D1
-#   D2
-#   D3
-#   D4
-#   S1
-#   S2
-#
-
-class TagIterator
-
-  attr :text
-  attr :option, true
-  attr :tag
-  attr :attributes
-
-  private
-
-  def initialize(text,tag=nil,attributes={})
-    raise RuntimeError,"Only String accepted" unless text.is_a?(String)
-    @text=text
-    @option="pi"
-    @tag=tag
-    @attributes=attributes
-    def @attributes.[](aname)
-      super aname.downcase
-    end
-  end
-
-  def find_element(element,st=0)
-    rex=Regexp.new('<(\s|\n)*'+element+'(\s|\n|>)',@option)
-    @text.index(rex,st)
-  end
-
-  def parse_attribute(attstr)
-    k={}; r={}; 
-    attstr.scan(/(\w+)=(\S+)/) do |pt| k[ pt[0] ] = pt[1] end
-    attstr.scan(/(\w+)="([^"]*)"/) do |pt| k[ pt[0] ] = pt[1] end
-    k.each do |key,val| r[key.downcase]=val end
-    r
-  end
-
-  def find_opentag(tag,st=0)
-    s=find_element(tag,st)
-    return nil unless s
-
-    r=@text.index('>',s)
-    return r+1,@text[s+1..r-1]
-  end
-
-  def find_closetag(tag,st,opentag=nil)
-    if opentag then
-      p=find_element(tag,st)
-      q,d = find_opentag(opentag,st)
-    else
-      p=find_element('/\s*'+tag,st)
-      q,d = find_opentag(tag,st)
-    end
-    p-=1 if p 
-
-    if p and q then if p > q then    # tag nested
-      p=find_closetag(tag,find_closetag(tag,q,opentag)+2,opentag)
-    end end
-
-    return p
-  end
-
-  def find_closeenumtag(tag,st=0)
-    rex=Regexp.new('<\s*'+tag,@option)
-    s=@text.index(rex,st)
-    s-=1 if s
-    s
-  end
-  alias_method :find_openenumtag, :find_opentag
-
-  public
-
-  def nth(tag,n,closetag=nil)
-    raise RuntimeError,"nth: number not specified" unless n
-    t=0
-    e=s=0   # for their scope
-    d=nil
-
-    1.upto(n) do |i|
-      s,d = find_opentag(tag,t)
-      raise RuntimeError,"tag(#{tag}) not found at(#{i})" unless s
-
-      if closetag then
-        e=find_closetag(closetag,s,tag)
-      else
-        e=find_closetag(tag,s)
-      end
-      e=-1 unless e
-      t=@text.index('>',e+1)
-      t=@text.length unless t
-    end
-    yield self.class.new(text[s..e],tag,parse_attribute(d))
-    self.class.new(text[t+1..-1])
-  end
-
-  def first(tag,*arg) nth(tag,1,*arg) do |f| yield f end end
-  alias_method :next, :first
-
-  def each_block(tag,closetag=nil)
-    t=0
-    s,d =find_opentag(tag)
-    raise RuntimeError,"tag(#{tag}) not found" unless s
-
-    while s do
-      if closetag then
-        e=find_closetag(closetag,s,tag)
-      else
-        e=find_closetag(tag,s)
-      end
-      e=-1 unless e
-      yield self.class.new(@text[s..e],tag,parse_attribute(d))
-      if e>=0 then 
-        t=@text.index('>',e+1)
-        t=@text.length unless t
-        s,d = find_opentag(tag,t)
-      else
-        s=false
-      end
-    end
-    self.class.new(text[t+1..-1])
-  end
-
-  def collect(*arg)
-    a=[]
-    each_block(*arg) do |tt| a.push tt end
-    a
-  end
-
-  def enumtag(tag)
-    s,d = find_openenumtag(tag)
-    while s do
-      e=find_closeenumtag(tag,s+1)
-      e=-1 unless e
-      yield self.class.new(@text[s..e],tag,parse_attribute(d))
-      s,d = find_openenumtag(tag,s)
-    end
-  end
-
-  def enumcollect(tag)
-    a=[]
-    enumtag(tag) do |t| a.push t end
-    a
-  end
-
-  def for_this
-    yield self
-  end
-
-  def get_nth(*arg) r=nil; nth(*arg) do |bl| r=bl end; r; end
-
-  def get_first(*arg) r=nil; first(*arg) do |bl| r=bl end; r; end
-
-  def tagexist?(tag,st=0)
-    s=find_element(tag,st)
-    if s then true else false end
-  end
-
-  def tagnext
-    s=@text.index("<")
-    return nil unless s
-    e=@text.index(">",s)
-    return nil unless s
-    @text[s..e].scan(/[^<>\s]+/)[0]
-  end
-
-  def nth_tailer(tag,n)
-    nth(tag,n) do end
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-require 'test/unit'
-
-class TC_TagIterator < Test::Unit::TestCase
-
-  STEXT = <<-EOS
-  <body> This is a test...
-    <sub> S1 </sub> <sub> S2 </sub>
-    <DL>
-      <DT> A1
-      <DT> A2
-      <DT> A3
-    </DL>
-    <DL>
-      <DT> B1
-      <DT> B2
-      <DT> B3
-    </DL>
-    <NEST>
-      <P ALIGN="R">TOP</P>
-      <NEST>
-        <P>SECOND</P>
-        <OL>
-          <LI>C1
-          <LI>C2
-          <LI>C3
-          <LI>C4
-        </OL>
-      </NEST>
-      <OL>
-        <LI>D1
-        <LI>D2
-        <LI>D3
-        <LI>D4
-      </OL>
-    </NEST>
-  </body>
-  EOS
-
-  def test_all
-    assert_nothing_raised{ @a = TagIterator.new( STEXT ) }
-    @f = []
-    assert_nothing_raised {
-      @a.first("body") do |y|
-        y.nth("dl",2) do |dl|
-          dl.enumtag("dt") do |t|
-            @f << t.text.strip
-          end
-        end
-        y.first("nest") do |n|
-          n.first("p") do |c|
-            @f << c.text
-            @f.concat c.attributes.collect{ |k,v| "#{k}=#{v}" }
-          end.next("nest") do |m|
-            m.first("p") do |c|
-              @f << c.text
-            end.next("ol") do |o|
-              o.enumtag("li") do |i| @f << i.text.strip end
-            end
-          end.next("ol") do |o|
-            o.enumtag("li") do |i| @f << i.text.strip end
-          end
-        end
-      end
-      @a.each_block("sub") do |y|
-        @f << y.text.strip
-      end
-    }
-    o = [ "B1", "B2", "B3",
-          "TOP", "align=R", "SECOND",
-          "C1", "C2", "C3", "C4",
-          "D1", "D2", "D3", "D4",
-          "S1", "S2" ]
-    assert_equal( o, @f )
-  end
-
-end
-
-=end