RubyGems - mack-facets - Versions diffs - 0.8.1 → 0.8.2 - Mend

mack-facets 0.8.1 → 0.8.2

Files changed (492) hide show

data/lib/gems/facets-2.4.5/lib/more/facets/tagiter.rb ADDED

@@ -0,0 +1,366 @@
+# = 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

data/lib/gems/facets-2.4.5/lib/more/facets/thread.rb ADDED

@@ -0,0 +1,51 @@
+# = Thread Related Extensions
+#
+# Thread extensions, in particular for Enumerable --send
+# a message to each member via a thread and collect the results.
+#
+# == Authors
+#
+# * Sean O'Halpin
+#
+# == Todo
+#
+# * Better names for these methods ?
+#
+# == Copying
+#
+# Copyright (c) 2006 Sean O'Halpin
+#
+# 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.
+require 'thread'
+require 'facets/enumerable/map_send'
+module Enumerable
+  # Like Enumerable#map but each iteration is processed via
+  # a separate thread.
+  #
+  #  CREDIT Sean O'Halpin
+  def threaded_map #:yield:
+    map{ |e| Thread.new(e){ |t| yield(t) } }.map{ |t| t.value }
+  end
+  # Like Enumerable#map_send but each iteration is processed via
+  # a separate thread.
+  #
+  #  CREDIT Sean O'Halpin
+  def threaded_map_send(meth, *args, &block)
+    map{ |e| Thread.new(e){ |t| t.send(meth, *args, &block) } }.map{ |t| t.value }
+  end
+end

data/lib/gems/facets-2.4.5/lib/more/facets/timer.rb ADDED

@@ -0,0 +1,274 @@
+# = Timer
+#
+# Provides a strightforward means for controlling time critical execution.
+# Can be used as a "stop watch" timer or as a "time bomb" timer.
+#
+# == Usage
+#
+#   t = Timer.new(10) { raise TimeoutError, "timeout!" }
+#   t.start
+#     :      # done within 10sec timeout
+#   t.stop
+#   t.start
+#     :
+#   if condition then
+#     t.reset       #--> restart timer
+#   end
+#
+# A Kernel method is also provided for easily timing the exectuion of a block.
+#
+#   timed { |timer|
+#
+#      timer.total_time.round #=> 0
+#
+#      sleep 1
+#      timer.total_time.round #=> 1
+#
+#      timer.stop
+#      timer.total_time.round #=> 1
+#
+#      sleep 2
+#      timer.total_time.round #=> 1
+#
+#      timer.start
+#      timer.total_time.round #=> 1
+#
+#      sleep 1
+#      timer.total_time.round #=> 2
+#
+#   }
+#
+# == HISTORY
+#
+# Thanks to Paul Brannan for TimeLimit and Minero Aoki for Timer.
+# These two libraries served as models for building this class.
+#
+# == AUTHORS
+#
+# * Thomas Sawyer
+# * Minero Aoki
+# * Paul Brannan
+#
+# == COPYRIGHT
+#
+#   Copyright (c) 2004 Thomas Sawyer
+#
+# == LICENSE
+#
+#   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.
+require 'timeout'  # for TimeoutError
+# = Timer
+#
+# Provides a strightforward means for controlling time critical execution.
+# Can be used as a "stop watch" timer or as a "time bomb" timer.
+#
+#   t = Timer.new(10) { raise TimeoutError, "timeout!" }
+#   t.start
+#     :      # done within 10sec timeout
+#   t.stop
+#   t.start
+#     :
+#   if condition then
+#     t.reset       #--> restart timer
+#   end
+#
+# A Kernel method is also provided for easily timing the exectuion of a block.
+#
+#   timed { |timer|
+#      timer.total_time.round #=> 0
+#
+#      sleep 1
+#      timer.total_time.round #=> 1
+#
+#      timer.stop
+#      timer.total_time.round #=> 1
+#
+#      sleep 2
+#      timer.total_time.round #=> 1
+#
+#      timer.start
+#      timer.total_time.round #=> 1
+#
+#      sleep 1
+#      timer.total_time.round #=> 2
+#   }
+class Timer
+  attr_reader :start_time, :end_time
+  attr_accessor :time_limit
+  def initialize( time_limit=nil, &block )
+    # standard timer
+    @start_time = nil
+    @end_time = nil
+    @total_time = 0
+    @runnning = nil
+    # for using time limit
+    @time_limit = time_limit
+    @on_timeout = block
+    @current_thread = nil
+    @timer_thread = nil
+  end
+  def on_timeout( &block )
+    if block then
+      @on_timeout = block
+      true
+    else
+      false
+    end
+  end
+  # Start the timer.
+  def start
+    @running = true
+    @start_time = Time.now
+    limit if @time_limit
+    self
+    #if block_given? then
+    #  begin
+    #    yield( self )
+    #  ensure
+    #    stop
+    #  end
+    #else
+    #  @time_limit
+    #end
+  end
+  # Establish a time limit on execution.
+  def limit( time_limit=nil )
+    if @time_limit || time_limit
+      @current_thread = Thread.current
+      @timer_thread = Thread.fork {
+        sleep @time_limit
+        if @on_timeout then
+          @on_timeout.call @time_limit
+        else
+          @current_thread.raise TimeoutError, "#{@time_limit} seconds past"
+        end
+      }
+    end
+  end
+  # Kill time limit thread, if any.
+  def defuse
+    if @timer_thread
+      Thread.kill @timer_thread
+      @timer_thread = nil
+    end
+  end
+  # Stops timer and returns total time.
+  # If timer was not running returns false.
+  def stop
+    if @running
+      defuse
+      # record running time
+      @end_time = Time.now
+      @running = false
+      @total_time += (@end_time - @start_time)
+    else
+      nil
+    end
+  end
+  # Stops and resets the timer. If the timer was running
+  # returns the total time. If not returns 0.
+  def reset
+    if running?
+      r = stop
+    else
+      r = 0
+    end
+    @total_time = 0
+    return r
+  end
+  # Resets the time limit. Same as:
+  #
+  #   t.stop
+  #   t.start
+  #
+  def reset_limit
+    #stop
+    #start
+    defuse
+    limit
+  end
+  # Queries whether the timer is still running.
+  def running?
+    return @running
+  end
+  # Queries whether the timer is still not running.
+  def stopped?
+    return !@running
+  end
+  # Queries total recorded time of timer.
+  def total_time
+    if running? then
+      return @total_time + (Time.now - @start_time)
+    else
+      return @total_time
+    end
+  end
+  #
+  # Timer::Dummy - Dummy Timer (i.e. no real time limit)
+  #--
+  # NEEDS WORK!
+  #++
+  class Dummy < self
+    def start
+      if block_given? then
+        yield
+      else
+        time_limit()
+      end
+    end
+    def stop
+      false
+    end
+  end #class Dummy
+end #class Timer
+module Kernel
+  # Takes a block and returns the total time it took to execute.
+  def timed
+    yield( timer = Timer.new.start )
+    return timer.total_time
+  end
+end