revolt 0.5.1

data/bin/rv_install_level_urls.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/ruby
+#
+require 'optparse'
+require 'pp'
+require 'revolt'
+require 'set'
+
+
+def main
+  @cmd = CmdArguments.new(ARGV)
+
+  @summary = {
+    :installed => [],
+    :skipped   => [],
+    :exists    => [],
+    :error_url => [],
+  }
+  
+  # Setup some callbacks so that progress is reported
+  ReVolt::global_args = REPORTING_ARGS 
+  
+  ReVolt::Logger::enable if @cmd[:debug]
+  @levels   = ReVolt::Levels.at(@cmd[:base])
+  tmplevels = ReVolt::Levels.new(ReVolt::Util::tmpdir + 'rv_install_level')
+  # Delete any tmplevel directory if it existed
+  tmplevels.base_path.rmtree
+  tmplevels.create_dir_structure
+  
+  puts "Enter track URLs to install. Press Ctrl+D to install."
+  input_open(@cmd[:input]) do |input|
+    input.each_line do |tracksrc|
+      tmplevels.install_urls tracksrc
+    end
+  end
+  
+  puts "Installing tracks"
+  tmplevels.each do |level|
+    # Install only levels that do not exist already
+    if !@cmd[:force] && @levels.member?(level)
+      puts "Skipping installing of " + level.to_s + " because it exists"
+      @summary[:exists] << level
+    else 
+      puts "Installing level " + level.to_s
+      level.move_to @levels
+      @summary[:installed] << level
+    end
+  end
+  
+  # Output summary of installed tracks.
+  puts
+  puts "Summary"
+  puts "-------"
+  unless @summary[:installed].empty?
+    puts "Installed Tracks:"
+    @summary[:installed].each {|l| puts "  #{l}"}  
+  end
+  unless @summary[:skipped].empty?
+    puts "Likely exists (use option -f to force installing):"
+    @summary[:skipped].each {|(l,u)| puts "  #{l} [name from URL #{u}]}"}  
+  end
+  unless @summary[:exists].empty?
+    puts "Already exists (use option -f to force installing):"
+    @summary[:exists].each {|l| puts "  #{l}"}  
+  end
+  unless @summary[:error_url].empty?
+    puts "Errors installing URLs:"
+    @summary[:error_url].each {|(e,u)| puts "  #{u}: #{e}"}  
+  end
+  
+  ReVolt::Logger::debug "Removing uninstalled tracks"
+  
+  # Remove any remaining files from the temporary directory
+  tmplevels.each do |level|
+    ReVolt::Logger::debug "Removing uninstalled level " + 
+      level.to_s + " from temporary levels"
+    level.delete
+  end
+end
+
+# Opens input file safely so that it gets closed too,
+# and uses STDIN without the closing command otherwise
+def input_open(input)
+  input   = File.open(input) if input
+  input ||= STDIN
+  yield input
+ensure
+  input.close unless input == STDIN
+end
+
+
+# Expects @levels instance variable
+def track_installed?(url)
+  return false if @cmd[:force]
+  trackname = $1 if url =~ /dload\.php\?trackname=([^\&]+)/
+  return false if !trackname
+
+  urltrackname = URI::decode(trackname) # ).gsub!(/\+/, ' ')
+  trackname    = normalize_track_name(urltrackname)
+  ReVolt::Logger::debug "Normalized track name to #{trackname}"
+  @levels.each_custom do |level|
+    levelname = normalize_track_name(level.name)
+    if trackname == levelname
+      ReVolt::Logger::debug "Match #{trackname} -> #{levelname}"
+      puts "URL probably already installed as #{level}, skipping (use -f option to force install)"
+      @summary[:skipped] << [level,urltrackname]
+      return true
+    end
+  end
+  
+  false
+end
+
+def normalize_track_name(s)
+  t = s.chomp
+  t.downcase!
+  # Remove 'by someone' from the end
+  t.gsub!(/ +by +.*$/, '')
+  # Remove all special characters
+  t.gsub!(/[^a-z0-9]+/, '')
+  t
+end
+
+# Callbacks for different stages of track installing
+REPORTING_ARGS = {
+  ReVolt::ARG_INSTALL_URL => lambda {|url|
+    # Often people copy-paste a link to RVZT comment section,
+    # so in that case automatically make a download link of it
+    url = url.to_s.sub(/comments.php/, 'dload.php')
+    puts "Installing URL #{url}"
+    # Only install tracks that most likely haven't already been
+    # installed. The track_installed? takes the URL and tries
+    # using a heuristic to determine if similar track is installed
+    track_installed?(url) ? nil : url
+  },
+  ReVolt::ARG_INSTALL_URL_EX => lambda {|e,url|
+    # Called if exception raised when installing url
+    @summary[:error_url] << [e,url]
+    puts "Error installing: #{e}"
+  },  
+  ReVolt::ARG_FETCHER_PROGRESS => lambda {|obj,url,nread,total|
+    $now = Time.new().sec()
+    if !$last or $now - $last > 1 then
+      puts '%.2f%% (%d/%d bytes) downloaded' % 
+           [(total > 0 ? nread*100/total : 0), nread, total]
+      $last = $now
+    end
+  },
+  ReVolt::ARG_FETCHER_STOP => lambda {|obj,url,total|
+    $last = nil
+    ReVolt::call_arg(ReVolt::ARG_FETCHER_PROGRESS, {}, obj, url, total, total)
+  }
+}
+
+class CmdArguments < Hash
+  def initialize(cmd)
+    super()    
+    inf_matches = []
+    self[:base] = ReVolt::Info::path
+    
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #$0 [options]\n"
+      opts.separator "By default the URLs are read from standard console input"
+
+      opts.separator ""  
+      opts.separator "Options:"  
+
+      opts.on('-i', '--input [FILE]', 
+              'Reads the URLs from given file') do |value|
+        self[:input] = value
+      end
+      opts.on('-b', '--base [DIR]',
+              'RV base path. Defaults to RV installation') do |value|
+        self[:base] = value
+      end
+      opts.on('-f', '--force',
+              'Forces installing of tracks') do
+        self[:force] = true
+      end
+
+      opts.on_tail('-h', '--help',
+                   'Display this help and exit') do
+        puts opts
+        exit(1)
+      end
+    end
+  
+    opts.parse!(cmd)
+  end
+end
+
+main

