revolt 0.5.1

data/lib/revolt/package/archive/analyzer/normalized.rb

@@ -0,0 +1,50 @@
+require 'revolt/logger'
+
+module ReVolt; module Package; module Archive; end; end; end
+
+module ReVolt::Package::Archive::Analyzer
+  class Normalized
+    include ReVolt::Logger
+    def track_files(browser, args = {})
+      a = {}
+      browser.each do |entry|
+        case entry.to_s
+        when /levels\/([^\/]+)\/([^\/]+)\.inf$/i then
+          id, id2 = $1.downcase, $2.downcase
+          if id == id2
+            a[:inf]     ||= {}
+            a[:inf][id] ||= entry
+
+            a[:level]     ||= {}
+            a[:level][id] ||= []
+            a[:level][id] << entry
+          else
+            ReVolt::Logger::debug "Differing ids: #{id}, #{id2}"
+          end
+        when /levels\/([^\/]+)\/([^\/]+)$/i then
+          id = $1.downcase
+          a[:level]     ||= {}
+          a[:level][id] ||= []
+          a[:level][id] << entry
+        when /levels\/([^\/]+)\/reversed\/([^\/]+)$/i then
+          id = $1.downcase
+          a[:reversed]     ||= {}
+          a[:reversed][id] ||= []
+          a[:reversed][id] << entry
+        when /gfx\/(.*)\.bm[pq]/i then
+          id = $1.downcase
+          a[:gfx]     ||= {}
+          a[:gfx][id] ||= []
+          a[:gfx][id] << entry
+        when ReVolt::Package::installer_class_for(entry.to_s)
+          a[:possible] ||= []
+          a[:possible] << entry
+        end
+        
+        ReVolt::Logger::debug "Normalized: #{entry}"
+      end
+      a
+    end
+  end # Analyzer::Normalized
+
+end # ReVolt::Package::Archive

data/lib/revolt/package/archive/analyzer/troubled.rb

@@ -0,0 +1,97 @@
+require 'set'
+
+require 'revolt/logger'
+
+module ReVolt; module Package; module Archive; end; end; end
+
+module ReVolt::Package::Archive::Analyzer
+  class Troubled
+    include ReVolt::Logger
+    
+    def initialize possible_infs
+      # Map possible infs to lower case string ids
+      @id_set = Set.new
+      possible_infs.each do |inf|
+        id = File.basename inf.to_s.downcase, '.inf'
+        debug "TroubleTrack Inf: " + inf.to_s
+        debug "TroubleTrack Inf id: " + id
+        @id_set.add id
+      end
+    end
+
+    def track_files(browser, args = {})
+      a = {}
+      browser.each do |entry|
+        debug "TroubleTrack #{entry}"
+        next unless entry.to_s =~ /([^\/]+)$/i
+        file = $1.downcase
+        id = @id_set.find do |id| 
+          # Try replacing the start of the match
+          # with the each known id and see if the
+          # result is a match
+          filetry = file.dup
+          filetry[0...id.length] = id
+          debug("Comparing #{filetry} to original #{file}")
+          filetry == file
+        end
+
+        if id == nil 
+          if ReVolt::Package::installer_class_for(entry.to_s)
+            a[:possible] ||= []
+            a[:possible] << entry
+            debug "Possible package #{entry}"
+            next
+          elsif @id_set.size == 1
+            # If there is only one .inf file in the directory,
+            # put unrecognized files to level category. This
+            # way misc files such as "readme.txt" end up somewhere..
+            # Of course if the package includes more than one .inf
+            # then it is impossible to know where to put the files.
+            debug "Unknown entry #{entry}, " + 
+              "but only one possible track in package"
+            id = @id_set.to_a[0]
+          else
+            debug "Could not use file #{entry}"
+            next
+          end
+        end
+
+        # If gotten this far, the file belongs to some track
+        # category for the id. Simple rules:
+        # 1. if reversed found before the name, there it goes
+        # 2. if it is id.bmp or id.bmq, to gfx it goes
+        # 3. if it is an .inf file, to :inf and :level it goes
+        # 3. otherwise to level it goes
+
+        idrex = Regexp.escape id
+        debug "filerex: #{idrex}"
+        category = case entry.to_s
+                   when /reversed\/[^\/]+$/i: :reversed
+                   when /#{idrex}\.bm[pq]$/i: :gfx
+                   when /#{idrex}\.inf$/i:    :inf
+                   else                       :level
+                   end
+
+        begin
+          debug "TroubleTrack: category #{category} for file #{entry}"
+          a[category]     ||= {}
+
+          if category == :inf
+            a[category][id] = entry
+          else
+            a[category][id] ||= []
+            a[category][id] << entry
+          end
+
+          begin
+            # Redo the loop to add to levels also if it was an inf file
+            category = :level
+            redo
+          end if category == :inf
+        end until true
+
+      end
+      a
+    end
+  end # Analyzer::Troubled
+end # module ReVolt::Package::Archive

