revolt 0.5.3 → 0.8.0

data/README

@@ -13,8 +13,9 @@ 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
+- Install track packages from WWW server or local file
+- Create track packages from locally installed tracks
+- Move, copy, rename and delete tracks
 - Search tracks with various criteria
 - Create alternative track repositories
 
@@ -129,19 +130,81 @@ 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
+  rv_find_levels.rb 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'
-  
+  rv_find_levels.rb -m 'custom?,reverse?,farclip>10000'
+
+The match rules separated by ',' are AND. To create OR rules
+you can specify several matching rules. For example to find
+all tracks that are raceable in reverse or whose name is
+'RV Temple':
+
+  rv_find_levels.rb -m 'custom?,reverse?' -m 'name=RV Temple'
+
 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.
 
+=== rv_info_levels.rb
+Displays information about levels, such as if it's a custom
+track, stock track, can be raced in reverse, or is a so called
+"Full Custom" track. Also the contents INF file can be
+output. The same match format can be used as for rv_find_levels.rb
+
+For more information and options:
+
+  rv_info_levels.rb -h
+
+=== rv_delete_levels.rb
+Deletes levels. Before deleting confirms by default. Match options format
+is similar as rv_find_levels.rb
+
+For more information and options:
+
+  rv_info_levels.rb -h
+
+
+=== rv_package_levels.rb
+Creates packages of levels. The parameters are the
+folder names of the levels to pack. From each level
+a separate package is created. Matching options can
+be used with -m as with rv_find_levels.rb
+
+Example:
+
+  rv_package_levels_level.rb rvt chilled
+
+This would create rvt.zip and chilled.zip of corresponding
+levels.
+
+For more information and options:
+
+  rv_rename_level.rb -h
+
+=== rv_rename_level.rb
+Renames a level. Changes the directory name and 
+necessary file names to the one specified. Confirms
+by default before doing the operation.
+
+Example:
+
+  rv_rename_level.rb USER678 global_race
+
+The parameters must be level ids, that is, they are
+the folder names of the level. The above command
+would rename USER678 to global_race.
+
+The matching parameters can be used with -m option
+for the level to be renamed, but only one level
+can be matched or error is produced.
+
+For more information and options:
 
+  rv_rename_level.rb -h

data/bin/rv_delete_levels.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/ruby
+#
+require 'optparse'
+require 'pp'
+require 'revolt'
+require 'set'
+
+def main
+  del_levs = []
+  cmd = CmdArguments.new(ARGV)
+  ReVolt::Logger.enable if cmd[:debug]
+  levels = ReVolt::Levels.at(cmd[:base])
+  levels.each_level do |level|
+    all_matches  = {}
+    nmatches = ReVolt::Util::Matcher.multi(level, cmd[:match], all_matches)
+    if nmatches > 0
+      keyvaluestr = all_matches.map{|(k,v)|"#{k}=#{v}"}.join(', ')
+      del_levs << level
+      puts "%s [%s]" % [level.inspect, keyvaluestr]
+    end
+  end
+  
+  if del_levs.size > 0
+    unless cmd[:force]
+      puts ""
+      print "Delete these levels? (y/N) "
+      answer = STDIN.gets.chomp
+      if answer.downcase != 'y'
+        puts "Deleting not done"
+        exit(0)
+      end
+    end
+    del_levs.each do |l, match|
+      puts "Deleting %s (%s)" % [l.name, l.id.to_s]
+      l.delete
+    end
+  else
+    puts "No matching levels"
+  end
+end
+
+
+class CmdArguments < Hash
+  include ReVolt::Util::CommonCmdArgs
+  
+  def initialize(cmd)
+    super()
+    
+    self[:base]  = ReVolt::Info::path
+    self[:force] = false
+    
+    matchstrs   = []
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #$0 [options] [name_match ...]\n"
+      opts.separator ""
+      opts.separator "Deletes levels. By default confirms deletion of matched levels"
+      opts.separator ""
+      opts.separator "Examples:"
+      opts.separator "  Deletes for all tracks which name contains temple:"
+      opts.separator "  #$0 temple"  
+      opts.separator "  Deletes tracks which farclip is more than 31000 and startgrid is 3"
+      opts.separator "  #$0 -m 'farclip>31000,startgrid=3'"  
+
+      opts.separator ""
+      match_help(opts)
+      opts.separator ""
+      
+      opts.separator "Options:"  
+
+      on_match(opts) do |value|
+        matchstrs << value
+      end
+      opts.on('-d', '--debug',
+              'Outputs debug information') do
+        self[:debug] = true
+      end
+      opts.on('-f', '--force',
+              'Force deletion without confirmation') do
+        self[:force] = true
+      end
+      
+      on_base_path(opts) do |value|
+        self[:base] = value
+      end
+      
+      opts.on_tail('-h', '--help',
+                   'Display full help and exit') do
+        puts opts
+        
+        exit(0)
+      end
+    end
+  
+    opts.parse!(cmd)
+
+    cmd.each do |n|
+      matchstrs << '%s=~%s' % ['name', n]
+    end
+
+    # If input file not specified, at least start date is required
+    if matchstrs.size == 0
+      puts "Error: no matches specified\n" 
+      STDERR.puts opts.banner
+      exit 1
+    end
+
+    begin
+      # Create the matcher objects
+      self[:match] = []
+      for m in matchstrs
+        self[:match] << ReVolt::Util::Matcher.parse(m)
+      end
+    rescue ReVolt::Util::Matcher::ParseError => e
+      STDERR.puts e.errstr
+      exit(1)
+    end
+  end
+end
+
+
+main

