revolt 0.5.1

data/README

@@ -0,0 +1,150 @@
+= Ruby Re-Volt Tools
+A library for easy managing of Re-Volt's files in various ways.
+ 
+== Requirements
+  gem install rubyzip
+
+== Install
+Download the gem:
+  http://users.tkk.fi/~ajalkane/ruby/revolt-0.5.0.gem
+Install it:
+  gem install revolt-0.5.0.gem
+
+== Summary
+For the moment the library mostly has functionality related to
+track management. This may extend in the future.
+
+Using the library users can easily create automated
+tasks. Some of the major features are:
+- Install track packages from WWW server
+- Move, copy and delete tracks
+- Search tracks with various criteria
+- Create alternative track repositories
+
+== Documentation
+Most of the important API documentation is in ReVolt::Levels and ReVolt::Level
+classes. The rest of the library is usually accessed through
+them.
+
+Conventions:
+- methods that return files return Pathname objects.
+
+== Examples
+Here is a listing of some very simple, but illustrative
+examples of how the library could be used.
+
+=== Listing all installed track names
+  require 'revolt'
+  
+  levels = ReVolt::Levels.installed
+  levels.each_level do |level|
+    puts "Level: " + level.name
+  end
+
+=== Installing a track from a web-site
+  require 'revolt'
+  
+  levels = ReVolt::Levels.installed
+  levels.install('http://url.for.track/trackname.zip')
+
+=== Moving all non-favorite custom tracks to c:/removed
+Note that in this example the c:/removed folder has to
+exist. The favorite array has the level names of all
+your favorite tracks that you want to keep, other custom
+tracks are removed. If a filename given as a parameter,
+reads the leves from there. Since the favorite tracks
+are as strings and not as symbol, the level id is 
+changed to string before comparison (favorites.member?(level.id.to_s)
+
+  require 'revolt'
+  
+  favorites = [
+    'alderon',
+    'sakura',
+    're-ville'
+  ]
+  
+  if ARGV[0]
+    favorites = open(ARGV[0]).readlines.map {|l| l.chomp}
+  end
+  levels  = ReVolt::Levels.installed
+  removed = ReVolt::Levels.at('c:/removed')
+  removed.create_dir_structure
+  levels.each_custom do |level|
+    level.move_to(removed) if !favorites.member?(level.id.to_s)
+  end
+
+=== Installing everything that looks like URL
+A bit more complex example. Reads input from the user and 
+tries installing everything that looks like an URL first 
+to a temporary directory. From there copies tracks to 
+installed tracks that do not exist already. This example 
+is useful as it stands for example to install track URLs 
+that are copy pasted to a chat.
+
+  require 'revolt'
+  levels    = ReVolt::Levels.installed
+  tmplevels = ReVolt::Levels.at('./tmp')
+  tmplevels.create_dir_structure
+
+  # Read input from console line by line
+  STDIN.each_line do |possible_urls|
+    tmplevels.install_urls(possible_urls)
+  end
+
+  # Copy the levels that have arrived to tmplevels
+  # into installed levels
+  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 " + level.to_s
+      level.copy_to levels
+    end
+  end
+
+== Applications
+There are a couple of applications distributed with the library
+that are useful on their own
+
+=== rv_install_level_urls.rb
+Reads from the console everything that looks like an URL and tries
+to install it. Useful for installing easily tracks that are copy 
+pasted to a chat. Use the -h switch to see more usage options.
+
+=== rv_install_levels.rb
+Installs track packages that are given as command line parameters.
+The tracks can be on a web-server or on the file system.
+For example if you have in my_tracks directory sakura.zip and
+happy_track.zip that are track packages, you can install them both
+with:
+
+  rv_install_levels.rb my_tracks/sakura.zip my_tracks/happy_track.zip
+
+Or if you want to get a track from web-site use:
+
+  rv_install_levels.rb 'http://somesite.com/the_track_url'
+  
+=== rv_find_levels.rb
+Finds levels by various criteria from installed levels. Basically
+you can find tracks by any property defined in the tracks .inf file.
+The easiest way to use it is to just enter the part of the name of
+the track you want to find. For examples:
+
+  rv_find_levels temple
+
+That would search for all levels whose name contains 'temple' 
+(case insensitive). Another more complex example is to find
+all custom tracks that can be raced in reverse mode that
+have FARCLIP more than 10000:
+  
+  rv_find_levels -m 'custom?,reverse?,farclip>10000'
+  
+Use the -h option to get more help. The output format is:
+
+  <level id> (<level name>) [<matched_attribute>=<matched_value>]
+
+Trying it in practice should clear the syntax if that seems weird.
+
+

data/Rakefile

@@ -0,0 +1,197 @@
+# Rakefile
+require "rake/testtask"
+require "rake/clean"
+require "rake/rdoctask"
+require "rake/gempackagetask"
+
+# The name of your project
+PROJECT = "Re-Volt tools"
+MAIN_NAMESPACE = "ReVolt"
+# Your name, used in packaging.
+MY_NAME = "Arto Jalkanen"
+# Your email address, used in packaging.
+MY_EMAIL = "ajalkane@gmail.com"
+# Short summary of your project, used in packaging.
+PROJECT_SUMMARY = "Library for managing Re-Volt game, and some Commandline tools"
+# The project's package name (as opposed to its display name). Used for
+# RubyForge connectivity and packaging.
+UNIX_NAME = "revolt"
+# Your RubyForge user name.
+RUBYFORGE_USER = ENV["RUBYFORGE_USER"] || "ajalkane"
+# Directory on RubyForge where your website's files should be uploaded.
+WEBSITE_DIR = "website"
+# Output directory for the rdoc html files.
+# If you don't have a custom homepage, and want to use the RDoc
+# index.html as homepage, just set it to WEBSITE_DIR.
+RDOC_HTML_DIR = "#{WEBSITE_DIR}" # /rdoc"
+
+HAVE_EXT = nil
+EXT_DIST_FILES = nil
+
+#################
+##
+## Getting Version of library
+##
+#################
+REQUIRE_PATHS = ["lib"]
+REQUIRE_PATHS << EXT_DIR if HAVE_EXT
+$LOAD_PATH.concat(REQUIRE_PATHS)
+# This library file defines the MyProject::VERSION constant.
+require "#{UNIX_NAME}"
+PROJECT_VERSION = eval("#{MAIN_NAMESPACE}::VERSION") # e.g., "1.0.2"
+
+# Options common to RDocTask AND Gem::Specification.
+# The --main argument specifies which file appears on the index.html page
+GENERAL_RDOC_OPTS = {
+  "--title" => "#{PROJECT} API documentation",
+  "--main" => "README"
+}
+
+# Additional RDoc formatted files, besides the Ruby source files.
+RDOC_FILES = FileList["README"]
+# Remove the following line if you don't want to extract RDoc from
+# the extension C sources.
+# RDOC_FILES.include(EXT_SOURCES)
+# Ruby library code.
+LIB_FILES = FileList["lib/**/*.rb"]
+# Filelist with Test::Unit test cases.
+TEST_FILES = FileList["test/ts_base.rb"]
+# Executable scripts, all non-garbage files under bin/.
+BIN_FILES = FileList["bin/*"]
+# This filelist is used to create source packages.
+# Include all Ruby and RDoc files.
+DIST_FILES = FileList["**/*.rb", "**/*.rdoc"]
+DIST_FILES.include("Rakefile")
+DIST_FILES.include(BIN_FILES)
+DIST_FILES.include("test/fixtures/**/*")
+DIST_FILES.include("#{WEBSITE_DIR}/**/*.{html,css}", "man/*.[0-9]")
+# Don't package files which are autogenerated by RDocTask
+DIST_FILES.exclude(/^(\.\/)?#{RDOC_HTML_DIR}(\/|$)/)
+# Include extension source files.
+DIST_FILES.include(EXT_DIST_FILES) if EXT_DIST_FILES
+# Don't package temporary files, perhaps created by tests.
+DIST_FILES.exclude("**/temp_*", "**/*.tmp")
+# Don't get into recursion...
+DIST_FILES.exclude(/^(\.\/)?pkg(\/|$)/)
+
+# Run the tests if rake is invoked without arguments.
+task "default" => ["test"]
+
+test_task_name = HAVE_EXT ? "run-tests" : "test"
+Rake::TestTask.new(test_task_name) do |t|
+  # t.libs << "test"
+  t.test_files = TEST_FILES
+  t.libs = REQUIRE_PATHS
+end
+
+# The "rdoc" task generates API documentation.
+
+Rake::RDocTask.new("rdoc") do |t|
+  t.rdoc_files = RDOC_FILES + LIB_FILES
+  t.title = GENERAL_RDOC_OPTS["--title"]
+  t.main = GENERAL_RDOC_OPTS["--main"]
+  t.rdoc_dir = RDOC_HTML_DIR
+end
+
+GEM_SPEC = Gem::Specification.new do |s|
+  s.name = UNIX_NAME
+  s.version = PROJECT_VERSION
+  s.summary = PROJECT_SUMMARY
+  s.rubyforge_project = UNIX_NAME
+  s.homepage = "http://#{UNIX_NAME}.rubyforge.org/"
+  s.author = MY_NAME
+  s.email = MY_EMAIL
+  s.files = DIST_FILES
+  s.test_files = TEST_FILES
+  s.executables = BIN_FILES.map { |fn| File.basename(fn) }
+  s.has_rdoc = true
+  s.extra_rdoc_files = RDOC_FILES
+  s.rdoc_options = GENERAL_RDOC_OPTS.to_a.flatten
+  if HAVE_EXT
+    s.extensions = EXTCONF_FILES
+    s.require_paths << EXT_DIR
+  end
+end
+
+# Now we can generate the package-related tasks.
+Rake::GemPackageTask.new(GEM_SPEC) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc "Upload website to RubyForge. " +
+  "scp will prompt for your RubyForge password."
+task "publish-website" => ["rdoc"] do
+  rubyforge_path = "/var/www/gforge-projects/#{UNIX_NAME}/"
+  sh "scp -r #{WEBSITE_DIR}/* " +
+    "#{RUBYFORGE_USER}@rubyforge.org:#{rubyforge_path}",
+    :verbose => true
+end
+
+task "rubyforge-setup" do
+  unless File.exist?(File.join(ENV["HOME"], ".rubyforge"))
+    puts "rubyforge will ask you to edit its config.yml now."
+    puts "Please set the `username' and `password' entries"
+    puts "to your RubyForge username and RubyForge password!"
+    puts "Press ENTER to continue."
+    $stdin.gets
+    sh "rubyforge setup", :verbose => true
+  end
+end
+
+task "rubyforge-login" => ["rubyforge-setup"] do
+  # Note: We assume that username and password were set in
+  # rubyforge's config.yml.
+  sh "rubyforge login", :verbose => true
+end
+
+task "publish-packages" => ["package", "rubyforge-login"] do
+  # Upload packages under pkg/ to RubyForge
+  # This task makes some assumptions:
+  # * You have already created a package on the "Files" tab on the
+  # RubyForge project page. See pkg_name variable below.
+  # * You made entries under package_ids and group_ids for this
+  # project in rubyforge's config.yml. If not, eventually read
+  # "rubyforge --help" and then run "rubyforge setup".
+  pkg_name = ENV["PKG_NAME"] || UNIX_NAME
+  cmd = "rubyforge add_release #{UNIX_NAME} #{pkg_name} " +
+  "#{PROJECT_VERSION} #{UNIX_NAME}-#{PROJECT_VERSION}"
+  cd "pkg" do
+    sh(cmd + ".gem", :verbose => true)
+    sh(cmd + ".tgz", :verbose => true)
+    sh(cmd + ".zip", :verbose => true)
+  end
+end
+
+# The "prepare-release" task makes sure your tests run, and then generates
+# files for a new release.
+desc "Run tests, generate RDoc and create packages."
+task "prepare-release" => ["clobber"] do
+  puts "Preparing release of #{PROJECT} version #{VERSION}"
+  Rake::Task["test"].invoke
+  Rake::Task["rdoc"].invoke
+  Rake::Task["package"].invoke
+end
+
+# The "publish" task is the overarching task for the whole project. It
+# builds a release and then publishes it to RubyForge.
+desc "Publish new release of #{PROJECT}"
+task "publish" => ["prepare-release"] do
+  puts "Uploading documentation..."
+  Rake::Task["publish-website"].invoke
+  puts "Checking for rubyforge command..."
+  `rubyforge --help`
+  if $? == 0
+    puts "Uploading packages..."
+    Rake::Task["publish-packages"].invoke
+    puts "Release done!"
+  else
+    puts "Can't invoke rubyforge command."
+    puts "Either install rubyforge with 'gem install rubyforge'"
+    puts "and retry or upload the package files manually!"
+  end
+end
+
+
+# To get an overview of this extensive Rakefile, run rake -T:
+

data/bin/rv_find_levels.rb

@@ -0,0 +1,186 @@
+#!/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])
+  levels.each_level do |level|
+    matches  = {}
+    nmatches = 0
+    cmd[:match].each do |op|
+      value = level_cmp_match(op, level)
+      if value != nil
+         # level.inf[key].send(:=~, ''/#{value}/i')) # =~ /#{value}/i
+        matches[op[:name]] = value # level.inf[key]
+        nmatches += 1
+      end      
+    end
+    if cmd[:match].size == nmatches
+      keyvaluestr = matches.map{|(k,v)|"#{k}=#{v}"}.join(', ')
+      puts "%s [%s]" % [level.to_s, keyvaluestr]
+    end
+  end
+end
+
+def level_cmp_match(op, level)
+  return false if !level || !op
+  args1 = [op[:method]]
+  args2 = [op[:cmp], op[:expect]]
+  obj   = level
+  ret_value = true
+  if op[:method] == :inf
+    lvlinfval = level.inf[op[:infkey]]
+    return false if !lvlinfval
+    obj = lvlinfval
+    # op[:method] = [op[:infcmp], op[:infval]]
+    ret_value   = lvlinfval
+    
+    # Check if comparing to a number (if non digits, not a number)
+    #ReVolt::Logger.debug("Second class: #{s.class} value: #{s}")
+    case
+    when op[:infcmp] == :=~:
+      ReVolt::Logger.debug("Its a regexp")
+      # If a regular expression, do the comparison to reg exp match's return value
+      obj = lvlinfval =~ /#{op[:infval]}/i
+      # If the return value is integer, a match was found
+      args1 = [:is_a?, Integer]
+    when !(op[:infval] =~ /[^\d]/)
+      ReVolt::Logger.debug("Its a number")
+      # If comparing to an integer
+      # Return false unless both comparisons to integer
+      return false if lvlinfval =~ /[^\d]/    
+      # Do the comparison as integers
+      obj   = lvlinfval.to_i
+      args1 = [op[:infcmp], op[:infval].to_i]
+    else
+      # obj   = lvlinfval
+      args1 = [op[:infcmp], op[:infval]]
+    end
+  end
+    
+  ReVolt::Logger.debug("Sending operation #{args1} to object #{obj.class} with value #{obj}")
+  ReVolt::Logger.debug("Args2: #{args2}") # Sending operation #{args} to object #{obj.class}")
+  # ret = obj.send(infcmp, infval) # *args)
+  # ret = (obj =~ infval)
+  # ReVolt::Logger.debug("Return value: #{ret}, class: #{ret.class}")
+  if (obj.send(*args1)).send(*args2)
+    ReVolt::Logger.debug("Returning value #{ret_value}")
+    return ret_value
+  end
+  nil
+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] [name_match]\n"
+
+      opts.separator "Examples:"
+      opts.separator "  Searches for all tracks which name contains temple:"
+      opts.separator "  #$0 temple"  
+      opts.separator "  All tracks which farclip is more than 31000 and startgrid is 3"
+      opts.separator "  #$0 -m 'farclip>31000,startgrid=3'"  
+      opts.separator "  All custom tracks that can be raced in reversed mode"
+      opts.separator "  #$0 -m 'reverse?,custom?'"  
+
+      opts.separator ""
+      opts.separator "Operators:"
+      opts.separator "  <op> in the options can be replaced with:"
+      opts.separator "  = equality"
+      opts.separator "  <  smaller than"
+      opts.separator "  >  larger than"
+      opts.separator "  =~ regular expression match"      
+      opts.separator "" 
+      opts.separator "  The match can include also the following toggles:" 
+      opts.separator "  reversed?"
+      opts.separator "  stock?"
+      opts.separator "  custom?"
+      
+      opts.separator ""
+      
+      opts.separator "Options:"  
+
+      opts.on('-m', '--match [key<op>match[,key2<op>match2[,...]]]', Array,
+              'Matches values in the .inf file with operator') do |value|
+# 'Match to values in level inf files') do |value|
+        inf_matches = value
+      end
+      opts.on('-d', '--debug',
+              'Outputs debug 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 cmd.size != 0
+      inf_matches << '%s=~%s' % ['name', cmd[0]]
+    end
+
+    # If input file not specified, at least start date is required
+    if inf_matches.size == 0
+      puts "Error: no matches specified" 
+      STDERR.puts opts
+      exit 1
+    end
+
+    self[:match] = []
+    inf_matches.each do |keyvalue|
+      op = {
+        :cmp    => :==,
+        :expect => true
+      }
+      case keyvalue
+      when 'reverse?','stock?','custom?'
+        op.merge!({
+          :method => keyvalue.to_sym,
+          :name   => keyvalue
+        })
+      else
+        ((key,cmp,value)) = keyvalue.scan(/(\w+)(=~|<|>|=)(.+)/)
+        # (key, value) = keyvalue.split('=')
+        if key.nil?
+          STDERR.puts "Error: invalid match '#{keyvalue}', should be key<cmp>value"
+          STDERR.puts " where cmp is comparison type, one of: =,<,> or =~"
+          STDERR.puts " Example: name=~temple"
+          STDERR.puts opts
+          exit 1
+        end
+        
+        cmp = '==' if cmp == '='
+        op.merge!({
+          :method => :inf,
+          :infkey => key.downcase.to_sym,
+          :infcmp => cmp.to_sym,
+          :infval => value,
+          :name   => key,
+        })
+        
+      end
+      self[:match] << op
+    end
+  end
+end
+
+
+main