data/lib/revolt/package/archive/analyzer.rb

@@ -0,0 +1,34 @@
+require 'revolt/package/archive/zip/browser'
+require 'revolt/package/archive/analyzer/normalized'
+require 'revolt/package/archive/analyzer/troubled'
+
+module ReVolt; module Package; module Archive; end; end; end
+
+module ReVolt::Package::Archive
+  module Analyzer
+
+    module_function
+
+    def for_track(browser, args = {})
+      looks_like    = Set.new
+      possible_infs = Set.new
+      
+      browser.each do |entry|
+        case entry.to_s
+        when /levels\//i: looks_like.add :normalized
+        when /.inf$/i: possible_infs.add entry
+        end
+      end
+      
+      case
+      when looks_like.member?(:normalized): return Normalized.new
+      else
+        return Troubled.new(possible_infs.to_a)
+      end
+
+      raise "err"
+      nil
+    end
+
+  end # module 
+end # module 

data/lib/revolt/package/archive/zip/browser.rb

@@ -0,0 +1,44 @@
+# require 'delegate'
+require 'rubygems'
+require 'zip/zip'
+require 'zip/zipfilesystem'
+require 'set'
+require 'pp'
+
+require 'revolt/logger'
+
+module ReVolt; module Package; module Archive; end; end; end
+
+module ReVolt::Package::Archive::Zip
+  class Browser < Zip::ZipFile
+    include ReVolt::Logger
+
+    def self.open(file, &block)
+      me = new(file)
+      ReVolt::Logger::debug("1Zip::Browser::open me: #{me.class}, #{file}")
+
+      if block
+        begin
+          block.call(me)
+        rescue
+          me.close
+          raise
+        end
+      end
+    end
+
+    def copy(entry, target, args = {})
+      debug("Copying from zip #{entry} -> #{target}")
+      if File.directory?(target) then
+        target = Pathname.new(target) + File.basename(entry.to_s)
+        debug("Copying2 from zip #{entry} -> #{target}")
+      end
+
+      # extract throws an error if the target file exists, so remove it
+      # if that is so
+      File.unlink(target) if File.exist?(target)
+      entry.extract(target, &p)
+    end
+  end # Zip
+end # ReVolt::Package::Zip
+

data/lib/revolt/package/archive.rb

@@ -0,0 +1,35 @@
+require 'revolt/package/archive/zip/browser'
+
+module ReVolt; module Package; module Archive; end; end; end
+
+module ReVolt::Package
+  module Archive
+
+    module_function
+
+    def browser_class_for(file, args = {})
+      case file.to_s
+      when /.zip$/i : ReVolt::Package::Archive::Zip::Browser
+      else
+        nil
+      end
+    end
+
+=begin
+    def browser_for(file, args = {})
+      klass = browser_class_for(file, args)
+      klass.new if klass
+    end
+=end
+
+    def open(file, args = {}, &block)
+      browser = browser_class_for(file, args)
+
+      raise "Can not handle archive #{file}" unless browser
+
+      browser.open(file, &block)
+    end
+  end
+
+end
+  

data/lib/revolt/package/exe.rb

@@ -0,0 +1,10 @@
+require 'revolt/package/archive/zip/browser'
+
+module ReVolt; module Package; module Archive; end; end; end
+
+module ReVolt::Package
+  module Exe
+
+  end
+end
+  

data/lib/revolt/package/installer/archive.rb