data/bin/rv_install_levels.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/ruby
+#
+require 'optparse'
+require 'pp'
+require 'revolt'
+require 'set'
+
+
+def main
+  cmd = CmdArguments.new(ARGV)
+
+  ReVolt::Logger::enable if cmd[:debug]
+  levels    = ReVolt::Levels.at(cmd[:base])
+  
+  levelids = []
+  ARGV.each do |levelpackage|
+    puts "Installing #{levelpackage}"
+    levelids += levels.install(levelpackage) || []
+  end
+  puts "Installed levels: " if levelids.size > 0
+  levelids.each do |levelid|
+    level = levels[levelid]
+    puts "  #{level}" if level
+  end
+end
+
+# Opens input file safely so that it gets closed too,
+# and uses STDIN without the closing command otherwise
+def input_open(input)
+  input   = File.open(input) if input
+  input ||= STDIN
+  yield input
+ensure
+  input.close unless input == STDIN
+end
+
+class CmdArguments < Hash
+  def initialize(cmd)
+    super()    
+    inf_matches = []
+    self[:base] = ReVolt::Info::path
+    
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #$0 [options] package1 [package2 ...]\n"
+      opts.separator "By default the URLs are read from standard console input"
+
+      opts.separator ""  
+      opts.separator "Options:"  
+
+      opts.on('-d', '--debug', 
+              'Writes debugging information') do
+        self[:debug] = true
+      end
+      opts.on('-b', '--base [DIR]',
+              'RV base path. Defaults to RV installation') do |value|
+        self[:base] = value
+      end
+
+      opts.on_tail('-h', '--help',
+                   'Display this help and exit') do
+        puts opts
+        exit(1)
+      end
+    end
+  
+    opts.parse!(cmd)
+    
+    if ARGV.size <= 0
+      puts opts
+      exit(1)
+    end
+  end
+end
+
+
+main

data/examples/find_rv_track.rb

