revolt 0.5.1

data/lib/revolt/level.rb

@@ -0,0 +1,298 @@
+require 'pathname'
+require 'set'
+require 'revolt/exceptions'
+require 'revolt/logger'
+require 'revolt/util'
+require 'pp'
+
+module ReVolt
+  # Level contains information about one Re-Volt level.
+  # A unique identifier is used which is a symbol from
+  # the directory name of the Level.
+  # 
+  # The operations on Level are dynamic in nature, so that
+  # information about the Level are loaded only if it is
+  # requested. For example the .inf file is loaded only
+  # if information from it is required, such as the level's
+  # name.
+  # 
+  # Level's identifier is its directory name in lowercase.
+  # The identifier passed to the various functions can
+  # be:
+  #   - a lowercase symbol denoting the level name
+  #   - a Level object, which own identifier is used to find the instance
+  #   - a string that is the same as the directory name
+  #
+  # Internally all above identifiers are turned into a lowercase
+  # symbol.
+  # 
+  # Usually Level is associated with a parent object, which is
+  # Levels. Many of the functions require this association to exist
+  # because otherwise the full path to the level directory, and
+  # thus its files, can not be determined
+  # 
+  # The 
+  class Level
+    include ReVolt::Logger
+    
+    attr_accessor :parent
+    attr_reader :id
+
+    @@stock_ids = Set.new [
+      :nhood1,
+      :market2,
+      :muse2,
+      :garden1,
+      :toylite,
+      :wild_west1,
+      :toy2,
+      :ship1,
+      :nhood2,
+      :muse1,
+      :market1,
+      :wild_west2,
+      :ship2,
+      
+      # Battle tags
+      :nhood1_battle,
+      :markar,
+      :bot_bat,
+      :muse_bat,
+      
+      # Stunt track
+      :stunts
+    ]
+    
+    # Creates a new Level object that has the given identifier
+    def initialize(id, args = {})
+      @id     = ReVolt::Level::to_level_id id
+      @parent = args[:parent]
+      @name   = args[:name]
+      @inf    = nil
+      @loaded = false
+    end
+
+    # Tries to create a level identifier from the passed
+    # object.
+    def self.to_level_id(id)
+      case
+      when id.is_a?(ReVolt::Level) then
+        ReVolt::Logger::debug("Level::to_level_id: from id Level #{id}")
+        id.id
+      when id.is_a?(Symbol) then
+        ReVolt::Logger::debug("Level::to_level_id: from id Symbol #{id}")
+        id
+      else
+        ReVolt::Logger::debug("Level::to_level_id: default action from id #{id}")
+        id.to_s.downcase.to_sym
+      end
+    end
+
+    # Returns true if the Level's .inf file has been loaded
+    def loaded?
+      @loaded
+    end
+
+    # Returns the name of the level
+    def name
+      reload unless @name
+      @name
+    end
+
+    # Returns true if the Level is a stock level.
+    # The comparison is done only on the basis of
+    # the Level's identifier.
+    def stock?
+      @@stock_ids.member?(@id)
+    end
+
+    # Inverse of #stock?
+    def custom?
+      not stock?
+    end
+    
+    # Returns true if there is a reversed version of this
+    # level. Basically just checks if the track has a
+    # reversed folder
+    def reverse?
+      ensure_parent
+      rpath = path + 'reversed'
+      rpath.directory?
+    end
+    
+    # Returns the files belonging to this level, relative
+    # to the Re-Volt base directory. Pathname objects.
+    def files
+      self.dirs_and_files[1]
+    end
+
+    # Returns the directories belonging to this level,
+    # relative to the Re-Volt base directory
+    def dirs
+      self.dirs_and_files[0]
+    end
+    
+    # Returns the files and directories belonging to this
+    # level in an array, in first element array of the directories
+    # and in second element array of the files. Each file
+    # and directory is a Pathname object.
+    def dirs_and_files
+      ensure_parent
+
+      # Level directories, and level files
+      d = []
+      f = []
+      # Level globs, and graphics globs
+      globs = [path + '**/*',
+               gfx_path + ReVolt::Util::caseinsensitiveglob(id.to_s + '.bm?')
+              ]
+      debug("Level gfx glob: #{globs[1]}")
+
+      # Creates relative paths to base directory
+      globs.each do |g|
+        debug("Globbing: #{g}")
+        Pathname::glob(g) do |path|
+          debug("Inspecting file #{path}")
+          addto = path.directory?() ? d : f
+          addto << path.relative_path_from(@parent.base_path)
+        end
+      end
+      
+      debug("Returning #{d} and #{f}")
+      [d, f]
+=begin
+      # The gfx files then
+      debug("Level path: #{path}")
+      debug("Level gfx path: #{gfx_path}")
+      debug("files: #{f.join(' ')}")
+      (f + d).each do |p|
+        debug("Level: relative path to RV base from #{p}")
+        p = relative_path_from(@parent.base_path)
+        debug("Level: relative path result: #{p}")
+      end
+      r = f.map do |f| 
+        f.relative_path_from(@parent.base_path)
+      end
+      
+      debug("files relative: #{r.join(' ')}")
+      
+      r
+=end
+    end
+    
+    def path
+      ensure_parent
+      @parent.path + @id.to_s
+    end
+
+    # Returns the full name and path of the .inf file
+    # of this level.
+    def inf_path
+      ensure_parent
+      path + (@id.to_s + '.inf')
+    end
+
+    # Returns the path to the graphics files of the Level
+    def gfx_path
+      ensure_parent
+      @parent.gfx_path
+    end
+
+    # Convenience function for moving this Level
+    # to given Levels. See Levels::move_level_to
+    def move_to(levels, args = {})
+      ensure_parent
+      raise(ArgumentError, 
+            "Not ReVolt::Levels") unless levels.is_a? ReVolt::Levels
+      @parent.move_level_to(id, levels, args)
+    end
+
+    # Convenience function for copying this Level
+    # to given Levels. See Levels::copy_level_to
+    def copy_to(levels, args = {})
+      ensure_parent
+      raise(ArgumentError, 
+            "Not ReVolt::Levels") unless levels.is_a? ReVolt::Levels
+      @parent.copy_level_to(id, levels, args)
+    end
+
+    # Convenience function for deleting this Level
+    # from given Levels. See Levels::delete
+    def delete(args = {})
+      ensure_parent
+      @parent.delete(id, args)
+    end
+
+    # Reloads the details of the Level (from .inf file)
+    def reload
+      raise "ReVolt::Levels instance must be specified before Level can be loaded" unless @parent
+      
+      inf_file = Pathname.new(@parent.path)
+      inf_file += id.to_s
+      inf_file += id.to_s + ".inf"
+      debug "Loading inf file: #{inf_file}"
+
+      if !inf_file.file?
+        raise(InfFileNotFoundError.new(@parent, self, inf_file), 
+              "Inf file not found from #{inf_file}")
+      end
+
+      @inf = {}
+      open(inf_file).each do |line|
+        # Remove comments:
+        debug "Level::reload .inf line: #{line}"
+        line.sub!(/;.*/, '')
+        if line =~ /^(\w+)\s+([^\s].*)$/
+          key, value = $1, $2
+          value.rstrip!
+          key.downcase!
+          # Replace 'string' values with string
+          value.gsub!(/'([^']*)'/, '\1')
+          @inf[key.intern] = value
+        end
+      end
+
+      @name = @inf[:name]
+      @loaded = true
+    end
+
+    # Returns a hash of the name/value pairs from
+    # the .inf file. The key of the hash is a lowercase
+    # symbol of the corresponding entry in the .inf file
+    # 
+    # For example getting the STARTGRID from .inf file:
+    # level.inf[:startgrid]
+    def inf
+      reload unless loaded?
+      @inf
+    end
+
+    def <=>(o)
+      id === o.id # .to_s.casecmp(o.id.to_s)
+    end
+
+    # Turns the level's id (and possibly name if it has been loaded)
+    # to a human readable string
+    def to_s
+      if loaded?
+        "%s (%s)" % [id.to_s, @name]
+      else
+        id.to_s
+      end
+    end
+    
+    def to_sym
+      id
+    end
+    
+    def to_symbol
+      id
+    end
+    
+    private
+    def ensure_parent
+      c = caller.first
+      raise "ReVolt::Levels instance must be specified before #{c} can be called" unless @parent
+    end
+  end # Levels
+end # ReVolt