@@ -0,0 +1,105 @@
+require 'pathname'
+
+require 'revolt/logger'
+require 'revolt/package/archive'
+require 'revolt/package/archive/analyzer'
+require 'revolt/exceptions'
+
+module ReVolt; module Package; module Installer; end; end; end
+
+module ReVolt::Package::Installer
+  class Archive
+    include ReVolt::Logger
+
+    # Convenience function to create an archive
+    # installer for file if can handle it
+    def self.create_for(file_name, args = {})
+      return new() if handles?(file_name, args)
+    end
+
+    def self.handles?(file_name, args = {})
+      if ReVolt::Package::Archive::browser_class_for(file_name, args)
+        return true
+      end
+      false
+    end
+
+    def install_track(source, rv_target, args = {})
+      @args = args
+      inst_ids = []
+      ReVolt::Package::Archive::open(source, args) do |browser|
+        analyzer = ReVolt::Package::Archive::Analyzer::for_track(browser, args)
+        files    = analyzer.track_files(browser, args)
+
+        if files[:inf] && files[:inf].size > 0 then
+          inst_ids = install_analyzed_files(files, rv_target, browser)
+        elsif files[:possible] && files[:possible].size > 0
+          inst_ids = install_try_possible_files(files, rv_target, browser)
+        end
+        if inst_ids.size.zero?
+          raise ReVolt::PackageUnknownError.new("Can't find track " + 
+                                                  "files from #{source}")
+        end
+      end # browser.open
+      inst_ids
+    end
+
+    private
+    def install_analyzed_files(files, rv_target, browser)
+      raise "No inf in install_analyzed_files" unless files[:inf]
+
+      files[:inf].each do |(id,file)|
+        debug("Inf (#{id}): #{file}")
+
+        install_analyzed_section(files, rv_target, browser, id, :level)
+        install_analyzed_section(files, rv_target, browser, id, :gfx)
+        install_analyzed_section(files, rv_target, browser, id, :reversed)
+      end
+
+      return files[:inf].keys
+    end
+
+    def install_analyzed_section(files, rv_target, browser, id, section)
+      path  = Pathname.new(rv_target.to_s)
+      path += case section
+              when :gfx      then 'gfx'
+              when :level    then "levels/#{id}"
+              when :reversed then "levels/#{id}/reversed"
+              end
+      
+      debug("  #{section}: to path #{path}")
+
+      if files[section] && files[section][id]
+        Dir.mkdir(path) unless File.directory?(path)
+
+        files[section][id].each do |file|
+          debug("  #{section}: #{file}")
+          browser.copy(file, path, @args)
+        end
+      end
+    end
+
+    def install_try_possible_files(files, rv_target, browser)
+      inst_ids = []
+      files[:possible].each do |file|
+        debug("Trying to install a possible file: #{file}")
+        # Copy as a temporary file and try to install it
+        tmpfile  = ReVolt::Util::tmpdir
+        tmpfile += File.basename(file.to_s)
+        browser.copy(file, tmpfile)
+        begin
+          tmp_ids   = ReVolt::Package.install_track(tmpfile, rv_target, @args)
+          inst_ids += tmp_ids
+        rescue ReVolt::PackageUnknownError => e
+          debug("The tried file #{tmpfile} did not seem to be track: #{e}")
+        ensure
+          debug("Deleting temporary file #{tmpfile}")
+          tmpfile.delete          
+        end
+      end
+      debug("Archive: installed %d from %d possibles" %
+              [inst_ids.size, files[:possible].size])
+      inst_ids
+    end
+  end # Archive
+end # ReVolt::Package::Installer

data/lib/revolt/package/installer/exe.rb

@@ -0,0 +1,10 @@
+module ReVolt; module Package; module Installer; end; end; end
+
+module ReVolt::Package::Installer
+  class Exe
+    def self.handles?(file_name, args = {})
+      # No support yet for any executable formats
+      false
+    end
+  end # Archive
+end # ReVolt::Package::Installer

data/lib/revolt/package.rb

@@ -0,0 +1,64 @@
+require 'revolt/package/archive'
+require 'revolt/package/exe'
+require 'revolt/package/installer/archive'
+require 'revolt/package/installer/exe'
+require 'revolt/exceptions'
+
+module ReVolt
+  module Package
+    # class NoBrowserForError < StandardError; end
+
+    module_function
+
+    def installer_class_for(file, args = {})
+      inst ||= if args[:installer_class_for] then 
+                 args[:installer_class_for].call(file, args)
+               end
+      inst ||= Installer::Archive if Installer::Archive::handles?(file, args)
+      inst ||= Installer::Exe     if Installer::Exe::handles?(file, args)
+      inst
+    end
+
+    def installer_for(file, args = {})
+      klass = installer_class_for(file, args)
+      klass.create_for(file, args) if klass
+    end
+
+    def install_track(source, rv_path, args = {})
+      inst = installer_for source
+      if inst
+        inst.install_track source, rv_path, args
+      else
+        raise PackageUnknownError.new,"Could not find installer for #{source}"
+      end
+    end
+
+=begin
+    # A factory function for creating a filesystem like
+    # browser for the given package
+    def browser file
+      if !block_given?
+        raise ArgumentError, "block is required"
+      end
+      
+      klass = package_class file
+
+      raise NoBrowserForError, "No browser for #{file}" unless klass
+      
+      obj = klass.new file
+      yield obj
+      obj.close
+    end
+
+    def is_package? filename
+      browser_class(filename) != nil
+    end
+
+    def browser_class filename
+      klass = case filename
+              when /.zip$/i : ReVolt::Package::Zip::Browser
+              end
+    end
+=end
+  end # Package
+end # ReVolt

data/lib/revolt/util/fs_browser.rb

