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

mack-facets 0.8.1 → 0.8.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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