data/lib/revolt/levels.rb

@@ -0,0 +1,362 @@
+require 'pathname'
+require 'fileutils'
+require 'revolt/info'
+require 'revolt/level'
+require 'revolt/package'
+require 'revolt/logger'
+require 'revolt/logger'
+require 'revolt/args'
+
+module ReVolt  
+  # Is used to handle the levels of Re-Volt installation.
+  # Possible uses:
+  #   - Install a track into it
+  #   - Delete a track from it
+  #   - Move a track to another level directory
+  #   - Copy a track to another level directory
+  #   - Create a new levels directory structure
+  #   - Iterate through all installed tracks etc.
+  #   
+  # The Levels and their handling is dynamic. In practice
+  # this means that the library only loads as much as is
+  # needed about the levels to supply the requested information.
+  # As an example, at first when the level is created nothing
+  # is loaded. When the user requests a certain Level, then
+  # all the directories in the levels are read and made into
+  # Level classes. But the actual Level's .inf file and detailed
+  # information is loaded only when such detailed information
+  # is needed such as requesting the name of the level.
+  # This makes the operation very fast.
+  #
+  # The downside is that the Levels can contain entries
+  # that are not really tracks, but some garbage files in the
+  # levels folder. 
+  class Levels
+    include ReVolt::Logger
+    include Enumerable
+
+    # Pathname objects
+    attr_accessor :path, :gfx_path, :base_path
+
+    # Creates new Levels instance with given Re-Volt
+    # base path. The actual levels directory
+    # will be in base_rv_path/levels and the
+    # graphics files in base_rv_path/gfx
+    def initialize(base_rv_path, args = {}) 
+      @base_path = Pathname.new(base_rv_path)
+      @path      = @base_path + "levels"
+      @gfx_path  = @base_path + "gfx"
+      @path_checked = false
+
+      @levels = nil
+    end
+
+    # Just another way of saying new.
+    # 
+    # Example: levels = ReVolt::Levels.at('tmpdir/test')
+    def self.at(*a)
+      new(*a)
+    end
+    
+    # Creates new Levels instance of the levels
+    # in the standard Re-Volt installation directory.
+    # The directory is detected from registry
+    def self.installed(args = {})
+      new(ReVolt::Info::path, args)
+    end
+    
+    # Iterates through every Level in the directory
+    # returning it to the block. Note that this
+    # method returns all directories in the levels
+    # direcotry as a Level object, so if there is
+    # garbage directories the returned Level object
+    # might throw an exception if the directory is
+    # not an actual level.
+    # 
+    # For a bit slower versions that validate the Level
+    # before returning it see each_level method.
+    def each
+      ensure_levels
+
+      @levels.each do |key, level|
+        yield level
+      end
+    end
+
+    # Only returns valid levels (those with .inf file),
+    # Slower than each because the inf file will be loaded,
+    # but if any information from .inf (such as name) is
+    # needed anyway there is no difference
+    def each_level
+      ensure_levels
+      @levels.each do |key, level|
+        begin
+          level.reload # Throws InfFileNotFoundError if not level
+        rescue ReVolt::InfFileNotFoundError => e
+          debug "Levels::each_level: folder #{e.level.path} is not track"
+        else
+          yield level
+        end
+      end
+    end
+    
+    # Like each_level but only returns custom levels
+    def each_custom
+      each_level do |level|
+        if level.custom?
+          yield level
+        end
+      end
+    end
+
+    # Like each_level but only returns stock levels
+    def each_stock
+      each_level do |level|
+        if level.stock?
+          yield level
+        end
+      end
+    end
+    
+    # Returns a reference to a Level object matching
+    # the given level_id. Returns nil if no matching
+    # level.
+    def [](level_id)
+      ensure_levels
+      debug("Levels::[]: #{level_id}")
+      @levels[ReVolt::Level::to_level_id(level_id)]
+    end
+    
+    # Creates the directory needed for levels
+    # if it doesn't exist.
+    def create_dir_structure
+      @base_path.mkdir if !@base_path.exist?
+      @path.mkdir      if !@path.exist?
+      @gfx_path.mkdir  if !@gfx_path.exist?
+
+      ensure_paths      
+    end
+
+    # Installs a track package to the Levels.
+    # The package can be on local filesystem or
+    # an external one for which a Fetcher can be
+    # created. So for example an URL can be given
+    # and the track is downloaded and installed.
+    def install(src, args = {})
+      usesrc   = src.chomp if src.is_a? String
+      usesrc ||= src
+      fetcher = Fetcher.for(usesrc, args)
+      fetcher.run(args)
+
+      ids = ReVolt::Package::install_track(fetcher.target, @base_path, args)
+    end
+
+    # A convenience function for #install. Extracts all urls from
+    # a string and calls install on them. Useful for example
+    # for installing all track URLs pasted to a chat
+    def install_urls(src, args = {})
+      # Returns nil if any call to install returns
+      # nil as a sign that not all package installers
+      # could provide ids of installed tracks
+      ids = []
+      URI.extract(src, ['http', 'https']) do |url|
+        debug "Levels::install_urls: #{url}"
+        url = ReVolt::call_changer_arg(ReVolt::ARG_INSTALL_URL, args, url)
+        ReVolt::arg_ex_watch(ReVolt::ARG_INSTALL_URL_EX, args, url) {
+          debug "Levels::install_urls2: #{url}"
+          if url
+            id_ret = install(url, args)
+            debug "Levels::install_urls: install returned ids #{id_ret}"
+            ids  = nil unless id_ret
+            ids += id_ret if id_ret && ids
+          end
+        }
+      end
+      ids
+    end
+
+    # Returns true if the level exists
+    def member?(level)
+      ensure_levels
+
+      ret = @levels.has_key?(ReVolt::Level::to_level_id(level))
+    end
+    def include?(*args); member?(*args); end
+
+    # Adds a Level instance object. Doesn't copy any files.    
+    def add(level, args = {})
+      ensure_levels
+      raise ArgumentError, "not level: #{level}" unless level.is_a? ReVolt::Level
+      raise "Already exists #{level}" if @levels.has_key?(level.id)
+      @levels[level.id] = level
+      level.parent = self
+      debug("Levels add: #{level.id}")
+      level
+    end
+    
+    # Just removes the level from Levels, without deleting the
+    # files on filesystem
+    def remove(idpar, args = {})
+      ensure_levels
+
+      id = ReVolt::Level::to_level_id(idpar)
+      raise "Levels::remove: path #{path} #{idpar} don't exist" unless @levels.has_key?(id)
+      level = @levels[id]
+      
+      debug("Level class: #{level.class}")
+      @levels.delete(level.id)
+      level.parent = nil
+      debug("Levels removed: #{level.id}")
+      level
+    end
+    
+    # Removes from Levels and deletes the files
+    def delete(id_orig, args = {})
+      level = remove(id_orig)
+      begin
+        # Remove takes away parent association, so restore it
+        # temporarily so that files can be deleted
+        level.parent = self
+        (dirs, files) = level.dirs_and_files
+        files.each do |file|
+          src_file = base_path + file
+          debug("Deleting file #{src_file}")
+          src_file.delete
+        end
+        dirs.each do |dir|
+          src_dir = base_path + dir
+          debug("Deleting directory #{dir}")
+          src_dir.rmdir
+        end
+        debug("Deleting dir #{level.path}")
+        level.path.rmdir
+      ensure
+        level.parent = nil
+      end
+    end
+    
+    # Copies a Level identified by level_id and all its files to
+    # another Levels object. If matching Level did not exist, raises 
+    # InvalidLevelIdError
+    def copy_level_to(level_id, levels, args = {})
+      ensure_levels
+ 
+      level_files_to(level_id, levels, args) do |file, dst_dir|
+        debug("Levels: copying file #{file} to #{dst_dir}")
+        FileUtils.cp(file, dst_dir)
+      end
+      
+      id = ReVolt::Level::to_level_id(level_id)
+      levels.add(ReVolt::Level.new(id))
+    end
+
+    # Moves a Level identified by level_id  and all its files to
+    # another Levels object. If matching Level did not exist, raises 
+    # InvalidLevelIdError
+    def move_level_to(id_orig, levels, args = {})
+      ensure_levels
+      
+      level_files_to(id_orig, levels, args) do |file, dst_dir|
+        debug("Levels: moving file #{file} to #{dst_dir}")
+        FileUtils.mv(file, dst_dir)
+      end
+      
+      id = ReVolt::Level::to_level_id(id_orig)
+      level = @levels[id]
+
+      # Remove the source level directory and any other directory
+      # possibly remaining
+      level.path.rmtree if level.path.exist?
+      remove(level)
+      levels.add(level)
+    end
+
+    # Reloads all the levels. Essentially discards the Level objects
+    # that have been loaded. This means that the references you had 
+    # before reload to Level objects should not be used anymore
+    def reload
+      @levels = nil
+    end
+    
+    # Number of levels
+    def size
+      ensure_levels
+      @levels.size
+    end
+    def length
+      size
+    end
+    
+    def level_files_to(id_orig, levels, args = {}) # :nodoc:
+      raise ArgumentError unless levels.respond_to?(:base_path)
+      # raise ArgumentError unless levels.respond_to?(:add)
+      # raise ArgumentError unless levels.respond_to?(:remove)
+
+      ensure_levels
+
+      id = ReVolt::Level::to_level_id(id_orig)
+
+      # If level already exists in target
+      # then remove it to replace with the new instance
+      if levels.member?(id)
+        levels.remove(id)
+      end
+      
+      raise(InvalidLevelIdError, 
+            "No level for id #{id_orig}") unless id && @levels.has_key?(id)
+      level = @levels[id]
+
+      (dirs, files) = level.dirs_and_files
+
+      # Prepare needed directories
+      dirs.each do |p|
+        tp = levels.base_path + p
+        debug "Levels: preparing path #{tp}"
+        tp.mkpath
+      end
+      
+      # The actual level directory is not with the
+      # above command, so create it if necessary
+      level_dir = levels.path + level.id.to_s
+      level_dir.mkdir if !level_dir.directory?
+            
+      dst_path  = levels.base_path
+      debug("Levels dst path: #{dst_path}")
+      level.files.each do |file|
+        src_file = base_path + file
+        debug("File parent: #{file.parent}")
+        dst_dir = dst_path + file.parent
+        debug("Levels: dst dir: #{dst_dir}")
+        dst_dir.mkpath unless dst_dir.exist?
+        yield(src_file, dst_dir)
+      end
+      
+      id
+    end
+    
+    private
+    def ensure_paths
+      return if @path_checked
+      raise IOError, "#{@path} does not exist"     if !@path.exist?
+      raise IOError, "#{@path} is not dir"         if !@path.directory?
+      raise IOError, "#{@gfx_path} does not exist" if !@gfx_path.exist?
+      raise IOError, "#{@gfx_path} is not dir"     if !@gfx_path.directory?
+      @path_checked = true
+    end
+    
+    def ensure_levels
+      ensure_paths
+
+      return if @levels
+
+      debug("Levels: finding all from #{path}")
+      @levels = {}
+      @path.children.select {|f| f.directory?}.each do |path_level|
+        id    = path_level.basename
+        level = Level.new(id, { :parent => self })
+        add(level)
+      end
+    end
+
+  end # Levels
+end # ReVolt

data/lib/revolt/logger.rb

@@ -0,0 +1,24 @@
+require 'logger'
+require 'revolt/config'
+
+module ReVolt
+  module Logger
+    # if Config::LOGGING
+    #  puts "Initializing logging"
+    #end
+    @@log = nil
+    module_function
+    def enable
+      @@log = ::Logger.new($stderr) unless @@log
+    end
+    def disable
+      @@log = nil
+    end
+    
+    def debug(*a)
+      @@log.debug(*a) if @@log
+    end
+  end
+end
+
+