@@ -0,0 +1,30 @@
+require 'revolt/logger'
+
+module ReVolt; module Util; end; end
+
+module ReVolt::Util
+  # FileSystem browser. Provides the given path's contents like other
+  # browsers in a format like:
+  # path/file.ext
+  # path/subdir/file2.ext
+  # ...
+  class FsBrowser
+    include Enumerable
+    include ReVolt::Logger
+
+    attr_reader :files
+
+    def initialize(path)
+      @files = Dir["#{path}/**/*"]
+    end
+
+    def self.open(path, &block)
+      me = new(path)
+      me.each(block) if block
+    end
+
+    def each(&block)
+      @files.each(&block)
+    end
+  end # class FsBrowser
+end # module

data/lib/revolt/util.rb

@@ -0,0 +1,20 @@
+require 'tmpdir'
+require 'tempfile'
+require 'pathname'
+
+module ReVolt
+  module Util
+    module_function
+
+    def tmpdir 
+      # For now just the same as system tmpdir.
+      # Maybe later create a subdirectory there
+      # to help debugging
+      Pathname.new(Dir.tmpdir)
+    end
+    
+    def caseinsensitiveglob(glob)
+      glob.downcase.gsub(/[a-z]/) {|m| '['+m.downcase+m.upcase+']' }
+    end
+  end
+end

data/lib/revolt.rb

@@ -0,0 +1,12 @@
+require 'revolt/levels'
+require 'revolt/level'
+require 'revolt/fetcher'
+require 'revolt/info'
+require 'revolt/package'
+require 'revolt/util'
+require 'revolt/util/fs_browser'
+require 'revolt/args'
+
+module ReVolt
+  VERSION = '0.5.1'
+end

data/test/common.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/ruby -w
+
+require 'pathname'
+
+module ReVolt
+  module Test
+    ZIPS = {
+      :standard       => 'standard_track.zip',
+      :standard_rev   => 'standard_rev_track.zip',
+      :standard_multi => 'standard_multi.zip',
+      :zips_inside    => 'zips_inside.zip',
+      :rickyd_style   => 'rickyd_track.zip',
+      :nodirs_style   => 'nodirs_track.zip'
+    }
+    ZIPS_IDS = {
+      :standard       => [:levid],
+    }
+    
+    module_function
+
+    def setup
+      @output_dir  = Pathname.new(File.dirname(__FILE__)) + 'temp_out'
+      clean_working_dir
+      @output_dir.mkdir
+    end
+
+    def clean_working_dir
+      # Clean output dir
+      if @output_dir.directory?
+        STDERR.puts "Cleaning #{@output_dir}"
+        @output_dir.rmtree # FileUtils.rm_r @output_dir
+      end
+    end
+        
+    def get_test_file filename
+      File.join(File.dirname(__FILE__), 'fixtures', 'files', filename)
+    end
+
+    def get_test_output_dir(subdir = nil)
+      t = @output_dir.dup
+      t.mkdir unless t.directory?
+      if subdir
+        t += subdir
+        t.mkdir unless t.directory?
+      end
+      t.to_s
+    end
+    
+    def stringify_and_order_structure(c)
+      operation_and_order_structure(c) {|a| 
+        a = a.to_s
+        a = yield(a) if block_given?
+        a
+      }
+    end
+
+    def strdowncase_and_order_structure(c)
+      stringify_and_order_structure(c) {|a| 
+        a = a.downcase
+        a = yield(a) if block_given?
+        a
+      }
+    end
+    
+    def operation_and_order_structure(c, &blk)
+      if c.is_a? Hash
+      c.each {|(k,v)| c[k] = operation_and_order_structure(v,&blk)}
+      elsif c.is_a? Array
+        c.map! {|v| operation_and_order_structure(v,&blk)}
+        c.sort!
+      else
+        c = yield(c) if block_given?
+      end
+      
+      c
+    end
+  end # module Test
+end

data/test/fixtures/files/readme.txt

@@ -0,0 +1 @@
+

data/test/fixtures/rv/gfx/levid.bmp

@@ -0,0 +1 @@
+

data/test/fixtures/rv/gfx/levid.bmq

@@ -0,0 +1 @@
+

data/test/fixtures/rv/gfx/levidrev.bmp

@@ -0,0 +1 @@
+

data/test/fixtures/rv/gfx/levidrev.bmq

@@ -0,0 +1 @@
+

data/test/fixtures/rv/gfx/tEsT Level.bmp

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levid/levid.inf

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levid/levid.w

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levid/levida.bmp

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levid/readme.txt

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levidrev/levidrev.inf

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levidrev/levidrev.w

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levidrev/levidreva.bmp

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levidrev/readme.txt

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levidrev/reversed/levidrev.cam

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levidrev/reversed/levidrev.fan

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/levidrev/reversed/levidrev.fin

@@ -0,0 +1 @@
+

data/test/fixtures/rv/levels/test lEveL/TEst level.inf

@@ -0,0 +1,4 @@
+; Re-Volt test level
+y
+NAME  'Test Level'
+STARTGRID 3

data/test/fixtures/rv/levels/test lEveL/TeST level.w

@@ -0,0 +1 @@
+