mack-facets 0.8.2 → 0.8.3

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

@@ -1,136 +0,0 @@
-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

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

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