data/bin/rv_find_levels.rb

@@ -10,80 +10,26 @@ def main
   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]
+    all_matches  = {}
+    nmatches = ReVolt::Util::Matcher.multi(level, cmd[:match], all_matches)
+    if nmatches > 0
+      keyvaluestr = all_matches.map{|(k,v)|"#{k}=#{v}"}.join(', ')
+      puts "%s [%s]" % [level.inspect, 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
+  include ReVolt::Util::CommonCmdArgs
+  
   def initialize(cmd)
     super()
     
-    inf_matches = []
     self[:base] = ReVolt::Info::path
-    
+    matchstrs   = []
     opts = OptionParser.new do |opts|
-      opts.banner = "Usage: #$0 [options] [name_match]\n"
+      opts.banner = "Usage: #$0 [options] [name_match ...]\n"
 
       opts.separator "Examples:"
       opts.separator "  Searches for all tracks which name contains temple:"
@@ -92,92 +38,58 @@ class CmdArguments < Hash
       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 "  All full custom tracks or custom tracks that can be raced in reverse"
+      opts.separator "  #$0 -m 'full_custom?' -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?"
-      
+      match_help(opts)
       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
+      on_match(opts) do |value|
+        matchstrs << 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|
+      
+      on_base_path(opts) do |value|
         self[:base] = value
       end
       
       opts.on_tail('-h', '--help',
-                   'Display this help and exit') do
+                   'Display full help and exit') do
         puts opts
-        exit(1)
+        
+        exit(0)
       end
     end
   
     opts.parse!(cmd)
 
-    if cmd.size != 0
-      inf_matches << '%s=~%s' % ['name', cmd[0]]
+    cmd.each do |n|
+      matchstrs << '%s=~%s' % ['name', n]
     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
+    if matchstrs.size == 0
+      puts "Error: no matches specified\n" 
+      STDERR.puts opts.banner
       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,
-        })
-        
+    begin
+      # Create the matcher objects
+      self[:match] = []
+      for m in matchstrs
+        self[:match] << ReVolt::Util::Matcher.parse(m)
       end
-      self[:match] << op
+    rescue ReVolt::Util::Matcher::ParseError => e
+      STDERR.puts e.errstr
+      exit(1)
     end
   end
 end

data/bin/rv_info_levels.rb

@@ -0,0 +1,118 @@
+#!/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|
+    nmatches = ReVolt::Util::Matcher.multi(level, @cmd[:match])
+    if nmatches > 0
+      output_info(level)
+    end
+  end  
+end
+
+def output_info(l)
+  puts "%s (%s)" % [l.name, l.id]
+  [
+    [:stock?,      ' - This is a stock level'],
+    [:custom?,     ' - This is a custom level'],
+    [:reverse?,    '  - Can be played in reverse'],
+    [:full_custom?,'  - Can be played in Full Custom mode']
+  ].each do |(question, msg)|
+    puts msg if l.send(question)
+  end
+
+  if @cmd[:all]
+    puts "Elements from info file:"
+    l.inf.sort{|a,b| a.to_s <=> b.to_s}.each do |key, value|
+      value = l.inf[key]
+      puts "%-20s %s" % [key.to_s.upcase, value]
+    end
+  end
+  
+  puts ""  
+end
+
+class CmdArguments < Hash
+  include ReVolt::Util::CommonCmdArgs
+  
+  def initialize(cmd)
+    super()
+    
+    self[:base] = ReVolt::Info::path
+    self[:all]  = false
+    
+    matchstrs   = []
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #$0 [options] [name_match ...]\n"
+      opts.separator ""
+      opts.separator "Outputs information about matching levels from their inf file."
+      opts.separator ""
+      opts.separator "Examples:"
+      opts.separator "  Information about levels whose name includes temple:"
+      opts.separator "  #$0 temple"  
+
+      opts.separator ""
+      match_help(opts)
+      opts.separator ""
+      
+      opts.separator "Options:"  
+
+      on_match(opts) do |value|
+        matchstrs << value
+      end
+      opts.on('-d', '--debug',
+              'Outputs debug information') do
+        self[:debug] = true
+      end
+      opts.on('-a', '--all',
+              'All information from the level output') do
+        self[:all] = true
+      end
+      
+      on_base_path(opts) do |value|
+        self[:base] = value
+      end
+      
+      opts.on_tail('-h', '--help',
+                   'Display full help and exit') do
+        puts opts
+        
+        exit(0)
+      end
+    end
+  
+    opts.parse!(cmd)
+
+    cmd.each do |n|
+      matchstrs << '%s=~%s' % ['name', n]
+    end
+
+    # If input file not specified, at least start date is required
+    if matchstrs.size == 0
+      puts "Error: no matches specified\n" 
+      STDERR.puts opts.banner
+      exit 1
+    end
+
+    begin
+      # Create the matcher objects
+      self[:match] = []
+      for m in matchstrs
+        self[:match] << ReVolt::Util::Matcher.parse(m)
+      end
+    rescue ReVolt::Util::Matcher::ParseError => e
+      STDERR.puts e.errstr
+      exit(1)
+    end
+  end
+end
+
+
+main

