mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/dictionarymatcher.rb

@@ -0,0 +1,136 @@
+class DictionaryMatcher
+  attr_reader :word_count
+
+  #Contains the index matched, and the word matched
+  class MatchData < Struct.new(:index,:match)
+    def inspect
+      "#{match.inspect}@#{index}"
+    end
+  end
+
+  def inspect
+    to_s
+  end
+
+  #Create a DictionaryMatcher with no words in it
+  def initialize
+    @trie = {}
+    @word_count = 0
+  end
+
+  #Add a word to the DictionaryMatcher
+  def add(word)
+    @word_count += 1
+    container = @trie
+    containers=[]
+
+    i=0
+    word.each_byte do |b|
+      container[b] = {} unless container.has_key? b
+      container[:depth]=i
+      containers << container
+      container = container[b]
+      i+=1
+    end
+    containers << container
+
+    container[0] = true # Mark end of word
+    container[:depth]=i
+     
+    ff=compute_failure_function word
+    ff.zip(containers).each do |pointto,container|
+      container[:failure]=containers[pointto] if pointto
+    end
+
+    self
+
+  end
+
+  alias << add
+
+  def compute_failure_function p
+    m=p.size
+    pi=[nil,0]
+    k=0
+    2.upto m do |q|
+      k=pi[k] while k>0 and p[k] != p[q-1]
+      k=k+1 if p[k]==p[q-1]
+      pi[q]=k
+    end
+    pi
+  end
+  private :compute_failure_function
+
+   #Determine whether +string+ was previously <tt>add</tt>ed to the 
+   #Trie.
+  def include?(word)
+    container = @trie
+    word.each_byte do |b|
+      break unless container.has_key? b
+      container = container[b]
+    end
+    container[0]
+  end
+
+   #Determines whether one of the words in the DictionaryMatcher is a 
+   #substring of
+   #+string+. Returns the index of the match if found, +nil+ if not 
+   #found.
+  def =~ text
+    internal_match(text){|md| return md.index}
+    nil
+  end
+
+   #Determine whether one of the words in the DictionaryMatcher is a 
+   #substring of
+   #+string+. Returns a DictionaryMatcher::MatchData object if found, 
+   #+nil+ if not #found.
+  def match text
+    internal_match(text){|md| return md}
+    nil
+  end
+
+  def internal_match string
+      node=@trie
+      pos=0
+      string.each_byte do |b|
+	 advance=false
+	 until advance
+	    nextnode=node[b]
+	    if not nextnode
+	       if node[:failure]
+		  node=node[:failure]
+	       else
+		  advance=true 
+	       end
+	    elsif nextnode[0]
+	       yield MatchData.new(pos, string[pos+1-nextnode[:depth],nextnode[:depth]])
+	       advance=true
+	       node=@trie
+	    else
+	       advance=true
+	       node=nextnode
+	    end
+	    pos+=1
+	 end
+      end
+  end
+  private :internal_match
+
+   #Scans +string+ for all occurrances of strings in the 
+   #DictionaryMatcher.
+   #Overlapping matches are skipped (only the first one is yielded), and 
+   #when some strings in the
+   #DictionaryMatcher are substrings of others, only the shortest match 
+   #at a given position is found.
+  def scan(text, &block)
+    matches=[]
+    block= lambda{ |md| matches << md } unless block
+    internal_match(text,&block)
+    matches
+  end
+
+  #Case equality. Similar to =~.
+  alias_method :===, :=~
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/downloader.rb

