test app for creating dir images and encoding files, do not use this is garbagge just a proof of concept, this will be used for the additional resources feature of rubin install builders

gistfile1.txt

class Test
  def initialize
  end
  
  
  
  
  def encode(target)
    if File.file?(target) == false ;  raise "No such file." ;  end
    begin ;  f = File.open(target,"rb") ;  dat = f.read ;  f.close
    rescue ;  raise "Failed to read file."
	end
	
	encdat = ""
	dat.split("").each do |ch| ;  c = ch.ord.to_s ;  loop do ;  if c.length >= 3 ;  break ;  end ;  c = "0" + c ;  end ;  encdat << c ;  end
	
	begin ;  f = File.open(target + ".enc","w") ;  f.write(encdat) ;  f.close
    rescue ;  raise "Failed to write file."
	end
	
	return true
  end

  def decode(target)
    if File.file?(target) == false ;  raise "No such file." ;  end
    begin ;  f = File.open(target, "r") ;  encdat = f.read ;  f.close
	rescue ;  raise "Failed to read file."
	end
	
	dat = "" ;  i = 0
	loop do
	  if encdat[i] == nil ;  break ;  end
	  ordinal = encdat[i..(i+2)]
      dat << [ordinal.to_i].pack("C")
	  i += 3
	end
	
	begin ;  f = File.open(target[0..-5], "wb") ;  f.write(dat) ;  f.close
	rescue ;  raise "Failed to write file."
    end
	
	return true
  end



  def testcopy(target)
	f = File.open(target,"rb") ;  odat = f.read ;  f.close
    self.encode(target)
	f = File.open(target,"rb") ;  encdat = f.read ;  f.close
	self.decode(target+".enc")

	
	i = 0
	
	loop do
	  if odat[i] == nil ;  break ;  end
	  puts "Original: " + odat[i].to_s + " New: " + encdat[i].to_s + "  MATCH: " + (odat[i].to_s == encdat[i].to_s).to_s
	  
	  i += 1
	end
	
	
	
  end












  def compdir(target)
    if File.directory?(target) == false ;  raise "Invalid directory." ;  end
    dirs = [] ; files = [] ;  remaining = [target] ;  cur = nil
	begin
	  loop do
	    if remaining.length == 0 ;  break ;  end
	    cur = remaining[0] ;  remaining.delete_at(0)
	    cont = Dir.entries(cur) ;  cont.delete(".") ;  cont.delete("..")
	    cont.each do |i|
	      p = cur + "/" + i
	  	  if File.file?(p) ;  files << p
		  elsif File.directory?(p) ;  dirs << p ;  remaining << p
		  end
	    end
	  end
	rescue ;  raise "Failed to map target directory."
	end
	if dirs.length == 0 and files.length == 0 ;  raise "Error, target directory is empty." ;  end
	
	puts "Found " + dirs.length.to_s + " directories."
	puts "Found " + files.length.to_s + " files."
	puts ""
	
	
	dir_mappings = []
	file_mappings = []

    package = "" ;  write_position = 0
    
	if dirs.length > 0
	  dirs.each do |d|
	    puts "Mapping dir: " + d.to_s
	    p = d.to_s.split(target)[-1]
		package << p
		dir_mappings << [write_position, write_position + (p.length - 1)]
		write_position += p.length
	  end 
	else
	  
	end
	
	puts ""
	
	begin
	  before_fail = nil
	  if files.length > 0
	    files.each do |f| ;  before_fail = f ## we wont use this var unless the loop crashes
		  puts "Mapping file: " + f.to_s
	      fp = f.split(target)[-1]
		  fi = File.open(f, "rb") ;  fc = fi.read ;  fi.close
		  fd = fp + fc
		  package << fd
		  file_mappings << [write_position, write_position + (fd.length - 1), fp.length - 1]
		  write_position += fd.length
	    end
	  else
	
	  end
	rescue ;  raise "Failed to read file: " + before_fail
	end
	
	index = target.split("/")[-1] + ":"
	
	ddm = []
	dir_mappings.each do |dm|
	  ddm << dm.join("?")
	end
	index << ddm.join(";")
	
	index << "*"
	
	ffm = []
	file_mappings.each do |fm|
	  ffm << fm.join("?")
	end
	index << ffm.join(";")
	
	package = index + "|" + package
	
	begin ;  f = File.open(target.split("/")[0..-2].join("/")+"/"+target.split("/")[-1]+".img", "wb") ;  f.write(package) ;  f.close
	rescue ;  raise "Failed to write file."
	end
	
	puts "DIR MAPPINGS: " + dir_mappings.to_s
	puts ""
	puts "FILE MAPPINGS: " + file_mappings.to_s
	
	return true
  end
  
  
  
  
  
 
  def decompdir(source,destination)
    if File.file?(source) == false ;  raise "No such file." ;  end
	begin ;  f = File.open(source, "rb") ;  package = f.read ;  f.close
	rescue ;  raise "Failed to read file."
	end
	
	index = ""
	
	i = 0
	loop do
	  if package[i] == "|" ;  break ;  end
	  index << package[i]
	  i += 1
	end
	
	package_data = package[Range.new((i+1),-1)]
	
	data = index.split(":")
	dirname = data[0]
	
	
	puts "Target directory name: " + dirname.to_s
	puts "index: " + data[1]
	puts "" 
	
	mappings = data[1].split("*")
	
	dir_mappings = mappings[0].split(";")
	file_mappings = mappings[1].split(";")
	
	puts "Dir mappings: " + dir_mappings.to_s
	puts "File mappings: " + file_mappings.to_s
	puts ""
	
	dir_paths = []
	file_paths = []
	file_contents = []
	
	dir_mappings.each do |dm|
	  puts "Processing dir mapping: " + dm.to_s
	  range = dm.split("?")
	  range[0] = range[0].to_i
	  range[1] = range[1].to_i
	  puts "Result: " + package_data[Range.new(range[0].to_i,range[1].to_i)]
	  dir_paths << destination + "/" + dirname + package_data[Range.new(range[0].to_i,range[1].to_i)]
	end
	
	puts "Processed dir paths: " + dir_paths.to_s
	
	puts ""
	
	file_mappings.each do |fm|
	  puts "Processing file mapping: " + fm.to_s
	  range = fm.split("?")
	  range[0] = range[0].to_i
	  range[1] = range[1].to_i
	  range[2] = range[2].to_i
	  
	  puts "File path: " + package_data[Range.new(range[0].to_i,(range[0].to_i + range[2].to_i))]
	  
	  puts "File contents: " + package_data[Range.new((range[0].to_i + range[2].to_i)+1,range[1].to_i)]
	  puts ""
	  
	  file_paths << destination + "/" + dirname + package_data[Range.new(range[0].to_i,(range[0].to_i + range[2].to_i))]
	  file_contents << package_data[Range.new((range[0]+(range[2]+1)),range[1])]
	end
	
	puts "Processed file paths: " + file_paths.to_s
	puts "Processed file contents: " + file_contents.to_s
	
	if File.directory?(destination + "/" + dirname) == true ;  raise "ERROR target directory already exists." ;  end
	begin ;  Dir.mkdir(destination + "/" + dirname)
	rescue ;  raise "Failed to create target directory."
	end
	
	before_fail = nil
	dir_paths.each do |dp|
	  begin ;  before_fail = dp ;  Dir.mkdir(dp)
	  rescue ;  raise "Failed to create directory: " + before_fail
	  end
	end
	
	i = 0
	file_paths.each do |fp|
	  f = File.open(fp, "wb")  ;  f.write(file_contents[i]) ;  f.close
	  i += 1
	end
	
	return true
  end

  ## if this class is the shell context, exit the shell session
  def quit ;  if SYSTEM.shell.sessions[SYSTEM.shell.current_session][0] == self ;  SYSTEM.shell.stop(SYSTEM.shell.current_session) ;  return true ;  end ;  end



end

@app = Test.new

@appshell = true

note on app quit: i just pulled this out of my ass because i got tired of having to set context back to system
this code makes 4 calls to SYSTEM when it could just do one, SYSTEM.shell.appstop(self) which will check if the app passed is context for the current session and stop it if so