facets 0.9.0 → 1.0.0

data/lib/mega/downloader.rb

@@ -1,240 +0,0 @@
-# Baker - The Delicious Program Maker
-# (c)2003 PsiT Corporation, LGPL
-
-# LICENSE HERE
-
-require 'digest/md5'
-require 'open-uri'
-require 'progressbar'
-require 'nano/string/unbracket'
-
-#class DownloadError < StandardError ; end
-
-# :title: Downloader
-#
-# This is module of tools for downloading and extracting
-# archived files.
-
-class Downloader
-
-  class Mirror
-    def initialize( url, region=nil )
-      @url = url
-      @region = region
-      @interface = nil
-    end
-    attr_accessor :url, :region
-  end
-
-  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
-
-  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 :( we'll see :)
-  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, 'w' )
-      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/mega/dynamod.rb

@@ -1,249 +0,0 @@
-#--
-# Dynamic Module
-#
-# Copyright (c) 2005 George Moschovitis and 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.
-#
-# ==========================================================================
-# Revision History ::
-# --------------------------------------------------------------------------
-#  2005.09.19  trans     * Cleaned up and renamed.
-#  2005.04.28  trans     * Added to Mega Modules
-# ==========================================================================
-#
-# TODO include parameters may need to be kept separate from include
-# parameters. Currently they are clobbering one another --which must be
-# fixed.
-#++
-
-#:title: Dynamic Module
-#
-# Provides a construction mechinism for creating dynamically generated
-# module features as well as instance accessible module parameters which
-# can be set at the time of inclusion or extension.
-#
-# == Example
-#
-# To create a dynamic feature use the #dyanmic_feature method defining a block
-# which returns a block or string to by evaluated into the modules body upon
-# inclusion or extension.
-#
-#
-#   module Mixin
-#
-#     dynamic_feature do |options|
-#
-#         define_method :hello do
-#           puts "Hello from #{options[:name]}"
-#         end
-#
-#     end
-#
-#   end
-#
-#   class MyClass
-#     include Mixin, :name => 'Ruby'
-#   end
-#
-#   m = MyClass.new
-#   m.hello -> 'Hello from Ruby'
-#
-# While it is prefereable to use a block, you can also provide a string.
-#
-#   module Mixin
-#
-#     dynamic_feature do |options| %/
-#
-#         def hello
-#           puts "Hello from #{options[:name]}"
-#         end
-#
-#     /end
-#
-#   end
-#
-#   class MyClass
-#     include Mixin, :name => 'Ruby'
-#   end
-#
-#   m = MyClass.new
-#   m.hello -> 'Hello from Ruby'
-#
-# == Author(s)
-#
-# * George Moschovitis
-# * Thomas Sawyer
-#
-
-class Module
-
-  def dynamic_feature( &blk )
-    (@module_features ||= []) << blk
-  end
-
-  # Store for a module's dynamic features.
-  def module_features ; @module_features ||= [] ; end
-
-  # Store for module parameters. This is local per module
-  # and indexed on module/class included-into.
-  def module_parameters ; @module_parameters ||= {} ; end
-
-  alias_method :include_without_dynamic_features, :include
-
-  def include(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    for mod in args
-      module_parameters[mod] = options
-      mod.append_dynamic_features( self, options )
-    end
-    include_without_dynamic_features(*args)
-  end
-
-  def append_dynamic_features( base, options )
-    # module_options
-    mod = self
-    define_method( :module_options ) do |key|
-      base.module_parameter_get( mod, key )
-    end
-    # dynamic features
-    module_features.each do |mf|
-      eingenclass = (class << base; self; end)
-      eingenclass.class_eval {
-        define_method( :_explode, &mf )
-      }
-      r = base._explode(options)
-      eingenclass.class_eval {
-        remove_method( :_explode )
-      }
-      # if it is a string block
-      base.class_eval r if r.is_a?(String)
-    end
-  end
-
-  alias_method :extend_without_dynamic_features, :extend
-
-  def extend(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    for mod in args
-      module_parameters[mod] = options
-      mod.extend_dynamic_object( self, options )
-    end
-    extend_without_dynamic_features(*args)
-  end
-
-  # Note: Is this the best name for this callback?
-  def extend_dynamic_object( base, options )
-    # module_options
-    mod = self
-    eingenclass = (class << base; self; end)
-    eingenclass.__send__(:define_method, :module_options ) do |key|
-      base.module_parameter_get( mod, key )
-    end
-    module_features.each do |mf|
-      eingenclass.class_eval {
-        (class << self; self; end).__send__(:define_method, :_explode, &mf )
-      }
-      r = eingenclass._explode(options)
-      eingenclass.class_eval {
-        (class << self; self; end).__send__(:remove_method, :_explode )
-      }
-      # if it is a string block
-      eingenclass.class_eval r if r.is_a?(String)
-    end
-  end
-
-#   # Defines a instance attribute linked to a specific module parameter.
-#   def attr_parameter( *opts )
-#     hopts = opts.pop if Hash === opts.last
-#     opts.each { |k| hopts[k] = nil }
-#     mod = self
-#     hopts.each { |key, default|
-#       self.instance_eval {
-#         define_method( key ) do
-#           self.class.module_parameter_get( mod, key ) || default
-#         end
-#       }
-#     }
-#   end
-
-  # Convenice method for looking up a parameter
-  def module_parameter_get( mod, key )
-    if self.module_parameters.key?(mod)
-      self.module_parameters[mod][key]
-    else
-      anc = self.ancestors[1]
-      if anc
-        anc.module_parameter_get( mod, key )
-      end
-    end
-  end
-  #protected :module_parameter_get
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC01 < Test::Unit::TestCase
-
-    module M
-      dynamic_feature do |opt|
-        define_method :f do
-          opt[:p]
-        end
-      end
-    end
-    class C
-      include M, :p => "check"
-    end
-
-    def test_01_001
-      assert_equal( "check", C.new.f )
-    end
-  end
-
-  class TC02 < Test::Unit::TestCase
-    module M
-      def f ; module_options(:s) ; end
-    end
-    class C
-      include M, :s => "check 123"
-    end
-
-    def test_02_001
-      assert_equal( "check 123", C.new.f )
-    end
-  end
-
-  class TC03 < Test::Unit::TestCase
-    module M
-      def f ; module_options(:q) ; end
-    end
-    class C
-      extend M, :q => "check 123"
-    end
-
-    def test_03_001
-      assert_equal( "check 123", C.f )
-    end
-  end
-
-=end