@@ -0,0 +1,281 @@
+# = Downloader
+#
+# Tool module for downloading files and extracting
+# archive files. Currently this is console-based
+# but in the future will have SOC for any interface.
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Todo
+#
+# * Should thre be two classes? The main Downloader which is
+#   independent of any interface. The second "Console::Downloader"
+#   using the first but with a console interface?
+#
+# == Copying
+#
+# Copyright (c) 2005 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.
+
+require 'digest/md5'
+require 'open-uri'
+
+require 'facets/string/bracket' # for unbracket
+require 'facets/progressbar'
+
+# = Downloader
+#
+# Tool module for downloading files and extracting
+# archive files. Currently this is console-based
+# but in the future will have SOC for any interface.
+#
+class Downloader
+
+  #class DownloadError < StandardError #:nodoc:
+  #end
+
+  class Checksum < StandardError #:nodoc:
+  end
+
+  class Mirror #:nodoc:
+    def initialize( url, region=nil )
+      @url = url
+      @region = region
+      @interface = nil
+    end
+    attr_accessor :url, :region
+  end
+
+  # delegate to an interface (under development)
+
+  def interface ; @interface; end
+  def interface=(iface)
+    @interface = iface
+  end
+
+  def initialize( destination, mirrors=nil, region=nil, &config )
+    @destination = destination
+    @mirrors = []
+    add_mirrors( mirrors ) if mirrors
+    @region = (region || 'US').to_s
+    config.call(self) if config
+  end
+
+  attr_accessor :destination, :region
+
+  def add_mirror( url, region=nil )
+    @mirrors << Mirror.new( url, region )
+  end
+
+  def add_mirrors( mirrors )
+    mirrors.each { |mirror|
+      case mirror
+      when String
+        url, rgn = *mirror.strip.split(' ')
+        add_mirror( url, rgn.unbracket )
+      when Array
+        add_mirror( *mirror )
+      when Hash
+        add_mirror( mirror[:url], mirror[:region] )
+      when Mirror
+        @mirrors << mirror
+      else
+        raise "unrecogized mirror definition #{mirror.inspect}"
+      end
+    }
+  end
+
+  def mirrors
+    @mirrors.sort{ |a,b| a.region == region ? 1 : ( b.region == region ? -1 : 0 ) }
+  end
+
+  # fetch
+
+  def fetch( file, checksum=0, est_size=0, force=false )
+    urls = mirrors.collect { |m| "#{m.url.chomp('/')}/#{file}" }
+    urls = prioritize_urls( urls )
+    filepath = "#{destination.chomp('/')}/#{file}"
+    monitored_download( urls, filepath, checksum, est_size, force )
+  end
+
+#   def download_verbose
+#     @download_verbose ||= $VERBOSE
+#     true
+#   end
+#
+#   def download_verbose=(x)
+#     @download_verbose = x ? true : false
+#   end
+
+  # regional_urls - array of arrays of [ url, region, md5, expected_size ]
+  # local_region - region of the user's system
+  # to_dir - where to store downloaded file (full path)
+  # force - download even if file already exists locally
+
+  def monitored_download( urls, filepath, checksum, est_size=0, force=false )
+
+    checksum = checksum.to_s.strip
+    est_size = nil if est_size == 0
+
+    success=nil
+
+    # source file exists and passes checksum then we need not fetch
+    #file_path = File.join(to_dir,File.basename(url[0]))
+    if File.exists?(filepath)
+      if compute_checksum(filepath) == checksum and ! force
+        interface.report("File has already been fetched and passes checksum.")
+        success = filepath
+      else
+        File.delete(filepath)
+      end
+    end
+
+    unless success
+      # download
+      urls.each do |url|
+        begin
+          #file_path = File.join(to_dir,File.basename(url[0]))
+          #file_checksum = url[2].to_s.strip
+          #file_size = url[3].to_i
+          success = self.download( url, filepath, checksum, est_size )
+          break if success
+        rescue
+          next
+        end
+      end
+    end
+
+    return success
+  end
+
+  # In the future we may test each connection for fastest download
+
+  def prioritize_urls( urls )
+    urls
+    # put local region first
+    #prioritized_urls = regional_urls.find_all { |a| a[1] == local_region }
+    #prioritized_urls.concat regional_urls.find_all { |a| a[1] != local_region }
+    #return prioritized_urls
+  end
+
+  # currently can only download a single compressed file
+  # does not handle downloading an uncompressed directory tree (should it? doubt it)
+  #
+  # currently this displays progress to STDOUT; either their should
+  # be a way to activate/deactivate or preferably use ducktype singletons
+  # (more on that later, see google://_whytheluckystiff if interested)
+  # of course I prefer chain messaging but matz said no :(
+
+  def download( url, filepath, checksum='', est_size=nil )
+
+    checksum = checksum.to_s.strip
+    est_size = nil if est_size == 0
+
+    download_complete = nil
+
+    if interface
+      interface.preparing_to_download( File.basename( filepath ), url, est_size )
+    end
+
+    progress_total = est_size ? est_size : 100000000  # pretend 100MB if no size
+    pbar = ProgressBar.new( "Status", progress_total, STDOUT )
+    pbar.bar_mark = "="
+    pbar.format = "%-6s %3d%% %s %s"
+    pbar.file_transfer_mode if est_size
+
+    progress_proc = proc { |posit| pbar.set(posit) }
+
+    STDOUT.sync = true
+    begin
+      local_file = File.open( filepath, 'wb' )
+      remote_file = open( url, :progress_proc => progress_proc )
+      local_file << remote_file.read
+    rescue
+      pbar.halt
+      download_complete = nil
+      raise
+    else
+      pbar.finish
+      download_complete = filepath
+    ensure
+      remote_file.close unless remote_file.nil?
+      local_file.close unless local_file.nil?
+      STDOUT.sync = false
+    end
+
+    unless checksum.empty?
+      raise ChecksumError if compute_checksum(filepath) != checksum
+    end
+
+    if interface
+      if checksum.empty?
+        interface.lacks_checksum( compute_checksum(filepath), :md5 )
+      end
+      unless est_size
+        interface.lacks_size( File.size(filepath) )
+      end
+    end
+
+    if download_complete
+      if interface
+        interface.downloaded( filepath )
+      end
+    end
+
+    return download_complete
+  end
+
+  # compute_checksum
+
+  def compute_checksum( local_path )
+    if File.exists?( local_path )
+      File.open( local_path ) do |local_file|
+        return Digest::MD5.new( local_file.read ).hexdigest
+      end
+    end
+  end
+
+  # extract
+
+  def extract( local_path )
+    success = false
+    local_dir = File.dirname(local_path)
+    local_file = File.basename(local_path)
+    current_dir = Dir.getwd
+    begin
+      Dir.chdir(local_dir)
+      case local_file
+        when /.*gz$/
+          system "tar -xzf #{local_file}"
+        when /.*bz2$/
+          system "tar -xjf #{local_file}"
+        when /.zip$/
+          system "unzip #{local_file}"
+        else
+          success = false
+      end
+    rescue
+      success = false
+    else
+      success = true
+    ensure
+      Dir.chdir(current_dir)
+    end
+    if interface
+      interface.extracted( local_path)
+    end
+    return success
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/duplicable.rb

@@ -0,0 +1,43 @@
+# = Duplicable
+#
+# This is not a mixin, since nearly all objects have this baehavior.
+#
+# Is this the same as immutable? Whould that be a better name?
+
+class Object
+  # Can you safely .dup this object?
+  # False for nil, false, true, symbols, and numbers; true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Symbol #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Numeric #:nodoc:
+  def duplicable?
+    false
+  end
+end