data/bin/rv_install_level_urls.rb

@@ -40,10 +40,10 @@ def main
   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"
+      puts "Skipping installing of " + level.inspect + " because it exists"
       @summary[:exists] << level
     else 
-      puts "Installing level " + level.to_s
+      puts "Installing level " + level.inspect
       level.move_to @levels
       @summary[:installed] << level
     end

data/bin/rv_package_levels.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/ruby
+#
+require 'optparse'
+require 'pp'
+require 'revolt'
+require 'set'
+
+def main
+  pkg_levs = []
+  cmd      = CmdArguments.new(ARGV)
+  ReVolt::Logger.enable if cmd[:debug]
+  levels = ReVolt::Levels.at(cmd[:base])
+  levels.each_level do |level|
+    all_matches  = {}
+    nmatches = ReVolt::Util::Matcher.multi(level, cmd[:match], all_matches)
+    if nmatches > 0
+      keyvaluestr = all_matches.map{|(k,v)|"#{k}=#{v}"}.join(', ')
+      pkg_levs << level
+      puts "%s [%s]" % [level.inspect, keyvaluestr]
+    end
+  end
+  
+  if pkg_levs.size > 0
+    puts ''
+    puts "Creating packages of #{pkg_levs.size} matching levels"
+    pkg_levs.each do |l, match|
+      pkgfname = "%s.%s" % [l.id.to_s, 'zip']
+      puts "Creating package %s from %s" % [pkgfname, l.inspect]
+      l.package(pkgfname)
+    end
+  else
+    puts "No matching levels"
+  end
+end
+
+
+class CmdArguments < Hash
+  include ReVolt::Util::CommonCmdArgs
+  
+  def initialize(cmd)
+    super()
+    
+    self[:base]  = ReVolt::Info::path
+    self[:force] = false
+    
+    matchstrs   = []
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #$0 [options] [levelid ...]\n"
+      opts.separator ""
+      opts.separator "Creates packages of levels. Each packaged level will be"
+      opts.separator "named by its id"
+      opts.separator ""
+      opts.separator "Examples:"
+      opts.separator "  Package a level that is in RV levels sub-directory temple:"
+      opts.separator "  #$0 temple"  
+      opts.separator "  Packages all custom tracks that can be raced in reverse:"
+      opts.separator "  #$0 -m 'custom?,reverse?'"  
+
+      opts.separator ""
+      match_help(opts)
+      opts.separator ""
+      
+      opts.separator "Options:"  
+
+      on_match(opts) do |value|
+        matchstrs << value
+      end
+      opts.on('-d', '--debug',
+              'Outputs debug information') do
+        self[:debug] = true
+      end
+      
+      on_base_path(opts) do |value|
+        self[:base] = value
+      end
+      
+      opts.on_tail('-h', '--help',
+                   'Display full help and exit') do
+        puts opts
+        
+        exit(0)
+      end
+    end
+  
+    opts.parse!(cmd)
+
+    cmd.each do |pkgid|
+      matchstrs << 'id=%s' % ['name', cmd[0]]
+    end
+
+    # If input file not specified, at least start date is required
+    if matchstrs.size == 0
+      puts "Error: no matches specified\n" 
+      STDERR.puts opts.banner
+      exit 1
+    end
+
+    begin
+      # Create the matcher objects
+      self[:match] = []
+      for m in matchstrs
+        self[:match] << ReVolt::Util::Matcher.parse(m)
+      end
+    rescue ReVolt::Util::Matcher::ParseError => e
+      STDERR.puts e.errstr
+      exit(1)
+    end
+  end
+end
+
+
+main