@@ -0,0 +1,17 @@
+require 'revolt'
+
+# Very simple example of how to find a track
+# with some name (case insensitive).
+
+search_for = ARGV[0]
+unless search_for
+  STDERR.puts "Usage: #{$0} track_name_search_pattern"
+  exit(1)
+end 
+
+levels    = ReVolt::Levels.installed
+levels.each_level do |level|
+  if level.name.match(/#{search_for}/i)
+    puts "Level matched: " + level.to_s
+  end
+end

data/examples/install_rv_track.rb

@@ -0,0 +1,28 @@
+require 'revolt'
+
+levels    = ReVolt::Levels.installed
+tmplevels = ReVolt::Levels.at('./tmp')
+tmplevels.create_dir_structure
+
+# Install to temporary levels dir first
+STDIN.each_line do |tracksrc|
+  puts "Installing: " + tracksrc + " to temporary levels directory"
+  tmplevels.install tracksrc
+end
+
+tmplevels.each do |level|
+  # Install only levels that do not exist already
+  if levels.member? level
+    puts "Skipping installing of " + level.to_s + " because it exists"
+  else 
+    puts "Installing level " + levels.to_s
+    level.move_to levels
+  end
+end
+
+# Remove any remaining files from the temporary directory
+tmplevels.each do |level|
+  puts "Removing uninstalled level " + level.to_s + " from temporary levels"
+  level.delete
+end
+

data/lib/revolt/args.rb

@@ -0,0 +1,46 @@
+module ReVolt
+  @@global_args = {}
+
+  ARG_INSTALL_URL      = :install_url
+  ARG_INSTALL_URL_EX   = :install_url_ex
+  ARG_FETCHER_PROGRESS = :fetcher_progress
+  ARG_FETCHER_START    = :fetcher_start
+  ARG_FETCHER_STOP     = :fetcher_stop
+    
+  module_function
+  
+  def global_args
+    @@global_args
+  end
+  def global_args=(o)
+    @@global_args = (o.is_a?(Hash) ? o : {})
+  end
+  
+  def arg(id, args = {})
+    return args[id] if args.member?(id)
+    return @@global_args[id] if @@global_args.member?(id)
+    nil
+  end
+  def call_arg(id, args, *params)
+    a = arg(id, args)
+    a.call(*params) if a
+  end
+  def call_changer_arg(id, args, *params)
+    a = arg(id, args)
+    a ? a.call(*params) : params
+  end
+  
+  # Calls the defined callback if the block raises Runtime error
+  # and otherwise rethrows it
+  def arg_ex_watch(id, args, *rest)
+    begin
+      yield
+    rescue RuntimeError => e
+      if arg(id, args)
+        call_arg(id, args, e, *rest)
+      else
+        raise e
+      end
+    end
+  end
+end

data/lib/revolt/config.rb

@@ -0,0 +1,5 @@
+module ReVolt
+  module Config
+    # For now nothing
+  end
+end

data/lib/revolt/exceptions.rb

@@ -0,0 +1,34 @@
+require 'pathname'
+
+module ReVolt
+
+  # All exceptions derived from RVException
+  class RVException < RuntimeError; end
+
+  # Thrown if a file is not found. The file can
+  # be accessed via an attribute if necessary
+  class FileNotFoundError < RVException
+    attr_reader :file
+    def initialize(filename)
+      @file = filename.to_s
+    end
+  end
+
+  # Thrown if level's .inf file was not found
+  # when needed.
+  class InfFileNotFoundError < FileNotFoundError
+    attr_reader :levels, :level
+    def initialize(levels, level, inf_file)
+      super inf_file
+      @levels, @level = levels, level
+    end
+  end
+
+  # Thrown if an unknown package was tried to be
+  # operated on.
+  class PackageUnknownError < RVException; end
+  # Thrown if no Fetcher could be created for
+  # the given source.
+  class FetcherNoneError    < RVException; end
+  class InvalidLevelIdError < RVException; end
+end # module ReVolt

data/lib/revolt/fetcher/file_system.rb

@@ -0,0 +1,31 @@
+require 'pathname'
+
+require 'revolt/exceptions'
+require 'revolt/logger'
+
+module ReVolt
+  module Fetcher
+    
+    class FileSystem
+      include ReVolt::Logger
+
+      attr_reader :target, :source
+
+      def initialize(id, args = {})
+        debug("Source id: #{id} size #{id.size}")
+        @source    = Pathname.new(id.to_s)
+      end
+
+      # Possible exceptions:
+      # FileNotFoundError
+      def run(args = {})
+        debug Dir['*'].join(" ")
+        
+        raise ReVolt::FileNotFoundError.new(@source),
+        "File #{source} not found" unless File.exist?(@source.to_s) # @source.exist?
+
+        @target = @source
+      end
+    end # FileSystem
+  end # Fetcher
+end # ReVolt

data/lib/revolt/fetcher/www.rb

@@ -0,0 +1,117 @@
+require 'pathname'
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'set'
+
+require 'revolt/exceptions'
+require 'revolt/util'
+require 'revolt/logger'
+require 'revolt/args'
+
+module ReVolt
+  module Fetcher
+    
+    class WWW
+      include ReVolt::Logger
+
+      class TooManyRedirectionsError < ReVolt::RVException; end
+
+      attr_reader :target, :source, :final_uri
+      def initialize(id, args = {})
+        @@file_name_count = 0
+        @max_redirects = 3
+
+        @source    = (id.is_a?(URI) ? id : URI.parse(id.to_s))
+      end
+
+      # Possible exceptions:
+      # TooManyRedirections
+      def run(args = {})
+        fetch(@source) do |resp,final_uri|
+          # debug "Headers: "
+          # resp.each {|key,val| debug "#{key}: #{val}"}
+          @target = ReVolt::Util::tmpdir
+          @target += generate_basename_from final_uri
+
+          debug "Saving to target #{@target}"
+
+          total = resp.content_length
+          total ||= 0
+          nread = 0
+          debug "Total size: " + total.to_s
+
+          ReVolt::call_arg(ReVolt::ARG_FETCHER_START, args, 
+                           self, @source, total)
+
+          open(@target, 'wb') do |file|
+            resp.read_body do |segment|
+              debug("%s: read %d/%d bytes read" %
+                      [@source.to_s, nread, total])
+              ReVolt::call_arg(ReVolt::ARG_FETCHER_PROGRESS, args, 
+                               self, @source, nread, total)
+              file.syswrite segment
+              nread += segment.size
+            end
+          end
+
+          ReVolt::call_arg(ReVolt::ARG_FETCHER_STOP, args, 
+                           self, @source, nread)
+
+          debug "Saved to target #{@target}"
+        end
+      end
+
+      def fetch(uri, args = {}, &block)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+
+        debug "Fetching #{uri}"
+
+        req = Net::HTTP::Get.new(uri.request_uri)
+        urls_seen = args[:urls_seen] || Set.new
+        http.request(req) do |resp|
+          if resp.is_a? Net::HTTPRedirection
+            debug "Is a redirection. Location: " + resp['Location']
+            new_loc = resp['Location']
+            if urls_seen.size < @max_redirects && new_loc
+              urls_seen << uri
+              new_uri = URI.parse new_loc
+              new_uri = uri.merge new_uri if new_uri.relative?
+
+              if urls_seen.member? new_uri
+                raise TooManyRedirectionsError, 
+                "Too many redirections (max #{@max_redirects}): #{urls_seen}" 
+              end
+
+              fetch(new_uri, args, &block)
+            end
+          else
+            debug "Final uri: " + uri.to_s
+            yield resp,uri
+          end
+        end
+      end
+
+      def generate_basename_from(uri)
+        uri  = URI.parse uri unless uri.is_a? URI
+        name = Pathname.new uri.path.downcase
+        name = name.basename
+
+        # If the gotten name looks safe, use it as the
+        # basename. Otherwise use generated sequence.
+        if name.to_s =~ /^[^\.][\w\.]+/
+        else
+          name = "rvfetcher" + @@file_name_count.to_s
+          @@file_name_count += 1
+        end
+
+        name
+      end
+      
+      def to_i
+        'WWW Fetcher'
+      end
+    end # WWW
+  end # Fetcher
+end # ReVolt

data/lib/revolt/fetcher.rb

@@ -0,0 +1,30 @@
+require 'revolt/fetcher/www'
+require 'revolt/fetcher/file_system'
+require 'revolt/exceptions'
+
+module ReVolt
+  # Internally used module that shouldn't usually be needed
+  # to call directly
+  module Fetcher
+    include ReVolt
+
+    module_function
+
+    # Factory method for creating a specific fetcher.
+    # At the moment recognizes http(s) and basically
+    # others are treated as files on local filesystem
+    def for(id, args = {})
+      clas = nil
+      case id.to_s
+      when /^http[s]?/
+        clas = WWW
+      when /^ftp:\/\//
+        raise FetcherNoneError, "No fetcher for FTP sites implemented: #{id}"
+      else
+        clas = FileSystem
+      end
+
+      return clas.new(id, args)
+    end
+  end # Fetcher
+end # ReVolt

data/lib/revolt/info.rb

@@ -0,0 +1,40 @@
+require 'win32/registry'
+
+module ReVolt
+
+  # Contains functions that can be used to find
+  # information about the Re-Volt installation
+  module Info
+    RV_REG_KEY      = 'SOFTWARE\Acclaim\Re-Volt\1.0'
+    RV_REG_KEY_PATH = 'SOFTWARE\Microsoft\DirectPlay\Applications\Re-Volt'
+       
+    module_function 
+
+    def reg_path_to_hash(key) # :nodoc:
+      h = {}
+      Win32::Registry::HKEY_LOCAL_MACHINE.open(key) do |root|
+        # puts "Root keyname: #{root.keyname}, hkey: #{root.class}"
+        root.each do |key, type, data|
+          h[key.to_s.downcase.to_sym] = data
+          # puts 'key: %s, type: %s, data: %s' % [key, type, data]
+        end
+      end
+      h
+    end
+   
+    # Returns full path of the Re-Volt base directory
+    def path
+      h = reg_path_to_hash(RV_REG_KEY_PATH)
+      p = Pathname.new(h[:path])
+      p
+    end
+
+    # Returns full path of the Re-Volt executable
+    def exe_path
+      h = reg_path_to_hash(RV_REG_KEY_PATH)
+      p = Pathname.new(h[:path])
+      p += h[:file]
+      p
+    end
+  end # Info
+end # ReVolt